@nest-omni/core 3.1.1-10 → 3.1.1-9

package/validator-json/defaultConverters.js

@@ -1,376 +0,0 @@
-"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/validator-json/index.d.ts

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

package/validator-json/index.js

@@ -1,20 +0,0 @@
-"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/validator-json/options.d.ts

@@ -1,11 +0,0 @@
-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/validator-json/options.js

@@ -1,10 +0,0 @@
-"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/validators/file-mimetype.validator.d.ts

@@ -1,13 +0,0 @@
-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/validators/file-mimetype.validator.js

@@ -1,21 +0,0 @@
-"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/validators/index.d.ts

@@ -1,6 +0,0 @@
-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/validators/index.js

@@ -1,22 +0,0 @@
-"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);

package/validators/is-exists.validator.d.ts

@@ -1,18 +0,0 @@
-import type { ValidationArguments, ValidationOptions, ValidatorConstraintInterface } from 'class-validator';
-import type { EntitySchema, FindOptionsWhere, ObjectType } from 'typeorm';
-import { DataSource } from 'typeorm';
-export declare class IsExistsValidator implements ValidatorConstraintInterface {
-    private readonly dataSource;
-    constructor(dataSource: DataSource);
-    validate<E>(value: string, args: IExistsValidationArguments<E>): Promise<boolean>;
-    defaultMessage(args: ValidationArguments): string;
-}
-type ExistsValidationConstraints<E> = [
-    ObjectType<E> | EntitySchema<E> | string,
-    (validationArguments: ValidationArguments) => FindOptionsWhere<E>
-];
-interface IExistsValidationArguments<E> extends ValidationArguments {
-    constraints: ExistsValidationConstraints<E>;
-}
-export declare function IsExists<E>(constraints: Partial<ExistsValidationConstraints<E>>, validationOptions?: ValidationOptions): PropertyDecorator;
-export {};

package/validators/is-exists.validator.js

@@ -1,60 +0,0 @@
-"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 __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsExistsValidator = void 0;
-exports.IsExists = IsExists;
-const class_validator_1 = require("class-validator");
-const typeorm_1 = require("typeorm");
-const nestjs_i18n_1 = require("nestjs-i18n");
-const common_1 = require("@nestjs/common");
-let IsExistsValidator = class IsExistsValidator {
-    constructor(dataSource) {
-        this.dataSource = dataSource;
-    }
-    validate(value, args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [entityClass, findCondition] = args.constraints;
-            args.value = value;
-            return ((yield this.dataSource.getRepository(entityClass).count({
-                where: findCondition(args),
-            })) > 0);
-        });
-    }
-    defaultMessage(args) {
-        return (0, nestjs_i18n_1.i18nValidationMessage)('validation.IS_EXISTS')(args);
-    }
-};
-exports.IsExistsValidator = IsExistsValidator;
-exports.IsExistsValidator = IsExistsValidator = __decorate([
-    (0, common_1.Injectable)(),
-    (0, class_validator_1.ValidatorConstraint)({ name: 'isExists', async: true }),
-    __metadata("design:paramtypes", [typeorm_1.DataSource])
-], IsExistsValidator);
-function IsExists(constraints, validationOptions) {
-    return (object, propertyName) => {
-        (0, class_validator_1.registerDecorator)({
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            constraints,
-            validator: IsExistsValidator,
-        });
-    };
-}

package/validators/is-unique.validator.d.ts

@@ -1,17 +0,0 @@
-import type { ValidationArguments, ValidationOptions, ValidatorConstraintInterface } from 'class-validator';
-import { DataSource, EntitySchema, FindOptionsWhere, ObjectType } from 'typeorm';
-export declare class IsUniqueValidator implements ValidatorConstraintInterface {
-    private readonly dataSource;
-    constructor(dataSource: DataSource);
-    validate<E>(value: string, args: IUniqueValidationArguments<E>): Promise<boolean>;
-    defaultMessage(args: ValidationArguments): string;
-}
-type UniqueValidationConstraints<E> = [
-    ObjectType<E> | EntitySchema<E> | string,
-    (validationArguments: ValidationArguments) => FindOptionsWhere<E>
-];
-interface IUniqueValidationArguments<E> extends ValidationArguments {
-    constraints: UniqueValidationConstraints<E>;
-}
-export declare function IsUnique<E>(constraints: Partial<UniqueValidationConstraints<E>>, validationOptions?: ValidationOptions): PropertyDecorator;
-export {};

package/validators/is-unique.validator.js

@@ -1,91 +0,0 @@
-"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 __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsUniqueValidator = void 0;
-exports.IsUnique = IsUnique;
-const class_validator_1 = require("class-validator");
-const typeorm_1 = require("typeorm");
-const nestjs_i18n_1 = require("nestjs-i18n");
-let IsUniqueValidator = class IsUniqueValidator {
-    constructor(dataSource) {
-        this.dataSource = dataSource;
-    }
-    validate(value, args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [entityClass, findCondition] = args.constraints;
-            args.value = value;
-            let exists;
-            const defCon = findCondition(args);
-            const pkCols = this.dataSource
-                .getMetadata(entityClass)
-                .primaryColumns.map((column) => column.propertyName);
-            const isNew = pkCols.some((pk) => args.object[pk]);
-            if (!isNew) {
-                exists =
-                    (yield this.dataSource
-                        .getRepository(entityClass)
-                        .count({ where: defCon })) < 1;
-            }
-            else {
-                const entities = yield this.dataSource
-                    .getRepository(entityClass)
-                    .createQueryBuilder()
-                    .where(defCon)
-                    .select(pkCols)
-                    .limit(2)
-                    .execute();
-                const entityCount = entities.length;
-                if (entityCount === 1) {
-                    const entity = entities[0];
-                    const oldPk = {};
-                    const newPk = {};
-                    pkCols.map((pk) => {
-                        oldPk[pk] = entity[pk];
-                        newPk[pk] = args.object[pk];
-                    });
-                    exists = JSON.stringify(oldPk) === JSON.stringify(newPk);
-                }
-                else {
-                    exists = entityCount < 1;
-                }
-            }
-            return exists;
-        });
-    }
-    defaultMessage(args) {
-        return (0, nestjs_i18n_1.i18nValidationMessage)('validation.IS_UNIQUE')(args);
-    }
-};
-exports.IsUniqueValidator = IsUniqueValidator;
-exports.IsUniqueValidator = IsUniqueValidator = __decorate([
-    (0, class_validator_1.ValidatorConstraint)({ name: 'isUnique', async: true }),
-    __metadata("design:paramtypes", [typeorm_1.DataSource])
-], IsUniqueValidator);
-function IsUnique(constraints, validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            target: object.constructor,
-            propertyName,
-            options: validationOptions,
-            constraints,
-            validator: IsUniqueValidator,
-        });
-    };
-}