@flusys/nestjs-shared 4.0.2 → 4.1.1

package/cjs/classes/api-controller.class.js

@@ -8,14 +8,15 @@ Object.defineProperty(exports, "createApiController", {
         return createApiController;
     }
 });
-const _decorators = require("../decorators");
-const _dtos = require("../dtos");
-const _guards = require("../guards");
-const _interceptors = require("../interceptors");
 const _common = require("@nestjs/common");
 const _swagger = require("@nestjs/swagger");
 const _classtransformer = require("class-transformer");
+const _decorators = require("../decorators");
 const _apiresponsedecorator = require("../decorators/api-response.decorator");
+const _dtos = require("../dtos");
+const _exceptions = require("../exceptions");
+const _guards = require("../guards");
+const _interceptors = require("../interceptors");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -54,6 +55,24 @@ function _ts_param(paramIndex, decorator) {
     };
     return config;
 }
+/**
+ * Helper to check if endpoint is enabled
+ */ function isEndpointEnabled(endpoint, enabledEndpoints) {
+    if (!enabledEndpoints || enabledEndpoints === 'all') return true;
+    return enabledEndpoints.includes(endpoint);
+}
+/**
+ * Helper to conditionally exclude endpoint from Swagger if disabled
+ */ function createEndpointDecorators(security, endpoint, enabledEndpoints) {
+    const decorators = [];
+    // Add security decorators
+    decorators.push(createSecurityDecorators(security));
+    // Exclude from Swagger if endpoint is disabled
+    if (!isEndpointEnabled(endpoint, enabledEndpoints)) {
+        decorators.push((0, _swagger.ApiExcludeEndpoint)());
+    }
+    return (0, _common.applyDecorators)(...decorators);
+}
 /**
  * Creates security decorators based on configuration
  */ function createSecurityDecorators(security) {
@@ -96,7 +115,10 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
         'insert',
         'insertMany',
         'getById',
+        'getByIds',
         'getAll',
+        'bulkUpsert',
+        'getByFilter',
         'update',
         'updateMany',
         'delete'
@@ -115,13 +137,23 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
         insert: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.insert),
         insertMany: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.insertMany),
         getById: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.getById),
+        getByIds: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.getByIds),
         getAll: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.getAll),
+        getByFilter: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.getByFilter),
+        bulkUpsert: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.bulkUpsert),
         update: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.update),
         updateMany: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.updateMany),
         delete: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.delete)
     };
     let ApiController = class ApiController {
+        isEnabled(endpoint) {
+            if (this.enabledEndpoints === 'all') return true;
+            return Array.isArray(this.enabledEndpoints) && this.enabledEndpoints.includes(endpoint);
+        }
         async insert(addDto, user) {
+            if (!this.isEnabled('insert')) {
+                throw new _exceptions.ForbiddenException(`Endpoint 'insert' is disabled`);
+            }
             const entity = await this.service.insert(addDto, user);
             const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entity);
             return {
@@ -132,6 +164,9 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
             };
         }
         async insertMany(addDto, user) {
+            if (!this.isEnabled('insertMany')) {
+                throw new _exceptions.ForbiddenException(`Endpoint 'insertMany' is disabled`);
+            }
             const entities = await this.service.insertMany(addDto, user);
             const data = entities.map((item)=>(0, _classtransformer.plainToInstance)(responseDtoClass, item));
             return {
@@ -150,6 +185,9 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
             };
         }
         async getById(id, body, user) {
+            if (!this.isEnabled('getById')) {
+                throw new _exceptions.ForbiddenException(`Endpoint 'getById' is disabled`);
+            }
             const entity = await this.service.findById(id, user, body?.select);
             const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entity);
             return {
@@ -159,7 +197,30 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 data
             };
         }
