@nest-omni/core 1.0.14 → 1.0.15

package/dist/validator-json/decorators.d.ts

@@ -0,0 +1,6 @@
+import { ReferenceObject, SchemaObject } from '@nestjs/swagger/dist/interfaces/open-api-spec.interface';
+import 'reflect-metadata';
+import { IOptions } from './options';
+export type DecoratorSchema = ReferenceObject | SchemaObject | ((source: SchemaObject, options: IOptions) => ReferenceObject | SchemaObject);
+export declare function JSONSchema(schema: DecoratorSchema): (target: object | Function, key?: string) => void;
+export declare function getMetadataSchema(target: object | Function, key: string): DecoratorSchema;

package/dist/validator-json/decorators.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadataSchema = exports.JSONSchema = void 0;
+require("reflect-metadata");
+const SCHEMA_KEY = Symbol('class-validator-jsonschema:JSONSchema');
+function JSONSchema(schema) {
+    return (target, key) => {
+        if (key) {
+            setMetadataSchema(schema, target.constructor, key);
+        }
+        else {
+            setMetadataSchema(schema, target, target.name);
+        }
+    };
+}
+exports.JSONSchema = JSONSchema;
+function getMetadataSchema(target, key) {
+    return Reflect.getMetadata(SCHEMA_KEY, target.constructor, key) || {};
+}
+exports.getMetadataSchema = getMetadataSchema;
+function setMetadataSchema(value, target, key) {
+    return Reflect.defineMetadata(SCHEMA_KEY, value, target, key);
+}

package/dist/validator-json/default.d.ts

@@ -0,0 +1,6 @@
+import { ValidationMetadata } from 'class-validator/types/metadata/ValidationMetadata';
+import { IOptions } from './options';
+import { I18nService } from 'nestjs-i18n';
+export { JSONSchema } from './decorators';
+export declare function validationMetadataArrayToSchemas(metadatas: ValidationMetadata[], i18n: any, userOptions?: Partial<IOptions>): any;
+export declare function targetConstructorToSchema(targetConstructor: Function, i18n: I18nService, userOptions?: Partial<IOptions>): any;

