@flusys/nestjs-shared 0.1.0-alpha.1

package/fesm/modules-index.js

@@ -0,0 +1,106 @@
+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 __require=(x=>typeof require!=="undefined"?require:typeof Proxy!=="undefined"?new Proxy(x,{get:(a,b)=>(typeof require!=="undefined"?require:a)[b]}):x)(function(x){if(typeof require!=="undefined")return require.apply(this,arguments);throw Error('Dynamic require of "'+x+'" is not supported')});var __commonJS=(cb,mod)=>function __require2(){return mod||(0,cb[__getOwnPropNames(cb)[0]])((mod={exports:{}}).exports,mod),mod.exports};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 __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"(exports){"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.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(".","_")}};exports.SnakeNamingStrategy=SnakeNamingStrategy2}});var require_typeorm_naming_strategies=__commonJS({"node_modules/typeorm-naming-strategies/index.js"(exports){"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.SnakeNamingStrategy=void 0;var snake_naming_strategy_1=require_snake_naming_strategy();Object.defineProperty(exports,"SnakeNamingStrategy",{enumerable:true,get:__name(function(){return snake_naming_strategy_1.SnakeNamingStrategy},"get")})}});import{HybridCache}from"@flusys/nestjs-shared/classes";import{CACHE_INSTANCE}from"@flusys/nestjs-shared/constants";import{Module}from"@nestjs/common";var CacheModule=class{static forRoot(isGlobal=true,memoryTtl=6e4,memorySize=5e3){return{module:CacheModule,global:isGlobal,providers:[{provide:CACHE_INSTANCE,useFactory:__name(()=>new HybridCache(memoryTtl,memorySize),"useFactory")}],exports:[CACHE_INSTANCE]}}};__name(CacheModule,"CacheModule");CacheModule=__decorateClass([Module({})],CacheModule);import{MODULE_OPTIONS as MODULE_OPTIONS2}from"@flusys/nestjs-core";import{Module as Module2}from"@nestjs/common";var import_typeorm_naming_strategies=__toESM(require_typeorm_naming_strategies());import{DEFAULT_TENANT_HEADER,MODULE_OPTIONS}from"@flusys/nestjs-core";import{BadRequestException,Inject,Injectable,Logger,Optional,Scope}from"@nestjs/common";import{REQUEST}from"@nestjs/core";import{DataSource}from"typeorm";var MultiTenantDataSourceService=class{constructor(options,request){this.options=options;this.request=request;this.initializeFromOptions()}logger=new Logger(this.constructor.name);tenantHeader=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 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 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([Injectable({scope:Scope.REQUEST}),__decorateParam(0,Optional()),__decorateParam(0,Inject(MODULE_OPTIONS)),__decorateParam(1,Optional()),__decorateParam(1,Inject(REQUEST))],MultiTenantDataSourceService);var DataSourceModule=class{static forRoot(options){const{global=false,...moduleOptions}=options;return{module:DataSourceModule,global,providers:[{provide:MODULE_OPTIONS2,useValue:moduleOptions},MultiTenantDataSourceService],exports:[MODULE_OPTIONS2,MultiTenantDataSourceService]}}static forRootAsync(asyncOptions){const{global=false,imports=[]}=asyncOptions;return{module:DataSourceModule,global,imports,providers:[...this.createAsyncProviders(asyncOptions),MultiTenantDataSourceService],exports:[MODULE_OPTIONS2,MultiTenantDataSourceService]}}static forFeature(){return{module:DataSourceModule,providers:[MultiTenantDataSourceService],exports:[MultiTenantDataSourceService]}}static createAsyncProviders(options){if(options.useFactory){return[{provide:MODULE_OPTIONS2,useFactory:options.useFactory,inject:options.inject||[]}]}if(options.useClass){return[{provide:options.useClass,useClass:options.useClass},{provide:MODULE_OPTIONS2,useFactory:__name(async factory=>factory.createOptions(),"useFactory"),inject:[options.useClass]}]}if(options.useExisting){return[{provide:MODULE_OPTIONS2,useFactory:__name(async factory=>factory.createOptions(),"useFactory"),inject:[options.useExisting]}]}return[{provide:MODULE_OPTIONS2,useValue:{}}]}};__name(DataSourceModule,"DataSourceModule");DataSourceModule=__decorateClass([Module2({})],DataSourceModule);import{Global,Module as Module3}from"@nestjs/common";import{Injectable as Injectable2}from"@nestjs/common";import{isEmail}from"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(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([Injectable2()],UtilsService);var UtilsModule=class{};__name(UtilsModule,"UtilsModule");UtilsModule=__decorateClass([Global(),Module3({imports:[],providers:[UtilsService],exports:[UtilsService]})],UtilsModule);export{CacheModule,DataSourceModule,MultiTenantDataSourceService,UtilsModule,UtilsService};

package/fesm/utils-index.js

@@ -0,0 +1 @@
+var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:true});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)}`)}};export{ErrorHandler};

package/guards/index.d.ts

@@ -0,0 +1,2 @@
+export * from './jwt-auth.guard';
+export * from './permission.guard';

package/guards/jwt-auth.guard.d.ts

@@ -0,0 +1,10 @@
+import { ExecutionContext } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+declare const JwtAuthGuard_base: import("@nestjs/passport").Type<import("@nestjs/passport").IAuthGuard>;
+export declare class JwtAuthGuard extends JwtAuthGuard_base {
+    private reflector;
+    constructor(reflector: Reflector);
+    canActivate(context: ExecutionContext): boolean | Promise<boolean> | import("rxjs").Observable<boolean>;
+    handleRequest(err: any, user: any): any;
+}
+export {};

package/guards/permission.guard.d.ts

@@ -0,0 +1,18 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { HybridCache } from '../classes/hybrid-cache.class';
+import { ILogger } from '../interfaces/logger.interface';
+import { PermissionGuardConfig } from '../interfaces/permission.interface';
+export declare class PermissionGuard implements CanActivate {
+    private readonly reflector;
+    private readonly cache?;
+    private readonly config;
+    private readonly logger;
+    constructor(reflector: Reflector, cache?: HybridCache, config?: PermissionGuardConfig, logger?: ILogger);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+    private normalizePermissionConfig;
+    private isNestedCondition;
+    private evaluateCondition;
+    private getUserPermissions;
+    private hasPermission;
+}

package/index.d.ts

@@ -0,0 +1,12 @@
+export * from './classes';
+export * from './constants';
+export * from './decorators';
+export * from './dtos';
+export * from './entities';
+export * from './exceptions';
+export * from './guards';
+export * from './interceptors';
+export * from './interfaces';
+export * from './middlewares';
+export * from './modules';
+export * from './utils';

package/interceptors/delete-empty-id-from-body.interceptor.d.ts

@@ -0,0 +1,5 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+export declare class DeleteEmptyIdFromBodyInterceptor implements NestInterceptor {
+    intercept<T = any>(context: ExecutionContext, next: CallHandler<T>): Observable<T>;
+}

package/interceptors/idempotency.interceptor.d.ts

@@ -0,0 +1,10 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { HybridCache } from '../classes/hybrid-cache.class';
+export declare class IdempotencyInterceptor implements NestInterceptor {
+    private readonly cache?;
+    private readonly CACHE_TTL;
+    private readonly PROCESSING_MARKER;
+    constructor(cache?: HybridCache);
+    intercept<T = any>(context: ExecutionContext, next: CallHandler<T>): Promise<Observable<T>>;
+}

package/interceptors/index.d.ts

@@ -0,0 +1,8 @@
+export * from './delete-empty-id-from-body.interceptor';
+export * from './idempotency.interceptor';
+export * from './query-performance.interceptor';
+export * from './response-meta.interceptor';
+export * from './set-create-by-on-body.interceptor';
+export * from './set-delete-by-on-body.interceptor';
+export * from './set-update-by-on-body.interceptor';
+export * from './slug.interceptor';

package/interceptors/query-performance.interceptor.d.ts

@@ -0,0 +1,8 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+export declare class QueryPerformanceInterceptor implements NestInterceptor {
+    private readonly logger;
+    private readonly threshold;
+    constructor(threshold?: number);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+}

package/interceptors/response-meta.interceptor.d.ts

@@ -0,0 +1,5 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+export declare class ResponseMetaInterceptor implements NestInterceptor {
+    intercept<T = any>(context: ExecutionContext, next: CallHandler<T>): Observable<T>;
+}

package/interceptors/set-create-by-on-body.interceptor.d.ts

@@ -0,0 +1,5 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+export declare class SetCreatedByOnBody implements NestInterceptor {
+    intercept<T = any>(context: ExecutionContext, next: CallHandler<T>): Observable<T>;
+}

package/interceptors/set-delete-by-on-body.interceptor.d.ts

@@ -0,0 +1,5 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+export declare class SetDeletedByOnBody implements NestInterceptor {
+    intercept<T = any>(context: ExecutionContext, next: CallHandler<T>): Observable<T>;
+}

package/interceptors/set-update-by-on-body.interceptor.d.ts

@@ -0,0 +1,5 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+export declare class SetUpdateByOnBody implements NestInterceptor {
+    intercept<T = any>(context: ExecutionContext, next: CallHandler<T>): Observable<T>;
+}

package/interceptors/slug.interceptor.d.ts

@@ -0,0 +1,7 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { UtilsService } from '../modules/utils/utils.service';
+export declare class Slug implements NestInterceptor {
+    utilsService: UtilsService;
+    intercept<T = any>(context: ExecutionContext, next: CallHandler<T>): Observable<T>;
+}

package/interfaces/api.interface.d.ts

@@ -0,0 +1,14 @@
+import { DeleteDto, FilterAndPaginationDto } from '@flusys/nestjs-shared/dtos';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+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>;
+    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>>;
+    delete(deleteDto: DeleteDto, user: ILoggedUserInfo | null): Promise<null>;
+}

package/interfaces/base-query.interface.d.ts

@@ -0,0 +1,7 @@
+export interface IBaseQueryDto {
+    search?: string;
+    sortBy?: string;
+    sortOrder?: 'ASC' | 'DESC';
+    page?: number;
+    limit?: number;
+}

package/interfaces/identity.interface.d.ts

@@ -0,0 +1,9 @@
+export interface IIdentity {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt: Date;
+    createdById: string;
+    updatedById: string;
+    deletedById: string;
+}

package/interfaces/index.d.ts

@@ -0,0 +1,6 @@
+export * from './api.interface';
+export * from './base-query.interface';
+export * from './identity.interface';
+export * from './logged-user-info.interface';
+export * from './logger.interface';
+export * from './permission.interface';

package/interfaces/logged-user-info.interface.d.ts

@@ -0,0 +1,11 @@
+export interface ILoggedUserInfo {
+    id: string;
+    email: string;
+    name?: string;
+    phone?: string;
+    profilePictureId?: string;
+    companyId?: string;
+    branchId?: string;
+    companyLogoId?: string;
+    branchLogoId?: string;
+}

package/interfaces/logger.interface.d.ts

@@ -0,0 +1,7 @@
+export interface ILogger {
+    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/interfaces/permission.interface.d.ts

@@ -0,0 +1,17 @@
+export type PermissionOperator = 'and' | 'or';
+export interface PermissionCondition {
+    permissions?: string[];
+    operator: PermissionOperator;
+    children?: PermissionCondition[];
+}
+export interface LegacyPermissionConfig {
+    permissions: string[];
+    operator: PermissionOperator;
+}
+export type PermissionConfig = PermissionCondition | LegacyPermissionConfig | string[];
+export interface PermissionGuardConfig {
+    enableCompanyFeature?: boolean;
+    cacheKeyPrefix?: string;
+    userPermissionKeyFormat?: string;
+    companyPermissionKeyFormat?: string;
+}

package/middlewares/index.d.ts

@@ -0,0 +1 @@
+export * from './logger.middleware';

package/middlewares/logger.middleware.d.ts

@@ -0,0 +1,23 @@
+import { NestMiddleware } from '@nestjs/common';
+import { Request, Response, NextFunction } from 'express';
+import { AsyncLocalStorage } from 'async_hooks';
+export interface IRequestContext {
+    requestId: string;
+    tenantId?: string;
+    userId?: string;
+    companyId?: string;
+    startTime: number;
+}
+export declare const requestContext: AsyncLocalStorage<IRequestContext>;
+export declare const getRequestId: () => string | undefined;
+export declare const getTenantId: () => string | undefined;
+export declare const getUserId: () => string | undefined;
+export declare const getCompanyId: () => string | undefined;
+export declare const setUserId: (userId: string) => void;
+export declare const setCompanyId: (companyId: string) => void;
+export declare class LoggerMiddleware implements NestMiddleware {
+    private readonly logger;
+    use(req: Request, res: Response, next: NextFunction): void;
+    private logRequest;
+    private logResponse;
+}

package/modules/cache/cache.module.d.ts

@@ -0,0 +1,4 @@
+import { DynamicModule } from '@nestjs/common';
+export declare class CacheModule {
+    static forRoot(isGlobal?: boolean, memoryTtl?: number, memorySize?: number): DynamicModule;
+}

package/modules/datasource/datasource.module.d.ts

@@ -0,0 +1,18 @@
+import { IAsyncModuleOptions, IDataSourceServiceOptions, IModuleOptionsFactory } from '@flusys/nestjs-core';
+import { DynamicModule, Type } from '@nestjs/common';
+export interface DataSourceModuleOptions extends IDataSourceServiceOptions {
+    global?: boolean;
+}
+export interface DataSourceOptionsFactory extends IModuleOptionsFactory<IDataSourceServiceOptions> {
+    createOptions(): Promise<IDataSourceServiceOptions> | IDataSourceServiceOptions;
+}
+export interface DataSourceModuleAsyncOptions extends IAsyncModuleOptions<IDataSourceServiceOptions> {
+    useClass?: Type<DataSourceOptionsFactory>;
+    useExisting?: Type<DataSourceOptionsFactory>;
+}
+export declare class DataSourceModule {
+    static forRoot(options: DataSourceModuleOptions): DynamicModule;
+    static forRootAsync(asyncOptions: DataSourceModuleAsyncOptions): DynamicModule;
+    static forFeature(): DynamicModule;
+    private static createAsyncProviders;
+}

package/modules/datasource/index.d.ts

@@ -0,0 +1,2 @@
+export * from './datasource.module';
+export * from './multi-tenant-datasource.service';

package/modules/datasource/multi-tenant-datasource.service.d.ts

@@ -0,0 +1,45 @@
+import { DatabaseMode, IDatabaseConfig, IDataSourceServiceOptions, ITenantDatabaseConfig } from '@flusys/nestjs-core';
+import { Logger, OnModuleDestroy } from '@nestjs/common';
+import { Request } from 'express';
+import { DataSource, EntityTarget, ObjectLiteral, Repository } from 'typeorm';
+export declare class MultiTenantDataSourceService implements OnModuleDestroy {
+    protected readonly options?: IDataSourceServiceOptions;
+    protected readonly request?: Request;
+    protected readonly logger: Logger;
+    protected static readonly tenantConnections: Map<string, DataSource>;
+    protected static singleDataSource: DataSource | null;
+    protected static readonly tenantsRegistry: Map<string, ITenantDatabaseConfig>;
+    protected static initialized: boolean;
+    protected static readonly connectionLocks: Map<string, Promise<DataSource>>;
+    protected static singleConnectionLock: Promise<DataSource> | null;
+    protected tenantHeader: string;
+    constructor(options?: IDataSourceServiceOptions, request?: Request);
+    private initializeFromOptions;
+    private registerTenants;
+    setTenantHeader(header: string): void;
+    getDatabaseMode(): DatabaseMode;
+    isMultiTenant(): boolean;
+    getCurrentTenantId(): string | null;
+    getCurrentTenant(): ITenantDatabaseConfig | null;
+    getTenant(tenantId: string): ITenantDatabaseConfig | null;
+    getAllTenants(): ITenantDatabaseConfig[];
+    getActiveTenants(): ITenantDatabaseConfig[];
+    getDataSource(): Promise<DataSource>;
+    getDataSourceForTenant(tenantId: string): Promise<DataSource>;
+    setDataSource(dataSource: DataSource): void;
+    getRepository<T extends ObjectLiteral>(entity: EntityTarget<T>): Promise<Repository<T>>;
+    getRepositoryForTenant<T extends ObjectLiteral>(entity: EntityTarget<T>, tenantId: string): Promise<Repository<T>>;
+    withTenant<T>(tenantId: string, callback: (ds: DataSource) => Promise<T>): Promise<T>;
+    forAllTenants<T>(callback: (tenant: ITenantDatabaseConfig, ds: DataSource) => Promise<T>): Promise<Map<string, T>>;
+    registerTenant(tenant: ITenantDatabaseConfig): void;
+    removeTenant(tenantId: string): Promise<void>;
+    closeTenantConnection(tenantId: string): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    static reset(): void;
+    protected getSingleDataSource(): Promise<DataSource>;
+    protected getTenantDataSource(): Promise<DataSource>;
+    protected getOrCreateTenantConnection(tenant: ITenantDatabaseConfig): Promise<DataSource>;
+    protected getDefaultDatabaseConfig(): IDatabaseConfig | undefined;
+    protected buildTenantDatabaseConfig(tenant: ITenantDatabaseConfig): IDatabaseConfig;
+    protected createDataSourceFromConfig(config: IDatabaseConfig, entities?: any[]): Promise<DataSource>;
+}

package/modules/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cache/cache.module';
+export * from './datasource';
+export * from './utils/utils.module';
+export * from './utils/utils.service';

package/modules/utils/utils.module.d.ts

@@ -0,0 +1,2 @@
+export declare class UtilsModule {
+}

package/modules/utils/utils.service.d.ts

@@ -0,0 +1,21 @@
+import { HybridCache } from '@flusys/nestjs-shared/classes';
+export declare class UtilsService {
+    constructor();
+    getCacheKey(entityName: string, params: any, entityId?: string, tenantId?: string): string;
+    trackCacheKey(cacheKey: string, entityName: string, cacheManager: HybridCache, entityId?: string, tenantId?: string): Promise<void>;
+    clearCache(entityName: string, cacheManager: HybridCache, entityId?: string, tenantId?: string): Promise<void>;
+    checkPhoneOrEmail(value: string): {
+        value: string | null;
+        type: 'phone' | 'email' | null;
+    };
+    transformToSlug(value: string, salt?: boolean): string;
+    getRandomInt(min: number, max: number): number;
+    generateRandomId(length: number): string;
+    getRandomOtpCode(): number;
+    extractColumnNameFromError(detail: string): {
+        columnName: string;
+        value: string;
+    };
+    getOtpEmailFormat(otp: number, userName?: string | null | undefined): string;
+    getResetPasswordEmailFormat(resetLink: string, userName?: string | null | undefined): string;
+}

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@flusys/nestjs-shared",
+  "version": "0.1.0-alpha.1",
+  "description": "Common shared utilities for Flusys NestJS applications",
+  "main": "cjs/index.js",
+  "module": "fesm/index.js",
+  "types": "index.d.ts",
+  "sideEffects": false,
+  "keywords": [
+    "nestjs",
+    "common",
+    "utilities",
+    "decorators",
+    "guards",
+    "@flusys"
+  ],
+  "license": "UNLICENSED",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./fesm/index.js",
+      "require": "./cjs/index.js"
+    },
+    "./classes": {
+      "types": "./classes/index.d.ts",
+      "import": "./fesm/classes-index.js",
+      "require": "./cjs/classes-index.js"
+    },
+    "./constants": {
+      "types": "./constants/index.d.ts",
+      "import": "./fesm/constants-index.js",
+      "require": "./cjs/constants-index.js"
+    },
+    "./decorators": {
+      "types": "./decorators/index.d.ts",
+      "import": "./fesm/decorators-index.js",
+      "require": "./cjs/decorators-index.js"
+    },
+    "./dtos": {
+      "types": "./dtos/index.d.ts",
+      "import": "./fesm/dtos-index.js",
+      "require": "./cjs/dtos-index.js"
+    },
+    "./entities": {
+      "types": "./entities/index.d.ts",
+      "import": "./fesm/entities-index.js",
+      "require": "./cjs/entities-index.js"
+    },
+    "./exceptions": {
+      "types": "./exceptions/index.d.ts",
+      "import": "./fesm/exceptions-index.js",
+      "require": "./cjs/exceptions-index.js"
+    },
+    "./guards": {
+      "types": "./guards/index.d.ts",
+      "import": "./fesm/guards-index.js",
+      "require": "./cjs/guards-index.js"
+    },
+    "./interceptors": {
+      "types": "./interceptors/index.d.ts",
+      "import": "./fesm/interceptors-index.js",
+      "require": "./cjs/interceptors-index.js"
+    },
+    "./interfaces": {
+      "types": "./interfaces/index.d.ts",
+      "import": "./fesm/interfaces-index.js",
+      "require": "./cjs/interfaces-index.js"
+    },
+    "./middlewares": {
+      "types": "./middlewares/index.d.ts",
+      "import": "./fesm/middlewares-index.js",
+      "require": "./cjs/middlewares-index.js"
+    },
+    "./modules": {
+      "types": "./modules/index.d.ts",
+      "import": "./fesm/modules-index.js",
+      "require": "./cjs/modules-index.js"
+    },
+    "./utils": {
+      "types": "./utils/index.d.ts",
+      "import": "./fesm/utils-index.js",
+      "require": "./cjs/utils-index.js"
+    }
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/config": "^3.0.0 || ^4.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
+    "@nestjs/jwt": "^10.0.0 || ^11.0.0",
+    "@nestjs/passport": "^10.0.0 || ^11.0.0",
+    "@nestjs/swagger": "^7.0.0 || ^11.0.0",
+    "@nestjs/typeorm": "^10.0.0 || ^11.0.0",
+    "class-transformer": "^0.5.0",
+    "class-validator": "^0.14.0",
+    "typeorm": "^0.3.0"
+  },
+  "dependencies": {
+    "@flusys/nestjs-core": "0.1.0-alpha.1"
+  }
+}

package/utils/error-handler.util.d.ts

@@ -0,0 +1,24 @@
+import { Logger } from '@nestjs/common';
+export declare class ErrorHandler {
+    static getErrorMessage(error: unknown): string;
+    static getErrorStack(error: unknown): string | undefined;
+    static createErrorContext(error: unknown, context?: {
+        operation?: string;
+        entity?: string;
+        userId?: string;
+        [key: string]: unknown;
+    }): {
+        error: {
+            message: string;
+            stack?: string;
+            name?: string;
+        };
+        context?: Record<string, unknown>;
+    };
+    static logError(logger: Logger, error: unknown, operation: string, context?: {
+        entity?: string;
+        userId?: string;
+        [key: string]: unknown;
+    }): void;
+    static rethrowError(error: unknown): never;
+}

package/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './error-handler.util';