@flusys/nestjs-shared 0.1.0-alpha.1

package/cjs/modules-index.js

@@ -0,0 +1,106 @@
+"use strict";var __create=Object.create;var __defProp=Object.defineProperty;var __getOwnPropDesc=Object.getOwnPropertyDescriptor;var __getOwnPropNames=Object.getOwnPropertyNames;var __getProtoOf=Object.getPrototypeOf;var __hasOwnProp=Object.prototype.hasOwnProperty;var __defNormalProp=(obj,key,value)=>key in obj?__defProp(obj,key,{enumerable:true,configurable:true,writable:true,value}):obj[key]=value;var __name=(target,value)=>__defProp(target,"name",{value,configurable:true});var __commonJS=(cb,mod)=>function __require(){return mod||(0,cb[__getOwnPropNames(cb)[0]])((mod={exports:{}}).exports,mod),mod.exports};var __export=(target,all)=>{for(var name in all)__defProp(target,name,{get:all[name],enumerable:true})};var __copyProps=(to,from,except,desc)=>{if(from&&typeof from==="object"||typeof from==="function"){for(let key of __getOwnPropNames(from))if(!__hasOwnProp.call(to,key)&&key!==except)__defProp(to,key,{get:()=>from[key],enumerable:!(desc=__getOwnPropDesc(from,key))||desc.enumerable})}return to};var __toESM=(mod,isNodeMode,target)=>(target=mod!=null?__create(__getProtoOf(mod)):{},__copyProps(isNodeMode||!mod||!mod.__esModule?__defProp(target,"default",{value:mod,enumerable:true}):target,mod));var __toCommonJS=mod=>__copyProps(__defProp({},"__esModule",{value:true}),mod);var __decorateClass=(decorators,target,key,kind)=>{var result=kind>1?void 0:kind?__getOwnPropDesc(target,key):target;for(var i=decorators.length-1,decorator;i>=0;i--)if(decorator=decorators[i])result=(kind?decorator(target,key,result):decorator(result))||result;if(kind&&result)__defProp(target,key,result);return result};var __decorateParam=(index,decorator)=>(target,key)=>decorator(target,key,index);var __publicField=(obj,key,value)=>__defNormalProp(obj,typeof key!=="symbol"?key+"":key,value);var require_snake_naming_strategy=__commonJS({"node_modules/typeorm-naming-strategies/snake-naming.strategy.js"(exports2){"use strict";Object.defineProperty(exports2,"__esModule",{value:true});exports2.SnakeNamingStrategy=void 0;var typeorm_1=require("typeorm");var StringUtils_1=require("typeorm/util/StringUtils");var SnakeNamingStrategy2=class extends typeorm_1.DefaultNamingStrategy{static{__name(this,"SnakeNamingStrategy")}tableName(className,customName){return customName?customName:StringUtils_1.snakeCase(className)}columnName(propertyName,customName,embeddedPrefixes){return StringUtils_1.snakeCase(embeddedPrefixes.concat("").join("_"))+(customName?customName:StringUtils_1.snakeCase(propertyName))}relationName(propertyName){return StringUtils_1.snakeCase(propertyName)}joinColumnName(relationName,referencedColumnName){return StringUtils_1.snakeCase(relationName+"_"+referencedColumnName)}joinTableName(firstTableName,secondTableName,firstPropertyName,secondPropertyName){return StringUtils_1.snakeCase(firstTableName+"_"+firstPropertyName.replace(/\./gi,"_")+"_"+secondTableName)}joinTableColumnName(tableName,propertyName,columnName){return StringUtils_1.snakeCase(tableName+"_"+(columnName?columnName:propertyName))}classTableInheritanceParentColumnName(parentTableName,parentTableIdPropertyName){return StringUtils_1.snakeCase(parentTableName+"_"+parentTableIdPropertyName)}eagerJoinRelationAlias(alias,propertyPath){return alias+"__"+propertyPath.replace(".","_")}};exports2.SnakeNamingStrategy=SnakeNamingStrategy2}});var require_typeorm_naming_strategies=__commonJS({"node_modules/typeorm-naming-strategies/index.js"(exports2){"use strict";Object.defineProperty(exports2,"__esModule",{value:true});exports2.SnakeNamingStrategy=void 0;var snake_naming_strategy_1=require_snake_naming_strategy();Object.defineProperty(exports2,"SnakeNamingStrategy",{enumerable:true,get:__name(function(){return snake_naming_strategy_1.SnakeNamingStrategy},"get")})}});var index_exports={};__export(index_exports,{CacheModule:()=>CacheModule,DataSourceModule:()=>DataSourceModule,MultiTenantDataSourceService:()=>MultiTenantDataSourceService,UtilsModule:()=>UtilsModule,UtilsService:()=>UtilsService});module.exports=__toCommonJS(index_exports);var import_classes=require("@flusys/nestjs-shared/classes");var import_constants=require("@flusys/nestjs-shared/constants");var import_common=require("@nestjs/common");var CacheModule=class{static forRoot(isGlobal=true,memoryTtl=6e4,memorySize=5e3){return{module:CacheModule,global:isGlobal,providers:[{provide:import_constants.CACHE_INSTANCE,useFactory:__name(()=>new import_classes.HybridCache(memoryTtl,memorySize),"useFactory")}],exports:[import_constants.CACHE_INSTANCE]}}};__name(CacheModule,"CacheModule");CacheModule=__decorateClass([(0,import_common.Module)({})],CacheModule);var import_nestjs_core2=require("@flusys/nestjs-core");var import_common3=require("@nestjs/common");var import_nestjs_core=require("@flusys/nestjs-core");var import_common2=require("@nestjs/common");var import_core=require("@nestjs/core");var import_typeorm=require("typeorm");var import_typeorm_naming_strategies=__toESM(require_typeorm_naming_strategies());var MultiTenantDataSourceService=class{constructor(options,request){this.options=options;this.request=request;this.initializeFromOptions()}logger=new import_common2.Logger(this.constructor.name);tenantHeader=import_nestjs_core.DEFAULT_TENANT_HEADER;initializeFromOptions(){if(!this.options)return;if(!MultiTenantDataSourceService.initialized){this.registerTenants();MultiTenantDataSourceService.initialized=true}}registerTenants(){this.options?.tenants?.forEach(tenant=>{MultiTenantDataSourceService.tenantsRegistry.set(tenant.id,tenant)})}setTenantHeader(header){this.tenantHeader=header}getDatabaseMode(){return this.options?.bootstrapAppConfig?.databaseMode??"single"}isMultiTenant(){return this.getDatabaseMode()==="multi-tenant"}getCurrentTenantId(){if(!this.request)return null;const tenantId=this.request.headers[this.tenantHeader];if(!tenantId)return null;if(!/^[a-zA-Z0-9_-]+$/.test(tenantId)){throw new import_common2.BadRequestException("Invalid tenant ID format. Only alphanumeric characters, hyphens, and underscores are allowed.")}return tenantId}getCurrentTenant(){const tenantId=this.getCurrentTenantId();return tenantId?this.getTenant(tenantId):null}getTenant(tenantId){return MultiTenantDataSourceService.tenantsRegistry.get(tenantId)??null}getAllTenants(){return Array.from(MultiTenantDataSourceService.tenantsRegistry.values())}getActiveTenants(){return this.getAllTenants()}async getDataSource(){return this.isMultiTenant()?this.getTenantDataSource():this.getSingleDataSource()}async getDataSourceForTenant(tenantId){const tenant=this.getTenant(tenantId);if(!tenant){throw new Error(`Tenant '${tenantId}' not found`)}return this.getOrCreateTenantConnection(tenant)}setDataSource(dataSource){MultiTenantDataSourceService.singleDataSource=dataSource}async getRepository(entity){const dataSource=await this.getDataSource();return dataSource.getRepository(entity)}async getRepositoryForTenant(entity,tenantId){const dataSource=await this.getDataSourceForTenant(tenantId);return dataSource.getRepository(entity)}async withTenant(tenantId,callback){const dataSource=await this.getDataSourceForTenant(tenantId);return callback(dataSource)}async forAllTenants(callback){const results=new Map;for(const tenant of this.getActiveTenants()){try{const dataSource=await this.getOrCreateTenantConnection(tenant);results.set(tenant.id,await callback(tenant,dataSource))}catch(error){this.logger.error(`Error processing tenant ${tenant.id}: ${error}`)}}return results}registerTenant(tenant){MultiTenantDataSourceService.tenantsRegistry.set(tenant.id,tenant)}async removeTenant(tenantId){await this.closeTenantConnection(tenantId);MultiTenantDataSourceService.tenantsRegistry.delete(tenantId)}async closeTenantConnection(tenantId){const connection=MultiTenantDataSourceService.tenantConnections.get(tenantId);if(connection?.isInitialized){await connection.destroy();MultiTenantDataSourceService.tenantConnections.delete(tenantId);this.logger.log(`Closed connection for tenant: ${tenantId}`)}}async onModuleDestroy(){for(const[tenantId]of MultiTenantDataSourceService.tenantConnections){await this.closeTenantConnection(tenantId)}}static reset(){MultiTenantDataSourceService.initialized=false;MultiTenantDataSourceService.singleDataSource=null;MultiTenantDataSourceService.singleConnectionLock=null;MultiTenantDataSourceService.tenantConnections.clear();MultiTenantDataSourceService.tenantsRegistry.clear();MultiTenantDataSourceService.connectionLocks.clear()}async getSingleDataSource(){if(MultiTenantDataSourceService.singleDataSource?.isInitialized){return MultiTenantDataSourceService.singleDataSource}if(MultiTenantDataSourceService.singleConnectionLock){return MultiTenantDataSourceService.singleConnectionLock}const config=this.getDefaultDatabaseConfig();if(!config){throw new Error("No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.")}const connectionPromise=this.createDataSourceFromConfig(config);MultiTenantDataSourceService.singleConnectionLock=connectionPromise;try{const dataSource=await connectionPromise;MultiTenantDataSourceService.singleDataSource=dataSource;return dataSource}finally{MultiTenantDataSourceService.singleConnectionLock=null}}async getTenantDataSource(){const tenant=this.getCurrentTenant();if(!tenant){throw new Error(`Tenant not found. Ensure '${this.tenantHeader}' header is set.`)}return this.getOrCreateTenantConnection(tenant)}async getOrCreateTenantConnection(tenant){const existing=MultiTenantDataSourceService.tenantConnections.get(tenant.id);if(existing?.isInitialized){return existing}const pendingConnection=MultiTenantDataSourceService.connectionLocks.get(tenant.id);if(pendingConnection){return pendingConnection}const config=this.buildTenantDatabaseConfig(tenant);const connectionPromise=this.createDataSourceFromConfig(config);MultiTenantDataSourceService.connectionLocks.set(tenant.id,connectionPromise);try{const dataSource=await connectionPromise;MultiTenantDataSourceService.tenantConnections.set(tenant.id,dataSource);this.logger.log(`Created connection for tenant: ${tenant.id}`);return dataSource}finally{MultiTenantDataSourceService.connectionLocks.delete(tenant.id)}}getDefaultDatabaseConfig(){return this.options?.defaultDatabaseConfig??this.options?.tenantDefaultDatabaseConfig}buildTenantDatabaseConfig(tenant){const defaultConfig=this.getDefaultDatabaseConfig();if(!defaultConfig){throw new Error("No default database config for multi-tenant mode.")}return{type:defaultConfig.type,host:tenant.host??defaultConfig.host,port:tenant.port??defaultConfig.port,username:tenant.username??defaultConfig.username,password:tenant.password??defaultConfig.password,database:tenant.database}}async createDataSourceFromConfig(config,entities=[]){const dataSource=new import_typeorm.DataSource({type:config.type,host:config.host,port:config.port,username:config.username,password:config.password,database:config.database,entities,synchronize:false,namingStrategy:new import_typeorm_naming_strategies.SnakeNamingStrategy});if(!dataSource.isInitialized){await dataSource.initialize()}return dataSource}};__name(MultiTenantDataSourceService,"MultiTenantDataSourceService");__publicField(MultiTenantDataSourceService,"tenantConnections",new Map);__publicField(MultiTenantDataSourceService,"singleDataSource",null);__publicField(MultiTenantDataSourceService,"tenantsRegistry",new Map);__publicField(MultiTenantDataSourceService,"initialized",false);__publicField(MultiTenantDataSourceService,"connectionLocks",new Map);__publicField(MultiTenantDataSourceService,"singleConnectionLock",null);MultiTenantDataSourceService=__decorateClass([(0,import_common2.Injectable)({scope:import_common2.Scope.REQUEST}),__decorateParam(0,(0,import_common2.Optional)()),__decorateParam(0,(0,import_common2.Inject)(import_nestjs_core.MODULE_OPTIONS)),__decorateParam(1,(0,import_common2.Optional)()),__decorateParam(1,(0,import_common2.Inject)(import_core.REQUEST))],MultiTenantDataSourceService);var DataSourceModule=class{static forRoot(options){const{global=false,...moduleOptions}=options;return{module:DataSourceModule,global,providers:[{provide:import_nestjs_core2.MODULE_OPTIONS,useValue:moduleOptions},MultiTenantDataSourceService],exports:[import_nestjs_core2.MODULE_OPTIONS,MultiTenantDataSourceService]}}static forRootAsync(asyncOptions){const{global=false,imports=[]}=asyncOptions;return{module:DataSourceModule,global,imports,providers:[...this.createAsyncProviders(asyncOptions),MultiTenantDataSourceService],exports:[import_nestjs_core2.MODULE_OPTIONS,MultiTenantDataSourceService]}}static forFeature(){return{module:DataSourceModule,providers:[MultiTenantDataSourceService],exports:[MultiTenantDataSourceService]}}static createAsyncProviders(options){if(options.useFactory){return[{provide:import_nestjs_core2.MODULE_OPTIONS,useFactory:options.useFactory,inject:options.inject||[]}]}if(options.useClass){return[{provide:options.useClass,useClass:options.useClass},{provide:import_nestjs_core2.MODULE_OPTIONS,useFactory:__name(async factory=>factory.createOptions(),"useFactory"),inject:[options.useClass]}]}if(options.useExisting){return[{provide:import_nestjs_core2.MODULE_OPTIONS,useFactory:__name(async factory=>factory.createOptions(),"useFactory"),inject:[options.useExisting]}]}return[{provide:import_nestjs_core2.MODULE_OPTIONS,useValue:{}}]}};__name(DataSourceModule,"DataSourceModule");DataSourceModule=__decorateClass([(0,import_common3.Module)({})],DataSourceModule);var import_common5=require("@nestjs/common");var import_common4=require("@nestjs/common");var import_class_validator=require("class-validator");var UtilsService=class{constructor(){}getCacheKey(entityName,params,entityId,tenantId){const tenantPrefix=tenantId?`tenant_${tenantId}_`:"";if(entityId)return`${tenantPrefix}entity_${entityName}_id_${entityId}${params?"_select_"+JSON.stringify(params):""}`;return`${tenantPrefix}entity_${entityName}_all_${JSON.stringify(params)}`}async trackCacheKey(cacheKey,entityName,cacheManager,entityId,tenantId){const tenantPrefix=tenantId?`tenant_${tenantId}_`:"";try{if(entityId){const trackingKey=`${tenantPrefix}entity_${entityName}_id_${entityId}_keys`;const idKeys=await cacheManager.get(trackingKey)||[];if(!idKeys.includes(cacheKey))idKeys.push(cacheKey);await cacheManager.set(trackingKey,idKeys)}else{const trackingKey=`${tenantPrefix}entity_${entityName}_keys`;const allKeys=await cacheManager.get(trackingKey)||[];if(!allKeys.includes(cacheKey))allKeys.push(cacheKey);await cacheManager.set(trackingKey,allKeys)}}catch(error){console.error(`Cache tracking failed for ${entityName}:`,error)}}async clearCache(entityName,cacheManager,entityId,tenantId){const tenantPrefix=tenantId?`tenant_${tenantId}_`:"";try{if(entityId){const trackingKey=`${tenantPrefix}entity_${entityName}_id_${entityId}_keys`;const idKeys=await cacheManager.get(trackingKey)||[];await Promise.allSettled(idKeys.map(key=>cacheManager.del(key)));await cacheManager.del(trackingKey)}else{const trackingKey=`${tenantPrefix}entity_${entityName}_keys`;const keySet=await cacheManager.get(trackingKey)||[];await Promise.allSettled(keySet.map(key=>cacheManager.del(key)));await cacheManager.del(trackingKey)}}catch(error){console.error(`Cache invalidation failed for ${entityName}:`,error)}}checkPhoneOrEmail(value){if((0,import_class_validator.isEmail)(value)){return{value,type:"email"}}const phoneMatch=value.match(/^((\+880)|0)?(13|15|16|17|18|19)\d{8}$/);if(phoneMatch){let phone=phoneMatch[0];if(!phone.startsWith("+88")){phone="+88"+phone}return{value:phone,type:"phone"}}return{value:null,type:null}}transformToSlug(value,salt){const slug=value?.trim().replace(/[^A-Z0-9]+/gi,"-").toLowerCase();return salt?`${slug}-${this.getRandomInt(1,100)}`:slug}getRandomInt(min,max){return Math.floor(Math.random()*(max-min+1))+min}generateRandomId(length){const characters="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";let result="";for(let i=0;i<length;i++){result+=characters.charAt(Math.floor(Math.random()*characters.length))}return result}getRandomOtpCode(){return Math.floor(Math.random()*(9999-1e3+1))+1e3}extractColumnNameFromError(detail){const match=detail.match(/\((.*?)\)=\((.*?)\)/);return{columnName:match?match[1]:"unknown",value:match?match[2]:"unknown"}}getOtpEmailFormat(otp,userName){return`
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+      <meta charset="UTF-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+      <title>Your OTP Code</title>
+      <style>
+        body {
+          font-family: Arial, sans-serif;
+          background-color: #f4f4f7;
+          margin: 0;
+          padding: 0;
+        }
+        .email-container {
+          max-width: 500px;
+          margin: 40px auto;
+          background-color: #ffffff;
+          padding: 30px;
+          border-radius: 8px;
+          box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);
+          text-align: center;
+        }
+        h1 {
+          color: #333;
+        }
+        p {
+          font-size: 16px;
+          color: #555;
+        }
+        .otp-box {
+          display: inline-block;
+          margin: 20px 0;
+          padding: 14px 28px;
+          font-size: 24px;
+          letter-spacing: 6px;
+          background-color: #007BFF;
+          color: white;
+          border-radius: 8px;
+          font-weight: bold;
+        }
+      </style>
+    </head>
+    <body>
+      <div class="email-container">
+        <p>Hi ${userName||"Sir/Madam"},</p>
+        <p>Use the code below to verify your identity:</p>
+        <div class="otp-box">${otp}</div>
+        <p>This OTP is valid for a limited time. Do not share it with anyone.</p>
+        <p>If you didn\u2019t request this, please ignore this email.</p>
+      </div>
+    </body>
+    </html>
+  `}getResetPasswordEmailFormat(resetLink,userName){return`
+  <!DOCTYPE html>
+  <html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+    <title>Reset Your Password</title>
+    <style>
+      body {
+        font-family: Arial, sans-serif;
+        background-color: #f4f4f7;
+        margin: 0;
+        padding: 0;
+      }
+      .email-container {
+        max-width: 500px;
+        margin: 40px auto;
+        background-color: #ffffff;
+        padding: 30px;
+        border-radius: 8px;
+        box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);
+        text-align: center;
+      }
+      h1 {
+        color: #333;
+      }
+      p {
+        font-size: 16px;
+        color: #555;
+      }
+      .reset-button {
+        display: inline-block;
+        margin: 20px 0;
+        padding: 14px 28px;
+        font-size: 16px;
+        background-color: #007BFF;
+        color: #ffffff !important;
+        text-decoration: none;
+        border-radius: 6px;
+        font-weight: bold;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="email-container">
+      <p>Hi ${userName||"Sir/Madam"},</p>
+      <p>We received a request to reset your password. Click the button below to reset it:</p>
+      <a href="${resetLink}" class="reset-button" target="_blank">Reset Password</a>
+      <p>If you didn\u2019t request a password reset, you can safely ignore this email.</p>
+    </div>
+  </body>
+  </html>
+  `}};__name(UtilsService,"UtilsService");UtilsService=__decorateClass([(0,import_common4.Injectable)()],UtilsService);var UtilsModule=class{};__name(UtilsModule,"UtilsModule");UtilsModule=__decorateClass([(0,import_common5.Global)(),(0,import_common5.Module)({imports:[],providers:[UtilsService],exports:[UtilsService]})],UtilsModule);0&&(module.exports={CacheModule,DataSourceModule,MultiTenantDataSourceService,UtilsModule,UtilsService});