package/dist/validator-json/default.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.targetConstructorToSchema = exports.validationMetadataArrayToSchemas = exports.JSONSchema = void 0;
+const cv = require("class-validator");
+const lodash_1 = require("lodash");
+const defaultConverters_1 = require("./defaultConverters");
+const options_1 = require("./options");
+var decorators_1 = require("./decorators");
+Object.defineProperty(exports, "JSONSchema", { enumerable: true, get: function () { return decorators_1.JSONSchema; } });
+function validationMetadataArrayToSchemas(metadatas, i18n, userOptions) {
+    const options = Object.assign(Object.assign({}, options_1.defaultOptions), userOptions);
+    const rules = [];
+    Object.entries((0, lodash_1.groupBy)(metadatas, ({ target }) => {
+        var _a;
+        return (_a = target[options.schemaNameField]) !== null && _a !== void 0 ? _a : target.name;
+    })).forEach(([key, ownMetas]) => {
+        const target = ownMetas[0].target;
+        const metas = ownMetas
+            .concat(getInheritedMetadatas(target, metadatas))
+            .filter((propMeta) => !(isExcluded(propMeta, options) ||
+            isExcluded(Object.assign(Object.assign({}, propMeta), { target }), options)));
+        const required = getRequiredPropNames(target, metas, options);
+        Object.entries((0, lodash_1.groupBy)(metas, 'propertyName')).forEach(([propName, propMetas]) => {
+            const schema = applyConverters(propMetas, options, i18n);
+            const filterSchema = schema.filter((item) => !['conditionalValidation', 'notEquals'].includes(item.type));
+            const fieldType = getFirstNonNullDataType(filterSchema);
+            rules.push({
+                field: propName,
+                fieldType,
+                required: required.includes(propName),
+                constraints: filterSchema,
+            });
+        });
+    });
+    return rules;
+}
+exports.validationMetadataArrayToSchemas = validationMetadataArrayToSchemas;
+function getFirstNonNullDataType(data) {
+    for (const item of data) {
+        const dataType = item.dataType;
+        delete item.dataType;
+        if (dataType) {
+            return dataType;
+        }
+    }
+    return undefined;
+}
+function targetConstructorToSchema(targetConstructor, i18n, userOptions) {
+    const options = Object.assign(Object.assign({}, options_1.defaultOptions), userOptions);
+    const storage = options.classValidatorMetadataStorage;
+    let metadatas = storage.getTargetValidationMetadatas(targetConstructor, '', true, false);
+    metadatas = populateMetadatasWithConstraints(storage, metadatas);
+    return validationMetadataArrayToSchemas(metadatas, i18n, userOptions);
+}
+exports.targetConstructorToSchema = targetConstructorToSchema;
+function populateMetadatasWithConstraints(storage, metadatas) {
+    return metadatas.map((meta) => {
+        if (meta.constraintCls) {
+            const constraint = storage.getTargetValidatorConstraints(meta.constraintCls);
+            if (constraint.length > 0) {
+                return Object.assign(Object.assign({}, meta), { type: constraint[0].name });
+            }
+        }
+        return Object.assign({}, meta);
+    });
+}
+function getInheritedMetadatas(target, metadatas) {
+    return metadatas.filter((d) => d.target instanceof Function &&
+        target.prototype instanceof d.target &&
+        !metadatas.find((m) => m.propertyName === d.propertyName &&
+            m.target === target &&
+            m.type === d.type));
+}
+function applyConverters(propertyMetadatas, options, i18n) {
+    const converters = Object.assign(Object.assign({}, defaultConverters_1.defaultConverters), options.additionalConverters);
+    const convert = (meta) => {
+        var _a;
+        const typeMeta = (_a = options.classTransformerMetadataStorage) === null || _a === void 0 ? void 0 : _a.findTypeMetadata(meta.target, meta.propertyName);
+        const isMap = typeMeta &&
+            typeMeta.reflectedType &&
+            new typeMeta.reflectedType() instanceof Map;
+        const converter = converters[meta.type] || converters[cv.ValidationTypes.CUSTOM_VALIDATION];
+        const converterResult = typeof converter === 'function' ? converter(meta, options) : converter;
+        const items = {};
+        let message = '';
+        const originMessage = typeof meta.message === 'function' ? meta.message(meta) : meta.message;
+        if ((0, lodash_1.isString)(originMessage)) {
+            const [translationKey, argsString] = originMessage.split('|');
+            const args = !!argsString ? JSON.parse(argsString) : {};
+            message = i18n.translate(translationKey, Object.assign(Object.assign({}, options), { args: Object.assign({ constraints: meta.constraints }, args) }));
+        }
+        items['type'] = meta.type;
+        items['dataType'] = (converterResult === null || converterResult === void 0 ? void 0 : converterResult.type) || undefined;
+        items['attrs'] = meta.constraints || [];
+        items['message'] = message;
+        if (meta.each && isMap) {
+            return {
+                additionalProperties: Object.assign({}, items),
+                type: 'object',
+            };
+        }
+        return meta.each ? { items, type: 'array' } : items;
+    };
+    const constraints = propertyMetadatas.map((meta) => {
+        return convert(meta);
+    });
+    return (0, lodash_1.reject)(constraints, (item) => (0, lodash_1.isEmpty)(item));
+}
+function isExcluded(propertyMetadata, options) {
+    var _a;
+    return !!((_a = options.classTransformerMetadataStorage) === null || _a === void 0 ? void 0 : _a.findExcludeMetadata(propertyMetadata.target, propertyMetadata.propertyName));
+}
+function getRequiredPropNames(target, metadatas, options) {
+    function isDefined(metas) {
+        return (metas && metas.some(({ type }) => type === cv.ValidationTypes.IS_DEFINED));
+    }
+    function isOptional(metas) {
+        return (metas &&
+            metas.some(({ type }) => [cv.ValidationTypes.CONDITIONAL_VALIDATION, cv.IS_EMPTY].includes(type)));
+    }
+    return (Object.entries((0, lodash_1.groupBy)(metadatas, (m) => m.propertyName))
+        .filter(([_, metas]) => {
+        const own = metas.filter((m) => m.target === target);
+        const inherited = metas.filter((m) => m.target !== target);
+        return options.skipMissingProperties
+            ? isDefined(own) || (!isOptional(own) && isDefined(inherited))
+            : !(isOptional(own) || isOptional(inherited));
+    })
+        .map(([name]) => name));
+}

