@nest-omni/core 3.1.1-9 → 3.1.2-0

package/decorators/property.decorators.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiBooleanProperty = ApiBooleanProperty;
+exports.ApiBooleanPropertyOptional = ApiBooleanPropertyOptional;
+exports.ApiUUIDProperty = ApiUUIDProperty;
+exports.ApiUUIDPropertyOptional = ApiUUIDPropertyOptional;
+exports.ApiEnumProperty = ApiEnumProperty;
+exports.ApiEnumPropertyOptional = ApiEnumPropertyOptional;
+const swagger_1 = require("@nestjs/swagger");
+const utils_1 = require("../common/utils");
+const field_decorators_1 = require("../decorators/field.decorators");
+function ApiBooleanProperty(options = {}) {
+    return (0, swagger_1.ApiProperty)(Object.assign({ type: Boolean }, options));
+}
+function ApiBooleanPropertyOptional(options = {}) {
+    return ApiBooleanProperty(Object.assign({ required: false }, options));
+}
+function ApiUUIDProperty(options = {}) {
+    return (0, swagger_1.ApiProperty)(Object.assign({ type: options.each ? [String] : String, format: 'uuid', isArray: options.each }, options));
+}
+function ApiUUIDPropertyOptional(options = {}) {
+    return ApiUUIDProperty(Object.assign({ required: false }, options));
+}
+function ApiEnumProperty(getEnum, options = {}) {
+    const enumValue = getEnum();
+    options.description = (0, field_decorators_1.getEnumDescription)(enumValue);
+    return (0, swagger_1.ApiProperty)(Object.assign({ enum: enumValue, enumName: (0, utils_1.getVariableName)(getEnum) }, options));
+}
+function ApiEnumPropertyOptional(getEnum, options = {}) {
+    return ApiEnumProperty(getEnum, Object.assign({ required: false }, options));
+}

package/decorators/public-route.decorator.d.ts

@@ -0,0 +1,3 @@
+import type { CustomDecorator } from '@nestjs/common';
+export declare const PUBLIC_ROUTE_KEY = "public_route";
+export declare const PublicRoute: (isPublic?: boolean) => CustomDecorator;

package/decorators/public-route.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicRoute = exports.PUBLIC_ROUTE_KEY = void 0;
+const common_1 = require("@nestjs/common");
+exports.PUBLIC_ROUTE_KEY = 'public_route';
+const PublicRoute = (isPublic = false) => (0, common_1.SetMetadata)(exports.PUBLIC_ROUTE_KEY, isPublic);
+exports.PublicRoute = PublicRoute;

package/decorators/swagger.schema.d.ts

@@ -0,0 +1,5 @@
+import _ from 'lodash';
+import type { IApiFile } from '../interfaces';
+export declare function ApiFile(files: _.Many<IApiFile>, options?: Partial<{
+    isRequired: boolean;
+}>): MethodDecorator;

