@flusys/nestjs-shared 3.0.0 → 4.0.0-rc

package/constants/permissions.d.ts

@@ -86,6 +86,42 @@ export declare const FORM_RESULT_PERMISSIONS: {
     readonly UPDATE: "form-result.update";
     readonly DELETE: "form-result.delete";
 };
+export declare const EVENT_PERMISSIONS: {
+    readonly CREATE: "event.create";
+    readonly READ: "event.read";
+    readonly UPDATE: "event.update";
+    readonly DELETE: "event.delete";
+};
+export declare const EVENT_PARTICIPANT_PERMISSIONS: {
+    readonly CREATE: "event-participant.create";
+    readonly READ: "event-participant.read";
+    readonly UPDATE: "event-participant.update";
+    readonly DELETE: "event-participant.delete";
+};
+export declare const NOTIFICATION_PERMISSIONS: {
+    readonly CREATE: "notification.create";
+    readonly READ: "notification.read";
+    readonly UPDATE: "notification.update";
+    readonly DELETE: "notification.delete";
+};
+export declare const LANGUAGE_PERMISSIONS: {
+    readonly CREATE: "language.create";
+    readonly READ: "language.read";
+    readonly UPDATE: "language.update";
+    readonly DELETE: "language.delete";
+};
+export declare const TRANSLATION_KEY_PERMISSIONS: {
+    readonly CREATE: "translation-key.create";
+    readonly READ: "translation-key.read";
+    readonly UPDATE: "translation-key.update";
+    readonly DELETE: "translation-key.delete";
+};
+export declare const TRANSLATION_PERMISSIONS: {
+    readonly CREATE: "translation.create";
+    readonly READ: "translation.read";
+    readonly UPDATE: "translation.update";
+    readonly DELETE: "translation.delete";
+};
 export declare const PERMISSIONS: {
     readonly USER: {
         readonly CREATE: "user.create";
@@ -175,5 +211,41 @@ export declare const PERMISSIONS: {
         readonly UPDATE: "form-result.update";
         readonly DELETE: "form-result.delete";
     };
+    readonly EVENT: {
+        readonly CREATE: "event.create";
+        readonly READ: "event.read";
+        readonly UPDATE: "event.update";
+        readonly DELETE: "event.delete";
+    };
+    readonly EVENT_PARTICIPANT: {
+        readonly CREATE: "event-participant.create";
+        readonly READ: "event-participant.read";
+        readonly UPDATE: "event-participant.update";
+        readonly DELETE: "event-participant.delete";
+    };
+    readonly NOTIFICATION: {
+        readonly CREATE: "notification.create";
+        readonly READ: "notification.read";
+        readonly UPDATE: "notification.update";
+        readonly DELETE: "notification.delete";
+    };
+    readonly LANGUAGE: {
+        readonly CREATE: "language.create";
+        readonly READ: "language.read";
+        readonly UPDATE: "language.update";
+        readonly DELETE: "language.delete";
+    };
+    readonly TRANSLATION_KEY: {
+        readonly CREATE: "translation-key.create";
+        readonly READ: "translation-key.read";
+        readonly UPDATE: "translation-key.update";
+        readonly DELETE: "translation-key.delete";
+    };
+    readonly TRANSLATION: {
+        readonly CREATE: "translation.create";
+        readonly READ: "translation.read";
+        readonly UPDATE: "translation.update";
+        readonly DELETE: "translation.delete";
+    };
 };
 export type PermissionCode = (typeof PERMISSIONS)[keyof typeof PERMISSIONS][keyof (typeof PERMISSIONS)[keyof typeof PERMISSIONS]];

package/decorators/index.d.ts

@@ -1,5 +1,6 @@
 export * from './api-response.decorator';
 export * from './current-user.decorator';
+export * from './log-action.decorator';
 export * from './public.decorator';
 export * from './require-permission.decorator';
 export * from './sanitize-html.decorator';

package/decorators/log-action.decorator.d.ts

@@ -0,0 +1,8 @@
+export interface ILogActionOptions {
+    action?: string;
+    module?: string;
+    includeParams?: boolean;
+    includeResult?: boolean;
+    logLevel?: 'debug' | 'info' | 'warn';
+}
+export declare function LogAction(options?: ILogActionOptions): MethodDecorator;

package/dtos/response-payload.dto.d.ts

@@ -6,6 +6,8 @@ export declare class RequestMetaDto {
 export declare class SingleResponseDto<T> {
     success: boolean;
     message: string;
+    messageKey?: string;
+    messageVariables?: Record<string, string | number>;
     data?: T;
     _meta?: RequestMetaDto;
 }
@@ -20,6 +22,8 @@ export declare class PaginationMetaDto {
 export declare class ListResponseDto<T> {
     success: boolean;
     message: string;
+    messageKey?: string;
+    messageVariables?: Record<string, string | number>;
     data?: T[];
     meta: PaginationMetaDto;
     _meta?: RequestMetaDto;
@@ -32,6 +36,8 @@ export declare class BulkMetaDto {
 export declare class BulkResponseDto<T> {
     success: boolean;
     message: string;
+    messageKey?: string;
+    messageVariables?: Record<string, string | number>;
     data?: T[];
     meta: BulkMetaDto;
     _meta?: RequestMetaDto;
@@ -39,5 +45,7 @@ export declare class BulkResponseDto<T> {
 export declare class MessageResponseDto {
     success: boolean;
     message: string;
+    messageKey?: string;
+    messageVariables?: Record<string, string | number>;
     _meta?: RequestMetaDto;
 }

package/enums/index.d.ts

@@ -0,0 +1,3 @@
+export * from './notification-type.enum';
+export * from './participant-status.enum';
+export * from './recurrence-type.enum';

package/enums/notification-type.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum NotificationType {
+    INFO = "info",
+    WARNING = "warning",
+    SUCCESS = "success",
+    ERROR = "error"
+}

package/enums/participant-status.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum ParticipantStatus {
+    PENDING = "pending",
+    ACCEPTED = "accepted",
+    DECLINED = "declined",
+    TENTATIVE = "tentative"
+}

package/enums/recurrence-type.enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum RecurrenceType {
+    NONE = "none",
+    DAILY = "daily",
+    WEEKLY = "weekly",
+    BIWEEKLY = "biweekly",
+    MONTHLY = "monthly"
+}

package/exceptions/base-app.exception.d.ts

@@ -0,0 +1,41 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+export interface IValidationError {
+    field: string;
+    message: string;
+}
+export interface IBaseAppExceptionOptions {
+    message: string;
+    messageKey?: string;
+    messageParams?: Record<string, unknown>;
+    status?: HttpStatus;
+    errors?: IValidationError[];
+    metadata?: Record<string, unknown>;
+}
+export declare class BaseAppException extends HttpException {
+    readonly messageKey: string;
+    readonly messageParams?: Record<string, unknown>;
+    readonly errors?: IValidationError[];
+    readonly metadata?: Record<string, unknown>;
+    constructor(options: IBaseAppExceptionOptions);
+}
+export declare class NotFoundException extends BaseAppException {
+    constructor(entity: string, id?: string);
+}
+export declare class ValidationException extends BaseAppException {
+    constructor(errors: IValidationError[]);
+}
+export declare class UnauthorizedException extends BaseAppException {
+    constructor(message?: string);
+}
+export declare class ForbiddenException extends BaseAppException {
+    constructor(message?: string);
+}
+export declare class ConflictException extends BaseAppException {
+    constructor(entity: string, field?: string);
+}
+export declare class InternalServerException extends BaseAppException {
+    constructor(message?: string);
+}
+export declare class ServiceUnavailableException extends BaseAppException {
+    constructor(service: string);
+}

package/exceptions/index.d.ts

@@ -1 +1,2 @@
+export * from './base-app.exception';
 export * from './permission.exception';

package/exceptions/permission.exception.d.ts

@@ -1,6 +1,6 @@
 import { ForbiddenException, InternalServerErrorException } from '@nestjs/common';
 export declare class PermissionSystemUnavailableException extends InternalServerErrorException {
-    constructor(message?: string);
+    constructor();
 }
 export declare class InsufficientPermissionsException extends ForbiddenException {
     constructor(missingPermissions: string[], operator?: 'AND' | 'OR');

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

@@ -78,6 +78,8 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
     return applyDecorators(...decorators);
 }
 /** Creates an API Controller with standardized CRUD endpoints (POST-only RPC pattern) */ export function createApiController(createDtoClass, updateDtoClass, responseDtoClass, options = {}) {
+    // Entity name for message keys (defaults to 'item')
+    const entityName = options.entityName ?? 'item';
     // Determine if security is global (applies to all) or per-endpoint
     const securityConfig = options.security;
     const endpointKeys = [
@@ -114,7 +116,8 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             const data = plainToInstance(responseDtoClass, entity);
             return {
                 success: true,
-                message: 'Item created successfully',
+                message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} created successfully`,
+                messageKey: `${entityName}.create.success`,
                 data
             };
         }
@@ -123,7 +126,11 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             const data = entities.map((item)=>plainToInstance(responseDtoClass, item));
             return {
                 success: true,
-                message: `${data.length} items created successfully`,
+                message: `${data.length} ${entityName}s created successfully`,
+                messageKey: `${entityName}.create.many.success`,
+                messageVariables: {
+                    count: data.length
+                },
                 data,
                 meta: {
                     count: data.length,
@@ -137,7 +144,8 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             const data = plainToInstance(responseDtoClass, entity);
             return {
                 success: true,
-                message: 'Item retrieved successfully',
+                message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} retrieved successfully`,
+                messageKey: `${entityName}.get.success`,
                 data
             };
         }
@@ -146,7 +154,8 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             const data = plainToInstance(responseDtoClass, entity);
             return {
                 success: true,
-                message: 'Item updated successfully',
+                message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} updated successfully`,
+                messageKey: `${entityName}.update.success`,
                 data
             };
         }
@@ -155,7 +164,11 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             const data = plainToInstance(responseDtoClass, entities);
             return {
                 success: true,
-                message: `${data.length} items updated successfully`,
+                message: `${data.length} ${entityName}s updated successfully`,
+                messageKey: `${entityName}.update.many.success`,
+                messageVariables: {
+                    count: data.length
+                },
                 data,
                 meta: {
                     count: data.length,
@@ -172,7 +185,8 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
             const totalPages = pageSize > 0 ? Math.ceil(result.total / pageSize) : 1;
             return {
                 success: true,
-                message: 'Data retrieved successfully',
+                message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)}s retrieved successfully`,
+                messageKey: `${entityName}.get.all.success`,
                 data,
                 meta: {
                     total: result.total,
@@ -187,10 +201,14 @@ import { ApiResponseDto } from '../decorators/api-response.decorator';
         async delete(deleteDto, user) {
             await this.service.delete(deleteDto, user);
             const count = Array.isArray(deleteDto.id) ? deleteDto.id.length : 1;
-            const action = deleteDto.type === 'restore' ? 'restored' : 'deleted';
+            const action = deleteDto.type === 'restore' ? 'restore' : 'delete';
             return {
                 success: true,
-                message: `${count} item${count > 1 ? 's' : ''} ${action} successfully`
+                message: `${count} ${entityName}${count > 1 ? 's' : ''} ${action}d successfully`,
+                messageKey: `${entityName}.${action}.success`,
+                messageVariables: {
+                    count
+                }
             };
         }
         constructor(service){

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

@@ -11,9 +11,20 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-import { ErrorHandler } from '../utils/error-handler.util';
-import { Logger, NotFoundException } from '@nestjs/common';
+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 { DeleteDto } from '../dtos';
+import { InternalServerErrorException, NotFoundException } from '@nestjs/common';
+import { SYSTEM_MESSAGES } from '../constants';
 import { In } from 'typeorm';
+import { LogAction } from '../decorators/log-action.decorator';
 /** Generic API service with CRUD operations and caching support */ export class ApiService {
     async insert(dto, user) {
         return this.executeInTransaction('insert', async (qr)=>{
@@ -78,7 +89,10 @@ import { In } from 'typeorm';
                 output = await finalQuery.getMany();
             }
             const result = this.convertEntityListToResponseListDto(output, isRaw);
-            if (!result || !result.length) throw new NotFoundException('No Data Found');
+            if (!result || !result.length) throw new NotFoundException({
+                message: 'No Data Found',
+                messageKey: SYSTEM_MESSAGES.NOT_FOUND
+            });
             return result;
         } catch (error) {
             if (error instanceof NotFoundException) {
@@ -109,7 +123,10 @@ import { In } from 'typeorm';
                     if (convertResult.length) result = convertResult[0];
                 } else {
                     output = await finalQuery.getOne();
-                    if (!output) throw new NotFoundException('No Data Found');
+                    if (!output) throw new NotFoundException({
+                        message: 'No Data Found',
+                        messageKey: SYSTEM_MESSAGES.NOT_FOUND
+                    });
                     result = this.convertEntityToResponseDto(output, false);
                 }
                 if (this.isCacheable) {
@@ -199,7 +216,15 @@ import { In } from 'typeorm';
                 const parameters = rawSubQuery.getParameters();
                 const orderedValues = [];
                 const convertedQuery = countSql.replace(/:(\w+)/g, (_, key)=>{
-                    if (!(key in parameters)) throw new Error(`Missing parameter value for: ${key}`);
+                    if (!(key in parameters)) {
+                        throw new InternalServerErrorException({
+                            message: `Missing parameter value for: ${key}`,
+                            messageKey: SYSTEM_MESSAGES.MISSING_PARAMETER,
+                            messageParams: {
+                                key
+                            }
+                        });
+                    }
                     orderedValues.push(parameters[key]);
                     return '?';
                 });
@@ -272,13 +297,14 @@ import { In } from 'typeorm';
     async clearCacheForId(entities) {
         await Promise.all(entities.map((item)=>this.utilsService.clearCache(this.entityName, this.cacheManager, item.id)));
     }
-    /**
-   * Helper method to handle errors with proper logging and type safety
-   */ handleError(error, operation) {
-        ErrorHandler.logError(this.logger, error, operation, {
-            entity: this.entityName
+    handleError(error, _operation) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw new InternalServerErrorException({
+            message: typeof error === 'string' ? error : 'Unknown error',
+            messageKey: SYSTEM_MESSAGES.INTERNAL_ERROR
         });
-        ErrorHandler.rethrowError(error);
     }
     /** Ensures value is always an array */ ensureArray(value) {
         return Array.isArray(value) ? value : [
@@ -375,7 +401,10 @@ import { In } from 'typeorm';
                     id: d.id
                 }
             });
-            if (!existing) throw new NotFoundException('No such entity data found for update! Please, Try Again.');
+            if (!existing) throw new NotFoundException({
+                message: 'No such entity data found for update! Please, Try Again.',
+                messageKey: SYSTEM_MESSAGES.NOT_FOUND
+            });
             return Object.assign(existing, d);
         }
         delete d.id;
@@ -393,21 +422,75 @@ import { In } from 'typeorm';
     async getEntityClass() {
         return await this.repository.create();
     }
-    constructor(entityName, repository, cacheManager, utilsService, loggerName, isCacheable = false){
+    constructor(entityName, repository, cacheManager, utilsService, _loggerName, isCacheable = false, moduleName){
         _define_property(this, "entityName", void 0);
         _define_property(this, "repository", void 0);
         _define_property(this, "cacheManager", void 0);
         _define_property(this, "utilsService", void 0);
-        _define_property(this, "loggerName", void 0);
+        _define_property(this, "_loggerName", void 0);
         _define_property(this, "isCacheable", void 0);
-        _define_property(this, "logger", void 0);
+        _define_property(this, "moduleName", void 0);
         this.entityName = entityName;
         this.repository = repository;
         this.cacheManager = cacheManager;
         this.utilsService = utilsService;
-        this.loggerName = loggerName;
+        this._loggerName = _loggerName;
         this.isCacheable = isCacheable;
-        this.logger = new Logger('ApiService');
-        this.logger = new Logger(loggerName);
+        this.moduleName = moduleName;
     }
 }
+_ts_decorate([
+    LogAction({
+        action: 'create'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof CreateDtoT === "undefined" ? Object : CreateDtoT,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "insert", null);
+_ts_decorate([
+    LogAction({
+        action: 'createMany'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Array === "undefined" ? Object : Array,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "insertMany", null);
+_ts_decorate([
+    LogAction({
+        action: 'update'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof UpdateDtoT === "undefined" ? Object : UpdateDtoT,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "update", null);
+_ts_decorate([
+    LogAction({
+        action: 'updateMany'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Array,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "updateMany", null);
+_ts_decorate([
+    LogAction({
+        action: 'delete'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof DeleteDto === "undefined" ? Object : DeleteDto,
+        Object
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "delete", null);

package/fesm/classes/winston-logger-adapter.class.js

@@ -11,39 +11,17 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-import { instance as winstonLogger } from './winston.logger.class';
+import { instance as winstonLogger, createModuleLogger } from './winston.logger.class';
 import { getRequestId, getUserId, getTenantId, getCompanyId } from '../middlewares/logger.middleware';
-/**
- * Get correlation context for logging
- * Automatically includes requestId, userId, tenantId, companyId if available
- */ function getCorrelationMeta() {
-    const meta = {};
-    const requestId = getRequestId();
-    const userId = getUserId();
-    const tenantId = getTenantId();
-    const companyId = getCompanyId();
-    if (requestId) meta.requestId = requestId;
-    if (userId) meta.userId = userId;
-    if (tenantId) meta.tenantId = tenantId;
-    if (companyId) meta.companyId = companyId;
-    return meta;
+function getCorrelationMeta() {
+    return Object.fromEntries(Object.entries({
+        requestId: getRequestId(),
+        userId: getUserId(),
+        tenantId: getTenantId(),
+        companyId: getCompanyId()
+    }).filter(([, v])=>v != null));
 }
-/**
- * Winston Logger Adapter
- * Adapts Winston logger to ILogger interface for dependency injection
- *
- * Features:
- * - Automatic correlation ID injection
- * - User ID tracking
- * - Structured metadata logging
- *
- * Usage:
- * ```typescript
- * const logger = new WinstonLoggerAdapter('MyService');
- * logger.log('Operation completed', undefined, { orderId: '123' });
- * // Output: { requestId: 'uuid', userId: 'user-id', context: 'MyService', message: 'Operation completed', orderId: '123' }
- * ```
- */ export class WinstonLoggerAdapter {
+export class WinstonLoggerAdapter {
     buildLogMeta(context, args, extra) {
         const meta = args?.length && typeof args[0] === 'object' ? args[0] : {};
         return {
@@ -54,34 +32,30 @@ import { getRequestId, getUserId, getTenantId, getCompanyId } from '../middlewar
         };
     }
     log(message, context, ...args) {
-        winstonLogger.info(message, this.buildLogMeta(context, args));
+        this.logger.info(message, this.buildLogMeta(context, args));
     }
     error(message, trace, context, ...args) {
-        winstonLogger.error(message, this.buildLogMeta(context, args, {
+        this.logger.error(message, this.buildLogMeta(context, args, {
             stack: trace
         }));
     }
     warn(message, context, ...args) {
-        winstonLogger.warn(message, this.buildLogMeta(context, args));
+        this.logger.warn(message, this.buildLogMeta(context, args));
     }
     debug(message, context, ...args) {
-        winstonLogger.debug(message, this.buildLogMeta(context, args));
+        this.logger.debug(message, this.buildLogMeta(context, args));
     }
     verbose(message, context, ...args) {
-        winstonLogger.verbose(message, this.buildLogMeta(context, args));
+        this.logger.verbose(message, this.buildLogMeta(context, args));
     }
-    constructor(context){
+    constructor(context, moduleName){
         _define_property(this, "context", void 0);
+        _define_property(this, "logger", void 0);
         this.context = context;
+        this.logger = moduleName ? createModuleLogger(moduleName) : winstonLogger;
     }
 }
-/**
- * NestJS Logger Adapter
- * Adapts NestJS Logger to ILogger interface
- *
- * Use this when you need to use NestJS's built-in logger
- * instead of Winston (e.g., for testing)
- */ export class NestLoggerAdapter {
+export class NestLoggerAdapter {
     formatMessage(message, args) {
         return args?.length ? `${message} ${JSON.stringify(args)}` : message;
     }