+        async getByIds(body, user) {
+            if (!this.isEnabled('getByIds')) {
+                throw new _exceptions.ForbiddenException(`Endpoint 'getByIds' is disabled`);
+            }
+            const entities = await this.service.findByIds(body.ids, user, body?.select);
+            const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entities);
+            return {
+                success: true,
+                message: `${data.length} ${entityName}${data.length !== 1 ? 's' : ''} retrieved successfully`,
+                messageKey: `${entityName}.get.by.ids.success`,
+                data,
+                meta: {
+                    total: data.length,
+                    page: 0,
+                    pageSize: data.length,
+                    count: data.length,
+                    totalPages: 1
+                }
+            };
+        }
         async update(updateDto, user) {
+            if (!this.isEnabled('update')) {
+                throw new _exceptions.ForbiddenException(`Endpoint 'update' is disabled`);
+            }
             const entity = await this.service.update(updateDto, user);
             const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entity);
             return {
@@ -170,6 +231,9 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
             };
         }
         async updateMany(updateDtos, user) {
+            if (!this.isEnabled('updateMany')) {
+                throw new _exceptions.ForbiddenException(`Endpoint 'updateMany' is disabled`);
+            }
             const entities = await this.service.updateMany(updateDtos, user);
             const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entities);
             return {
@@ -187,7 +251,63 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
                 }
             };
         }