package/cjs/utils-index.js

@@ -0,0 +1 @@
+"use strict";var __defProp=Object.defineProperty;var __getOwnPropDesc=Object.getOwnPropertyDescriptor;var __getOwnPropNames=Object.getOwnPropertyNames;var __hasOwnProp=Object.prototype.hasOwnProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:true});var __export=(target,all)=>{for(var name in all)__defProp(target,name,{get:all[name],enumerable:true})};var __copyProps=(to,from,except,desc)=>{if(from&&typeof from==="object"||typeof from==="function"){for(let key of __getOwnPropNames(from))if(!__hasOwnProp.call(to,key)&&key!==except)__defProp(to,key,{get:()=>from[key],enumerable:!(desc=__getOwnPropDesc(from,key))||desc.enumerable})}return to};var __toCommonJS=mod=>__copyProps(__defProp({},"__esModule",{value:true}),mod);var index_exports={};__export(index_exports,{ErrorHandler:()=>ErrorHandler});module.exports=__toCommonJS(index_exports);var ErrorHandler=class{static{__name(this,"ErrorHandler")}static getErrorMessage(error){if(error instanceof Error){return error.message}if(typeof error==="string"){return error}return"Unknown error occurred"}static getErrorStack(error){if(error instanceof Error){return error.stack}return void 0}static createErrorContext(error,context){const errorContext={error:{message:this.getErrorMessage(error)}};if(error instanceof Error){errorContext.error.stack=error.stack;errorContext.error.name=error.name}if(context&&Object.keys(context).length>0){errorContext.context=context}return errorContext}static logError(logger,error,operation,context){const errorContext=this.createErrorContext(error,{operation,...context});const errorMessage=`Failed to ${operation}: ${errorContext.error.message}`;const loggerContext=logger.context||"ErrorHandler";logger.error(errorMessage,errorContext.error.stack,loggerContext,errorContext)}static rethrowError(error){if(error instanceof Error){throw error}throw new Error(`Unexpected error: ${String(error)}`)}};0&&(module.exports={ErrorHandler});

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