package/dist/validator-json/defaultConverters.d.ts

@@ -0,0 +1,8 @@
+import type { ValidationMetadata } from 'class-validator/types/metadata/ValidationMetadata';
+import 'reflect-metadata';
+import { IOptions } from './options';
+export interface ISchemaConverters {
+    [validatorType: string]: any;
+}
+export type SchemaConverter = (meta: ValidationMetadata, options: IOptions) => any;
+export declare const defaultConverters: ISchemaConverters;

package/dist/validator-json/defaultConverters.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConverters = void 0;
+const cv = require("class-validator");
+require("reflect-metadata");
+exports.defaultConverters = {
+    [cv.ValidationTypes.CUSTOM_VALIDATION]: (meta, options) => {
+        if (typeof meta.target === 'function') {
+            const type = getPropType(meta.target.prototype, meta.propertyName);
+            return targetToSchema(type, options);
+        }
+    },
+    [cv.ValidationTypes.NESTED_VALIDATION]: (meta, options) => {
+        if (typeof meta.target === 'function') {
+            const typeMeta = options.classTransformerMetadataStorage
+                ? options.classTransformerMetadataStorage.findTypeMetadata(meta.target, meta.propertyName)
+                : null;
+            const childType = typeMeta
+                ? typeMeta.typeFunction()
+                : getPropType(meta.target.prototype, meta.propertyName);
+            return targetToSchema(childType, options);
+        }
+    },
+    [cv.ValidationTypes.WHITELIST]: {},
+    [cv.ValidationTypes.CONDITIONAL_VALIDATION]: {},
+    [cv.ValidationTypes.IS_DEFINED]: {
+        not: { type: 'null' },
+    },
+    [cv.EQUALS]: (meta) => {
+        const schema = constraintToSchema(meta.constraints[0]);
+        if (schema) {
+            return Object.assign(Object.assign({}, schema), { enum: [meta.constraints[0]] });
+        }
+    },
+    [cv.NOT_EQUALS]: (meta) => {
+        const schema = constraintToSchema(meta.constraints[0]);
+        if (schema) {
+            return { not: Object.assign(Object.assign({}, schema), { enum: [meta.constraints[0]] }) };
+        }
+    },
+    [cv.IS_EMPTY]: {
+        type: 'string',
+        anyOf: [
+            { type: 'string', enum: [''] },
+            {
+                not: {
+                    anyOf: [
+                        { type: 'string' },
+                        { type: 'number' },
+                        { type: 'boolean' },
+                        { type: 'integer' },
+                        { type: 'array' },
+                        { type: 'object' },
+                    ],
+                },
+                nullable: true,
+            },
+        ],
+    },
+    [cv.IS_NOT_EMPTY]: {
+        minLength: 1,
+        type: 'string',
+    },
+    [cv.IS_IN]: (meta) => {
+        const [head, ...rest] = meta.constraints[0].map(constraintToSchema);
+        if (head && rest.every((item) => item.type === head.type)) {
+            return Object.assign(Object.assign({}, head), { enum: meta.constraints[0] });
+        }
+        return {
+            type: 'string',
+        };
+    },
+    [cv.IS_NOT_IN]: (meta) => {
+        const [head, ...rest] = meta.constraints[0].map(constraintToSchema);
+        if (head && rest.every((item) => item.type === head.type)) {
+            return { not: Object.assign(Object.assign({}, head), { enum: meta.constraints[0] }) };
+        }
+        return {
+            type: 'string',
+        };
+    },
+    [cv.IS_BOOLEAN]: {
+        type: 'boolean',
+    },
+    [cv.IS_DATE]: {
+        type: 'string',
+        oneOf: [
+            { format: 'date', type: 'string' },
+            { format: 'date-time', type: 'string' },
+        ],
+    },
+    [cv.IS_NUMBER]: {
+        type: 'number',
+    },
+    [cv.IS_STRING]: {
+        type: 'string',
+    },
+    [cv.IS_DATE_STRING]: {
+        pattern: '\\d{4}-[01]\\d-[0-3]\\dT[0-2]\\d:[0-5]\\d:[0-5]\\d.\\d+Z?',
+        type: 'string',
+    },
+    [cv.IS_ARRAY]: {
+        items: {},
+        type: 'array',
+    },
+    [cv.IS_INT]: {
+        type: 'integer',
+    },
+    [cv.IS_ENUM]: (meta) => {
+        return {
+            enum: Object.values(meta.constraints[0]),
+            type: 'string',
+        };
+    },
+    [cv.IS_DIVISIBLE_BY]: (meta) => ({
+        multipleOf: meta.constraints[0],
+        type: 'number',
+    }),
+    [cv.IS_POSITIVE]: {
+        exclusiveMinimum: 0,
+        type: 'number',
+    },
+    [cv.IS_NEGATIVE]: {
+        exclusiveMaximum: 0,
+        type: 'number',
+    },
+    [cv.MIN]: (meta) => ({
+        minimum: meta.constraints[0],
+        type: 'number',
+    }),
+    [cv.MAX]: (meta) => ({
+        maximum: meta.constraints[0],
+        type: 'number',
+    }),
+    [cv.MIN_DATE]: (meta) => ({
+        description: `After ${meta.constraints[0].toJSON()}`,
+        oneOf: [
+            { format: 'date', type: 'string' },
+            { format: 'date-time', type: 'string' },
+        ],
+    }),
+    [cv.MAX_DATE]: (meta) => ({
+        description: `Before ${meta.constraints[0].toJSON()}`,
+        oneOf: [
+            { format: 'date', type: 'string' },
+            { format: 'date-time', type: 'string' },
+        ],
+    }),
+    [cv.IS_BOOLEAN_STRING]: {
+        enum: ['true', 'false'],
+        type: 'string',
+    },
+    [cv.IS_NUMBER_STRING]: {
+        pattern: '^[-+]?[0-9]+$',
+        type: 'string',
+    },
+    [cv.CONTAINS]: (meta) => ({
+        pattern: meta.constraints[0],
+        type: 'string',
+    }),
+    [cv.NOT_CONTAINS]: (meta) => ({
+        not: { pattern: meta.constraints[0] },
+        type: 'string',
+    }),
+    [cv.IS_ALPHA]: {
+        pattern: '^[a-zA-Z]+$',
+        type: 'string',
+    },
+    [cv.IS_ALPHANUMERIC]: {
+        pattern: '^[0-9a-zA-Z]+$',
+        type: 'string',
+    },
+    [cv.IS_ASCII]: {
+        pattern: '^[\\x00-\\x7F]+$',
+        type: 'string',
+    },
+    [cv.IS_BASE64]: {
+        format: 'base64',
+        type: 'string',
+    },
+    [cv.IS_BYTE_LENGTH]: {
+        type: 'string',
+    },
+    [cv.IS_CREDIT_CARD]: {
+        format: 'credit-card',
+        type: 'string',
+    },
+    [cv.IS_CURRENCY]: {
+        format: 'currency',
+        type: 'string',
+    },
+    [cv.IS_EMAIL]: {
+        format: 'email',
+        type: 'string',
+    },
+    [cv.IS_FQDN]: {
+        format: 'hostname',
+        type: 'string',
+    },
+    [cv.IS_FULL_WIDTH]: {
+        pattern: '[^\\u0020-\\u007E\\uFF61-\\uFF9F\\uFFA0-\\uFFDC\\uFFE8-\\uFFEE0-9a-zA-Z]',
+        type: 'string',
+    },
+    [cv.IS_HALF_WIDTH]: {
+        pattern: '[\\u0020-\\u007E\\uFF61-\\uFF9F\\uFFA0-\\uFFDC\\uFFE8-\\uFFEE0-9a-zA-Z]',
+        type: 'string',
+    },
+    [cv.IS_VARIABLE_WIDTH]: {
+        type: 'string',
+    },
+    [cv.IS_HEX_COLOR]: {
+        pattern: '^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$',
+        type: 'string',
+    },
+    [cv.IS_HEXADECIMAL]: {
+        pattern: '^[0-9a-fA-F]+$',
+        type: 'string',
+    },
+    [cv.IS_IP]: (meta) => ({
+        format: 'ipv' + (meta.constraints[0] === '6' ? 6 : 4),
+        type: 'string',
+    }),
+    [cv.IS_ISBN]: {
+        format: 'isbn',
+        type: 'string',
+    },
+    [cv.IS_ISIN]: {
+        format: 'isin',
+        type: 'string',
+    },
+    [cv.IS_ISO8601]: {
+        oneOf: [
+            { format: 'date', type: 'string' },
+            { format: 'date-time', type: 'string' },
+        ],
+    },
+    [cv.IS_JSON]: {
+        format: 'json',
+        type: 'string',
+    },
+    [cv.IS_LOWERCASE]: {
+        type: 'string',
+    },
+    [cv.IS_MOBILE_PHONE]: {
+        format: 'mobile-phone',
+        type: 'string',
+    },
+    [cv.IS_MONGO_ID]: {
+        pattern: '^[0-9a-fA-F]{24}$',
+        type: 'string',
+    },
+    [cv.IS_MULTIBYTE]: {
+        pattern: '[^\\x00-\\x7F]',
+        type: 'string',
+    },
+    [cv.IS_SURROGATE_PAIR]: {
+        pattern: '[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]',
+        type: 'string',
+    },
+    [cv.IS_URL]: {
+        format: 'url',
+        type: 'string',
+    },
+    [cv.IS_UUID]: {
+        format: 'uuid',
+        type: 'string',
+    },
+    [cv.IS_LENGTH]: (meta) => {
+        const [minLength, maxLength] = meta.constraints;
+        if (maxLength || maxLength === 0) {
+            return { min: minLength, max: maxLength, type: 'Range' };
+        }
+        return { min: minLength, type: 'Range' };
+    },
+    [cv.IS_UPPERCASE]: {
+        type: 'string',
+    },
+    [cv.IS_OBJECT]: {
+        type: 'object',
+    },
+    [cv.IS_NOT_EMPTY_OBJECT]: {
+        type: 'object',
+        minProperties: 1,
+    },
+    [cv.MIN_LENGTH]: (meta) => ({
+        minLength: meta.constraints[0],
+        type: 'string',
+    }),
+    [cv.MAX_LENGTH]: (meta) => ({
+        maxLength: meta.constraints[0],
+        type: 'string',
+    }),
+    [cv.MATCHES]: (meta) => ({
+        pattern: meta.constraints[0].source,
+        type: 'string',
+    }),
+    [cv.IS_MILITARY_TIME]: {
+        pattern: '^([01]\\d|2[0-3]):?([0-5]\\d)$',
+        type: 'string',
+    },
+    [cv.ARRAY_CONTAINS]: (meta) => {
+        const schemas = meta.constraints[0].map(constraintToSchema);
+        if (schemas.length > 0 && schemas.every((s) => s && s.type)) {
+            return {
+                not: {
+                    anyOf: schemas.map((d, i) => ({
+                        items: {
+                            not: Object.assign(Object.assign({}, d), { enum: [meta.constraints[0][i]] }),
+                        },
+                    })),
+                },
+                type: 'array',
+            };
+        }
+        return { items: {}, type: 'array' };
+    },
+    [cv.ARRAY_NOT_CONTAINS]: (meta) => {
+        const schemas = meta.constraints[0].map(constraintToSchema);
+        if (schemas.length > 0 && schemas.every((s) => s && s.type)) {
+            return {
+                items: {
+                    not: {
+                        anyOf: schemas.map((d, i) => (Object.assign(Object.assign({}, d), { enum: [meta.constraints[0][i]] }))),
+                    },
+                },
+                type: 'array',
+            };
+        }
+        return { items: {}, type: 'array' };
+    },
+    [cv.ARRAY_NOT_EMPTY]: {
+        items: {},
+        minItems: 1,
+        type: 'array',
+    },
+    [cv.ARRAY_MIN_SIZE]: (meta) => ({
+        items: {},
+        minItems: meta.constraints[0],
+        type: 'array',
+    }),
+    [cv.ARRAY_MAX_SIZE]: (meta) => ({
+        items: {},
+        maxItems: meta.constraints[0],
+        type: 'array',
+    }),
+    [cv.ARRAY_UNIQUE]: {
+        items: {},
+        type: 'array',
+        uniqueItems: true,
+    },
+};
+function getPropType(target, property) {
+    return Reflect.getMetadata('design:type', target, property);
+}
+function constraintToSchema(primitive) {
+    const primitives = ['string', 'number', 'boolean'];
+    const type = typeof primitive;
+    if (primitives.includes(type)) {
+        return { type: type };
+    }
+}
+function targetToSchema(type, options) {
+    if (typeof type === 'function') {
+        if (type.prototype === String.prototype ||
+            type.prototype === Symbol.prototype) {
+            return { type: 'string' };
+        }
+        else if (type.prototype === Number.prototype) {
+            return { type: 'number' };
+        }
+        else if (type.prototype === Boolean.prototype) {
+            return { type: 'boolean' };
+        }
+        return { $ref: options.refPointerPrefix + type.name };
+    }
+}

