@flusys/nestjs-shared 1.0.0-rc → 2.0.0

package/fesm/utils/request.util.js

@@ -0,0 +1,58 @@
+import { CLIENT_TYPE_HEADER } from '../constants';
+/** Time unit multipliers in milliseconds */ const TIME_UNIT_MS = {
+    s: 1000,
+    m: 60 * 1000,
+    h: 60 * 60 * 1000,
+    d: 24 * 60 * 60 * 1000,
+    w: 7 * 24 * 60 * 60 * 1000
+};
+/** Get normalized client type from request header */ function getClientType(req) {
+    const clientType = req.headers[CLIENT_TYPE_HEADER];
+    return clientType ? clientType.toLowerCase() : null;
+}
+/**
+ * Detect if request is from a browser client.
+ * Uses x-client-type header first, then falls back to user-agent detection.
+ */ export function isBrowserRequest(req) {
+    const clientType = getClientType(req);
+    if (clientType) {
+        return clientType === 'browser' || clientType === 'web';
+    }
+    const accept = req.headers['accept'] || '';
+    if (accept.includes('text/html')) return true;
+    const userAgent = req.headers['user-agent'] || '';
+    const browserPatterns = /mozilla|chrome|safari|firefox|edge|opera|msie/i;
+    return browserPatterns.test(userAgent) && !userAgent.includes('Postman');
+}
+/**
+ * Build secure cookie options based on request context.
+ * Handles HTTPS detection for TLS-terminating proxies.
+ */ export function buildCookieOptions(req) {
+    const hostname = req.hostname || '';
+    const origin = req.headers.origin || '';
+    const isProduction = process.env.NODE_ENV === 'production';
+    const forwardedProto = req.headers['x-forwarded-proto'];
+    const isHttps = isProduction || forwardedProto === 'https' || origin.startsWith('https://') || req.secure;
+    let domain;
+    const domainParts = hostname.split('.');
+    if (domainParts.length > 2 && !hostname.includes('localhost')) {
+        domain = '.' + domainParts.slice(-2).join('.');
+    }
+    return {
+        secure: isHttps,
+        sameSite: isHttps ? 'strict' : 'lax',
+        ...domain && {
+            domain
+        }
+    };
+}
+/**
+ * Parse duration string to milliseconds.
+ * @example '7d' → 604800000, '24h' → 86400000, '30m' → 1800000
+ */ export function parseDurationToMs(duration, defaultMs = TIME_UNIT_MS.w) {
+    const match = duration.match(/^(\d+)(s|m|h|d|w)$/);
+    if (!match) return defaultMs;
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    return value * (TIME_UNIT_MS[unit] ?? TIME_UNIT_MS.d);
+}

package/fesm/utils/string.util.js

@@ -0,0 +1,71 @@
+/**
+ * String utility functions
+ */ /**
+ * Generate URL-friendly slug from a string
+ * @param text - The text to convert to slug
+ * @param maxLength - Maximum length of the slug (default: 100)
+ * @returns URL-friendly slug
+ *
+ * @example
+ * generateSlug('My Company Name') // 'my-company-name'
+ * generateSlug('Hello World!') // 'hello-world'
+ */ export function generateSlug(text, maxLength = 100) {
+    return text.toLowerCase().trim().replace(/[^a-z0-9\s-]/g, '') // Remove special characters
+    .replace(/\s+/g, '-') // Replace spaces with hyphens
+    .replace(/-+/g, '-') // Replace multiple hyphens with single
+    .replace(/^-+|-+$/g, '') // Remove leading/trailing hyphens
+    .substring(0, maxLength);
+}
+/**
+ * Generate unique slug using single database query (optimized for large datasets)
+ * Appends numeric suffix if collision exists (e.g., 'my-company-1', 'my-company-2')
+ *
+ * Performance: O(1) database query regardless of collision count
+ * - Works efficiently with millions of records
+ * - Requires index on slug column for best performance
+ *
+ * @param text - The text to convert to slug
+ * @param findMatchingSlugs - Async function that returns all slugs matching base pattern
+ *                            Should query: WHERE slug = baseSlug OR slug LIKE 'baseSlug-%'
+ * @param maxLength - Maximum length of the base slug (default: 100)
+ * @returns Unique URL-friendly slug
+ *
+ * @example
+ * const slug = await generateUniqueSlug('My Company', async (baseSlug) => {
+ *   return repo
+ *     .createQueryBuilder('c')
+ *     .select('c.slug')
+ *     .where('c.slug = :base OR c.slug LIKE :pattern', {
+ *       base: baseSlug,
+ *       pattern: `${baseSlug}-%`,
+ *     })
+ *     .getMany()
+ *     .then(rows => rows.map(r => r.slug));
+ * });
+ */ export async function generateUniqueSlug(text, findMatchingSlugs, maxLength = 100) {
+    const baseSlug = generateSlug(text, maxLength);
+    // Single query to get all matching slugs
+    const existingSlugs = await findMatchingSlugs(baseSlug);
+    // No collisions - base slug is available
+    if (existingSlugs.length === 0) {
+        return baseSlug;
+    }
+    // Build set for O(1) lookup
+    const existingSet = new Set(existingSlugs);
+    // Base slug not taken (only suffixed versions exist)
+    if (!existingSet.has(baseSlug)) {
+        return baseSlug;
+    }
+    // Find next available suffix in memory (fast)
+    let counter = 1;
+    while(counter < 10000){
+        const slugWithSuffix = `${baseSlug}-${counter}`;
+        if (!existingSet.has(slugWithSuffix)) {
+            return slugWithSuffix;
+        }
+        counter++;
+    }
+    // Fallback: append random string (extremely rare edge case)
+    const randomSuffix = Math.random().toString(36).substring(2, 8);
+    return `${baseSlug}-${randomSuffix}`;
+}

