@mondart/nestjs-common-module 2.5.0 → 2.6.5

package/dist/decorators/iam-context.decorator.d.ts

@@ -1 +1,3 @@
+import { IamContextDto } from '../dto/response/iam-context.dto';
 export declare const IamContext: (...dataOrPipes: unknown[]) => ParameterDecorator;
+export declare const getIamContext: (request: any) => IamContextDto;

package/dist/decorators/iam-context.decorator.js

@@ -1,44 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IamContext = void 0;
+exports.getIamContext = exports.IamContext = void 0;
 const common_1 = require("@nestjs/common");
 const crypto_1 = require("crypto");
 const iam_context_dto_1 = require("../dto/response/iam-context.dto");
 exports.IamContext = (0, common_1.createParamDecorator)((data, ctx) => {
     const request = ctx.switchToHttp().getRequest();
-    const iam = new iam_context_dto_1.IamContextDto();
+    return (0, exports.getIamContext)(request);
+});
+const getIamContext = (request) => {
     const injectedPayload = request?.headers?.['injectedpayload'];
-    iam.ip =
-        request?.headers['x-forwarded-for'] ||
-            request?.socket?.remoteAddress ||
-            null;
-    iam.requestId = request?.headers['request-id'] ?? (0, crypto_1.randomUUID)();
-    iam.timestamp = new Date(request?.headers?.['timestamp']);
+    const ip = request?.headers['x-forwarded-for'] ||
+        request?.socket?.remoteAddress ||
+        null;
+    const requestId = request?.headers['request-id'] ?? (0, crypto_1.randomUUID)();
+    const timestamp = new Date(request?.headers?.['timestamp']);
+    let isAgent = false;
+    let user;
+    let agent;
     if (injectedPayload) {
         const data = JSON.parse(injectedPayload);
         const token = request?.headers?.['authorization'];
         if (data) {
             if (!data?.is_agent && (data?.contact_id || data?.store_id)) {
-                iam.user = {
+                user = {
                     userId: data?.sub,
                     contactId: data?.contact_id,
                     storeId: data?.store_id,
                     token,
                 };
-                iam.userId = data?.sub;
             }
             else if (data?.is_agent) {
-                iam.agent = {
+                isAgent = true;
+                agent = {
                     agentId: data?.sub,
-                    isAgent: data?.is_agent,
                     storeIds: data?.store_ids,
                     groupsMembership: data?.groups_membership,
                     token,
                 };
-                iam.agentId = data?.sub;
             }
         }
         delete request?.headers?.['authorization'];
     }
-    return iam;
-});
+    return new iam_context_dto_1.IamContextDto({
+        ip,
+        requestId,
+        timestamp,
+        isAgent,
+        user,
+        agent,
+    });
+};
+exports.getIamContext = getIamContext;

package/dist/dto/response/iam-context.dto.d.ts

@@ -1,13 +1,12 @@
-import { GetUserInterface } from '../../interfaces/get-user.interface';
-import { GetAgentInterface } from '../../interfaces/get-agent.interface';
+import { GetUserInterface, GetAgentInterface } from '../../interfaces';
 export declare class IamContextDto {
     timestamp: Date;
     requestId: string;
     ip?: string;
+    agentId: string;
     user?: GetUserInterface;
     userId: string;
-    contactId: number;
     agent?: GetAgentInterface;
-    agentId: string;
-    constructor(init?: Partial<any>);
+    isAgent?: boolean;
+    constructor(init?: Partial<Omit<IamContextDto, 'agentId' | 'userId'>>);
 }

package/dist/dto/response/iam-context.dto.js

