@nest-omni/core 1.0.2 → 1.0.5

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/{dist → src}/validators/phone-country-code.validator.js

@@ -28,4 +28,3 @@ function IsPhoneNumberWithCountryCode(validationOptions) {
     };
 }
 exports.IsPhoneNumberWithCountryCode = IsPhoneNumberWithCountryCode;
-//# sourceMappingURL=phone-country-code.validator.js.map

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/{dist → src}/validators/same-as.validator.js

@@ -13,7 +13,7 @@ function SameAs(property, validationOptions) {
             validator: {
                 validate(value, args) {
                     const [relatedPropertyName] = args.constraints;
-                    return args?.object[relatedPropertyName] === value;
+                    return (args === null || args === void 0 ? void 0 : args.object[relatedPropertyName]) === value;
                 },
                 defaultMessage() {
                     return '$property must match $constraint1';
@@ -23,4 +23,3 @@ function SameAs(property, validationOptions) {
     };
 }
 exports.SameAs = SameAs;
-//# sourceMappingURL=same-as.validator.js.map

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

@@ -0,0 +1,27 @@
+import type { ValidationOptions } from 'class-validator';
+import { registerDecorator } from 'class-validator';
+
+export function SameAs(
+  property: string,
+  validationOptions?: ValidationOptions,
+): PropertyDecorator {
+  return function (object, propertyName: string) {
+    registerDecorator({
+      name: 'sameAs',
+      target: object.constructor,
+      propertyName,
+      options: validationOptions,
+      constraints: [property],
+      validator: {
+        validate(value, args) {
+          const [relatedPropertyName] = args!.constraints;
+
+          return args?.object[relatedPropertyName] === value;
+        },
+        defaultMessage() {
+          return '$property must match $constraint1';
+        },
+      },
+    });
+  };
+}

package/{dist → src}/validators/skip-empty.validator.d.ts

@@ -1 +1,6 @@
+/**
+ * When the value is emtpy, validation is skipped
+ * @param field
+ * @constructor
+ */
 export declare function SkipEmpty(field?: string): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/{dist → src}/validators/skip-empty.validator.js

@@ -5,6 +5,11 @@ const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
 const lodash_1 = require("lodash");
+/**
+ * When the value is emtpy, validation is skipped
+ * @param field
+ * @constructor
+ */
 function SkipEmpty(field) {
     return (0, common_1.applyDecorators)((0, swagger_1.ApiProperty)({ required: false }), (0, class_validator_1.ValidateIf)((obj, value) => {
         if (field) {
@@ -16,4 +21,3 @@ function SkipEmpty(field) {
     }));
 }
 exports.SkipEmpty = SkipEmpty;
-//# sourceMappingURL=skip-empty.validator.js.map

package/src/validators/skip-empty.validator.ts

@@ -0,0 +1,25 @@
+import { applyDecorators } from '@nestjs/common';
+import { ApiProperty } from '@nestjs/swagger';
+import { ValidateIf } from 'class-validator';
+import { isString } from 'lodash';
+
+/**
+ * When the value is emtpy, validation is skipped
+ * @param field
+ * @constructor
+ */
+export function SkipEmpty(field?: string) {
+  return applyDecorators(
+    ApiProperty({ required: false }),
+    ValidateIf((obj, value) => {
+      if (field) {
+        value = obj[field];
+      }
+      return !(
+        value === null ||
+        value === undefined ||
+        (isString(value) && value.trim() === '')
+      );
+    }),
+  );
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "es6",
+    "sourceMap": false,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false,
+    "resolveJsonModule": true,
+  },
+  "include": [
+    "./src/**/*.ts",
+    "./src/i18n/**/*.json"
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "../../dist/libs/core"
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "test",
+    "**/*spec.ts"
+  ]
+}