@mondart/nestjs-common-module 2.9.1 → 3.0.0

package/dist/lib/bottleneck/interfaces/bottleneck-options.interface.d.ts

@@ -1,39 +0,0 @@
-import { ModuleMetadata, Type } from '@nestjs/common';
-export declare const BOTTLENECK_MODULE_OPTIONS = "BOTTLENECK_MODULE_OPTIONS";
-export interface BottleneckModuleOptions {
-    appName?: string;
-    basePath?: string;
-    paramKey?: string;
-    useGlobal?: boolean;
-    maxConcurrent?: number | null;
-    minTime?: number | null;
-    highWater?: number | null;
-    penalty?: number | null;
-    reservoir?: number | null;
-    reservoirRefreshInterval?: number | null;
-    reservoirRefreshAmount?: number | null;
-    reservoirIncreaseAmount?: number | null;
-    reservoirIncreaseInterval?: number | null;
-    reservoirIncreaseMaximum?: number | null;
-    rejectOnDrop?: boolean | null;
-    trackDoneStatus?: boolean | null;
-    useRedis?: boolean;
-    redis?: {
-        host: string;
-        port: number;
-        username?: string;
-        password?: string;
-        database?: number;
-        ttl?: number;
-        tls?: boolean;
-    };
-}
-export interface BottleneckModuleFactory {
-    createModuleOptions: () => Promise<BottleneckModuleOptions> | BottleneckModuleOptions;
-}
-export interface BottleneckModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
-    inject?: any[];
-    useClass?: Type<BottleneckModuleFactory>;
-    useExisting?: Type<BottleneckModuleFactory>;
-    useFactory?: (...args: any[]) => Promise<BottleneckModuleOptions> | BottleneckModuleOptions;
-}

package/dist/lib/bottleneck/interfaces/bottleneck-options.interface.js

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

package/dist/lib/bottleneck/services/bottleneck.service.d.ts

@@ -1,14 +0,0 @@
-import { OnModuleDestroy } from '@nestjs/common';
-import Bottleneck from 'bottleneck';
-import { BottleneckModuleOptions } from '../interfaces/bottleneck-options.interface';
-export declare class BottleneckService implements OnModuleDestroy {
-    private readonly options;
-    private readonly logger;
-    private readonly group;
-    private readonly cache;
-    constructor(options: BottleneckModuleOptions);
-    private getLimiter;
-    scheduleForKey<T>(key: string, task: () => Promise<T>, opts?: Bottleneck.ConstructorOptions): Promise<T>;
-    runQueuedTask<T>(key: string, fn: () => Promise<T>): Promise<T>;
-    onModuleDestroy(): Promise<void>;
-}

package/dist/lib/bottleneck/services/bottleneck.service.js

