@flusys/nestjs-shared 4.0.1 → 4.1.0

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

@@ -25,14 +25,15 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { CurrentUser, Public, RequirePermission, RequireAnyPermission, RequirePermissionLogic } from '../decorators';
-import { DeleteDto, FilterAndPaginationDto, GetByIdBodyDto } from '../dtos';
-import { JwtAuthGuard, PermissionGuard } from '../guards';
-import { IdempotencyInterceptor, SetCreatedByOnBody, SetDeletedByOnBody, SetUpdateByOnBody, Slug } from '../interceptors';
 import { applyDecorators, Body, HttpCode, HttpStatus, Param, Post, Query, UseGuards, UseInterceptors, Version, VERSION_NEUTRAL } from '@nestjs/common';
-import { ApiBearerAuth, ApiBody, ApiHeader, ApiOperation, ApiParam, ApiQuery, ApiResponse } from '@nestjs/swagger';
+import { ApiBearerAuth, ApiBody, ApiExcludeEndpoint, ApiHeader, ApiOperation, ApiParam, ApiQuery, ApiResponse } from '@nestjs/swagger';
 import { plainToInstance } from 'class-transformer';
+import { CurrentUser, Public, RequireAnyPermission, RequirePermission, RequirePermissionLogic } from '../decorators';
 import { ApiResponseDto } from '../decorators/api-response.decorator';
+import { DeleteDto, FilterAndPaginationDto, GetByIdBodyDto, GetByIdsDto } from '../dtos';
+import { ForbiddenException, NotFoundException } from '../exceptions';
+import { JwtAuthGuard, PermissionGuard } from '../guards';
+import { IdempotencyInterceptor, SetCreatedByOnBody, SetDeletedByOnBody, SetUpdateByOnBody, Slug } from '../interceptors';
 /**
  * Helper to normalize security config
  */ function normalizeSecurity(config) {
@@ -44,6 +45,24 @@ import { ApiResponseDto } from '../decorators/api-response.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(ApiExcludeEndpoint());
+    }
+    return applyDecorators(...decorators);
+}
 /**
  * Creates security decorators based on configuration
  */ function createSecurityDecorators(security) {
@@ -86,7 +105,10 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
         'insert',
         'insertMany',
         'getById',
+        'getByIds',
         'getAll',
+        'bulkUpsert',
+        'getByFilter',
         'update',
         'updateMany',
         'delete'
@@ -105,13 +127,23 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
         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 ForbiddenException(`Endpoint 'insert' is disabled`);
+            }
             const entity = await this.service.insert(addDto, user);
             const data = plainToInstance(responseDtoClass, entity);
             return {
@@ -122,6 +154,9 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             };
         }
         async insertMany(addDto, user) {
+            if (!this.isEnabled('insertMany')) {
+                throw new ForbiddenException(`Endpoint 'insertMany' is disabled`);
+            }
             const entities = await this.service.insertMany(addDto, user);
             const data = entities.map((item)=>plainToInstance(responseDtoClass, item));
             return {
@@ -140,6 +175,9 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             };
         }
         async getById(id, body, user) {
+            if (!this.isEnabled('getById')) {
+                throw new ForbiddenException(`Endpoint 'getById' is disabled`);
+            }
             const entity = await this.service.findById(id, user, body?.select);
             const data = plainToInstance(responseDtoClass, entity);
             return {
@@ -149,7 +187,30 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
                 data
             };
         }
+        async getByIds(body, user) {
+            if (!this.isEnabled('getByIds')) {
+                throw new ForbiddenException(`Endpoint 'getByIds' is disabled`);
+            }
+            const entities = await this.service.findByIds(body.ids, user, body?.select);
+            const data = 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 ForbiddenException(`Endpoint 'update' is disabled`);
+            }
             const entity = await this.service.update(updateDto, user);
             const data = plainToInstance(responseDtoClass, entity);
             return {
@@ -160,6 +221,9 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             };
         }
         async updateMany(updateDtos, user) {
+            if (!this.isEnabled('updateMany')) {
+                throw new ForbiddenException(`Endpoint 'updateMany' is disabled`);
+            }
             const entities = await this.service.updateMany(updateDtos, user);
             const data = plainToInstance(responseDtoClass, entities);
             return {
@@ -177,7 +241,63 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
                 }
             };
         }
