bb-inspired/dist/pipes/validation.module.js

Core library for BB-inspired NestJS backend

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var ValidationModule_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValidationModule = void 0;
const common_1 = require("@nestjs/common");
const core_1 = require("@nestjs/core");
const validation_pipe_1 = require("./validation.pipe");
const sanitization_pipe_1 = require("./sanitization.pipe");
let ValidationModule = ValidationModule_1 = class ValidationModule {
    static forRoot(options = {}) {
        const providers = [];
        const defaultOptions = {
            useGlobalValidationPipe: true,
            useGlobalSanitizationPipe: false,
            validationPipeOptions: {
                transform: true,
                whitelist: true,
                forbidNonWhitelisted: false,
                validateNested: true,
                enableDetailedErrors: true,
                errorHttpStatusCode: 400,
            },
            sanitizationPipeOptions: {
                stripAllTags: false,
                sanitizeMode: 'strict',
            },
        };
        const mergedOptions = { ...defaultOptions, ...options };
        mergedOptions.validationPipeOptions = {
            ...defaultOptions.validationPipeOptions,
            ...options.validationPipeOptions,
        };
        mergedOptions.sanitizationPipeOptions = {
            ...defaultOptions.sanitizationPipeOptions,
            ...options.sanitizationPipeOptions,
        };
        if (mergedOptions.useGlobalValidationPipe) {
            providers.push({
                provide: core_1.APP_PIPE,
                useFactory: () => {
                    return new validation_pipe_1.GlobalValidationPipe(mergedOptions.validationPipeOptions);
                },
            });
        }
        if (mergedOptions.useGlobalSanitizationPipe) {
            providers.push({
                provide: core_1.APP_PIPE,
                useFactory: () => {
                    return new sanitization_pipe_1.SanitizationPipe(mergedOptions.sanitizationPipeOptions);
                },
            });
        }
        return {
            module: ValidationModule_1,
            providers,
            exports: providers,
        };
    }
    static forRootAsync(options) {
        return {
            module: ValidationModule_1,
            imports: options.imports || [],
            providers: [
                {
                    provide: 'VALIDATION_MODULE_OPTIONS',
                    useFactory: options.useFactory,
                    inject: options.inject || [],
                },
                {
                    provide: core_1.APP_PIPE,
                    useFactory: async (moduleOptions) => {
                        const defaultOptions = {
                            transform: true,
                            whitelist: true,
                            forbidNonWhitelisted: false,
                            validateNested: true,
                            enableDetailedErrors: true,
                            errorHttpStatusCode: 400,
                        };
                        const validationOptions = {
                            ...defaultOptions,
                            ...(moduleOptions.validationPipeOptions || {}),
                        };
                        return new validation_pipe_1.GlobalValidationPipe(validationOptions);
                    },
                    inject: ['VALIDATION_MODULE_OPTIONS'],
                },
                {
                    provide: core_1.APP_PIPE,
                    useFactory: async (moduleOptions) => {
                        if (moduleOptions.useGlobalSanitizationPipe) {
                            const defaultOptions = {
                                stripAllTags: false,
                                sanitizeMode: 'strict',
                            };
                            const sanitizationOptions = {
                                ...defaultOptions,
                                ...(moduleOptions.sanitizationPipeOptions || {}),
                            };
                            return new sanitization_pipe_1.SanitizationPipe(sanitizationOptions);
                        }
                        return null;
                    },
                    inject: ['VALIDATION_MODULE_OPTIONS'],
                },
            ],
        };
    }
};
exports.ValidationModule = ValidationModule;
exports.ValidationModule = ValidationModule = ValidationModule_1 = __decorate([
    (0, common_1.Module)({})
], ValidationModule);
//# sourceMappingURL=validation.module.js.map