@@ -1,93 +0,0 @@
-"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); }
-};
-var BottleneckService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BottleneckService = void 0;
-const common_1 = require("@nestjs/common");
-const bottleneck_1 = require("bottleneck");
-const bottleneck_options_interface_1 = require("../interfaces/bottleneck-options.interface");
-const ioredis_1 = require("ioredis");
-let BottleneckService = BottleneckService_1 = class BottleneckService {
-    constructor(options) {
-        this.options = options;
-        this.logger = new common_1.Logger(BottleneckService_1.name, {
-            timestamp: true,
-        });
-        this.cache = new Map();
-        const { useRedis, redis, appName, ...rest } = this.options;
-        const redisOptions = useRedis && redis
-            ? {
-                datastore: 'ioredis',
-                Redis: ioredis_1.default,
-                clientOptions: {
-                    host: redis.host,
-                    port: redis.port,
-                    username: redis.username,
-                    password: redis.password,
-                    db: redis.database,
-                    tls: redis.tls ? {} : undefined,
-                },
-                timeout: redis.ttl,
-            }
-            : undefined;
-        this.group = new bottleneck_1.default.Group({
-            id: `bottleneck-${appName ?? 'app'}`,
-            maxConcurrent: 1,
-            minTime: 0,
-            clearDatastore: true,
-            ...redisOptions,
-            ...rest,
-        });
-        this.group.on('idle', (key) => {
-            setTimeout(() => this.group.deleteKey(key).catch(() => { }), 30_000);
-        });
-    }
-    getLimiter(key, opts) {
-        const limiter = this.group.key(key);
-        if (opts)
-            limiter.updateSettings(opts);
-        return limiter;
-    }
-    scheduleForKey(key, task, opts) {
-        const limiter = this.getLimiter(key, opts);
-        this.logger.debug(`Scheduling task for key ${key}`);
-        return limiter.schedule(task);
-    }
-    async runQueuedTask(key, fn) {
-        if (this.cache.has(key)) {
-            this.logger.debug(`Cache hit for key ${key}`);
-            return this.cache.get(key);
-        }
-        const limiter = this.getLimiter(key);
-        const taskPromise = limiter.schedule(async () => {
-            try {
-                return await fn();
-            }
-            finally {
-                this.cache.delete(key);
-            }
-        });
-        this.cache.set(key, taskPromise);
-        return taskPromise;
-    }
-    async onModuleDestroy() {
-        await this.group.disconnect();
-    }
-};
-exports.BottleneckService = BottleneckService;
-exports.BottleneckService = BottleneckService = BottleneckService_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)(bottleneck_options_interface_1.BOTTLENECK_MODULE_OPTIONS)),
-    __metadata("design:paramtypes", [Object])
-], BottleneckService);

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

@@ -1,22 +0,0 @@
-import { ModuleMetadata, Type } from '@nestjs/common';
-export declare const CACHING_MODULE_OPTIONS = "CACHING_MODULE_OPTIONS";
-export interface CachingModuleOptions {
-    host: string;
-    port: number;
-    username?: string;
-    password: string;
-    database?: number;
-    keepAlive?: boolean | undefined;
-    tls?: boolean;
-    namespace?: string;
-    ttl?: number;
-}
-export interface CachingModuleFactory {
-    createModuleOptions: () => Promise<CachingModuleOptions> | CachingModuleOptions;
-}
-export interface CachingModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
-    inject?: any[];
-    useClass?: Type<CachingModuleFactory>;
-    useExisting?: Type<CachingModuleFactory>;
-    useFactory?: (...args: any[]) => Promise<CachingModuleOptions> | CachingModuleOptions;
-}

package/dist/lib/caching/caching.interface.js

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

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

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

package/dist/lib/caching/caching.module.js