+        async bulkUpsert(dtos, user) {
+            if (!this.isEnabled('bulkUpsert')) {
+                throw new 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 = 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 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 NotFoundException(entityName);
+            }
+            const entity = result.data[0];
+            const data = 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 ForbiddenException(`Endpoint 'getAll' is disabled`);
+            }
             const result = await this.service.getAll(search ?? '', filterAndPaginationDto, user);
             const data = plainToInstance(responseDtoClass, result.data);
             const page = filterAndPaginationDto.pagination?.currentPage ?? 0;
@@ -199,6 +319,9 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             };
         }
         async delete(deleteDto, user) {
+            if (!this.isEnabled('delete')) {
+                throw new 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';
@@ -213,11 +336,13 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
         }
         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),
         Version(VERSION_NEUTRAL),
         Post('insert'),
         HttpCode(HttpStatus.CREATED),
@@ -245,7 +370,7 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
         _ts_metadata("design:returntype", Promise)
     ], ApiController.prototype, "insert", null);
     _ts_decorate([
-        createSecurityDecorators(security.insertMany),
+        createEndpointDecorators(security.insertMany, 'insertMany', options.enabledEndpoints),
         Version(VERSION_NEUTRAL),
         Post('insert-many'),
         HttpCode(HttpStatus.CREATED),
@@ -274,7 +399,7 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
         _ts_metadata("design:returntype", Promise)
     ], ApiController.prototype, "insertMany", null);
     _ts_decorate([
-        createSecurityDecorators(security.getById),
+        createEndpointDecorators(security.getById, 'getById', options.enabledEndpoints),
         Version(VERSION_NEUTRAL),
         Post('get/:id'),
         HttpCode(HttpStatus.OK),
@@ -304,7 +429,29 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
         _ts_metadata("design:returntype", Promise)
     ], ApiController.prototype, "getById", null);
     _ts_decorate([
-        createSecurityDecorators(security.update),
+        createEndpointDecorators(security.getByIds, 'getByIds', options.enabledEndpoints),
+        Version(VERSION_NEUTRAL),
+        Post('get-by-ids'),
+        HttpCode(HttpStatus.OK),
+        ApiOperation({
+            summary: 'Get items by IDs',
+            description: 'Retrieves multiple items by their IDs. Optionally specify fields to select.'
+        }),
+        ApiBody({
+            type: GetByIdsDto
+        }),
+        ApiResponseDto(responseDtoClass, true, 'list'),
+        _ts_param(0, Body()),
+        _ts_param(1, CurrentUser()),
+        _ts_metadata("design:type", Function),
+        _ts_metadata("design:paramtypes", [
+            typeof GetByIdsDto === "undefined" ? Object : GetByIdsDto,
+            Object
+        ]),
+        _ts_metadata("design:returntype", Promise)
+    ], ApiController.prototype, "getByIds", null);
+    _ts_decorate([
+        createEndpointDecorators(security.update, 'update', options.enabledEndpoints),
         Version(VERSION_NEUTRAL),
         Post('update'),
         HttpCode(HttpStatus.OK),
@@ -327,7 +474,7 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
         _ts_metadata("design:returntype", Promise)
     ], ApiController.prototype, "update", null);
     _ts_decorate([
-        createSecurityDecorators(security.updateMany),
+        createEndpointDecorators(security.updateMany, 'updateMany', options.enabledEndpoints),
         Version(VERSION_NEUTRAL),
         Post('update-many'),
         HttpCode(HttpStatus.OK),
@@ -351,7 +498,56 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
         _ts_metadata("design:returntype", Promise)
     ], ApiController.prototype, "updateMany", null);
     _ts_decorate([
-        createSecurityDecorators(security.getAll),
+        createEndpointDecorators(security.bulkUpsert, 'bulkUpsert', options.enabledEndpoints),
+        Version(VERSION_NEUTRAL),
+        Post('bulk-upsert'),
+        HttpCode(HttpStatus.OK),
+        ApiOperation({
+            summary: 'Create or update multiple items',
+            description: 'Bulk upsert: items without ID are created, items with ID are updated.'
+        }),
+        ApiResponseDto(responseDtoClass, true, 'bulk'),
+        ApiBody({
+            type: createDtoClass,
+            isArray: true
+        }),
+        UseInterceptors(SetCreatedByOnBody, SetUpdateByOnBody, Slug),
+        _ts_param(0, Body()),
+        _ts_param(1, 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),
+        Version(VERSION_NEUTRAL),
+        Post('get-by-filter'),
+        HttpCode(HttpStatus.OK),
+        ApiOperation({
+            summary: 'Get single item by filter',
+            description: 'Retrieves a single item matching the provided filter criteria. Returns first match if multiple exist.'
+        }),
+        ApiBody({
+            schema: {
+                type: 'object',
+                description: 'Filter criteria'
+            }
+        }),
+        ApiResponseDto(responseDtoClass),
+        _ts_param(0, Body()),
+        _ts_param(1, 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),
         Version(VERSION_NEUTRAL),
         Post('get-all'),
         HttpCode(HttpStatus.OK),
@@ -380,7 +576,7 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
         _ts_metadata("design:returntype", Promise)
     ], ApiController.prototype, "getAll", null);
     _ts_decorate([
-        createSecurityDecorators(security.delete),
+        createEndpointDecorators(security.delete, 'delete', options.enabledEndpoints),
         Version(VERSION_NEUTRAL),
         Post('delete'),
         HttpCode(HttpStatus.OK),

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

@@ -20,11 +20,11 @@ function _ts_decorate(decorators, target, key, desc) {
 function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-import { DeleteDto } from '../dtos';
 import { InternalServerErrorException, NotFoundException } from '@nestjs/common';
-import { SYSTEM_MESSAGES } from '../constants';
 import { In } from 'typeorm';
+import { SYSTEM_MESSAGES } from '../constants';
 import { LogAction } from '../decorators/log-action.decorator';
+import { DeleteDto } from '../dtos';
 /** Generic API service with CRUD operations and caching support */ export class ApiService {
     async insert(dto, user) {
         return this.executeInTransaction('insert', async (qr)=>{
@@ -74,14 +74,38 @@ import { LogAction } from '../decorators/log-action.decorator';
             };
         });
     }
-    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: 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();
@@ -483,6 +507,18 @@ _ts_decorate([
     ]),
     _ts_metadata("design:returntype", Promise)
 ], ApiService.prototype, "updateMany", null);
+_ts_decorate([
+    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([
     LogAction({
         action: 'delete'

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

@@ -0,0 +1,55 @@
+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);
+}
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsArray, IsNotEmpty, IsOptional, IsUUID } from 'class-validator';
+export class GetByIdsDto {
+    constructor(){
+        _define_property(this, "ids", void 0);
+        _define_property(this, "select", void 0);
+    }
+}
+_ts_decorate([
+    ApiProperty({
+        description: 'Array of IDs to retrieve',
+        type: [
+            String
+        ],
+        example: [
+            'uuid-1',
+            'uuid-2'
+        ]
+    }),
+    IsNotEmpty(),
+    IsArray(),
+    IsUUID('all', {
+        each: true
+    }),
+    _ts_metadata("design:type", Array)
+], GetByIdsDto.prototype, "ids", void 0);
+_ts_decorate([
+    ApiPropertyOptional({
+        description: 'Select specific fields to return (comma-separated or array)'
+    }),
+    IsOptional(),
+    _ts_metadata("design:type", Object)
+], GetByIdsDto.prototype, "select", void 0);

package/fesm/dtos/index.js

@@ -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/fesm/entities/index.js

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

package/fesm/entities/raw-type.js

@@ -0,0 +1 @@
+export { };

package/interfaces/api.interface.d.ts

@@ -4,11 +4,13 @@ export interface IService<CreateDtoT, UpdateDtoT, InterfaceT> {
     insert(addDto: CreateDtoT, user: ILoggedUserInfo | null): Promise<InterfaceT>;
     insertMany(addDto: Array<CreateDtoT>, user: ILoggedUserInfo | null): Promise<Array<InterfaceT>>;
     findById(id: string, user: ILoggedUserInfo | null, select?: string[]): Promise<InterfaceT>;
+    findByIds(ids: string[], user: ILoggedUserInfo | null, select?: string[] | string): Promise<Array<InterfaceT>>;
     getAll(search: string, filterAndPaginationDto: FilterAndPaginationDto, user: ILoggedUserInfo | null): Promise<{
         data: Array<InterfaceT>;
         total: number;
     }>;
     update(updateDto: UpdateDtoT, user: ILoggedUserInfo | null): Promise<InterfaceT>;
     updateMany(updateDto: Array<UpdateDtoT>, user: ILoggedUserInfo | null): Promise<Array<InterfaceT>>;
+    bulkUpsert(toInsert: Array<CreateDtoT>, toUpdate: Array<UpdateDtoT>, user: ILoggedUserInfo | null): Promise<Array<InterfaceT>>;
     delete(deleteDto: DeleteDto, user: ILoggedUserInfo | null): Promise<null>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-shared",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "Common shared utilities for Flusys NestJS applications",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -112,6 +112,6 @@
     "rxjs": "^7.8.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "4.0.1"
+    "@flusys/nestjs-core": "4.1.0"
   }
 }