@@ -16,14 +16,10 @@ const crypto_1 = require("crypto");
 class IamContextDto {
     constructor(init) {
         this.ip = init?.ip;
+        this.agentId = init?.agent ? init?.agent?.agentId : undefined;
         this.agent = init?.agent;
-        if (init?.agent?.agentId)
-            this.agentId = init?.agent?.agentId;
+        this.userId = init?.user ? init?.user?.userId : undefined;
         this.user = init?.user;
-        if (init?.user?.contactId)
-            this.contactId = init?.user?.contactId;
-        if (init?.user?.userId)
-            this.userId = init?.user?.userId;
         this.requestId = init?.requestId ?? (0, crypto_1.randomUUID)();
         this.timestamp = init?.timestamp ?? new Date();
     }
@@ -44,6 +40,11 @@ __decorate([
     (0, class_validator_1.IsString)(),
     __metadata("design:type", String)
 ], IamContextDto.prototype, "ip", void 0);
+__decorate([
+    (0, swagger_1.ApiResponseProperty)({ type: String }),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], IamContextDto.prototype, "agentId", void 0);
 __decorate([
     (0, swagger_1.ApiResponseProperty)({ type: Object }),
     (0, class_validator_1.IsObject)(),
@@ -54,18 +55,12 @@ __decorate([
     (0, class_validator_1.IsString)(),
     __metadata("design:type", String)
 ], IamContextDto.prototype, "userId", void 0);
-__decorate([
-    (0, swagger_1.ApiResponseProperty)({ type: Number }),
-    (0, class_validator_1.IsNumber)(),
-    __metadata("design:type", Number)
-], IamContextDto.prototype, "contactId", void 0);
 __decorate([
     (0, swagger_1.ApiResponseProperty)({ type: Object }),
     (0, class_validator_1.IsObject)(),
     __metadata("design:type", Object)
 ], IamContextDto.prototype, "agent", void 0);
 __decorate([
-    (0, swagger_1.ApiResponseProperty)({ type: String }),
-    (0, class_validator_1.IsString)(),
-    __metadata("design:type", String)
-], IamContextDto.prototype, "agentId", void 0);
+    (0, swagger_1.ApiResponseProperty)({ type: Boolean }),
+    __metadata("design:type", Boolean)
+], IamContextDto.prototype, "isAgent", void 0);

package/dist/interfaces/get-agent.interface.d.ts

@@ -1,6 +1,5 @@
 export interface GetAgentInterface {
     agentId?: string;
-    isAgent?: boolean;
     storeIds?: number[];
     groupsMembership?: string[];
     token?: string;

package/dist/lib/captcha/captcha.decorator.d.ts

@@ -0,0 +1,4 @@
+import { CaptchaDecorators } from './enums/captcha-decorators.enum';
+export declare const Captcha: (params: {
+    executeAfter: number;
+}) => import("@nestjs/common").CustomDecorator<CaptchaDecorators>;

package/dist/lib/captcha/captcha.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Captcha = void 0;
+const common_1 = require("@nestjs/common");
+const captcha_decorators_enum_1 = require("./enums/captcha-decorators.enum");
+const Captcha = (params) => (0, common_1.SetMetadata)(captcha_decorators_enum_1.CaptchaDecorators.CAPTCHA, params);
+exports.Captcha = Captcha;

package/dist/lib/captcha/captcha.exception.d.ts

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

package/dist/lib/captcha/captcha.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidCaptcha = void 0;
+const common_1 = require("@nestjs/common");
+const captcha_messages_enum_1 = require("./enums/captcha-messages.enum");
+class InvalidCaptcha extends common_1.UnauthorizedException {
+    constructor(cause) {
+        super(captcha_messages_enum_1.CaptchaErrors.INVALID_CAPTCHA, { cause });
+    }
+}
+exports.InvalidCaptcha = InvalidCaptcha;

package/dist/lib/captcha/captcha.guard.d.ts

@@ -0,0 +1,16 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { CaptchaModuleOptions, IGoogleResponse } from './captcha.interface';
+import { RequestService } from '../request';
+import { Reflector } from '@nestjs/core';
+import { CachingService } from '../caching';
+export declare class CaptchaGuard implements CanActivate {
+    private reflector;
+    private captchaModuleOptions;
+    private readonly requestService;
+    private readonly cachingService;
+    constructor(reflector: Reflector, captchaModuleOptions: CaptchaModuleOptions, requestService: RequestService<IGoogleResponse>, cachingService: CachingService);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+    private getCaptchaDetails;
+    private incExecutionTimes;
+    private isCaptchaValid;
+}

package/dist/lib/captcha/captcha.guard.js

@@ -0,0 +1,83 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaptchaGuard = void 0;
+const common_1 = require("@nestjs/common");
+const captcha_interface_1 = require("./captcha.interface");
+const request_1 = require("../request");
+const core_1 = require("@nestjs/core");
+const captcha_decorators_enum_1 = require("./enums/captcha-decorators.enum");
+const captcha_exception_1 = require("./captcha.exception");
+const request_2 = require("../request");
+const caching_1 = require("../caching");
+const decorators_1 = require("../../decorators");
+let CaptchaGuard = class CaptchaGuard {
+    constructor(reflector, captchaModuleOptions, requestService, cachingService) {
+        this.reflector = reflector;
+        this.captchaModuleOptions = captchaModuleOptions;
+        this.requestService = requestService;
+        this.cachingService = cachingService;
+    }
+    async canActivate(context) {
+        const captchaSettings = this.getCaptchaDetails(context);
+        const request = context.switchToHttp().getRequest();
+        const iamContext = (0, decorators_1.getIamContext)(request);
+        if (iamContext?.agentId || iamContext?.userId)
+            return true;
+        if (captchaSettings && captchaSettings.executeAfter) {
+            const ip = request.headers['x-forwarded-for'] || request.socket.remoteAddress;
+            const result = await this.incExecutionTimes(ip, captchaSettings.executeAfter);
+            if (result)
+                return true;
+        }
+        const text = request.headers['captcha-token'];
+        if (!text)
+            throw new captcha_exception_1.InvalidCaptcha();
+        await this.isCaptchaValid(text);
+        return true;
+    }
+    getCaptchaDetails(context) {
+        const captchaDetailsForEndpoint = this.reflector.get(captcha_decorators_enum_1.CaptchaDecorators.CAPTCHA, context.getHandler());
+        const captchaDetailsForController = this.reflector.get(captcha_decorators_enum_1.CaptchaDecorators.CAPTCHA, context.getClass());
+        return captchaDetailsForEndpoint || captchaDetailsForController;
+    }
+    async incExecutionTimes(ip, executionCount) {
+        const cacheKey = `captcha-execution-count-${ip}`;
+        const executionTimes = await this.cachingService.get(cacheKey);
+        if (executionTimes < executionCount) {
+            await this.cachingService.set(cacheKey, (executionTimes || 0) + 1, this.captchaModuleOptions.executionAfterTtlSeconds);
+            return true;
+        }
+    }
+    async isCaptchaValid(text) {
+        const params = new URLSearchParams();
+        params.append('secret', this.captchaModuleOptions.secret);
+        params.append('response', text);
+        const result = await this.requestService.send({
+            path: this.captchaModuleOptions.verifyUrl,
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            params: params.toString(),
+            method: request_2.HttpMethods.POST,
+        });
+        if (!result.success)
+            throw new captcha_exception_1.InvalidCaptcha(result?.['error-codes']?.join(', '));
+    }
+};
+exports.CaptchaGuard = CaptchaGuard;
+exports.CaptchaGuard = CaptchaGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)(captcha_interface_1.CAPTCHA_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [core_1.Reflector, Object, request_1.RequestService,
+        caching_1.CachingService])
+], CaptchaGuard);

