@nest-omni/core 1.0.14 → 1.0.15

package/dist/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/dist/validators/is-exists.validator.js

@@ -0,0 +1,61 @@
+"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.IsExists = exports.IsExistsValidator = void 0;
+const class_validator_1 = require("class-validator");
+const typeorm_1 = require("typeorm");
+const typeorm_transactional_1 = require("typeorm-transactional");
+const nestjs_i18n_1 = require("nestjs-i18n");
+const common_1 = require("@nestjs/common");
+let IsExistsValidator = class IsExistsValidator {
+    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);
+    }
+};
+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,
+        });
+    };
+}
+exports.IsExists = IsExists;

package/dist/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/dist/validators/is-unique.validator.js

@@ -0,0 +1,92 @@
+"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.IsUnique = exports.IsUniqueValidator = void 0;
+const class_validator_1 = require("class-validator");
+const typeorm_1 = require("typeorm");
+const typeorm_transactional_1 = require("typeorm-transactional");
+const nestjs_i18n_1 = require("nestjs-i18n");
+let IsUniqueValidator = class IsUniqueValidator {
+    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);
+    }
+};
+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,
+        });
+    };
+}
+exports.IsUnique = IsUnique;

package/dist/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/dist/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/dist/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/dist/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;

package/dist/validators/skip-empty.validator.d.ts

@@ -0,0 +1 @@
+export declare function SkipEmpty(field?: string): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/dist/validators/skip-empty.validator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkipEmpty = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
+const lodash_1 = require("lodash");
+function SkipEmpty(field) {
+    return (0, common_1.applyDecorators)((0, swagger_1.ApiProperty)({ required: false }), (0, class_validator_1.ValidateIf)((obj, value) => {
+        if (field) {
+            value = obj[field];
+        }
+        return !(value === null ||
+            value === undefined ||
+            ((0, lodash_1.isString)(value) && value.trim() === ''));
+    }));
+}
+exports.SkipEmpty = SkipEmpty;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-omni/core",
-  "version": "1.0.14",
+  "version": "1.0.15",
   "description": "framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -18,22 +18,7 @@
     "typescript": "^5.4.5"
   },
   "files": [
-    "common",
-    "constants",
-    "decorators",
-    "exceptions",
-    "filters",
-    "health-checker",
-    "helpers",
-    "i18n",
-    "interceptors",
-    "interfaces",
-    "middlewares",
-    "providers",
-    "setup",
-    "shared",
-    "validators",
-    "validator-json"
+    "dist"
   ],
   "peerDependencies": {
     "@dataui/crud": "^5.3.0",