+        async bulkUpsert(dtos, user) {
+            if (!this.isEnabled('bulkUpsert')) {
+                throw new _exceptions.ForbiddenException(`Endpoint 'bulkUpsert' is disabled`);
+            }
+            const toInsert = [];
+            const toUpdate = [];
+            for (const dto of dtos){
+                if ('id' in dto && dto.id) {
+                    toUpdate.push(dto);
+                } else {
+                    toInsert.push(dto);
+                }
+            }
+            const allEntities = await this.service.bulkUpsert(toInsert, toUpdate, user);
+            const data = (0, _classtransformer.plainToInstance)(responseDtoClass, allEntities);
+            return {
+                success: true,
+                message: `${data.length} ${entityName}s upserted successfully`,
+                messageKey: `${entityName}.upsert.many.success`,
+                messageVariables: {
+                    count: data.length
+                },
+                data,
+                meta: {
+                    count: data.length,
+                    total: dtos.length,
+                    failed: dtos.length - data.length
+                }
+            };
+        }
+        async getByFilter(filter, user) {
+            if (!this.isEnabled('getByFilter')) {
+                throw new _exceptions.ForbiddenException(`Endpoint 'getByFilter' is disabled`);
+            }
+            const result = await this.service.getAll('', {
+                filter,
+                pagination: {
+                    currentPage: 0,
+                    pageSize: 1
+                }
+            }, user);
+            if (!result.data || result.data.length === 0) {
+                throw new _exceptions.NotFoundException(entityName);
+            }
+            const entity = result.data[0];
+            const data = (0, _classtransformer.plainToInstance)(responseDtoClass, entity);
+            return {
+                success: true,
+                message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} retrieved successfully`,
+                messageKey: `${entityName}.get.by.filter.success`,
+                data
+            };
+        }
         async getAll(filterAndPaginationDto, user, search) {
+            if (!this.isEnabled('getAll')) {
+                throw new _exceptions.ForbiddenException(`Endpoint 'getAll' is disabled`);
+            }
             const result = await this.service.getAll(search ?? '', filterAndPaginationDto, user);
             const data = (0, _classtransformer.plainToInstance)(responseDtoClass, result.data);
             const page = filterAndPaginationDto.pagination?.currentPage ?? 0;
@@ -209,6 +329,9 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
             };
         }
         async delete(deleteDto, user) {
+            if (!this.isEnabled('delete')) {
+                throw new _exceptions.ForbiddenException(`Endpoint 'delete' is disabled`);
+            }
             await this.service.delete(deleteDto, user);
             const count = Array.isArray(deleteDto.id) ? deleteDto.id.length : 1;
             const action = deleteDto.type === 'restore' ? 'restore' : 'delete';
@@ -223,11 +346,13 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
         }
         constructor(service){
             _define_property(this, "service", void 0);
+            _define_property(this, "enabledEndpoints", void 0);
             this.service = service;
+            this.enabledEndpoints = options.enabledEndpoints ?? 'all';
         }
     };
     _ts_decorate([
-        createSecurityDecorators(security.insert),
+        createEndpointDecorators(security.insert, 'insert', options.enabledEndpoints),
         (0, _common.Version)(_common.VERSION_NEUTRAL),
         (0, _common.Post)('insert'),
         (0, _common.HttpCode)(_common.HttpStatus.CREATED),
@@ -255,7 +380,7 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
         _ts_metadata("design:returntype", Promise)
     ], ApiController.prototype, "insert", null);
     _ts_decorate([
-        createSecurityDecorators(security.insertMany),
+        createEndpointDecorators(security.insertMany, 'insertMany', options.enabledEndpoints),
         (0, _common.Version)(_common.VERSION_NEUTRAL),
         (0, _common.Post)('insert-many'),
         (0, _common.HttpCode)(_common.HttpStatus.CREATED),
@@ -284,7 +409,7 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
         _ts_metadata("design:returntype", Promise)
     ], ApiController.prototype, "insertMany", null);
     _ts_decorate([
-        createSecurityDecorators(security.getById),
+        createEndpointDecorators(security.getById, 'getById', options.enabledEndpoints),
         (0, _common.Version)(_common.VERSION_NEUTRAL),
         (0, _common.Post)('get/:id'),
         (0, _common.HttpCode)(_common.HttpStatus.OK),
@@ -314,7 +439,29 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
         _ts_metadata("design:returntype", Promise)
     ], ApiController.prototype, "getById", null);
     _ts_decorate([
-        createSecurityDecorators(security.update),
+        createEndpointDecorators(security.getByIds, 'getByIds', options.enabledEndpoints),
+        (0, _common.Version)(_common.VERSION_NEUTRAL),
+        (0, _common.Post)('get-by-ids'),
+        (0, _common.HttpCode)(_common.HttpStatus.OK),
+        (0, _swagger.ApiOperation)({
+            summary: 'Get items by IDs',
+            description: 'Retrieves multiple items by their IDs. Optionally specify fields to select.'
+        }),
+        (0, _swagger.ApiBody)({
+            type: _dtos.GetByIdsDto
+        }),
+        (0, _apiresponsedecorator.ApiResponseDto)(responseDtoClass, true, 'list'),
+        _ts_param(0, (0, _common.Body)()),
+        _ts_param(1, (0, _decorators.CurrentUser)()),
+        _ts_metadata("design:type", Function),
+        _ts_metadata("design:paramtypes", [
+            typeof _dtos.GetByIdsDto === "undefined" ? Object : _dtos.GetByIdsDto,
+            Object
+        ]),
+        _ts_metadata("design:returntype", Promise)
+    ], ApiController.prototype, "getByIds", null);
+    _ts_decorate([
+        createEndpointDecorators(security.update, 'update', options.enabledEndpoints),
         (0, _common.Version)(_common.VERSION_NEUTRAL),
         (0, _common.Post)('update'),
         (0, _common.HttpCode)(_common.HttpStatus.OK),
@@ -337,7 +484,7 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
         _ts_metadata("design:returntype", Promise)
     ], ApiController.prototype, "update", null);
     _ts_decorate([
-        createSecurityDecorators(security.updateMany),
+        createEndpointDecorators(security.updateMany, 'updateMany', options.enabledEndpoints),
         (0, _common.Version)(_common.VERSION_NEUTRAL),
         (0, _common.Post)('update-many'),
         (0, _common.HttpCode)(_common.HttpStatus.OK),
@@ -361,7 +508,56 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
         _ts_metadata("design:returntype", Promise)
     ], ApiController.prototype, "updateMany", null);
     _ts_decorate([
-        createSecurityDecorators(security.getAll),
+        createEndpointDecorators(security.bulkUpsert, 'bulkUpsert', options.enabledEndpoints),
+        (0, _common.Version)(_common.VERSION_NEUTRAL),
+        (0, _common.Post)('bulk-upsert'),
+        (0, _common.HttpCode)(_common.HttpStatus.OK),
+        (0, _swagger.ApiOperation)({
+            summary: 'Create or update multiple items',
+            description: 'Bulk upsert: items without ID are created, items with ID are updated.'
+        }),
+        (0, _apiresponsedecorator.ApiResponseDto)(responseDtoClass, true, 'bulk'),
+        (0, _swagger.ApiBody)({
+            type: createDtoClass,
+            isArray: true
+        }),
+        (0, _common.UseInterceptors)(_interceptors.SetCreatedByOnBody, _interceptors.SetUpdateByOnBody, _interceptors.Slug),
+        _ts_param(0, (0, _common.Body)()),
+        _ts_param(1, (0, _decorators.CurrentUser)()),
+        _ts_metadata("design:type", Function),
+        _ts_metadata("design:paramtypes", [
+            Array,
+            Object
+        ]),
+        _ts_metadata("design:returntype", Promise)
+    ], ApiController.prototype, "bulkUpsert", null);
+    _ts_decorate([
+        createEndpointDecorators(security.getByFilter, 'getByFilter', options.enabledEndpoints),
+        (0, _common.Version)(_common.VERSION_NEUTRAL),
+        (0, _common.Post)('get-by-filter'),
+        (0, _common.HttpCode)(_common.HttpStatus.OK),
+        (0, _swagger.ApiOperation)({
+            summary: 'Get single item by filter',
+            description: 'Retrieves a single item matching the provided filter criteria. Returns first match if multiple exist.'
+        }),
+        (0, _swagger.ApiBody)({
+            schema: {
+                type: 'object',
+                description: 'Filter criteria'
+            }
+        }),
+        (0, _apiresponsedecorator.ApiResponseDto)(responseDtoClass),
+        _ts_param(0, (0, _common.Body)()),
+        _ts_param(1, (0, _decorators.CurrentUser)()),
+        _ts_metadata("design:type", Function),
+        _ts_metadata("design:paramtypes", [
+            typeof Record === "undefined" ? Object : Record,
+            Object
+        ]),
+        _ts_metadata("design:returntype", Promise)
+    ], ApiController.prototype, "getByFilter", null);
+    _ts_decorate([
+        createEndpointDecorators(security.getAll, 'getAll', options.enabledEndpoints),
         (0, _common.Version)(_common.VERSION_NEUTRAL),
         (0, _common.Post)('get-all'),
         (0, _common.HttpCode)(_common.HttpStatus.OK),
@@ -390,7 +586,7 @@ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, o
         _ts_metadata("design:returntype", Promise)
     ], ApiController.prototype, "getAll", null);
     _ts_decorate([
-        createSecurityDecorators(security.delete),
+        createEndpointDecorators(security.delete, 'delete', options.enabledEndpoints),
         (0, _common.Version)(_common.VERSION_NEUTRAL),
         (0, _common.Post)('delete'),
         (0, _common.HttpCode)(_common.HttpStatus.OK),

package/cjs/classes/api-service.class.js

@@ -8,11 +8,11 @@ Object.defineProperty(exports, "ApiService", {
         return ApiService;
     }
 });
-const _dtos = require("../dtos");
 const _common = require("@nestjs/common");
-const _constants = require("../constants");
 const _typeorm = require("typeorm");
+const _constants = require("../constants");
 const _logactiondecorator = require("../decorators/log-action.decorator");
+const _dtos = require("../dtos");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -84,14 +84,38 @@ let ApiService = class ApiService {
             };
         });
     }
-    async findByIds(ids, user) {
+    async bulkUpsert(toInsert, toUpdate, user) {
+        return this.executeInTransaction('bulkUpsert', async (qr)=>{
+            const allResults = [];
+            if (toInsert.length > 0) {
+                await this.beforeInsertOperation(toInsert, user, qr);
+                const insertedEntities = await this.convertRequestDtoToEntity(toInsert, user);
+                const insertedSaved = await qr.manager.save(this.repository.target, insertedEntities);
+                await this.afterInsertOperation(this.ensureArray(insertedSaved), user, qr);
+                allResults.push(...this.ensureArray(insertedSaved));
+            }
+            if (toUpdate.length > 0) {
+                await this.beforeUpdateOperation(toUpdate, user, qr);
+                const updatedEntities = await this.convertRequestDtoToEntity(toUpdate, user);
+                const updatedSaved = await qr.manager.save(this.repository.target, updatedEntities);
+                await this.afterUpdateOperation(this.ensureArray(updatedSaved), user, qr);
+                allResults.push(...this.ensureArray(updatedSaved));
+            }
+            return {
+                saved: allResults,
+                returnFirst: false
+            };
+        });
+    }
+    async findByIds(ids, user, select) {
         await this.ensureRepositoryInitialized();
         try {
             const query = this.repository.createQueryBuilder(this.entityName);
             query.where({
                 id: (0, _typeorm.In)(ids)
             });
-            const { query: finalQuery, isRaw } = await this.getSelectQuery(query, user);
+            const selectArray = typeof select === 'string' ? select.split(',').map((s)=>s.trim()) : select;
+            const { query: finalQuery, isRaw } = await this.getSelectQuery(query, user, selectArray);
             let output;
             if (isRaw) {
                 output = await finalQuery.getRawMany();
@@ -427,7 +451,7 @@ let ApiService = class ApiService {
         return Object.assign({}, entity);
     }
     convertEntityListToResponseListDto(entities, _isRaw) {
-        return entities.map((entity)=>Object.assign({}, entity));
+        return entities.map((entity)=>this.convertEntityToResponseDto(entity, _isRaw));
     }
     async getEntityClass() {
         return await this.repository.create();
@@ -493,6 +517,18 @@ _ts_decorate([
     ]),
     _ts_metadata("design:returntype", Promise)
 ], ApiService.prototype, "updateMany", null);
+_ts_decorate([
+    (0, _logactiondecorator.LogAction)({
+        action: 'bulkUpsert'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Array,
+        Array,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "bulkUpsert", null);
 _ts_decorate([
     (0, _logactiondecorator.LogAction)({
         action: 'delete'

package/cjs/dtos/get-by-ids.dto.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "GetByIdsDto", {
+    enumerable: true,
+    get: function() {
+        return GetByIdsDto;
+    }
+});
+const _swagger = require("@nestjs/swagger");
+const _classvalidator = require("class-validator");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+let GetByIdsDto = class GetByIdsDto {
+    constructor(){
+        _define_property(this, "ids", void 0);
+        _define_property(this, "select", void 0);
+    }
+};
+_ts_decorate([
+    (0, _swagger.ApiProperty)({
+        description: 'Array of IDs to retrieve',
+        type: [
+            String
+        ],
+        example: [
+            'uuid-1',
+            'uuid-2'
+        ]
+    }),
+    (0, _classvalidator.IsNotEmpty)(),
+    (0, _classvalidator.IsArray)(),
+    (0, _classvalidator.IsUUID)('all', {
+        each: true
+    }),
+    _ts_metadata("design:type", Array)
+], GetByIdsDto.prototype, "ids", void 0);
+_ts_decorate([
+    (0, _swagger.ApiPropertyOptional)({
+        description: 'Select specific fields to return (comma-separated or array)'
+    }),
+    (0, _classvalidator.IsOptional)(),
+    _ts_metadata("design:type", Object)
+], GetByIdsDto.prototype, "select", void 0);

package/cjs/dtos/index.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 _export_star(require("./delete.dto"), exports);
 _export_star(require("./filter-and-pagination.dto"), exports);
+_export_star(require("./get-by-ids.dto"), exports);
 _export_star(require("./identity-response.dto"), exports);
 _export_star(require("./pagination.dto"), exports);
 _export_star(require("./response-payload.dto"), exports);

package/cjs/entities/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./identity"), exports);
+_export_star(require("./raw-type"), exports);
 _export_star(require("./user-root"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {

package/cjs/entities/raw-type.js

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

package/classes/api-controller.class.d.ts

@@ -1,8 +1,8 @@
-import { BulkResponseDto, DeleteDto, FilterAndPaginationDto, GetByIdBodyDto, ListResponseDto, MessageResponseDto, SingleResponseDto } from '../dtos';
+import { Type } from '@nestjs/common';
+import { BulkResponseDto, DeleteDto, FilterAndPaginationDto, GetByIdBodyDto, GetByIdsDto, ListResponseDto, MessageResponseDto, SingleResponseDto } from '../dtos';
 import { Identity } from '../entities';
 import { ILoggedUserInfo, IPermissionLogic, IService } from '../interfaces';
-import { Type } from '@nestjs/common';
-export type ApiEndpoint = 'insert' | 'insertMany' | 'getById' | 'getAll' | 'update' | 'updateMany' | 'delete';
+export type ApiEndpoint = 'insert' | 'insertMany' | 'getById' | 'getByIds' | 'getAll' | 'bulkUpsert' | 'getByFilter' | 'update' | 'updateMany' | 'delete';
 export type SecurityLevel = 'public' | 'jwt' | 'permission';
 export interface EndpointSecurity {
     level: SecurityLevel;
@@ -16,16 +16,22 @@ export type ApiSecurityConfig = {
 export interface ApiControllerOptions {
     security?: ApiSecurityConfig | EndpointSecurity | SecurityLevel;
     entityName?: string;
+    enabledEndpoints?: ApiEndpoint[] | 'all';
 }
 export declare function createApiController<CreateDtoT extends object, UpdateDtoT extends {
     id: string;
 }, ResponseDtoT extends object, InterfaceT extends Identity, ServiceT extends IService<CreateDtoT, UpdateDtoT, InterfaceT>>(createDtoClass: Type<CreateDtoT>, updateDtoClass: Type<UpdateDtoT>, responseDtoClass: Type<ResponseDtoT>, options?: ApiControllerOptions): abstract new (service: ServiceT) => {
+    readonly enabledEndpoints: ApiEndpoint[] | "all";
     service: ServiceT;
+    isEnabled(endpoint: ApiEndpoint): boolean;
     insert(addDto: CreateDtoT, user: ILoggedUserInfo | null): Promise<SingleResponseDto<ResponseDtoT>>;
     insertMany(addDto: CreateDtoT[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<ResponseDtoT>>;
     getById(id: string, body: GetByIdBodyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<ResponseDtoT>>;
+    getByIds(body: GetByIdsDto, user: ILoggedUserInfo | null): Promise<ListResponseDto<ResponseDtoT>>;
     update(updateDto: UpdateDtoT, user: ILoggedUserInfo | null): Promise<SingleResponseDto<ResponseDtoT>>;
     updateMany(updateDtos: UpdateDtoT[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<ResponseDtoT>>;
+    bulkUpsert(dtos: (CreateDtoT | UpdateDtoT)[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<ResponseDtoT>>;
+    getByFilter(filter: Record<string, any>, user: ILoggedUserInfo | null): Promise<SingleResponseDto<ResponseDtoT>>;
     getAll(filterAndPaginationDto: FilterAndPaginationDto, user: ILoggedUserInfo | null, search?: string): Promise<ListResponseDto<ResponseDtoT>>;
     delete(deleteDto: DeleteDto, user: ILoggedUserInfo | null): Promise<MessageResponseDto>;
 };

package/classes/api-service.class.d.ts

@@ -1,8 +1,8 @@
+import { QueryRunner, Repository, SelectQueryBuilder } from 'typeorm';
 import { DeleteDto, FilterAndPaginationDto } from '../dtos';
-import { Identity } from '../entities';
+import { Identity, RawEntity } from '../entities';
 import { ILoggedUserInfo, IService } from '../interfaces';
 import { UtilsService } from '../modules/utils/utils.service';
-import { QueryRunner, Repository, SelectQueryBuilder } from 'typeorm';
 import { HybridCache } from './hybrid-cache.class';
 export declare abstract class ApiService<CreateDtoT extends object, UpdateDtoT extends {
     id: string;
@@ -19,7 +19,8 @@ export declare abstract class ApiService<CreateDtoT extends object, UpdateDtoT e
     insertMany(dtos: Array<CreateDtoT>, user: ILoggedUserInfo | null): Promise<InterfaceT[]>;
     update(dto: UpdateDtoT, user: ILoggedUserInfo | null): Promise<InterfaceT>;
     updateMany(dtos: UpdateDtoT[], user: ILoggedUserInfo | null): Promise<InterfaceT[]>;
-    findByIds(ids: string[], user: ILoggedUserInfo | null): Promise<InterfaceT[]>;
+    bulkUpsert(toInsert: CreateDtoT[], toUpdate: UpdateDtoT[], user: ILoggedUserInfo | null): Promise<InterfaceT[]>;
+    findByIds(ids: string[], user: ILoggedUserInfo | null, select?: string[] | string): Promise<InterfaceT[]>;
     findById(id: string, user: ILoggedUserInfo | null, select?: string[]): Promise<InterfaceT>;
     getAll(search: string, filterAndPaginationDto: FilterAndPaginationDto, user: ILoggedUserInfo | null): Promise<{
         data: Array<InterfaceT>;
@@ -63,7 +64,7 @@ export declare abstract class ApiService<CreateDtoT extends object, UpdateDtoT e
     protected convertRequestDtoToEntity(dto: CreateDtoT | UpdateDtoT | Array<CreateDtoT | UpdateDtoT>, user: ILoggedUserInfo | null): Promise<Array<EntityT>>;
     protected convertSingleDtoToEntity(dto: CreateDtoT | UpdateDtoT, _user: ILoggedUserInfo | null): Promise<EntityT>;
     protected convertArrayDtoToEntities(dtos: Array<CreateDtoT | UpdateDtoT>, user: ILoggedUserInfo | null): Promise<Array<EntityT>>;
-    protected convertEntityToResponseDto(entity: EntityT, _isRaw: boolean): InterfaceT;
-    protected convertEntityListToResponseListDto(entities: EntityT[], _isRaw: boolean): InterfaceT[];
+    protected convertEntityToResponseDto(entity: EntityT | RawEntity, _isRaw: boolean): InterfaceT;
+    protected convertEntityListToResponseListDto(entities: EntityT[] | RawEntity[], _isRaw: boolean): InterfaceT[];
     protected getEntityClass(): Promise<EntityT>;
 }

package/dtos/get-by-ids.dto.d.ts

@@ -0,0 +1,4 @@
+export declare class GetByIdsDto {
+    ids: string[];
+    select?: string[] | string;
+}

package/dtos/index.d.ts

@@ -1,5 +1,6 @@
 export * from './delete.dto';
 export * from './filter-and-pagination.dto';
+export * from './get-by-ids.dto';
 export * from './identity-response.dto';
 export * from './pagination.dto';
 export * from './response-payload.dto';

package/entities/index.d.ts

@@ -1,2 +1,3 @@
 export * from './identity';
+export * from './raw-type';
 export * from './user-root';

package/entities/raw-type.d.ts

@@ -0,0 +1 @@
+export type RawEntity = Record<string, unknown>;