@@ -1,142 +0,0 @@
-"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 CachingModule_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CachingModule = void 0;
-const common_1 = require("@nestjs/common");
-const caching_service_1 = require("./caching.service");
-const cache_manager_1 = require("@nestjs/cache-manager");
-const caching_interface_1 = require("./caching.interface");
-const redis_1 = require("@keyv/redis");
-let CachingModule = CachingModule_1 = class CachingModule {
-    static register(options) {
-        return {
-            module: CachingModule_1,
-            imports: [
-                cache_manager_1.CacheModule.register({
-                    isGlobal: true,
-                    useFactory: async (cachingOptions) => ({
-                        stores: [
-                            new redis_1.Keyv({
-                                store: new redis_1.default({
-                                    url: `redis://${cachingOptions.host}:${cachingOptions.port}`,
-                                    socket: {
-                                        host: cachingOptions.host,
-                                        port: cachingOptions.port,
-                                        keepAlive: cachingOptions.keepAlive,
-                                        tls: cachingOptions.tls || false,
-                                    },
-                                    database: cachingOptions.database,
-                                    username: cachingOptions.username || 'default',
-                                    password: cachingOptions.password,
-                                }),
-                            }, {
-                                namespace: cachingOptions.namespace,
-                                ttl: cachingOptions.ttl,
-                            }),
-                        ],
-                    }),
-                }),
-            ],
-            providers: [
-                {
-                    provide: caching_interface_1.CACHING_MODULE_OPTIONS,
-                    useValue: options,
-                },
-                caching_service_1.CachingService,
-            ],
-            exports: [caching_service_1.CachingService, cache_manager_1.CacheModule],
-        };
-    }
-    static registerAsync(options) {
-        const asyncOptionsProvider = this.createAsyncOptionsProvider(options);
-        return {
-            module: CachingModule_1,
-            imports: [
-                ...(options.imports || []),
-                asyncOptionsProvider,
-                cache_manager_1.CacheModule.registerAsync({
-                    imports: [asyncOptionsProvider],
-                    useFactory: async (cachingOptions) => ({
-                        stores: [
-                            new redis_1.Keyv({
-                                store: new redis_1.default({
-                                    url: `redis://${cachingOptions.host}:${cachingOptions.port}`,
-                                    socket: {
-                                        host: cachingOptions.host,
-                                        port: cachingOptions.port,
-                                        keepAlive: cachingOptions.keepAlive,
-                                        tls: cachingOptions.tls || false,
-                                    },
-                                    database: cachingOptions.database,
-                                    username: cachingOptions.username || 'default',
-                                    password: cachingOptions.password,
-                                }),
-                            }, {
-                                namespace: cachingOptions.namespace,
-                                ttl: cachingOptions.ttl,
-                            }),
-                        ],
-                    }),
-                    inject: [caching_interface_1.CACHING_MODULE_OPTIONS],
-                }),
-            ],
-            providers: [
-                {
-                    provide: caching_service_1.CachingService,
-                    useFactory: (cacheManager) => new caching_service_1.CachingService(cacheManager),
-                    inject: [cache_manager_1.CACHE_MANAGER],
-                },
-            ],
-            exports: [caching_service_1.CachingService, cache_manager_1.CacheModule],
-        };
-    }
-    static createAsyncOptionsProvider(options) {
-        const providers = this.createAsyncProviders(options);
-        return {
-            module: CachingModule_1,
-            providers,
-            exports: [caching_interface_1.CACHING_MODULE_OPTIONS],
-        };
-    }
-    static createAsyncProviders(options) {
-        if (options.useFactory) {
-            return [
-                {
-                    provide: caching_interface_1.CACHING_MODULE_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject || [],
-                },
-            ];
-        }
-        const useClass = options.useClass || options.useExisting;
-        if (useClass) {
-            return [
-                {
-                    provide: caching_interface_1.CACHING_MODULE_OPTIONS,
-                    useFactory: async (optionsFactory) => await optionsFactory.createModuleOptions(),
-                    inject: [options.useExisting || options.useClass],
-                },
-                ...(options.useClass
-                    ? [
-                        {
-                            provide: options.useClass,
-                            useClass: options.useClass,
-                        },
-                    ]
-                    : []),
-            ];
-        }
-        throw new Error('Invalid CachingModuleAsyncOptions');
-    }
-};
-exports.CachingModule = CachingModule;
-exports.CachingModule = CachingModule = CachingModule_1 = __decorate([
-    (0, common_1.Global)(),
-    (0, common_1.Module)({})
-], CachingModule);

package/dist/lib/caching/caching.service.d.ts

@@ -1,25 +0,0 @@
-import { Cache } from 'cache-manager';
-import { Keyv } from '@keyv/redis';
-export declare class CachingService {
-    private cacheManager;
-    private readonly logger;
-    constructor(cacheManager: Cache);
-    getStore(): Keyv<any>;
-    get<T>(key: string): Promise<T | undefined>;
-    getMany<T>(keys?: string[]): Promise<T[] | undefined>;
-    set<T>(key: string, value: T, ttlSeconds?: number): Promise<string>;
-    setMany<T>(list: {
-        key: string;
-        value: T;
-        ttlSeconds?: number;
-    }[]): Promise<{
-        key: string;
-        value: string;
-        ttl?: number;
-    }[]>;
-    del(key: string): Promise<boolean>;
-    delMany(keys: string[]): Promise<boolean>;
-    clear(): Promise<boolean>;
-    has(key: string): Promise<boolean>;
-    ttl(key: string): Promise<number | undefined>;
-}

package/dist/lib/caching/caching.service.js