@@ -0,0 +1,30 @@
+import { BulkResponseDto, DeleteDto, FilterAndPaginationDto, GetByIdBodyDto, ListResponseDto, MessageResponseDto, SingleResponseDto } from '@flusys/nestjs-shared/dtos';
+import { Identity } from '@flusys/nestjs-shared/entities';
+import { ILoggedUserInfo, IService, PermissionCondition, PermissionOperator } from '@flusys/nestjs-shared/interfaces';
+import { Type } from '@nestjs/common';
+export type ApiEndpoint = 'insert' | 'insertMany' | 'getById' | 'getAll' | 'update' | 'updateMany' | 'delete';
+export type SecurityLevel = 'public' | 'jwt' | 'permission';
+export interface EndpointSecurity {
+    level: SecurityLevel;
+    permissions?: string[];
+    operator?: PermissionOperator;
+    condition?: PermissionCondition;
+}
+export type ApiSecurityConfig = {
+    [K in ApiEndpoint]?: EndpointSecurity | SecurityLevel;
+};
+export interface ApiControllerOptions {
+    security?: ApiSecurityConfig | EndpointSecurity | SecurityLevel;
+}
+export declare function createApiController<CreateDtoT extends Record<string, unknown>, UpdateDtoT extends {
+    id: string;
+}, ResponseDtoT extends Record<string, unknown>, InterfaceT extends Identity, ServiceT extends IService<CreateDtoT, UpdateDtoT, InterfaceT>>(createDtoClass: Type<CreateDtoT>, updateDtoClass: Type<UpdateDtoT>, responseDtoClass: Type<ResponseDtoT>, options?: ApiControllerOptions): abstract new (service: ServiceT) => {
+    service: ServiceT;
+    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>>;
+    update(updateDto: UpdateDtoT, user: ILoggedUserInfo | null): Promise<SingleResponseDto<ResponseDtoT>>;
+    updateMany(updateDtos: UpdateDtoT[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<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

@@ -0,0 +1,72 @@
+import { DeleteDto, FilterAndPaginationDto } from '@flusys/nestjs-shared/dtos';
+import { Identity } from '@flusys/nestjs-shared/entities';
+import { ILoggedUserInfo, IService } from '@flusys/nestjs-shared/interfaces';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { Logger } from '@nestjs/common';
+import { QueryRunner, Repository, SelectQueryBuilder } from 'typeorm';
+import { HybridCache } from './hybrid-cache.class';
+export declare abstract class ApiService<CreateDtoT extends Record<string, unknown>, UpdateDtoT extends {
+    id: string;
+}, InterfaceT extends Identity, EntityT extends Identity, RepositoryT extends Repository<EntityT>> implements IService<CreateDtoT, UpdateDtoT, InterfaceT> {
+    protected entityName: string;
+    protected repository: RepositoryT;
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    protected loggerName: string;
+    protected isCacheable: boolean;
+    protected logger: Logger;
+    constructor(entityName: string, repository: RepositoryT, cacheManager: HybridCache, utilsService: UtilsService, loggerName: string, isCacheable?: boolean);
+    insert(dto: CreateDtoT, user: ILoggedUserInfo | null): Promise<InterfaceT>;
+    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[]>;
+    findById(id: string, user: ILoggedUserInfo | null, select?: string[]): Promise<InterfaceT>;
+    getAll(search: string, filterAndPaginationDto: FilterAndPaginationDto, user: ILoggedUserInfo | null): Promise<{
+        data: Array<InterfaceT>;
+        total: number;
+    }>;
+    delete(option: DeleteDto, user: ILoggedUserInfo | null): Promise<null>;
+    clearCacheForAll(): Promise<void>;
+    clearCacheForId(entities: EntityT[]): Promise<void>;
+    private handleError;
+    protected ensureRepositoryInitialized(): Promise<void>;
+    protected beforeInsertOperation(_dto: CreateDtoT | Array<CreateDtoT>, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
+    protected afterInsertOperation(_entity: EntityT[], _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
+    protected beforeUpdateOperation(_dto: UpdateDtoT | Array<UpdateDtoT>, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
+    protected afterUpdateOperation(_entity: EntityT[], _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
+    protected beforeDeleteOperation(_dto: DeleteDto, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
+    protected afterDeleteOperation(_entity: Array<{
+        id: string;
+    }>, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
+    protected getFilterQuery(query: SelectQueryBuilder<EntityT>, filter: {
+        [key: string]: any;
+    }, _user: ILoggedUserInfo | null): Promise<{
+        query: SelectQueryBuilder<EntityT>;
+        isRaw: boolean;
+    }>;
+    protected getSortQuery(query: SelectQueryBuilder<EntityT>, sort: {
+        [key: string]: 'ASC' | 'DESC';
+    }, _user: ILoggedUserInfo | null): Promise<{
+        query: SelectQueryBuilder<EntityT>;
+        isRaw: boolean;
+    }>;
+    protected getSelectQuery(query: SelectQueryBuilder<EntityT>, _user: ILoggedUserInfo | null, select?: string[]): Promise<{
+        query: SelectQueryBuilder<EntityT>;
+        isRaw: boolean;
+    }>;
+    protected getGlobalSearchQuery(query: SelectQueryBuilder<EntityT>, search: string, _user: ILoggedUserInfo | null): Promise<{
+        query: SelectQueryBuilder<EntityT>;
+        isRaw: boolean;
+    }>;
+    protected getExtraManipulateQuery(query: SelectQueryBuilder<EntityT>, _dto: FilterAndPaginationDto, _user: ILoggedUserInfo | null): Promise<{
+        query: SelectQueryBuilder<EntityT>;
+        isRaw: boolean;
+    }>;
+    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 getEntityClass(): Promise<EntityT>;
+}

package/classes/hybrid-cache.class.d.ts

@@ -0,0 +1,10 @@
+export declare class HybridCache {
+    private memory?;
+    private redis?;
+    constructor(memoryTtl?: number, memorySize?: number);
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    del(key: string): Promise<void>;
+    reset(): Promise<void>;
+    resetL2(): Promise<void>;
+}

package/classes/index.d.ts

@@ -0,0 +1,6 @@
+export * from './api-controller.class';
+export * from './api-service.class';
+export * from './request-scoped-api.service';
+export * from './hybrid-cache.class';
+export * from './winston-logger-adapter.class';
+export * from './winston.logger.class';

package/classes/request-scoped-api.service.d.ts

@@ -0,0 +1,13 @@
+import { DataSource, EntityTarget, Repository } from 'typeorm';
+import { Identity } from '../entities';
+import { ApiService } from './api-service.class';
+export declare abstract class RequestScopedApiService<CreateDtoT extends Record<string, unknown>, UpdateDtoT extends {
+    id: string;
+}, InterfaceT extends Identity, EntityT extends Identity, RepositoryT extends Repository<EntityT>> extends ApiService<CreateDtoT, UpdateDtoT, InterfaceT, EntityT, RepositoryT> {
+    private repositoryInitialized;
+    protected abstract resolveEntity(): EntityTarget<EntityT>;
+    protected abstract getDataSourceProvider(): any;
+    protected ensureRepositoryInitialized(): Promise<void>;
+    protected initializeAdditionalRepositories(entities: EntityTarget<any>[]): Promise<Repository<any>[]>;
+    protected getDataSourceForService(): Promise<DataSource>;
+}

package/classes/winston-logger-adapter.class.d.ts

@@ -0,0 +1,20 @@
+import { Logger } from '@nestjs/common';
+import { ILogger } from '../interfaces/logger.interface';
+export declare class WinstonLoggerAdapter implements ILogger {
+    private readonly context?;
+    constructor(context?: string);
+    log(message: string, context?: string, ...args: any[]): void;
+    error(message: string, trace?: string, context?: string, ...args: any[]): void;
+    warn(message: string, context?: string, ...args: any[]): void;
+    debug(message: string, context?: string, ...args: any[]): void;
+    verbose(message: string, context?: string, ...args: any[]): void;
+}
+export declare class NestLoggerAdapter implements ILogger {
+    private readonly logger;
+    constructor(logger: Logger);
+    log(message: string, context?: string, ...args: any[]): void;
+    error(message: string, trace?: string, context?: string, ...args: any[]): void;
+    warn(message: string, context?: string, ...args: any[]): void;
+    debug(message: string, context?: string, ...args: any[]): void;
+    verbose(message: string, context?: string, ...args: any[]): void;
+}

package/classes/winston.logger.class.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from 'winston';
+export declare const instance: Logger;

package/constants/index.d.ts

@@ -0,0 +1,10 @@
+export declare const IS_PUBLIC_KEY = "isPublic";
+export declare const PERMISSIONS_KEY = "permissions";
+export declare const CACHE_INSTANCE = "CACHE_INSTANCE";
+export declare const PERMISSION_GUARD_CONFIG = "PERMISSION_GUARD_CONFIG";
+export declare const LOGGER_INSTANCE = "LOGGER_INSTANCE";
+export declare const IDEMPOTENCY_KEY_HEADER = "x-idempotency-key";
+export declare const REQUEST_ID_HEADER = "x-request-id";
+export declare const CLIENT_TYPE_HEADER = "x-client-type";
+export declare const PERMISSIONS_CACHE_PREFIX = "permissions";
+export declare const IDEMPOTENCY_CACHE_PREFIX = "idempotency";

package/decorators/api-response.decorator.d.ts

@@ -0,0 +1,3 @@
+import { Type } from '@nestjs/common';
+export type ArrayResponseType = 'list' | 'bulk';
+export declare const ApiResponseDto: <T extends Type<unknown>>(dto: T, isArray?: boolean, arrayType?: ArrayResponseType) => <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/decorators/current-user.decorator.d.ts

@@ -0,0 +1 @@
+export declare const CurrentUser: (...dataOrPipes: (string | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;

package/decorators/index.d.ts

@@ -0,0 +1,4 @@
+export * from './api-response.decorator';
+export * from './current-user.decorator';
+export * from './public.decorator';
+export * from './require-permission.decorator';

package/decorators/public.decorator.d.ts

@@ -0,0 +1 @@
+export declare const Public: () => import("@nestjs/common").CustomDecorator<string>;

package/decorators/require-permission.decorator.d.ts

@@ -0,0 +1,4 @@
+import { PermissionCondition } from '../interfaces/permission.interface';
+export declare const RequirePermission: (...permissions: string[]) => import("@nestjs/common").CustomDecorator<string>;
+export declare const RequireAnyPermission: (...permissions: string[]) => import("@nestjs/common").CustomDecorator<string>;
+export declare const RequirePermissionCondition: (condition: PermissionCondition) => import("@nestjs/common").CustomDecorator<string>;

package/dtos/delete.dto.d.ts

@@ -0,0 +1,4 @@
+export declare class DeleteDto {
+    id: string | string[];
+    type: 'delete' | 'restore' | 'permanent';
+}

package/dtos/filter-and-pagination.dto.d.ts

@@ -0,0 +1,13 @@
+import { PaginationDto } from './pagination.dto';
+export declare class FilterAndPaginationDto {
+    filter?: Record<string, unknown>;
+    pagination?: PaginationDto;
+    sort?: Record<string, 'ASC' | 'DESC'>;
+    select?: string[];
+    withDeleted?: boolean;
+    extraKey?: string[];
+}
+export declare class GetByIdBodyDto {
+    select?: string[];
+    extraKey?: string[];
+}

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

@@ -0,0 +1,9 @@
+export declare class IdentityResponseDto {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt?: Date | null;
+    createdById?: string | null;
+    updatedById?: string | null;
+    deletedById?: string | null;
+}

package/dtos/index.d.ts

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

package/dtos/pagination.dto.d.ts

@@ -0,0 +1,4 @@
+export declare class PaginationDto {
+    pageSize: number;
+    currentPage: number;
+}

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

@@ -0,0 +1,63 @@
+export declare class RequestMetaDto {
+    requestId?: string;
+    timestamp?: string;
+    responseTime?: number;
+}
+export declare class SingleResponseDto<T> {
+    success: boolean;
+    message: string;
+    data?: T;
+    _meta?: RequestMetaDto;
+}
+export declare class PaginationMetaDto {
+    total: number;
+    page: number;
+    pageSize: number;
+    count: number;
+    hasMore?: boolean;
+    totalPages?: number;
+}
+export declare class ListResponseDto<T> {
+    success: boolean;
+    message: string;
+    data?: T[];
+    meta: PaginationMetaDto;
+    _meta?: RequestMetaDto;
+}
+export declare class BulkMetaDto {
+    count: number;
+    failed?: number;
+    total?: number;
+}
+export declare class BulkResponseDto<T> {
+    success: boolean;
+    message: string;
+    data?: T[];
+    meta: BulkMetaDto;
+    _meta?: RequestMetaDto;
+}
+export declare class MessageResponseDto {
+    success: boolean;
+    message: string;
+    _meta?: RequestMetaDto;
+}
+export declare class ValidationErrorDto {
+    field: string;
+    message: string;
+    constraint?: string;
+}
+export declare class ErrorResponseDto {
+    success: false;
+    message: string;
+    code?: string;
+    errors?: ValidationErrorDto[];
+    _meta?: RequestMetaDto;
+}
+export declare class ResponsePayloadDto<T> {
+    success: boolean;
+    message: string;
+    data?: T;
+    meta?: PaginationMetaDto | BulkMetaDto;
+    _meta?: RequestMetaDto;
+}
+export type ApiResponse<T> = SingleResponseDto<T> | ListResponseDto<T> | BulkResponseDto<T> | MessageResponseDto | ErrorResponseDto;

package/entities/identity.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class Identity {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt: Date | null;
+    createdById: string | null;
+    updatedById: string | null;
+    deletedById: string | null;
+}

package/entities/index.d.ts

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

package/entities/user-root.d.ts

@@ -0,0 +1,19 @@
+export declare abstract class UserRoot {
+    id: string;
+    name: string | null;
+    password: string | null;
+    email: string;
+    phone: string | null;
+    isActive: boolean;
+    emailVerified: boolean;
+    phoneVerified: boolean;
+    profilePictureId: string | null;
+    lastLoginAt: Date | null;
+    additionalFields: Record<string, any> | null;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt: Date | null;
+    createdById: string | null;
+    updatedById: string | null;
+    deletedById: string | null;
+}

package/exceptions/index.d.ts

@@ -0,0 +1 @@
+export * from './permission.exception';

package/exceptions/permission.exception.d.ts

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