package/dist/validator-json/index.d.ts

@@ -0,0 +1,4 @@
+export * from './default';
+export * from './decorators';
+export * from './defaultConverters';
+export * from './options';

package/dist/validator-json/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./default"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./defaultConverters"), exports);
+__exportStar(require("./options"), exports);

package/dist/validator-json/options.d.ts

@@ -0,0 +1,11 @@
+import type { MetadataStorage as ClassTransformerMetadataStorage } from 'class-transformer/types/MetadataStorage';
+import { MetadataStorage, ValidatorOptions } from 'class-validator';
+import { ISchemaConverters } from './defaultConverters';
+export interface IOptions extends ValidatorOptions {
+    additionalConverters: ISchemaConverters;
+    classTransformerMetadataStorage?: ClassTransformerMetadataStorage;
+    classValidatorMetadataStorage: MetadataStorage;
+    refPointerPrefix: string;
+    schemaNameField: string;
+}
+export declare const defaultOptions: IOptions;

package/dist/validator-json/options.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOptions = void 0;
+const class_validator_1 = require("class-validator");
+exports.defaultOptions = {
+    additionalConverters: {},
+    classValidatorMetadataStorage: (0, class_validator_1.getMetadataStorage)(),
+    refPointerPrefix: '#/definitions/',
+    schemaNameField: 'name',
+};