package/guards/permission.guard.d.ts

@@ -11,8 +11,10 @@ export declare class PermissionGuard implements CanActivate {
     constructor(reflector: Reflector, cache?: HybridCache, config?: PermissionGuardConfig, logger?: ILogger);
     canActivate(context: ExecutionContext): Promise<boolean>;
     private normalizePermissionConfig;
+    private validateSimplePermissions;
     private isNestedCondition;
     private evaluateCondition;
     private getUserPermissions;
+    private buildPermissionCacheKey;
     private hasPermission;
 }

package/interceptors/index.d.ts

@@ -3,7 +3,4 @@ export * from './idempotency.interceptor';
 export * from './query-performance.interceptor';
 export * from './response-meta.interceptor';
 export * from './set-user-field-on-body.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/set-user-field-on-body.interceptor.d.ts

@@ -1,2 +1,5 @@
 import { NestInterceptor, Type } from '@nestjs/common';
 export declare function createSetUserFieldInterceptor(fieldName: string): Type<NestInterceptor>;
+export declare const SetCreatedByOnBody: Type<NestInterceptor<any, any>>;
+export declare const SetUpdateByOnBody: Type<NestInterceptor<any, any>>;
+export declare const SetDeletedByOnBody: Type<NestInterceptor<any, any>>;

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

@@ -6,6 +6,4 @@ export interface ILoggedUserInfo {
     profilePictureId?: string;
     companyId?: string;
     branchId?: string;
-    companyLogoId?: string;
-    branchLogoId?: string;
 }

package/middlewares/logger.middleware.d.ts

@@ -13,11 +13,11 @@ 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 setupResponseLogging;
     private logRequest;
     private logResponse;
+    private buildBaseLogData;
 }

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

@@ -15,4 +15,5 @@ export declare class DataSourceModule {
     static forRootAsync(asyncOptions: DataSourceModuleAsyncOptions): DynamicModule;
     static forFeature(): DynamicModule;
     private static createAsyncProviders;
+    private static createFactoryProvider;
 }

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

@@ -28,7 +28,6 @@ export declare class MultiTenantDataSourceService implements OnModuleDestroy {
     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;

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

@@ -1,27 +1,11 @@
 import { HybridCache } from '../../classes/hybrid-cache.class';
-export declare const DEFAULT_PHONE_REGEX: RegExp;
-export declare const DEFAULT_PHONE_COUNTRY_CODE = "+88";
-export interface PhoneValidationConfig {
-    regex: RegExp;
-    countryCode: string;
-}
 export declare class UtilsService {
     private readonly logger;
-    private phoneConfig;
-    setPhoneValidationConfig(config: PhoneValidationConfig): void;
     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;
-    };
+    private buildTenantPrefix;
+    private buildTrackingKey;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-shared",
-  "version": "1.0.0-rc",
+  "version": "2.0.0",
   "description": "Common shared utilities for Flusys NestJS applications",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -105,6 +105,6 @@
     "winston-daily-rotate-file": "^5.0.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "1.0.0-rc"
+    "@flusys/nestjs-core": "2.0.0"
   }
 }

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

@@ -9,26 +9,11 @@ export interface IErrorContext {
     sectionId?: string;
     data?: Record<string, unknown>;
 }