package/decorators/swagger.schema.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiFile = ApiFile;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("@nestjs/common/constants");
+const route_paramtypes_enum_1 = require("@nestjs/common/enums/route-paramtypes.enum");
+const platform_express_1 = require("@nestjs/platform-express");
+const swagger_1 = require("@nestjs/swagger");
+const reverse_object_keys_util_1 = require("@nestjs/swagger/dist/utils/reverse-object-keys.util");
+const lodash_1 = require("lodash");
+function explore(instance, propertyKey) {
+    const types = Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, instance, propertyKey);
+    const routeArgsMetadata = Reflect.getMetadata(constants_1.ROUTE_ARGS_METADATA, instance.constructor, propertyKey) || {};
+    const parametersWithType = lodash_1.default.mapValues((0, reverse_object_keys_util_1.reverseObjectKeys)(routeArgsMetadata), (param) => ({
+        type: types[param.index],
+        name: param.data,
+        required: true,
+    }));
+    for (const [key, value] of Object.entries(parametersWithType)) {
+        const keyPair = key.split(':');
+        if (Number(keyPair[0]) === route_paramtypes_enum_1.RouteParamtypes.BODY) {
+            return value.type;
+        }
+    }
+}
+function RegisterModels() {
+    return (target, propertyKey, descriptor) => {
+        const body = explore(target, propertyKey);
+        return body && (0, swagger_1.ApiExtraModels)(body)(target, propertyKey, descriptor);
+    };
+}
+function ApiFileDecorator(files = [], options = {}) {
+    return (target, propertyKey, descriptor) => {
+        const { isRequired = false } = options;
+        const fileSchema = {
+            type: 'string',
+            format: 'binary',
+        };
+        const properties = {};
+        for (const file of files) {
+            if (file.isArray) {
+                properties[file.name] = {
+                    type: 'array',
+                    items: fileSchema,
+                };
+            }
+            else {
+                properties[file.name] = fileSchema;
+            }
+        }
+        let schema = {
+            properties,
+            type: 'object',
+        };
+        const body = explore(target, propertyKey);
+        if (body) {
+            schema = {
+                allOf: [
+                    {
+                        $ref: (0, swagger_1.getSchemaPath)(body),
+                    },
+                    { properties, type: 'object' },
+                ],
+            };
+        }
+        return (0, swagger_1.ApiBody)({
+            schema,
+            required: isRequired,
+        })(target, propertyKey, descriptor);
+    };
+}
+function ApiFile(files, options = {}) {
+    const filesArray = lodash_1.default.castArray(files);
+    const apiFileInterceptors = filesArray.map((file) => file.isArray
+        ? (0, common_1.UseInterceptors)((0, platform_express_1.FilesInterceptor)(file.name))
+        : (0, common_1.UseInterceptors)((0, platform_express_1.FileInterceptor)(file.name)));
+    return (0, common_1.applyDecorators)(RegisterModels(), (0, swagger_1.ApiConsumes)('multipart/form-data'), ApiFileDecorator(filesArray, options), ...apiFileInterceptors);
+}

package/decorators/timestamp-column.decorator.d.ts

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

package/decorators/timestamp-column.decorator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimestampColumn = TimestampColumn;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const typeorm_1 = require("typeorm");
+const helpers_1 = require("../helpers");
+function TimestampColumn(name, description) {
+    return (0, common_1.applyDecorators)((0, swagger_1.ApiProperty)({
+        required: false,
+        type: 'string',
+        format: 'date-time',
+        example: '2018-10-01 12:18:48',
+        description,
+    }), (0, typeorm_1.Column)({
+        type: 'int',
+        name,
+        nullable: false,
+        unsigned: true,
+        default: 0,
+        comment: description,
+        transformer: {
+            to: (value) => value === 0 || /\d{10}/.test(value) ? value : (0, helpers_1.strToTimeStamp)(value),
+            from: (value) => (0, helpers_1.formatDateTime)(value),
+        },
+    }));
+}

package/decorators/transform.decorators.d.ts

@@ -0,0 +1,8 @@
+export declare function Trim(): PropertyDecorator;
+export declare function ToBoolean(): PropertyDecorator;
+export declare function ToInt(): PropertyDecorator;
+export declare function ToArray(): PropertyDecorator;
+export declare function ToLowerCase(): PropertyDecorator;
+export declare function ToUpperCase(): PropertyDecorator;
+export declare function S3UrlParser(): PropertyDecorator;
+export declare function PhoneNumberSerializer(): PropertyDecorator;

