@nest-omni/core 1.0.0

package/src/types.ts

@@ -0,0 +1,44 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export type Constructor<T, Arguments extends unknown[] = undefined[]> = new (
+  ...arguments_: Arguments
+) => T;
+
+export type Plain<T> = T;
+
+export type PathImpl<T, Key extends keyof T> = Key extends string
+  ? T[Key] extends Record<string, any>
+    ?
+        | `${Key}.${PathImpl<T[Key], Exclude<keyof T[Key], keyof any[]>> &
+            string}`
+        | `${Key}.${Exclude<keyof T[Key], keyof any[]> & string}`
+    : never
+  : never;
+
+export type PathImpl2<T> = PathImpl<T, keyof T> | keyof T;
+
+export type Path<T> = keyof T extends string
+  ? PathImpl2<T> extends string | keyof T
+    ? PathImpl2<T>
+    : keyof T
+  : never;
+
+export type PathValue<
+  T,
+  P extends Path<T>,
+> = P extends `${infer Key}.${infer Rest}`
+  ? Key extends keyof T
+    ? Rest extends Path<T[Key]>
+      ? PathValue<T[Key], Rest>
+      : never
+    : never
+  : P extends keyof T
+  ? T[P]
+  : never;
+
+export type KeyOfType<Entity, U> = {
+  [P in keyof Required<Entity>]: Required<Entity>[P] extends U
+    ? P
+    : Required<Entity>[P] extends U[]
+    ? P
+    : never;
+}[keyof Entity];

package/src/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/src/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/src/validators/file-mimetype.validator.ts

@@ -0,0 +1,34 @@
+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 class FileMimetypeValidator extends FileValidator<
+  FileMimetypeValidatorOptions,
+  IFile
+> {
+  private allowedMimetypes: string[];
+  private message: string;
+
+  constructor(options: FileMimetypeValidatorOptions) {
+    super(options);
+    this.allowedMimetypes = options.allowedMimetypes;
+    this.message = options.message;
+  }
+
+  buildErrorMessage(): string {
+    if (this.message) {
+      return this.message;
+    }
+    return `Invalid file type. Only ${this.allowedMimetypes.join(
+      ', ',
+    )} are allowed.`;
+  }
+
+  isValid(file?: IFile): boolean {
+    return this.allowedMimetypes.includes(file.mimetype);
+  }
+}

package/src/validators/index.d.ts

@@ -0,0 +1,3 @@
+export * from './phone-country-code.validator';
+export * from './skip-empty.validator';
+export * from './file-mimetype.validator';

package/src/validators/index.js

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

package/src/validators/index.ts

@@ -0,0 +1,3 @@
+export * from './phone-country-code.validator';
+export * from './skip-empty.validator';
+export * from './file-mimetype.validator';

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

@@ -0,0 +1,18 @@
+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/src/validators/is-exists.validator.js

@@ -0,0 +1,99 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+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());
+    });
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsExists = exports.IsExistsValidator = void 0;
+const class_validator_1 = require("class-validator");
+const typeorm_transactional_1 = require("typeorm-transactional");
+const nestjs_i18n_1 = require("nestjs-i18n");
+const common_1 = require("@nestjs/common");
+let IsExistsValidator = (() => {
+    let _classDecorators = [(0, common_1.Injectable)(), (0, class_validator_1.ValidatorConstraint)({ name: 'isExists', async: true })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var IsExistsValidator = _classThis = class {
+        constructor(dataSource) {
+            this.dataSource = dataSource;
+            this.dataSource = (0, typeorm_transactional_1.getDataSourceByName)('default');
+        }
+        validate(value, args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const [entityClass, findCondition] = args.constraints;
+                return ((yield this.dataSource.getRepository(entityClass).count({
+                    where: findCondition(args),
+                })) > 0);
+            });
+        }
+        defaultMessage(args) {
+            return (0, nestjs_i18n_1.i18nValidationMessage)('validation.IS_EXISTS')(args);
+        }
+    };
+    __setFunctionName(_classThis, "IsExistsValidator");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        IsExistsValidator = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return IsExistsValidator = _classThis;
+})();
+exports.IsExistsValidator = IsExistsValidator;
+function IsExists(constraints, validationOptions) {
+    return (object, propertyName) => {
+        (0, class_validator_1.registerDecorator)({
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            constraints,
+            validator: IsExistsValidator,
+        });
+    };
+}
+exports.IsExists = IsExists;

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