package/dist/lib/captcha/captcha.interface.d.ts

@@ -0,0 +1,26 @@
+import { ModuleMetadata, Type } from '@nestjs/common';
+export declare const CAPTCHA_MODULE_OPTIONS = "CAPTCHA_MODULE_OPTIONS";
+export interface CaptchaModuleOptions {
+    secret: string;
+    verifyUrl: string;
+    executionAfterTtlSeconds: number;
+}
+export interface CaptchaModuleFactory {
+    createModuleOptions: () => Promise<CaptchaModuleOptions> | CaptchaModuleOptions;
+}
+export interface CaptchaModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    inject?: any[];
+    useClass?: Type<CaptchaModuleFactory>;
+    useExisting?: Type<CaptchaModuleFactory>;
+    useFactory?: (...args: any[]) => Promise<CaptchaModuleOptions> | CaptchaModuleOptions;
+}
+export interface IGoogleResponse {
+    success: boolean;
+    challenge_ts: Date;
+    hostname?: string;
+    apk_package_name?: string;
+    error_codes: Array<string>;
+}
+export interface ICaptchaSettings {
+    executeAfter: number;
+}

package/dist/lib/captcha/captcha.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAPTCHA_MODULE_OPTIONS = void 0;
+exports.CAPTCHA_MODULE_OPTIONS = 'CAPTCHA_MODULE_OPTIONS';

package/dist/lib/captcha/captcha.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { CaptchaModuleAsyncOptions, CaptchaModuleOptions } from './captcha.interface';
+export declare class CaptchaModule {
+    static register(options: CaptchaModuleOptions): DynamicModule;
+    static registerAsync(options: CaptchaModuleAsyncOptions): DynamicModule;
+    private static createAsyncOptionsProvider;
+    private static createAsyncProviders;
+}

package/dist/lib/captcha/captcha.module.js