package/decorators/transform.decorators.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trim = Trim;
+exports.ToBoolean = ToBoolean;
+exports.ToInt = ToInt;
+exports.ToArray = ToArray;
+exports.ToLowerCase = ToLowerCase;
+exports.ToUpperCase = ToUpperCase;
+exports.S3UrlParser = S3UrlParser;
+exports.PhoneNumberSerializer = PhoneNumberSerializer;
+const class_transformer_1 = require("class-transformer");
+const libphonenumber_js_1 = require("libphonenumber-js");
+const lodash_1 = require("lodash");
+const providers_1 = require("../providers");
+function Trim() {
+    return (0, class_transformer_1.Transform)((params) => {
+        const value = params.value;
+        if ((0, lodash_1.isArray)(value)) {
+            return (0, lodash_1.map)(value, (v) => (0, lodash_1.trim)(v).replaceAll(/\s\s+/g, ' '));
+        }
+        return (0, lodash_1.trim)(value).replaceAll(/\s\s+/g, ' ');
+    });
+}
+function ToBoolean() {
+    return (0, class_transformer_1.Transform)((params) => {
+        switch (params.value) {
+            case 'true': {
+                return true;
+            }
+            case 'false': {
+                return false;
+            }
+            default: {
+                return params.value;
+            }
+        }
+    }, { toClassOnly: true });
+}
+function ToInt() {
+    return (0, class_transformer_1.Transform)((params) => {
+        const value = params.value;
+        return Number.parseInt(value, 10);
+    }, { toClassOnly: true });
+}
+function ToArray() {
+    return (0, class_transformer_1.Transform)((params) => {
+        const value = params.value;
+        if (!value) {
+            return value;
+        }
+        return (0, lodash_1.castArray)(value);
+    }, { toClassOnly: true });
+}
+function ToLowerCase() {
+    return (0, class_transformer_1.Transform)((params) => {
+        const value = params.value;
+        if (!value) {
+            return;
+        }
+        if (!Array.isArray(value)) {
+            return value.toLowerCase();
+        }
+        return value.map((v) => v.toLowerCase());
+    }, {
+        toClassOnly: true,
+    });
+}
+function ToUpperCase() {
+    return (0, class_transformer_1.Transform)((params) => {
+        const value = params.value;
+        if (!value) {
+            return;
+        }
+        if (!Array.isArray(value)) {
+            return value.toUpperCase();
+        }
+        return value.map((v) => v.toUpperCase());
+    }, {
+        toClassOnly: true,
+    });
+}
+function S3UrlParser() {
+    return (0, class_transformer_1.Transform)((params) => {
+        const key = params.value;
+        switch (params.type) {
+            case class_transformer_1.TransformationType.CLASS_TO_PLAIN: {
+                return providers_1.GeneratorProvider.getS3PublicUrl(key);
+            }
+            case class_transformer_1.TransformationType.PLAIN_TO_CLASS: {
+                return providers_1.GeneratorProvider.getS3Key(key);
+            }
+            default: {
+                return key;
+            }
+        }
+    });
+}
+function PhoneNumberSerializer() {
+    return (0, class_transformer_1.Transform)((params) => (0, libphonenumber_js_1.parsePhoneNumber)(params.value).number);
+}

package/decorators/translate.decorator.d.ts

@@ -0,0 +1,5 @@
+import type { ITranslationDecoratorInterface } from '../interfaces';
+export declare const STATIC_TRANSLATION_DECORATOR_KEY = "custom:static-translate";
+export declare const DYNAMIC_TRANSLATION_DECORATOR_KEY = "custom:dynamic-translate";
+export declare function StaticTranslate(data?: ITranslationDecoratorInterface): PropertyDecorator;
+export declare function DynamicTranslate(): PropertyDecorator;

package/decorators/translate.decorator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DYNAMIC_TRANSLATION_DECORATOR_KEY = exports.STATIC_TRANSLATION_DECORATOR_KEY = void 0;
+exports.StaticTranslate = StaticTranslate;
+exports.DynamicTranslate = DynamicTranslate;
+exports.STATIC_TRANSLATION_DECORATOR_KEY = 'custom:static-translate';
+exports.DYNAMIC_TRANSLATION_DECORATOR_KEY = 'custom:dynamic-translate';
+function StaticTranslate(data = {}) {
+    return (target, key) => {
+        Reflect.defineMetadata(exports.STATIC_TRANSLATION_DECORATOR_KEY, data, target, key);
+    };
+}
+function DynamicTranslate() {
+    return (target, key) => {
+        Reflect.defineMetadata(exports.DYNAMIC_TRANSLATION_DECORATOR_KEY, {}, target, key);
+    };
+}

package/decorators/use-dto.decorator.d.ts

@@ -0,0 +1,4 @@
+import type { AbstractEntity } from '../common/abstract.entity';
+import type { AbstractDto } from '../common/dto/abstract.dto';
+import type { Constructor } from '../common/types';
+export declare function UseDto(dtoClass: Constructor<AbstractDto, [AbstractEntity, unknown]>): ClassDecorator;