@@ -0,0 +1,60 @@
+import type {
+  ValidationArguments,
+  ValidationOptions,
+  ValidatorConstraintInterface,
+} from 'class-validator';
+import { registerDecorator, ValidatorConstraint } from 'class-validator';
+import type { EntitySchema, FindOptionsWhere, ObjectType } from 'typeorm';
+import { DataSource } from 'typeorm';
+import { getDataSourceByName } from 'typeorm-transactional';
+import { i18nValidationMessage } from 'nestjs-i18n';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+@ValidatorConstraint({ name: 'isExists', async: true })
+export class IsExistsValidator implements ValidatorConstraintInterface {
+  constructor(private readonly dataSource: DataSource) {
+    this.dataSource = getDataSourceByName('default');
+  }
+
+  public async validate<E>(
+    value: string,
+    args: IExistsValidationArguments<E>,
+  ): Promise<boolean> {
+    const [entityClass, findCondition] = args.constraints;
+
+    return (
+      (await this.dataSource.getRepository(entityClass).count({
+        where: findCondition(args),
+      })) > 0
+    );
+  }
+
+  defaultMessage(args: ValidationArguments): string {
+    return i18nValidationMessage('validation.IS_EXISTS')(args);
+  }
+}
+
+type ExistsValidationConstraints<E> = [
+  ObjectType<E> | EntitySchema<E> | string,
+  (validationArguments: ValidationArguments) => FindOptionsWhere<E>,
+];
+
+interface IExistsValidationArguments<E> extends ValidationArguments {
+  constraints: ExistsValidationConstraints<E>;
+}
+
+export function IsExists<E>(
+  constraints: Partial<ExistsValidationConstraints<E>>,
+  validationOptions?: ValidationOptions,
+): PropertyDecorator {
+  return (object, propertyName: string) => {
+    registerDecorator({
+      target: object.constructor,
+      propertyName,
+      options: validationOptions,
+      constraints,
+      validator: IsExistsValidator,
+    });
+  };
+}

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

@@ -0,0 +1,17 @@
+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/src/validators/is-unique.validator.js

@@ -0,0 +1,131 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+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());
+    });
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsUnique = exports.IsUniqueValidator = void 0;
+const class_validator_1 = require("class-validator");
+const typeorm_transactional_1 = require("typeorm-transactional");
+const nestjs_i18n_1 = require("nestjs-i18n");
+let IsUniqueValidator = (() => {
+    let _classDecorators = [(0, class_validator_1.ValidatorConstraint)({ name: 'isUnique', async: true })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var IsUniqueValidator = _classThis = class {
+        constructor(dataSource) {
+            this.dataSource = dataSource;
+            this.dataSource = (0, typeorm_transactional_1.getDataSourceByName)('default');
+        }
+        validate(value, args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const [entityClass, findCondition] = args.constraints;
+                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);
+        }
+    };
+    __setFunctionName(_classThis, "IsUniqueValidator");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        IsUniqueValidator = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return IsUniqueValidator = _classThis;
+})();
+exports.IsUniqueValidator = IsUniqueValidator;
+function IsUnique(constraints, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            constraints,
+            validator: IsUniqueValidator,
+        });
+    };
+}
+exports.IsUnique = IsUnique;

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

@@ -0,0 +1,93 @@
+import type {
+  ValidationArguments,
+  ValidationOptions,
+  ValidatorConstraintInterface,
+} from 'class-validator';
+import { registerDecorator, ValidatorConstraint } from 'class-validator';
+import {
+  DataSource,
+  EntitySchema,
+  FindOptionsWhere,
+  ObjectType,
+} from 'typeorm';
+import { getDataSourceByName } from 'typeorm-transactional';
+import { i18nValidationMessage } from 'nestjs-i18n';
+
+@ValidatorConstraint({ name: 'isUnique', async: true })
+export class IsUniqueValidator implements ValidatorConstraintInterface {
+  constructor(private readonly dataSource: DataSource) {
+    this.dataSource = getDataSourceByName('default');
+  }
+
+  public async validate<E>(
+    value: string,
+    args: IUniqueValidationArguments<E>,
+  ): Promise<boolean> {
+    const [entityClass, findCondition] = args.constraints;
+
+    let exists: boolean;
+    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 =
+        (await this.dataSource
+          .getRepository(entityClass)
+          .count({ where: defCon })) < 1;
+    } else {
+      const entities = await 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: ValidationArguments): string {
+    return i18nValidationMessage('validation.IS_UNIQUE')(args);
+  }
+}
+
+type UniqueValidationConstraints<E> = [
+  ObjectType<E> | EntitySchema<E> | string,
+  (validationArguments: ValidationArguments) => FindOptionsWhere<E>,
+];
+
+interface IUniqueValidationArguments<E> extends ValidationArguments {
+  constraints: UniqueValidationConstraints<E>;
+}
+
+export function IsUnique<E>(
+  constraints: Partial<UniqueValidationConstraints<E>>,
+  validationOptions?: ValidationOptions,
+): PropertyDecorator {
+  return function (object, propertyName: string) {
+    registerDecorator({
+      target: object.constructor,
+      propertyName,
+      options: validationOptions,
+      constraints,
+      validator: IsUniqueValidator,
+    });
+  };
+}