@@ -1,85 +0,0 @@
-"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); }
-};
-var CachingService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CachingService = void 0;
-const common_1 = require("@nestjs/common");
-const cache_manager_1 = require("@nestjs/cache-manager");
-const redis_1 = require("@keyv/redis");
-let CachingService = CachingService_1 = class CachingService {
-    constructor(cacheManager) {
-        this.cacheManager = cacheManager;
-        this.logger = new common_1.Logger(CachingService_1.name, {
-            timestamp: true,
-        });
-        if (this.cacheManager.stores?.length === 0) {
-            throw new Error('Cache manager is not initialized');
-        }
-        if (!(this.cacheManager.stores?.[0] instanceof redis_1.Keyv)) {
-            throw new Error('Cache manager is not a Keyv instance');
-        }
-        this.cacheManager.stores[0].opts.store.on('error', (error) => {
-            this.logger.error('Redis error:', error);
-        });
-    }
-    getStore() {
-        return this.cacheManager.stores?.[0];
-    }
-    async get(key) {
-        const result = await this.cacheManager.get(key);
-        if (result) {
-            return JSON.parse(result);
-        }
-        return undefined;
-    }
-    async getMany(keys) {
-        const results = await this.cacheManager.mget(keys);
-        if (results?.length) {
-            return results.map((result) => JSON.parse(result));
-        }
-        return undefined;
-    }
-    async set(key, value, ttlSeconds) {
-        return await this.cacheManager.set(key, JSON.stringify(value), ttlSeconds ? ttlSeconds * 1000 : undefined);
-    }
-    async setMany(list) {
-        const valuesToSet = list.map((item) => ({
-            key: item.key,
-            value: JSON.stringify(item.value),
-            ttl: item?.ttlSeconds ? item.ttlSeconds * 1000 : undefined,
-        }));
-        return await this.cacheManager.mset(valuesToSet);
-    }
-    async del(key) {
-        return await this.cacheManager.del(key);
-    }
-    async delMany(keys) {
-        return await this.cacheManager.mdel(keys);
-    }
-    async clear() {
-        return await this.cacheManager.clear();
-    }
-    async has(key) {
-        return (await this.cacheManager.get(key)) !== undefined;
-    }
-    async ttl(key) {
-        return this.cacheManager.ttl(key);
-    }
-};
-exports.CachingService = CachingService;
-exports.CachingService = CachingService = CachingService_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)(cache_manager_1.CACHE_MANAGER)),
-    __metadata("design:paramtypes", [Object])
-], CachingService);

package/dist/lib/core-crud/controllers/core-crud.controller.d.ts

@@ -1,23 +0,0 @@
-import { PaginateConfig } from 'nestjs-paginate/lib/paginate';
-import { BaseModelEntity } from '../../../entities';
-import { BaseResponse, IdDto, SuccessResponse } from '../../../dto';
-import { CoreBaseServiceOption, CoreCrudService, CoreFindAllWithPaginationServiceOption, CoreFindOneByIdServiceOption, CoreUpdateServiceOption } from '../index';
-import { PaginationQueryCustom } from '../../../interfaces';
-export declare class CoreCrudController<T extends BaseModelEntity, CreateDto, UpdateDto, ResponseDto extends BaseResponse> {
-    protected readonly coreService: CoreCrudService<T, CreateDto, UpdateDto>;
-    protected readonly responseDto: {
-        new (init?: Partial<BaseResponse>): ResponseDto;
-    };
-    static responseDto: {
-        new (init?: Partial<BaseResponse>): any;
-    };
-    protected constructor(coreService: CoreCrudService<T, CreateDto, UpdateDto>, responseDto: {
-        new (init?: Partial<BaseResponse>): ResponseDto;
-    });
-    findAllWithPagination(query: PaginationQueryCustom, paginateConfig: PaginateConfig<T>, options?: CoreFindAllWithPaginationServiceOption<T>, ...args: any[]): Promise<SuccessResponse<ResponseDto[]>>;
-    findOneById(id: number, options?: CoreFindOneByIdServiceOption<T>, ...args: any[]): Promise<SuccessResponse<ResponseDto>>;
-    create(createDto: CreateDto, options?: CoreBaseServiceOption, ...args: any[]): Promise<SuccessResponse<ResponseDto>>;
-    update({ id }: IdDto, updateDto: UpdateDto, options?: CoreUpdateServiceOption<T>, ...args: any[]): Promise<SuccessResponse<ResponseDto>>;
-    deleteById({ id }: IdDto, options?: CoreBaseServiceOption, ...args: any[]): Promise<SuccessResponse<void>>;
-    softDeleteById({ id }: IdDto, options?: CoreBaseServiceOption, ...args: any[]): Promise<SuccessResponse<void>>;
-}

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

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoreCrudController = void 0;
-const common_1 = require("@nestjs/common");
-const dto_1 = require("../../../dto");
-const enums_1 = require("../../../enums");
-class CoreCrudController {
-    constructor(coreService, responseDto) {
-        this.coreService = coreService;
-        this.responseDto = responseDto;
-        CoreCrudController.responseDto = responseDto;
-    }
-    async findAllWithPagination(query, paginateConfig, options, ...args) {
-        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,
-        });
-    }
-    async findOneById(id, options, ...args) {
-        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, ...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, ...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, ...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, ...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);
-    }
-}
-exports.CoreCrudController = CoreCrudController;