package/dist/validators/file-mimetype.validator.d.ts

@@ -0,0 +1,13 @@
+import { FileValidator } from '@nestjs/common/pipes/file/file-validator.interface';
+import { IFile } from '@nestjs/common/pipes/file/interfaces';
+export type FileMimetypeValidatorOptions = {
+    allowedMimetypes: string[];
+    message?: string;
+};
+export declare class FileMimetypeValidator extends FileValidator<FileMimetypeValidatorOptions, IFile> {
+    private allowedMimetypes;
+    private message;
+    constructor(options: FileMimetypeValidatorOptions);
+    buildErrorMessage(): string;
+    isValid(file?: IFile): boolean;
+}

package/dist/validators/file-mimetype.validator.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileMimetypeValidator = void 0;
+const file_validator_interface_1 = require("@nestjs/common/pipes/file/file-validator.interface");
+class FileMimetypeValidator extends file_validator_interface_1.FileValidator {
+    constructor(options) {
+        super(options);
+        this.allowedMimetypes = options.allowedMimetypes;
+        this.message = options.message;
+    }
+    buildErrorMessage() {
+        if (this.message) {
+            return this.message;
+        }
+        return `Invalid file type. Only ${this.allowedMimetypes.join(', ')} are allowed.`;
+    }
+    isValid(file) {
+        return this.allowedMimetypes.includes(file.mimetype);
+    }
+}
+exports.FileMimetypeValidator = FileMimetypeValidator;

package/dist/validators/index.d.ts

@@ -0,0 +1,6 @@
+export * from './phone-country-code.validator';
+export * from './skip-empty.validator';
+export * from './file-mimetype.validator';
+export * from './is-exists.validator';
+export * from './is-unique.validator';
+export * from './same-as.validator';

package/dist/validators/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./phone-country-code.validator"), exports);
+__exportStar(require("./skip-empty.validator"), exports);
+__exportStar(require("./file-mimetype.validator"), exports);
+__exportStar(require("./is-exists.validator"), exports);
+__exportStar(require("./is-unique.validator"), exports);
+__exportStar(require("./same-as.validator"), exports);