@@ -0,0 +1,97 @@
+"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 CaptchaModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaptchaModule = void 0;
+const common_1 = require("@nestjs/common");
+const captcha_interface_1 = require("./captcha.interface");
+const core_1 = require("@nestjs/core");
+const captcha_guard_1 = require("./captcha.guard");
+const request_1 = require("../request");
+let CaptchaModule = CaptchaModule_1 = class CaptchaModule {
+    static register(options) {
+        return {
+            module: CaptchaModule_1,
+            imports: [request_1.RequestModule],
+            providers: [
+                {
+                    provide: core_1.APP_GUARD,
+                    useClass: captcha_guard_1.CaptchaGuard,
+                },
+                {
+                    provide: captcha_interface_1.CAPTCHA_MODULE_OPTIONS,
+                    useValue: options,
+                },
+            ],
+            controllers: [],
+            exports: [],
+        };
+    }
+    static registerAsync(options) {
+        const asyncOptionsProvider = this.createAsyncOptionsProvider(options);
+        return {
+            module: CaptchaModule_1,
+            imports: [...(options.imports || []), asyncOptionsProvider],
+            providers: [],
+            controllers: [],
+            exports: [],
+        };
+    }
+    static createAsyncOptionsProvider(options) {
+        const providers = this.createAsyncProviders(options);
+        return {
+            module: CaptchaModule_1,
+            imports: [request_1.RequestModule],
+            providers,
+            exports: [captcha_interface_1.CAPTCHA_MODULE_OPTIONS],
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: core_1.APP_GUARD,
+                    useClass: captcha_guard_1.CaptchaGuard,
+                },
+                {
+                    provide: captcha_interface_1.CAPTCHA_MODULE_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                },
+            ];
+        }
+        const useClass = options.useClass || options.useExisting;
+        if (useClass) {
+            return [
+                {
+                    provide: captcha_interface_1.CAPTCHA_MODULE_OPTIONS,
+                    useFactory: async (optionsFactory) => await optionsFactory.createModuleOptions(),
+                    inject: [options.useExisting || options.useClass],
+                },
+                {
+                    provide: core_1.APP_GUARD,
+                    useClass: captcha_guard_1.CaptchaGuard,
+                },
+                ...(options.useClass
+                    ? [
+                        {
+                            provide: options.useClass,
+                            useClass: options.useClass,
+                        },
+                    ]
+                    : []),
+            ];
+        }
+        throw new Error('Invalid CaptchaModuleAsyncOptions');
+    }
+};
+exports.CaptchaModule = CaptchaModule;
+exports.CaptchaModule = CaptchaModule = CaptchaModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], CaptchaModule);

package/dist/lib/captcha/enums/captcha-decorators.enum.d.ts

@@ -0,0 +1,3 @@
+export declare enum CaptchaDecorators {
+    CAPTCHA = "captcha"
+}

package/dist/lib/captcha/enums/captcha-decorators.enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaptchaDecorators = void 0;
+var CaptchaDecorators;
+(function (CaptchaDecorators) {
+    CaptchaDecorators["CAPTCHA"] = "captcha";
+})(CaptchaDecorators || (exports.CaptchaDecorators = CaptchaDecorators = {}));

package/dist/lib/captcha/enums/captcha-messages.enum.d.ts

@@ -0,0 +1,3 @@
+export declare enum CaptchaErrors {
+    INVALID_CAPTCHA = "captcha.INVALID_CAPTCHA"
+}

package/dist/lib/captcha/enums/captcha-messages.enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaptchaErrors = void 0;
+var CaptchaErrors;
+(function (CaptchaErrors) {
+    CaptchaErrors["INVALID_CAPTCHA"] = "captcha.INVALID_CAPTCHA";
+})(CaptchaErrors || (exports.CaptchaErrors = CaptchaErrors = {}));

package/dist/lib/captcha/index.d.ts

@@ -0,0 +1,5 @@
+import { CAPTCHA_MODULE_OPTIONS } from './captcha.interface';
+import { CaptchaModule } from './captcha.module';
+import { CaptchaModuleOptions } from './captcha.interface';
+import { CaptchaGuard } from './captcha.guard';
+export { CaptchaGuard, CaptchaModule, CAPTCHA_MODULE_OPTIONS, CaptchaModuleOptions, };