package/dist/lib/core-crud/interfaces/crud-service-option.interface.d.ts

@@ -1,27 +0,0 @@
-import { EntityManager, SelectQueryBuilder } from 'typeorm';
-import { FindOptionsRelations } from 'typeorm/find-options/FindOptionsRelations';
-export interface CoreFindOneServiceOption extends CoreBaseServiceOption {
-    enableFirstLevelRelation?: boolean;
-    existsCheck?: boolean;
-}
-export interface CoreFindOneByIdServiceOption<T> extends CoreBaseServiceOption {
-    enableFirstLevelRelation?: boolean;
-    relations?: FindOptionsRelations<T> | string[];
-    existsCheck?: boolean;
-}
-export interface CoreFindAllServiceOption extends CoreBaseServiceOption {
-    enableFirstLevelRelation?: boolean;
-    existsCheck?: boolean;
-}
-export interface CoreFindAllWithPaginationServiceOption<T> {
-    selectQueryBuilder?: SelectQueryBuilder<T>;
-    relations?: FindOptionsRelations<T> | string[];
-    enableFirstLevelRelation?: boolean;
-}
-export interface CoreUpdateServiceOption<T> extends CoreBaseServiceOption {
-    relations?: FindOptionsRelations<T> | string[];
-    enableFirstLevelRelation?: boolean;
-}
-export interface CoreBaseServiceOption {
-    entityManager?: EntityManager;
-}

package/dist/lib/core-crud/interfaces/crud-service-option.interface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,36 +0,0 @@
-import { DeepPartial, DeleteResult, FindManyOptions, FindOptionsWhere, Repository, UpdateResult } from 'typeorm';
-import { BaseModelEntity } from '../../../entities';
-import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
-import { Paginated } from 'nestjs-paginate';
-import { PaginateConfig } from 'nestjs-paginate/lib/paginate';
-import { InsertResult } from 'typeorm/query-builder/result/InsertResult';
-import { UpsertOptions } from 'typeorm/repository/UpsertOptions';
-import { CoreBaseServiceOption, CoreFindAllServiceOption, CoreFindAllWithPaginationServiceOption, CoreFindOneByIdServiceOption, CoreFindOneServiceOption, CoreUpdateServiceOption } from '../interfaces/crud-service-option.interface';
-import { PaginationQueryCustom } from '../../../interfaces';
-export declare abstract class CoreCrudService<T extends BaseModelEntity, CreateDto, UpdateDto> {
-    protected readonly repository: Repository<T>;
-    private readonly relationsPath;
-    protected constructor(repository: Repository<T>);
-    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;
-    private isArray;
-    private isArrayOfObjectId;
-    private isArrayOfNumbers;
-}