package/decorators/use-dto.decorator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseDto = UseDto;
+function UseDto(dtoClass) {
+    return (ctor) => {
+        ctor.prototype.dtoClass = dtoClass;
+    };
+}

package/decorators/user-check.decorator.d.ts

@@ -0,0 +1,6 @@
+export interface IUser {
+    uid: number;
+    username: string;
+}
+export declare const User: (...dataOrPipes: (string | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare function getUserData(req: any, data?: string): IUser | null;

package/decorators/user-check.decorator.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+exports.getUserData = getUserData;
+const common_1 = require("@nestjs/common");
+const lodash = require("lodash");
+exports.User = (0, common_1.createParamDecorator)((data, ctx) => {
+    return getUserData(ctx.switchToHttp().getRequest(), data);
+});
+function getUserData(req, data) {
+    const headers = req.headers;
+    if (lodash.isEmpty(headers['x-user-id']) ||
+        lodash.isEmpty(headers['x-username'])) {
+        return null;
+    }
+    const user = {
+        uid: headers['x-user-id'],
+        username: headers['x-username'],
+    };
+    return data ? user[data] : user;
+}

package/decorators/user.decorator.d.ts

@@ -0,0 +1,12 @@
+export interface IUser {
+    uid: string;
+    username: string;
+    tenantId: string;
+    appId: string;
+    admin: boolean;
+    role: string;
+}
+export declare const User: (...dataOrPipes: (import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>> | keyof IUser)[]) => ParameterDecorator;
+export declare function getOmniAuthData<T extends keyof IUser>(request: {
+    headers: Record<string, string>;
+}, key?: T): IUser[T] | IUser;

package/decorators/user.decorator.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+exports.getOmniAuthData = getOmniAuthData;
+const common_1 = require("@nestjs/common");
+const lodash_1 = require("lodash");
+const config_1 = require("@nestjs/config");
+const providers_1 = require("../providers");
+exports.User = (0, common_1.createParamDecorator)((key) => {
+    const authUser = providers_1.ContextProvider.getAuthUser();
+    return key ? authUser[key] : authUser;
+});
+function getOmniAuthData(request, key) {
+    const headers = request.headers;
+    let user;
+    const configService = new config_1.ConfigService(request);
+    if ((0, lodash_1.isEmpty)(headers['x-user-id']) && (0, lodash_1.isEmpty)(headers['x-app-id'])) {
+        if (process.env.NODE_ENV === 'dev' || process.env.MOCK_ENABLED === 'true') {
+            user = {
+                uid: configService.get('MOCK_UID'),
+                username: configService.get('MOCK_USERNAME'),
+                appId: configService.get('MOCK_APP_ID'),
+                tenantId: configService.get('MOCK_TENANT_ID'),
+                admin: configService.get('MOCK_ADMIN', false),
+                role: configService.get('MOCK_ROLE', ''),
+            };
+        }
+        else {
+            console.debug('User information is not transparently transmitted through the gateway: ' +
+                JSON.stringify(headers));
+        }
+    }
+    else {
+        user = {
+            uid: headers['x-user-id'] || '',
+            username: headers['x-username'] || '',
+            appId: headers['x-app-id'] || '',
+            tenantId: headers['x-tenant-id'] || '',
+            admin: headers['x-admin'] === '1',
+            role: headers['x-role'] || '',
+        };
+    }
+    return key ? user[key] : user;
+}

package/decorators/user_auth.decorator.d.ts

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

package/decorators/user_auth.decorator.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserFilter = UserFilter;
+const common_1 = require("@nestjs/common");
+const crud_1 = require("@dataui/crud");
+const user_decorator_1 = require("./user.decorator");
+function UserFilter(field) {
+    const obj = {};
+    return (0, common_1.applyDecorators)((0, crud_1.CrudAuth)({
+        filter: (req) => {
+            obj[field] = (0, user_decorator_1.getOmniAuthData)(req, 'uid');
+            return obj;
+        },
+    }));
+}

package/decorators/validator.decorators.d.ts

@@ -0,0 +1,18 @@
+import type { ValidationOptions } from 'class-validator';
+import { IsPhoneNumber as isPhoneNumber, ValidationArguments, ValidatorConstraintInterface } from 'class-validator';
+export declare function IsPassword(validationOptions?: ValidationOptions): PropertyDecorator;
+export declare function IsPhoneNumber(validationOptions?: ValidationOptions & {
+    region?: Parameters<typeof isPhoneNumber>[0];
+}): PropertyDecorator;
+export declare function IsTmpKey(validationOptions?: ValidationOptions): PropertyDecorator;
+export declare function IsUndefinable(options?: ValidationOptions): PropertyDecorator;
+export declare function IsEmptyable(options?: ValidationOptions): PropertyDecorator;
+export declare function IsNullable(options?: ValidationOptions): PropertyDecorator;
+export declare function IsHttpUrl(validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare class AtLeastOneFieldConstraint implements ValidatorConstraintInterface {
+    validate(value: any, args: ValidationArguments): boolean;
+    defaultMessage(args: ValidationArguments): string;
+}
+export declare function AtLeastOneField(properties: string[], validationOptions?: ValidationOptions): PropertyDecorator;
+export declare function CustomValidation<T = any>(validationCallback: (value: T, args: ValidationArguments) => boolean | Promise<boolean>, validationOptions?: ValidationOptions): PropertyDecorator;
+export declare function CustomValidationMethod(methodName: string, validationOptions?: ValidationOptions): PropertyDecorator;

package/decorators/validator.decorators.js

@@ -0,0 +1,193 @@
+"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 __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.AtLeastOneFieldConstraint = void 0;
+exports.IsPassword = IsPassword;
+exports.IsPhoneNumber = IsPhoneNumber;
+exports.IsTmpKey = IsTmpKey;
+exports.IsUndefinable = IsUndefinable;
+exports.IsEmptyable = IsEmptyable;
+exports.IsNullable = IsNullable;
+exports.IsHttpUrl = IsHttpUrl;
+exports.AtLeastOneField = AtLeastOneField;
+exports.CustomValidation = CustomValidation;
+exports.CustomValidationMethod = CustomValidationMethod;
+const class_validator_1 = require("class-validator");
+const lodash_1 = require("lodash");
+const nestjs_i18n_1 = require("nestjs-i18n");
+function IsPassword(validationOptions) {
+    return (object, propertyName) => {
+        (0, class_validator_1.registerDecorator)({
+            propertyName,
+            name: 'isPassword',
+            target: object.constructor,
+            constraints: [],
+            options: validationOptions,
+            validator: {
+                validate(value) {
+                    return /^[\d!#$%&*@A-Z^a-z]*$/.test(value);
+                },
+            },
+        });
+    };
+}
+function IsPhoneNumber(validationOptions) {
+    return (0, class_validator_1.IsPhoneNumber)(validationOptions === null || validationOptions === void 0 ? void 0 : validationOptions.region, Object.assign({ message: 'error.phoneNumber' }, validationOptions));
+}
+function IsTmpKey(validationOptions) {
+    return (object, propertyName) => {
+        (0, class_validator_1.registerDecorator)({
+            propertyName,
+            name: 'tmpKey',
+            target: object.constructor,
+            options: validationOptions,
+            validator: {
+                validate(value) {
+                    return (0, lodash_1.isString)(value) && /^tmp\//.test(value);
+                },
+                defaultMessage() {
+                    return 'error.invalidTmpKey';
+                },
+            },
+        });
+    };
+}
+function IsUndefinable(options) {
+    return (0, class_validator_1.ValidateIf)((obj, value) => value !== undefined, options);
+}
+function IsEmptyable(options) {
+    return (0, class_validator_1.ValidateIf)((obj, value) => !(value === null ||
+        value === undefined ||
+        ((0, lodash_1.isString)(value) && value.trim() === '')), options);
+}
+function IsNullable(options) {
+    return (0, class_validator_1.ValidateIf)((obj, value) => value !== null, options);
+}
+function IsHttpUrl(validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'isHttpUrl',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value) {
+                    const httpUrlPattern = /^(https?:\/\/)/i;
+                    return typeof value === 'string' && httpUrlPattern.test(value);
+                },
+                defaultMessage() {
+                    return 'URL must start with http:// or https://';
+                },
+            },
+        });
+    };
+}
+let AtLeastOneFieldConstraint = class AtLeastOneFieldConstraint {
+    validate(value, args) {
+        const object = args.object;
+        const [requiredProperties] = args.constraints;
+        return requiredProperties.some((property) => {
+            const propValue = object[property];
+            return (propValue !== null &&
+                propValue !== undefined &&
+                propValue !== '' &&
+                !(Array.isArray(propValue) && propValue.length === 0));
+        });
+    }
+    defaultMessage(args) {
+        const [requiredProperties] = args.constraints;
+        return `At least one of the following fields must be provided: ${requiredProperties.join(', ')}`;
+    }
+};
+exports.AtLeastOneFieldConstraint = AtLeastOneFieldConstraint;
+exports.AtLeastOneFieldConstraint = AtLeastOneFieldConstraint = __decorate([
+    (0, class_validator_1.ValidatorConstraint)({ name: 'atLeastOneField', async: false })
+], AtLeastOneFieldConstraint);
+function AtLeastOneField(properties, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            target: object.constructor,
+            propertyName: propertyName,
+            options: Object.assign({ message: (0, nestjs_i18n_1.i18nValidationMessage)('validation.AT_LEAST_ONE_FIELD', {
+                    properties: properties.join(', '),
+                }) }, validationOptions),
+            constraints: [properties],
+            validator: AtLeastOneFieldConstraint,
+        });
+    };
+}
+function CustomValidation(validationCallback, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'customValidation',
+            target: object.constructor,
+            propertyName,
+            options: Object.assign({ message: (0, nestjs_i18n_1.i18nValidationMessage)('validation.CUSTOM_VALIDATION') }, validationOptions),
+            validator: {
+                validate(value, args) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        try {
+                            return yield validationCallback(value, args);
+                        }
+                        catch (error) {
+                            console.error('CustomValidation error:', error);
+                            return false;
+                        }
+                    });
+                },
+                defaultMessage(args) {
+                    return `Validation failed for ${args.property}`;
+                },
+            },
+        });
+    };
+}
+function CustomValidationMethod(methodName, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            name: 'customValidationMethod',
+            target: object.constructor,
+            propertyName,
+            constraints: [methodName],
+            options: Object.assign({ message: (0, nestjs_i18n_1.i18nValidationMessage)('validation.CUSTOM_VALIDATION_METHOD') }, validationOptions),
+            validator: {
+                validate(value, args) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const [method] = args.constraints;
+                        const object = args.object;
+                        if (typeof object[method] !== 'function') {
+                            console.error(`CustomValidationMethod: Method '${method}' not found on object`);
+                            return false;
+                        }
+                        try {
+                            const result = yield object[method](value, args);
+                            return Boolean(result);
+                        }
+                        catch (error) {
+                            console.error(`CustomValidationMethod error in '${method}':`, error);
+                            return false;
+                        }
+                    });
+                },
+                defaultMessage(args) {
+                    const [method] = args.constraints;
+                    return `Validation failed for ${args.property} using method ${method}`;
+                },
+            },
+        });
+    };
+}

package/exceptions/file-not-image.exception.d.ts

@@ -0,0 +1,4 @@
+import { BadRequestException } from '@nestjs/common';
+export declare class FileNotImageException extends BadRequestException {
+    constructor(error?: string);
+}

package/exceptions/file-not-image.exception.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileNotImageException = void 0;
+const common_1 = require("@nestjs/common");
+class FileNotImageException extends common_1.BadRequestException {
+    constructor(error) {
+        super('error.fileNotImage', error);
+    }
+}
+exports.FileNotImageException = FileNotImageException;

package/exceptions/index.d.ts

@@ -0,0 +1,2 @@
+export * from './file-not-image.exception';
+export * from './user-not-found.exception';