-export interface ISanitizedError {
-    message: string;
-    code?: string;
-    statusCode?: number;
-    stack?: string;
-}
 export declare class ErrorHandler {
-    static getErrorMessage(error: unknown, sanitizeForClient?: boolean): string;
-    private static containsSensitiveData;
-    static getErrorStack(error: unknown, forClient?: boolean): string | undefined;
-    static createClientError(error: unknown, statusCode?: number, code?: string): ISanitizedError;
+    static getErrorMessage(error: unknown): string;
     private static sanitizeContextForLogging;
-    static createErrorContext(error: unknown, context?: IErrorContext): {
-        error: {
-            message: string;
-            stack?: string;
-            name?: string;
-        };
-        context?: Record<string, unknown>;
-    };
+    private static createErrorContext;
     static logError(logger: Logger, error: unknown, operation: string, context?: Omit<IErrorContext, 'operation'>): void;
     static rethrowError(error: unknown): never;
+    static logAndRethrow(logger: Logger, error: unknown, operation: string, context?: Omit<IErrorContext, 'operation'>): never;
 }

package/utils/html-sanitizer.util.d.ts

@@ -1,3 +1,2 @@
 export declare function escapeHtml(str: string): string;
 export declare function escapeHtmlVariables(variables: Record<string, unknown>): Record<string, string>;
-export declare function containsHtmlContent(str: string): boolean;

package/utils/index.d.ts

@@ -1,3 +1,5 @@
 export * from './error-handler.util';
 export * from './html-sanitizer.util';
 export * from './query-helpers.util';
+export * from './request.util';
+export * from './string.util';

package/utils/request.util.d.ts

@@ -0,0 +1,4 @@
+import { CookieOptions, Request } from 'express';
+export declare function isBrowserRequest(req: Request): boolean;
+export declare function buildCookieOptions(req: Request): Pick<CookieOptions, 'secure' | 'sameSite' | 'domain'>;
+export declare function parseDurationToMs(duration: string, defaultMs?: number): number;

package/utils/string.util.d.ts

@@ -0,0 +1,2 @@
+export declare function generateSlug(text: string, maxLength?: number): string;
+export declare function generateUniqueSlug(text: string, findMatchingSlugs: (baseSlug: string) => Promise<string[]>, maxLength?: number): Promise<string>;

package/cjs/interceptors/set-create-by-on-body.interceptor.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "SetCreatedByOnBody", {
-    enumerable: true,
-    get: function() {
-        return SetCreatedByOnBody;
-    }
-});
-const _setuserfieldonbodyinterceptor = require("./set-user-field-on-body.interceptor");
-const SetCreatedByOnBody = (0, _setuserfieldonbodyinterceptor.createSetUserFieldInterceptor)('createdById');

package/cjs/interceptors/set-delete-by-on-body.interceptor.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "SetDeletedByOnBody", {
-    enumerable: true,
-    get: function() {
-        return SetDeletedByOnBody;
-    }
-});
-const _setuserfieldonbodyinterceptor = require("./set-user-field-on-body.interceptor");
-const SetDeletedByOnBody = (0, _setuserfieldonbodyinterceptor.createSetUserFieldInterceptor)('deletedById');

package/cjs/interceptors/set-update-by-on-body.interceptor.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "SetUpdateByOnBody", {
-    enumerable: true,
-    get: function() {
-        return SetUpdateByOnBody;
-    }
-});
-const _setuserfieldonbodyinterceptor = require("./set-user-field-on-body.interceptor");
-const SetUpdateByOnBody = (0, _setuserfieldonbodyinterceptor.createSetUserFieldInterceptor)('updatedById');

package/fesm/interceptors/set-create-by-on-body.interceptor.js

@@ -1,4 +0,0 @@
-import { createSetUserFieldInterceptor } from './set-user-field-on-body.interceptor';
-/**
- * Interceptor that sets createdById field on request body from authenticated user
- */ export const SetCreatedByOnBody = createSetUserFieldInterceptor('createdById');

package/fesm/interceptors/set-delete-by-on-body.interceptor.js

@@ -1,4 +0,0 @@
-import { createSetUserFieldInterceptor } from './set-user-field-on-body.interceptor';
-/**
- * Interceptor that sets deletedById field on request body from authenticated user
- */ export const SetDeletedByOnBody = createSetUserFieldInterceptor('deletedById');

package/fesm/interceptors/set-update-by-on-body.interceptor.js

@@ -1,4 +0,0 @@
-import { createSetUserFieldInterceptor } from './set-user-field-on-body.interceptor';
-/**
- * Interceptor that sets updatedById field on request body from authenticated user
- */ export const SetUpdateByOnBody = createSetUserFieldInterceptor('updatedById');

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

@@ -1 +0,0 @@
-export declare const SetCreatedByOnBody: import("@nestjs/common").Type<import("@nestjs/common").NestInterceptor<any, any>>;

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

@@ -1 +0,0 @@
-export declare const SetDeletedByOnBody: import("@nestjs/common").Type<import("@nestjs/common").NestInterceptor<any, any>>;

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

@@ -1 +0,0 @@
-export declare const SetUpdateByOnBody: import("@nestjs/common").Type<import("@nestjs/common").NestInterceptor<any, any>>;