@flusys/nestjs-shared 1.1.0 → 1.2.0-rc.1

package/cjs/middlewares/logger.middleware.js

@@ -54,18 +54,15 @@ function _ts_decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 // Configuration
-const IS_DEBUG = _config.envConfig.getLogConfig().level === 'debug';
+const logConfig = _config.envConfig.getLogConfig();
+const IS_DEBUG = logConfig.level === 'debug';
+const DISABLE_HTTP_LOGGING = logConfig.disableHttpLogging;
 const TENANT_ID_HEADER = 'x-tenant-id';
 const EXCLUDED_PATHS = [
     '/health',
     '/metrics',
     '/favicon.ico'
 ];
-const EXCLUDED_HEADERS = [
-    'authorization',
-    'cookie',
-    'x-api-key'
-];
 const MAX_BODY_LOG_SIZE = 1000;
 const requestContext = new _async_hooks.AsyncLocalStorage();
 const getRequestId = ()=>requestContext.getStore()?.requestId;
@@ -73,17 +70,71 @@ const getTenantId = ()=>requestContext.getStore()?.tenantId;
 const getUserId = ()=>requestContext.getStore()?.userId;
 const getCompanyId = ()=>requestContext.getStore()?.companyId;
 // Helper Functions
-function sanitizeHeaders(headers) {
-    const sanitized = {};
-    for (const [key, value] of Object.entries(headers)){
-        sanitized[key] = EXCLUDED_HEADERS.includes(key.toLowerCase()) ? '[REDACTED]' : value;
+function summarizeRequestBody(body) {
+    if (!body) return undefined;
+    const parsed = typeof body === 'string' ? tryParseJson(body) : body;
+    if (!parsed || typeof parsed !== 'object') {
+        const str = String(body);
+        return str.length > MAX_BODY_LOG_SIZE ? str.substring(0, MAX_BODY_LOG_SIZE) + '...' : str;
+    }
+    // For API request bodies, provide a concise summary
+    const summary = {};
+    // Pagination info
+    if (parsed.pagination) {
+        summary.page = parsed.pagination.currentPage;
+        summary.pageSize = parsed.pagination.pageSize;
+    }
+    // Filter keys only (not values - may contain sensitive data)
+    if (parsed.filter && typeof parsed.filter === 'object') {
+        const filterKeys = Object.keys(parsed.filter);
+        if (filterKeys.length > 0) summary.filterKeys = filterKeys;
+    }
+    // Select fields count
+    if (Array.isArray(parsed.select) && parsed.select.length > 0) {
+        summary.selectCount = parsed.select.length;
+    }
+    // Sort keys
+    if (parsed.sort && typeof parsed.sort === 'object') {
+        const sortKeys = Object.keys(parsed.sort);
+        if (sortKeys.length > 0) summary.sortKeys = sortKeys;
     }
-    return sanitized;
+    // ID for single item operations
+    if (parsed.id) summary.id = parsed.id;
+    // IDs for bulk operations
+    if (Array.isArray(parsed.ids)) summary.idsCount = parsed.ids.length;
+    return Object.keys(summary).length > 0 ? JSON.stringify(summary) : '{}';
 }
-function truncateBody(body) {
+function summarizeResponseBody(body) {
     if (!body) return undefined;
-    const str = typeof body === 'string' ? body : JSON.stringify(body);
-    return str.length > MAX_BODY_LOG_SIZE ? str.substring(0, MAX_BODY_LOG_SIZE) + '...' : body;
+    const parsed = typeof body === 'string' ? tryParseJson(body) : body;
+    if (!parsed || typeof parsed !== 'object') {
+        const str = String(body);
+        return str.length > MAX_BODY_LOG_SIZE ? str.substring(0, MAX_BODY_LOG_SIZE) + '...' : str;
+    }
+    const summary = {};
+    if ('success' in parsed) summary.success = parsed.success;
+    if ('message' in parsed) summary.message = parsed.message;
+    if ('code' in parsed) summary.code = parsed.code;
+    if (Array.isArray(parsed.data)) {
+        summary.dataCount = parsed.data.length;
+    } else if (parsed.data && typeof parsed.data === 'object') {
+        summary.hasData = true;
+    }
+    if (parsed.meta) {
+        summary.total = parsed.meta.total;
+        summary.page = parsed.meta.page;
+    }
+    if (parsed.errors) {
+        summary.errorsCount = Array.isArray(parsed.errors) ? parsed.errors.length : 1;
+    }
+    return JSON.stringify(summary);
+}
+function tryParseJson(str) {
+    try {
+        return JSON.parse(str);
+    } catch  {
+        return null;
+    }
 }
 function getClientIp(req) {
     return req.headers['x-forwarded-for']?.split(',')[0] || req.socket?.remoteAddress || 'unknown';
@@ -100,7 +151,7 @@ let LoggerMiddleware = class LoggerMiddleware {
             startTime
         };
         requestContext.run(context, ()=>{
-            const shouldSkipLogging = EXCLUDED_PATHS.some((path)=>req.originalUrl.startsWith(path));
+            const shouldSkipLogging = DISABLE_HTTP_LOGGING || EXCLUDED_PATHS.some((path)=>req.originalUrl.startsWith(path));
             if (!shouldSkipLogging) {
                 this.logRequest(req, requestId, tenantId);
                 this.setupResponseLogging(req, res, startTime, requestId, tenantId);
@@ -141,20 +192,22 @@ let LoggerMiddleware = class LoggerMiddleware {
         });
     }
     logRequest(req, requestId, tenantId) {
+        const ip = getClientIp(req);
+        const contentType = req.headers['content-type'] || 'none';
+        // Build descriptive message like: Started processing request "POST" "/api/users" from "192.168.1.1"
+        const message = `Started processing request "${req.method}" "${req.originalUrl}" from "${ip}"`;
         const logData = {
             ...this.buildBaseLogData(req, requestId, tenantId),
             query: Object.keys(req.query).length > 0 ? req.query : undefined,
-            ip: getClientIp(req),
+            ip,
             userAgent: req.headers['user-agent'],
-            contentType: req.headers['content-type'],
+            contentType,
             contentLength: req.headers['content-length']
         };
         if (IS_DEBUG) {
-            logData.headers = sanitizeHeaders(req.headers);
-            logData.body = truncateBody(req.body);
-            logData.params = Object.keys(req.params).length > 0 ? req.params : undefined;
+            logData.body = summarizeRequestBody(req.body);
         }
-        this.logger.info('Incoming request', logData);
+        this.logger.info(message, logData);
     }
     logResponse(req, res, startTime, body, requestId, tenantId) {
         const duration = Date.now() - startTime;
@@ -162,6 +215,10 @@ let LoggerMiddleware = class LoggerMiddleware {
         const level = statusCode >= 500 ? 'error' : statusCode >= 400 ? 'warn' : 'info';
         const userId = getUserId();
         const companyId = getCompanyId();
+        const contentType = res.getHeader('content-type') || 'none';
+        const contentLength = res.getHeader('content-length') || 'null';
+        // Build descriptive message like: Request finished "HTTP/1.1" "POST" "/api/users" - 200 "application/json" 534.29ms
+        const message = `Request finished "HTTP/1.1" "${req.method}" "${req.originalUrl}" - ${statusCode} ${contentLength} "${contentType}" ${duration.toFixed(2)}ms`;
         const logData = {
             ...this.buildBaseLogData(req, requestId, tenantId),
             userId,
@@ -170,15 +227,15 @@ let LoggerMiddleware = class LoggerMiddleware {
             statusMessage: res.statusMessage,
             duration: `${duration}ms`,
             durationMs: duration,
-            contentType: res.getHeader('content-type'),
-            contentLength: res.getHeader('content-length')
+            contentType,
+            contentLength
         };
         if (statusCode >= 400 || IS_DEBUG) {
-            logData.responseBody = truncateBody(body);
+            logData.responseBody = summarizeResponseBody(body);
         }
-        this.logger.log(level, `Response [${statusCode}]`, logData);
+        this.logger.log(level, message, logData);
         if (duration > 3000 && statusCode < 400) {
-            this.logger.warn('Slow request detected', {
+            this.logger.warn(`Slow request detected: "${req.method}" "${req.originalUrl}" took ${duration}ms (threshold: 3000ms)`, {
                 ...this.buildBaseLogData(req, requestId, tenantId),
                 userId,
                 companyId,

package/cjs/modules/datasource/index.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_export_star(require("./datasource.module"), exports);
 _export_star(require("./multi-tenant-datasource.service"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {

package/cjs/modules/datasource/multi-tenant-datasource.service.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "MultiTenantDataSourceService", {
 });
 const _nestjscore = require("@flusys/nestjs-core");
 const _common = require("@nestjs/common");
+const _constants = require("../../constants");
 const _core = require("@nestjs/core");
 const _express = require("express");
 const _typeorm = require("typeorm");
@@ -42,21 +43,21 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let MultiTenantDataSourceService = class MultiTenantDataSourceService {
+    get self() {
+        return this.constructor;
+    }
     initializeFromOptions() {
         if (!this.options) return;
-        if (!MultiTenantDataSourceService.initialized) {
+        if (!this.self.initialized) {
             this.registerTenants();
-            MultiTenantDataSourceService.initialized = true;
+            this.self.initialized = true;
         }
     }
     registerTenants() {
         this.options?.tenants?.forEach((tenant)=>{
-            MultiTenantDataSourceService.tenantsRegistry.set(tenant.id, tenant);
+            this.self.tenantsRegistry.set(tenant.id, tenant);
         });
     }
-    setTenantHeader(header) {
-        this.tenantHeader = header;
-    }
     getDatabaseMode() {
         return this.options?.bootstrapAppConfig?.databaseMode ?? 'single';
     }
@@ -68,7 +69,10 @@ let MultiTenantDataSourceService = class MultiTenantDataSourceService {
         const tenantId = this.request.headers[this.tenantHeader];
         if (!tenantId) return null;
         if (!/^[a-zA-Z0-9_-]+$/.test(tenantId)) {
-            throw new _common.BadRequestException('Invalid tenant ID format');
+            throw new _common.BadRequestException({
+                message: 'Invalid tenant ID format',
+                messageKey: _constants.SYSTEM_MESSAGES.INVALID_TENANT_ID
+            });
         }
         return tenantId;
     }
@@ -77,124 +81,78 @@ let MultiTenantDataSourceService = class MultiTenantDataSourceService {
         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();
+        return this.self.tenantsRegistry.get(tenantId) ?? null;
     }
     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 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);
+        const connection = this.self.tenantConnections.get(tenantId);
         if (connection?.isInitialized) {
             await connection.destroy();
-            MultiTenantDataSourceService.tenantConnections.delete(tenantId);
-            this.logger.log(`Closed connection for tenant: ${tenantId}`);
+            this.self.tenantConnections.delete(tenantId);
         }
     }
     async onModuleDestroy() {
-        for (const [tenantId] of MultiTenantDataSourceService.tenantConnections){
+        for (const [tenantId] of this.self.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();
-    }
-    // Protected Methods (for subclasses)
-    /**
-   * Get single database DataSource with connection locking to prevent race conditions
-   */ async getSingleDataSource() {
-        // Return existing initialized connection
-        if (MultiTenantDataSourceService.singleDataSource?.isInitialized) {
-            return MultiTenantDataSourceService.singleDataSource;
+    async getSingleDataSource() {
+        if (this.self.singleDataSource?.isInitialized) {
+            return this.self.singleDataSource;
         }
-        // If another request is creating the connection, wait for it
-        if (MultiTenantDataSourceService.singleConnectionLock) {
-            return MultiTenantDataSourceService.singleConnectionLock;
+        if (this.self.singleConnectionLock) {
+            return this.self.singleConnectionLock;
         }
         const config = this.getDefaultDatabaseConfig();
         if (!config) {
-            throw new Error('No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.');
+            throw new _common.InternalServerErrorException({
+                message: 'No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.',
+                messageKey: _constants.SYSTEM_MESSAGES.DATABASE_CONFIG_NOT_AVAILABLE
+            });
         }
-        // Create connection with lock to prevent race conditions
         const connectionPromise = this.createDataSourceFromConfig(config);
-        MultiTenantDataSourceService.singleConnectionLock = connectionPromise;
+        this.self.singleConnectionLock = connectionPromise;
         try {
             const dataSource = await connectionPromise;
-            MultiTenantDataSourceService.singleDataSource = dataSource;
+            this.self.singleDataSource = dataSource;
             return dataSource;
         } finally{
-            MultiTenantDataSourceService.singleConnectionLock = null;
+            this.self.singleConnectionLock = null;
         }
     }
-    /**
-   * Get tenant-specific DataSource
-   */ async getTenantDataSource() {
+    async getTenantDataSource() {
         const tenant = this.getCurrentTenant();
         if (!tenant) {
-            throw new Error(`Tenant not found. Ensure '${this.tenantHeader}' header is set.`);
+            throw new _common.BadRequestException({
+                message: `Tenant not found. Ensure '${this.tenantHeader}' header is set.`,
+                messageKey: _constants.SYSTEM_MESSAGES.TENANT_HEADER_REQUIRED,
+                messageVariables: {
+                    header: this.tenantHeader
+                }
+            });
         }
         return this.getOrCreateTenantConnection(tenant);
     }
     async getOrCreateTenantConnection(tenant) {
-        const existing = MultiTenantDataSourceService.tenantConnections.get(tenant.id);
+        const existing = this.self.tenantConnections.get(tenant.id);
         if (existing?.isInitialized) return existing;
-        const pendingConnection = MultiTenantDataSourceService.connectionLocks.get(tenant.id);
+        const pendingConnection = this.self.connectionLocks.get(tenant.id);
         if (pendingConnection) return pendingConnection;
         const config = this.buildTenantDatabaseConfig(tenant);
         const connectionPromise = this.createDataSourceFromConfig(config);
-        MultiTenantDataSourceService.connectionLocks.set(tenant.id, connectionPromise);
+        this.self.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}`);
+            this.self.tenantConnections.set(tenant.id, dataSource);
             return dataSource;
         } finally{
-            MultiTenantDataSourceService.connectionLocks.delete(tenant.id);
+            this.self.connectionLocks.delete(tenant.id);
         }
     }
     getDefaultDatabaseConfig() {
@@ -202,7 +160,12 @@ let MultiTenantDataSourceService = class MultiTenantDataSourceService {
     }
     buildTenantDatabaseConfig(tenant) {
         const defaultConfig = this.getDefaultDatabaseConfig();
-        if (!defaultConfig) throw new Error('No default database config for multi-tenant mode.');
+        if (!defaultConfig) {
+            throw new _common.InternalServerErrorException({
+                message: 'No default database config for multi-tenant mode.',
+                messageKey: _constants.SYSTEM_MESSAGES.DATABASE_CONFIG_NOT_AVAILABLE
+            });
+        }
         return {
             type: defaultConfig.type,
             host: tenant.host ?? defaultConfig.host,
@@ -230,11 +193,9 @@ let MultiTenantDataSourceService = class MultiTenantDataSourceService {
     constructor(options, request){
         _define_property(this, "options", void 0);
         _define_property(this, "request", void 0);
-        _define_property(this, "logger", void 0);
         _define_property(this, "tenantHeader", void 0);
         this.options = options;
         this.request = request;
-        this.logger = new _common.Logger(this.constructor.name);
         this.tenantHeader = _nestjscore.DEFAULT_TENANT_HEADER;
         this.initializeFromOptions();
     }

package/cjs/modules/utils/utils.service.js

@@ -9,19 +9,6 @@ Object.defineProperty(exports, "UtilsService", {
     }
 });
 const _common = require("@nestjs/common");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
 function _ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -47,8 +34,8 @@ let UtilsService = class UtilsService {
             const keys = await cacheManager.get(trackingKey) || [];
             if (!keys.includes(cacheKey)) keys.push(cacheKey);
             await cacheManager.set(trackingKey, keys);
-        } catch (error) {
-            this.logger.error(`Cache tracking failed for ${entityName}`, error instanceof Error ? error.stack : String(error));
+        } catch  {
+        // Silent failure - cache tracking is non-critical
         }
     }
     /**
@@ -59,8 +46,8 @@ let UtilsService = class UtilsService {
             const keys = await cacheManager.get(trackingKey) || [];
             await Promise.allSettled(keys.map((key)=>cacheManager.del(key)));
             await cacheManager.del(trackingKey);
-        } catch (error) {
-            this.logger.error(`Cache invalidation failed for ${entityName}`, error instanceof Error ? error.stack : String(error));
+        } catch  {
+        // Silent failure - cache invalidation is non-critical
         }
     }
     // ---------------- STRING HELPERS ----------------
@@ -83,9 +70,6 @@ let UtilsService = class UtilsService {
         const prefix = this.buildTenantPrefix(tenantId);
         return entityId ? `${prefix}entity_${entityName}_id_${entityId}_keys` : `${prefix}entity_${entityName}_keys`;
     }
-    constructor(){
-        _define_property(this, "logger", new _common.Logger(UtilsService.name));
-    }
 };
 UtilsService = _ts_decorate([
     (0, _common.Injectable)()

package/cjs/utils/date-time.util.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get formatInTimezone () {
+        return formatInTimezone;
+    },
+    get getTodayInTimezone () {
+        return getTodayInTimezone;
+    },
+    get localToUtc () {
+        return localToUtc;
+    },
+    get utcToLocal () {
+        return utcToLocal;
+    }
+});
+function getOffsetMinutes(utcDate, timezone) {
+    const extract = (tz)=>{
+        const parts = new Intl.DateTimeFormat('en-US', {
+            timeZone: tz,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hour12: false
+        }).formatToParts(utcDate);
+        const p = Object.fromEntries(parts.filter((x)=>x.type !== 'literal').map((x)=>[
+                x.type,
+                parseInt(x.value)
+            ]));
+        return Date.UTC(p['year'], p['month'] - 1, p['day'], p['hour'], p['minute'], p['second']);
+    };
+    return (extract(timezone) - extract('UTC')) / 60_000;
+}
+function localToUtc(dateStr, timeStr, timezone) {
+    const [year, month, day] = dateStr.split('-').map(Number);
+    const [hours, minutes] = timeStr.split(':').map(Number);
+    const approx = new Date(Date.UTC(year, month - 1, day, hours, minutes, 0));
+    const offset = getOffsetMinutes(approx, timezone);
+    const utcDate = new Date(approx.getTime() - offset * 60_000);
+    // DST boundary guard: re-check offset after adjustment
+    const finalOffset = getOffsetMinutes(utcDate, timezone);
+    return finalOffset !== offset ? new Date(approx.getTime() - finalOffset * 60_000) : utcDate;
+}
+function utcToLocal(utcDate, timezone) {
+    const d = typeof utcDate === 'string' ? new Date(utcDate) : utcDate;
+    const parts = new Intl.DateTimeFormat('en-CA', {
+        timeZone: timezone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false
+    }).formatToParts(d);
+    const p = Object.fromEntries(parts.filter((x)=>x.type !== 'literal').map((x)=>[
+            x.type,
+            x.value
+        ]));
+    // en-CA formats midnight hour as '24' — normalize to '00'
+    const hour = p['hour'] === '24' ? '00' : p['hour'];
+    return {
+        date: `${p['year']}-${p['month']}-${p['day']}`,
+        time: `${hour}:${p['minute']}`,
+        display: new Intl.DateTimeFormat('en-US', {
+            timeZone: timezone,
+            dateStyle: 'medium',
+            timeStyle: 'short'
+        }).format(d)
+    };
+}
+function formatInTimezone(utcDate, timezone, options = {
+    dateStyle: 'medium',
+    timeStyle: 'short'
+}) {
+    const d = typeof utcDate === 'string' ? new Date(utcDate) : utcDate;
+    return new Intl.DateTimeFormat('en-US', {
+        ...options,
+        timeZone: timezone
+    }).format(d);
+}
+function getTodayInTimezone(timezone) {
+    return utcToLocal(new Date(), timezone).date;
+}

package/cjs/utils/index.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_export_star(require("./error-handler.util"), exports);
+_export_star(require("./date-time.util"), exports);
 _export_star(require("./html-sanitizer.util"), exports);
 _export_star(require("./query-helpers.util"), exports);
 _export_star(require("./request.util"), exports);

package/cjs/utils/query-helpers.util.js

@@ -23,6 +23,7 @@ _export(exports, {
     }
 });
 const _common = require("@nestjs/common");
+const _constants = require("../constants");
 function applyCompanyFilter(query, config, user) {
     const columnName = config.columnName ?? 'companyId';
     if (config.isCompanyFeatureEnabled && user?.companyId) {
@@ -47,7 +48,13 @@ function hasCompanyId(entity) {
 function validateCompanyOwnership(entity, user, isCompanyFeatureEnabled, entityName) {
     if (isCompanyFeatureEnabled && user?.companyId && hasCompanyId(entity)) {
         if (entity.companyId && entity.companyId !== user.companyId) {
-            throw new _common.BadRequestException(`${entityName} belongs to another company`);
+            throw new _common.BadRequestException({
+                message: `${entityName} belongs to another company`,
+                messageKey: _constants.AUTH_MESSAGES.ENTITY_BELOG_ANOTHER_COMPANY,
+                messageVariables: {
+                    entity: entityName
+                }
+            });
         }
     }
 }

package/cjs/utils/request.util.js

@@ -12,6 +12,12 @@ _export(exports, {
     get buildCookieOptions () {
         return buildCookieOptions;
     },
+    get buildFrontendUrl () {
+        return buildFrontendUrl;
+    },
+    get extractFrontendUrl () {
+        return extractFrontendUrl;
+    },
     get isBrowserRequest () {
         return isBrowserRequest;
     },
@@ -69,3 +75,22 @@ function parseDurationToMs(duration, defaultMs = TIME_UNIT_MS.w) {
     const unit = match[2];
     return value * (TIME_UNIT_MS[unit] ?? TIME_UNIT_MS.d);
 }
+function extractFrontendUrl(req) {
+    const allowedOrigins = _config.envConfig.getOrigins();
+    const origin = (req.get('origin') ?? req.get('referer') ?? '').trim();
+    if (origin && allowedOrigins.length) {
+        const matched = allowedOrigins.find((u)=>origin.startsWith(u));
+        if (matched) {
+            return matched;
+        }
+    }
+    const host = req.get('host');
+    if (!host) {
+        throw new Error('Unable to determine frontend URL from request');
+    }
+    return `${req.protocol}://${host}`;
+}
+function buildFrontendUrl(req, path) {
+    const baseUrl = extractFrontendUrl(req);
+    return `${baseUrl}${path}`;
+}

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

@@ -1,30 +1,38 @@
-import { BulkResponseDto, DeleteDto, FilterAndPaginationDto, GetByIdBodyDto, ListResponseDto, MessageResponseDto, SingleResponseDto } from '../dtos';
-import { Identity } from '../entities';
-import { ILoggedUserInfo, IService, PermissionCondition, PermissionOperator } from '../interfaces';
 import { Type } from '@nestjs/common';
-export type ApiEndpoint = 'insert' | 'insertMany' | 'getById' | 'getAll' | 'update' | 'updateMany' | 'delete';
+import { BulkResponseDto, DeleteDto, FilterAndPaginationDto, GetByIdBodyDto, GetByIdsDto, ListResponseDto, MessageResponseDto, SingleResponseDto } from '../dtos';
+import { Identity } from '../entities';
+import { ILoggedUserInfo, IPermissionLogic, IService } from '../interfaces';
+export type ApiEndpoint = 'insert' | 'insertMany' | 'getById' | 'getByIds' | 'getAll' | 'bulkUpsert' | 'getByFilter' | 'update' | 'updateMany' | 'delete';
 export type SecurityLevel = 'public' | 'jwt' | 'permission';
 export interface EndpointSecurity {
     level: SecurityLevel;
     permissions?: string[];
-    operator?: PermissionOperator;
-    condition?: PermissionCondition;
+    operator?: 'AND' | 'OR';
+    logic?: IPermissionLogic;
 }
 export type ApiSecurityConfig = {
     [K in ApiEndpoint]?: EndpointSecurity | SecurityLevel;
 };
 export interface ApiControllerOptions {
     security?: ApiSecurityConfig | EndpointSecurity | SecurityLevel;
+    entityName?: string;
+    enabledEndpoints?: ApiEndpoint[] | 'all';
+    excludeExtraneousValues?: boolean;
 }
 export declare function createApiController<CreateDtoT extends object, UpdateDtoT extends {
     id: string;
 }, ResponseDtoT extends object, InterfaceT extends Identity, ServiceT extends IService<CreateDtoT, UpdateDtoT, InterfaceT>>(createDtoClass: Type<CreateDtoT>, updateDtoClass: Type<UpdateDtoT>, responseDtoClass: Type<ResponseDtoT>, options?: ApiControllerOptions): abstract new (service: ServiceT) => {
+    readonly enabledEndpoints: ApiEndpoint[] | "all";
     service: ServiceT;
+    isEnabled(endpoint: ApiEndpoint): boolean;
     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>>;
+    getByIds(body: GetByIdsDto, user: ILoggedUserInfo | null): Promise<ListResponseDto<ResponseDtoT>>;
     update(updateDto: UpdateDtoT, user: ILoggedUserInfo | null): Promise<SingleResponseDto<ResponseDtoT>>;
     updateMany(updateDtos: UpdateDtoT[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<ResponseDtoT>>;
+    bulkUpsert(dtos: (CreateDtoT | UpdateDtoT)[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<ResponseDtoT>>;
+    getByFilter(filter: Record<string, any>, user: ILoggedUserInfo | null): Promise<SingleResponseDto<ResponseDtoT>>;
     getAll(filterAndPaginationDto: FilterAndPaginationDto, user: ILoggedUserInfo | null, search?: string): Promise<ListResponseDto<ResponseDtoT>>;
     delete(deleteDto: DeleteDto, user: ILoggedUserInfo | null): Promise<MessageResponseDto>;
 };