package/dist/lib/captcha/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAPTCHA_MODULE_OPTIONS = exports.CaptchaModule = exports.CaptchaGuard = void 0;
+const captcha_interface_1 = require("./captcha.interface");
+Object.defineProperty(exports, "CAPTCHA_MODULE_OPTIONS", { enumerable: true, get: function () { return captcha_interface_1.CAPTCHA_MODULE_OPTIONS; } });
+const captcha_module_1 = require("./captcha.module");
+Object.defineProperty(exports, "CaptchaModule", { enumerable: true, get: function () { return captcha_module_1.CaptchaModule; } });
+const captcha_guard_1 = require("./captcha.guard");
+Object.defineProperty(exports, "CaptchaGuard", { enumerable: true, get: function () { return captcha_guard_1.CaptchaGuard; } });

package/dist/lib/core-crud/controllers/core-crud.controller.js

@@ -11,39 +11,42 @@ class CoreCrudController {
         CoreCrudController.responseDto = responseDto;
     }
     async findAllWithPagination(query, paginateConfig, options, ...args) {
-        const response = await this.coreService.findAllWithPagination(query, paginateConfig, options);
+        const response = await this.coreService.findAllWithPagination(query, paginateConfig, options, ...args);
         if (!response)
             throw new common_1.NotFoundException(enums_1.SharedMessages.FETCH_FAILED);
         const serializedData = response.data.map((item) => new this.responseDto(item));
-        return new dto_1.SuccessResponse(serializedData, enums_1.SharedMessages.SUCCESSFUL, common_1.HttpStatus.OK, { ...response.meta, links: response.links });
+        return new dto_1.SuccessResponse(serializedData, enums_1.SharedMessages.SUCCESSFUL, common_1.HttpStatus.OK, {
+            ...response.meta,
+            links: response.links,
+        });
     }
     async findOneById(id, options, ...args) {
-        const response = await this.coreService.findOneById(id, options);
+        const response = await this.coreService.findOneById(id, options, ...args);
         if (!response)
             throw new common_1.NotFoundException(enums_1.SharedMessages.RESOURCE_NOT_FOUND);
         return new dto_1.SuccessResponse(new this.responseDto(response), enums_1.SharedMessages.SUCCESSFUL, common_1.HttpStatus.OK);
     }
     async create(createDto, options, ...args) {
-        const response = await this.coreService.create(createDto, options);
+        const response = await this.coreService.create(createDto, options, ...args);
         if (!response)
             throw new common_1.BadRequestException(enums_1.SharedMessages.CREATE_FAILED);
         return new dto_1.SuccessResponse(new this.responseDto(response), enums_1.SharedMessages.SUCCESSFUL, common_1.HttpStatus.CREATED);
     }
     async update({ id }, updateDto, options, ...args) {
-        const response = await this.coreService.update(id, updateDto, options);
+        const response = await this.coreService.update(id, updateDto, options, ...args);
         if (!response)
             throw new common_1.BadRequestException(enums_1.SharedMessages.UPDATE_FAILED);
         const foundItem = await this.coreService.findOneById(id, options);
         return new dto_1.SuccessResponse(new this.responseDto(foundItem), enums_1.SharedMessages.SUCCESSFUL, common_1.HttpStatus.OK);
     }
     async deleteById({ id }, options, ...args) {
-        const result = await this.coreService.deleteById(id, options);
+        const result = await this.coreService.deleteById(id, options, ...args);
         if (!result)
             throw new common_1.BadRequestException(enums_1.SharedMessages.DELETE_FAILED);
         return new dto_1.SuccessResponse(undefined, enums_1.SharedMessages.SUCCESSFUL, common_1.HttpStatus.OK);
     }
     async softDeleteById({ id }, options, ...args) {
-        const result = await this.coreService.softDeleteById(id, options);
+        const result = await this.coreService.softDeleteById(id, options, ...args);
         if (!result)
             throw new common_1.BadRequestException(enums_1.SharedMessages.DELETE_FAILED);
         return new dto_1.SuccessResponse(undefined, enums_1.SharedMessages.SUCCESSFUL, common_1.HttpStatus.OK);

package/dist/lib/core-crud/services/core-crud.service.d.ts

@@ -11,22 +11,22 @@ export declare abstract class CoreCrudService<T extends BaseModelEntity, CreateD
     protected readonly repository: Repository<T>;
     private readonly relationsPath;
     protected constructor(repository: Repository<T>);
-    create(createDto: CreateDto, options?: CoreBaseServiceOption): Promise<T>;
-    update(id: number, updateDto: Partial<UpdateDto> | DeepPartial<T> | QueryDeepPartialEntity<T>, options?: CoreUpdateServiceOption<T>): Promise<UpdateResult>;
-    updateMany(query: FindManyOptions<T>, updateDto: Partial<UpdateDto> | DeepPartial<T> | QueryDeepPartialEntity<T>, options?: CoreUpdateServiceOption<T>): Promise<void>;
-    upsert(upsertDto: QueryDeepPartialEntity<T>, upsertOptions: UpsertOptions<T>, options?: CoreBaseServiceOption): Promise<InsertResult>;
-    findAllWithPagination(query: PaginationQueryCustom, paginateConfig: PaginateConfig<T>, options?: CoreFindAllWithPaginationServiceOption<T>): Promise<Paginated<T>>;
-    findAll(query: FindManyOptions<T>, options?: CoreFindAllServiceOption): Promise<T[]>;
-    findOneById(id: number, options?: CoreFindOneByIdServiceOption<T>): Promise<T>;
-    findOne(query: FindManyOptions<T>, options?: CoreFindOneServiceOption): Promise<T>;
-    isExists(query: FindManyOptions<T>, options?: CoreBaseServiceOption): Promise<boolean>;
-    count(query: FindManyOptions<T>, options?: CoreBaseServiceOption): Promise<number>;
-    softDelete(query: FindOptionsWhere<T>, options?: CoreBaseServiceOption): Promise<UpdateResult>;
-    softDeleteById(id: string | string[] | number | number[], options?: CoreBaseServiceOption): Promise<UpdateResult>;
-    restore(query: FindOptionsWhere<T>, options?: CoreBaseServiceOption): Promise<UpdateResult>;
-    restoreById(id: string | string[] | number | number[], options?: CoreBaseServiceOption): Promise<UpdateResult>;
-    delete(query: FindOptionsWhere<T>, options?: CoreBaseServiceOption): Promise<DeleteResult>;
-    deleteById(id: string | string[] | number | number[], options?: CoreBaseServiceOption): Promise<DeleteResult>;
+    create(createDto: CreateDto, options?: CoreBaseServiceOption, ...args: any[]): Promise<T>;
+    update(id: number, updateDto: Partial<UpdateDto> | DeepPartial<T> | QueryDeepPartialEntity<T>, options?: CoreUpdateServiceOption<T>, ...args: any[]): Promise<UpdateResult>;
+    updateMany(query: FindManyOptions<T>, updateDto: Partial<UpdateDto> | DeepPartial<T> | QueryDeepPartialEntity<T>, options?: CoreUpdateServiceOption<T>, ...args: any[]): Promise<void>;
+    upsert(upsertDto: QueryDeepPartialEntity<T>, upsertOptions: UpsertOptions<T>, options?: CoreBaseServiceOption, ...args: any[]): Promise<InsertResult>;
+    findAllWithPagination(query: PaginationQueryCustom, paginateConfig: PaginateConfig<T>, options?: CoreFindAllWithPaginationServiceOption<T>, ...args: any[]): Promise<Paginated<T>>;
+    findAll(query: FindManyOptions<T>, options?: CoreFindAllServiceOption, ...args: any[]): Promise<T[]>;
+    findOneById(id: number, options?: CoreFindOneByIdServiceOption<T>, ...args: any[]): Promise<T>;
+    findOne(query: FindManyOptions<T>, options?: CoreFindOneServiceOption, ...args: any[]): Promise<T>;
+    isExists(query: FindManyOptions<T>, options?: CoreBaseServiceOption, ...args: any[]): Promise<boolean>;
+    count(query: FindManyOptions<T>, options?: CoreBaseServiceOption, ...args: any[]): Promise<number>;
+    softDelete(query: FindOptionsWhere<T>, options?: CoreBaseServiceOption, ...args: any[]): Promise<UpdateResult>;
+    softDeleteById(id: string | string[] | number | number[], options?: CoreBaseServiceOption, ...args: any[]): Promise<UpdateResult>;
+    restore(query: FindOptionsWhere<T>, options?: CoreBaseServiceOption, ...args: any[]): Promise<UpdateResult>;
+    restoreById(id: string | string[] | number | number[], options?: CoreBaseServiceOption, ...args: any[]): Promise<UpdateResult>;
+    delete(query: FindOptionsWhere<T>, options?: CoreBaseServiceOption, ...args: any[]): Promise<DeleteResult>;
+    deleteById(id: string | string[] | number | number[], options?: CoreBaseServiceOption, ...args: any[]): Promise<DeleteResult>;
     private relatedPropertyTransformer;
     private whereQueryTransformer;
     private isObject;