package/src/validators/phone-country-code.validator.d.ts

@@ -0,0 +1,2 @@
+import { ValidationOptions } from 'class-validator';
+export declare function IsPhoneNumberWithCountryCode(validationOptions?: ValidationOptions): (object: NonNullable<unknown>, propertyName: string) => void;

package/src/validators/phone-country-code.validator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsPhoneNumberWithCountryCode = void 0;
+const class_validator_1 = require("class-validator");
+function IsPhoneNumberWithCountryCode(validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.ValidateIf)((_, value) => !!value)(object, propertyName);
+        const countryCodePropertyName = 'countryCode';
+        (0, class_validator_1.registerDecorator)({
+            name: 'isPhoneNumberWithCountryCode',
+            target: object.constructor,
+            propertyName: propertyName,
+            constraints: [countryCodePropertyName],
+            options: validationOptions,
+            validator: {
+                validate(value, args) {
+                    const [countryCodePropertyName] = args.constraints;
+                    const countryCode = args.object[countryCodePropertyName];
+                    return (0, class_validator_1.isPhoneNumber)(value, countryCode);
+                },
+                defaultMessage(args) {
+                    const [countryCodePropertyName] = args.constraints;
+                    const countryCode = args.object[countryCodePropertyName];
+                    return `$property must be a valid phone number in the country code ${countryCode}`;
+                },
+            },
+        });
+    };
+}
+exports.IsPhoneNumberWithCountryCode = IsPhoneNumberWithCountryCode;

package/src/validators/phone-country-code.validator.ts

@@ -0,0 +1,36 @@
+import {
+  isPhoneNumber,
+  registerDecorator,
+  ValidateIf,
+  ValidationArguments,
+  ValidationOptions,
+} from 'class-validator';
+
+export function IsPhoneNumberWithCountryCode(
+  validationOptions?: ValidationOptions,
+) {
+  return function (object: NonNullable<unknown>, propertyName: string) {
+    ValidateIf((_, value) => !!value)(object, propertyName);
+    const countryCodePropertyName = 'countryCode';
+
+    registerDecorator({
+      name: 'isPhoneNumberWithCountryCode',
+      target: object.constructor,
+      propertyName: propertyName,
+      constraints: [countryCodePropertyName],
+      options: validationOptions,
+      validator: {
+        validate(value: any, args: ValidationArguments) {
+          const [countryCodePropertyName] = args.constraints;
+          const countryCode = args.object[countryCodePropertyName];
+          return isPhoneNumber(value, countryCode);
+        },
+        defaultMessage(args: ValidationArguments) {
+          const [countryCodePropertyName] = args.constraints;
+          const countryCode = args.object[countryCodePropertyName];
+          return `$property must be a valid phone number in the country code ${countryCode}`;
+        },
+      },
+    });
+  };
+}

package/src/validators/same-as.validator.d.ts

@@ -0,0 +1,2 @@
+import type { ValidationOptions } from 'class-validator';
+export declare function SameAs(property: string, validationOptions?: ValidationOptions): PropertyDecorator;

package/src/validators/same-as.validator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SameAs = void 0;
+const class_validator_1 = require("class-validator");
+function SameAs(property, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'sameAs',
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            constraints: [property],
+            validator: {
+                validate(value, args) {
+                    const [relatedPropertyName] = args.constraints;
+                    return (args === null || args === void 0 ? void 0 : args.object[relatedPropertyName]) === value;
+                },
+                defaultMessage() {
+                    return '$property must match $constraint1';
+                },
+            },
+        });
+    };
+}
+exports.SameAs = SameAs;