@flusys/nestjs-shared 0.1.0-beta.3 → 1.0.0-rc

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

@@ -2,31 +2,55 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "UtilsService", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DEFAULT_PHONE_COUNTRY_CODE () {
+        return DEFAULT_PHONE_COUNTRY_CODE;
+    },
+    get DEFAULT_PHONE_REGEX () {
+        return DEFAULT_PHONE_REGEX;
+    },
+    get UtilsService () {
         return UtilsService;
     }
 });
 const _common = require("@nestjs/common");
 const _classvalidator = require("class-validator");
+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);
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
+const DEFAULT_PHONE_REGEX = /^((\+880)|0)?(13|15|16|17|18|19)\d{8}$/;
+const DEFAULT_PHONE_COUNTRY_CODE = '+88';
 let UtilsService = class UtilsService {
+    /**
+   * Configure phone validation regex and country code
+   */ setPhoneValidationConfig(config) {
+        this.phoneConfig = config;
+    }
     // ---------------- CACHE HELPERS ----------------
     /**
    * Generate cache key with optional tenant prefix for multi-tenant isolation
-   * @param entityName - Name of the entity being cached
-   * @param params - Query parameters for cache key uniqueness
-   * @param entityId - Optional entity ID for single entity caching
-   * @param tenantId - Optional tenant ID for multi-tenant isolation
    */ getCacheKey(entityName, params, entityId, tenantId) {
         const tenantPrefix = tenantId ? `tenant_${tenantId}_` : '';
         if (entityId) return `${tenantPrefix}entity_${entityName}_id_${entityId}${params ? '_select_' + JSON.stringify(params) : ''}`;
@@ -49,48 +73,44 @@ let UtilsService = class UtilsService {
                 await cacheManager.set(trackingKey, allKeys);
             }
         } catch (error) {
-            // Log but don't throw - cache tracking failure shouldn't break the request
-            console.error(`Cache tracking failed for ${entityName}:`, error);
+            this.logger.error(`Cache tracking failed for ${entityName}`, error instanceof Error ? error.stack : String(error));
         }
     }
     /**
    * Clear cache for entity with optional tenant prefix
-   * Uses Promise.allSettled to ensure all deletions are attempted even if some fail
    */ 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) || [];
-                // Use Promise.allSettled to ensure all deletions are attempted
                 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) || [];
-                // Use Promise.allSettled to ensure all deletions are attempted
                 await Promise.allSettled(keySet.map((key)=>cacheManager.del(key)));
                 await cacheManager.del(trackingKey);
             }
         } catch (error) {
-            // Log but don't throw - cache invalidation failure shouldn't break the request
-            console.error(`Cache invalidation failed for ${entityName}:`, error);
+            this.logger.error(`Cache invalidation failed for ${entityName}`, error instanceof Error ? error.stack : String(error));
         }
     }
+    // ---------------- VALIDATION HELPERS ----------------
     /**
-   * Check Phone or Email
+   * Check if value is phone or email and normalize phone number
    */ checkPhoneOrEmail(value) {
         if ((0, _classvalidator.isEmail)(value)) {
             return {
-                value: value,
+                value,
                 type: 'email'
             };
         }
-        const phoneMatch = value.match(/^((\+880)|0)?(13|15|16|17|18|19)\d{8}$/);
+        const phoneMatch = value.match(this.phoneConfig.regex);
         if (phoneMatch) {
             let phone = phoneMatch[0];
-            if (!phone.startsWith('+88')) {
-                phone = '+88' + phone;
+            if (!phone.startsWith(this.phoneConfig.countryCode)) {
+                phone = this.phoneConfig.countryCode + phone;
             }
             return {
                 value: phone,
@@ -102,22 +122,22 @@ let UtilsService = class UtilsService {
             type: null
         };
     }
+    // ---------------- STRING HELPERS ----------------
     /**
-   * STRING FUNCTIONS
-   * transformToSlug
+   * Transform string to URL-friendly slug
    */ transformToSlug(value, salt) {
         const slug = value?.trim().replace(/[^A-Z0-9]+/gi, '-').toLowerCase();
         return salt ? `${slug}-${this.getRandomInt(1, 100)}` : slug;
     }
+    // ---------------- RANDOM HELPERS ----------------
     /**
-   * RANDOM FUNCTIONS
-   * getRandomInt
-   * generateRandomId
-   * getRandomOtpCode
+   * Generate random integer between min and max (inclusive)
    */ getRandomInt(min, max) {
         return Math.floor(Math.random() * (max - min + 1)) + min;
     }
-    generateRandomId(length) {
+    /**
+   * Generate random alphanumeric string
+   */ generateRandomId(length) {
         const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
         let result = '';
         for(let i = 0; i < length; i++){
@@ -125,131 +145,29 @@ let UtilsService = class UtilsService {
         }
         return result;
     }
-    getRandomOtpCode() {
+    /**
+   * Generate 4-digit OTP code
+   */ getRandomOtpCode() {
         return Math.floor(Math.random() * (9999 - 1000 + 1)) + 1000;
     }
-    extractColumnNameFromError(detail) {
+    // ---------------- ERROR HELPERS ----------------
+    /**
+   * Extract column name and value from PostgreSQL error detail
+   */ 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’t 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’t request a password reset, you can safely ignore this email.</p>
-    </div>
-  </body>
-  </html>
-  `;
+    constructor(){
+        _define_property(this, "logger", new _common.Logger(UtilsService.name));
+        _define_property(this, "phoneConfig", {
+            regex: DEFAULT_PHONE_REGEX,
+            countryCode: DEFAULT_PHONE_COUNTRY_CODE
+        });
     }
-    constructor(){}
 };
 UtilsService = _ts_decorate([
-    (0, _common.Injectable)(),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [])
+    (0, _common.Injectable)()
 ], UtilsService);

package/cjs/utils/error-handler.util.js

@@ -8,28 +8,104 @@ Object.defineProperty(exports, "ErrorHandler", {
         return ErrorHandler;
     }
 });
+const _common = require("@nestjs/common");
+/** Check if running in production environment */ const IS_PRODUCTION = process.env.NODE_ENV === 'production';
+/** Sensitive keys that should be redacted from logs */ const SENSITIVE_KEYS = [
+    'password',
+    'secret',
+    'token',
+    'apiKey',
+    'credential',
+    'authorization'
+];
+/** Patterns that indicate sensitive data in error messages */ const SENSITIVE_PATTERNS = [
+    /password/i,
+    /secret/i,
+    /token/i,
+    /key/i,
+    /credential/i,
+    /authorization/i,
+    /bearer/i
+];
 let ErrorHandler = class ErrorHandler {
     /**
-   * Safely extract error message from unknown error
-   */ static getErrorMessage(error) {
+   * Safely extract error message from unknown error.
+   * @param error - The error to extract message from
+   * @param sanitizeForClient - If true, redacts potentially sensitive info in production
+   */ static getErrorMessage(error, sanitizeForClient = false) {
+        let message = 'Unknown error occurred';
         if (error instanceof Error) {
-            return error.message;
+            message = error.message;
+        } else if (typeof error === 'string') {
+            message = error;
         }
-        if (typeof error === 'string') {
-            return error;
+        // Sanitize for client responses in production
+        if (sanitizeForClient && IS_PRODUCTION) {
+            if (this.containsSensitiveData(message)) {
+                return 'An unexpected error occurred. Please try again later.';
+            }
         }
-        return 'Unknown error occurred';
+        return message;
+    }
+    /**
+   * Check if a string contains potentially sensitive data.
+   */ static containsSensitiveData(text) {
+        return SENSITIVE_PATTERNS.some((pattern)=>pattern.test(text));
     }
     /**
-   * Safely extract error stack from unknown error
-   */ static getErrorStack(error) {
+   * Safely extract error stack from unknown error.
+   * Returns undefined in production for client responses.
+   * @param error - The error to extract stack from
+   * @param forClient - If true, never returns stack in production
+   */ static getErrorStack(error, forClient = false) {
+        // Never expose stack traces to clients in production
+        if (forClient && IS_PRODUCTION) {
+            return undefined;
+        }
         if (error instanceof Error) {
             return error.stack;
         }
         return undefined;
     }
     /**
-   * Create error context object for logging
+   * Create a sanitized error response for clients.
+   * In production, sensitive data is redacted and stack traces removed.
+   */ static createClientError(error, statusCode = _common.HttpStatus.INTERNAL_SERVER_ERROR, code) {
+        const sanitizedError = {
+            message: this.getErrorMessage(error, true),
+            statusCode
+        };
+        if (code) {
+            sanitizedError.code = code;
+        }
+        // Include stack only in development
+        if (!IS_PRODUCTION) {
+            sanitizedError.stack = this.getErrorStack(error);
+        }
+        return sanitizedError;
+    }
+    /**
+   * Sanitize context data to redact sensitive fields from logs.
+   */ static sanitizeContextForLogging(context) {
+        const sanitized = {};
+        for (const [key, value] of Object.entries(context)){
+            // Check if key contains sensitive words
+            const isSensitive = SENSITIVE_KEYS.some((sk)=>key.toLowerCase().includes(sk.toLowerCase()));
+            if (isSensitive) {
+                sanitized[key] = '[REDACTED]';
+            } else if (Array.isArray(value)) {
+                sanitized[key] = value.map((item)=>typeof item === 'object' && item !== null ? this.sanitizeContextForLogging(item) : item);
+            } else if (typeof value === 'object' && value !== null) {
+                sanitized[key] = this.sanitizeContextForLogging(value);
+            } else {
+                sanitized[key] = value;
+            }
+        }
+        return sanitized;
+    }
+    /**
+   * Create error context object for internal logging.
+   * Context data is sanitized to redact sensitive fields.
    */ static createErrorContext(error, context) {
         const errorContext = {
             error: {
@@ -41,20 +117,22 @@ let ErrorHandler = class ErrorHandler {
             errorContext.error.name = error.name;
         }
         if (context && Object.keys(context).length > 0) {
-            errorContext.context = context;
+            // Sanitize context to redact sensitive fields
+            errorContext.context = this.sanitizeContextForLogging(context);
         }
         return errorContext;
     }
     /**
-   * Log error with consistent format
+   * Log error with consistent format.
+   * Sensitive data in context is automatically redacted.
    */ 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);
+        // Log full details internally (stack traces are fine for internal logs)
+        logger.error(errorMessage, errorContext.error.stack, errorContext);
     }
     /**
    * Re-throw error with proper type checking

package/cjs/utils/html-sanitizer.util.js

@@ -0,0 +1,74 @@
+/**
+ * HTML Sanitizer Utilities
+ *
+ * Provides functions for escaping HTML content to prevent XSS attacks.
+ * Use these utilities when interpolating user-provided variables into HTML content.
+ */ /**
+ * HTML entity mapping for escaping special characters
+ */ "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 containsHtmlContent () {
+        return containsHtmlContent;
+    },
+    get escapeHtml () {
+        return escapeHtml;
+    },
+    get escapeHtmlVariables () {
+        return escapeHtmlVariables;
+    }
+});
+const HTML_ESCAPE_MAP = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#x27;',
+    '/': '&#x2F;',
+    '`': '&#x60;',
+    '=': '&#x3D;'
+};
+/**
+ * Regex pattern matching characters that need HTML escaping
+ */ const HTML_ESCAPE_REGEX = /[&<>"'`=/]/g;
+function escapeHtml(str) {
+    if (!str || typeof str !== 'string') {
+        return str ?? '';
+    }
+    return str.replace(HTML_ESCAPE_REGEX, (char)=>HTML_ESCAPE_MAP[char] || char);
+}
+function escapeHtmlVariables(variables) {
+    if (!variables || typeof variables !== 'object') {
+        return {};
+    }
+    const escaped = {};
+    for (const [key, value] of Object.entries(variables)){
+        if (value === null || value === undefined) {
+            escaped[key] = '';
+        } else if (typeof value === 'string') {
+            escaped[key] = escapeHtml(value);
+        } else if (typeof value === 'object') {
+            // For objects/arrays, stringify and escape
+            escaped[key] = escapeHtml(JSON.stringify(value));
+        } else {
+            // For numbers, booleans, etc., convert to string (no escaping needed)
+            escaped[key] = String(value);
+        }
+    }
+    return escaped;
+}
+function containsHtmlContent(str) {
+    if (!str || typeof str !== 'string') {
+        return false;
+    }
+    // Check for common HTML patterns
+    return /<[a-z][\s\S]*>/i.test(str) || /javascript:/i.test(str) || /on\w+=/i.test(str);
+}

package/cjs/utils/index.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./error-handler.util"), exports);
+_export_star(require("./html-sanitizer.util"), exports);
+_export_star(require("./query-helpers.util"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

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

@@ -0,0 +1,53 @@
+"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 applyCompanyFilter () {
+        return applyCompanyFilter;
+    },
+    get buildCompanyWhereCondition () {
+        return buildCompanyWhereCondition;
+    },
+    get hasCompanyId () {
+        return hasCompanyId;
+    },
+    get validateCompanyOwnership () {
+        return validateCompanyOwnership;
+    }
+});
+const _common = require("@nestjs/common");
+function applyCompanyFilter(query, config, user) {
+    const columnName = config.columnName ?? 'companyId';
+    if (config.isCompanyFeatureEnabled && user?.companyId) {
+        query.andWhere(`${config.entityAlias}.${columnName} = :companyId`, {
+            companyId: user.companyId
+        });
+    }
+    return query;
+}
+function buildCompanyWhereCondition(baseWhere, isCompanyFeatureEnabled, user) {
+    if (isCompanyFeatureEnabled && user?.companyId) {
+        return {
+            ...baseWhere,
+            companyId: user.companyId
+        };
+    }
+    return baseWhere;
+}
+function hasCompanyId(entity) {
+    return entity !== null && typeof entity === 'object' && 'companyId' in 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`);
+        }
+    }
+}

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

@@ -1,6 +1,6 @@
-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 { 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';
 export type SecurityLevel = 'public' | 'jwt' | 'permission';
@@ -16,9 +16,9 @@ export type ApiSecurityConfig = {
 export interface ApiControllerOptions {
     security?: ApiSecurityConfig | EndpointSecurity | SecurityLevel;
 }
-export declare function createApiController<CreateDtoT extends Record<string, unknown>, UpdateDtoT extends {
+export declare function createApiController<CreateDtoT extends object, 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) => {
+}, 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) => {
     service: ServiceT;
     insert(addDto: CreateDtoT, user: ILoggedUserInfo | null): Promise<SingleResponseDto<ResponseDtoT>>;
     insertMany(addDto: CreateDtoT[], user: ILoggedUserInfo | null): Promise<BulkResponseDto<ResponseDtoT>>;

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

@@ -1,11 +1,11 @@
-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 { DeleteDto, FilterAndPaginationDto } from '../dtos';
+import { Identity } from '../entities';
+import { ILoggedUserInfo, IService } from '../interfaces';
+import { UtilsService } from '../modules/utils/utils.service';
 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 {
+export declare abstract class ApiService<CreateDtoT extends object, UpdateDtoT extends {
     id: string;
 }, InterfaceT extends Identity, EntityT extends Identity, RepositoryT extends Repository<EntityT>> implements IService<CreateDtoT, UpdateDtoT, InterfaceT> {
     protected entityName: string;

package/classes/index.d.ts

@@ -4,3 +4,4 @@ export * from './request-scoped-api.service';
 export * from './hybrid-cache.class';
 export * from './winston-logger-adapter.class';
 export * from './winston.logger.class';
+export * from '../constants/permissions';

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

@@ -1,12 +1,13 @@
 import { DataSource, EntityTarget, Repository } from 'typeorm';
 import { Identity } from '../entities';
+import { IDataSourceProvider } from '../interfaces';
 import { ApiService } from './api-service.class';
-export declare abstract class RequestScopedApiService<CreateDtoT extends Record<string, unknown>, UpdateDtoT extends {
+export declare abstract class RequestScopedApiService<CreateDtoT extends object, 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 abstract getDataSourceProvider(): IDataSourceProvider;
     protected ensureRepositoryInitialized(): Promise<void>;
     protected initializeAdditionalRepositories(entities: EntityTarget<any>[]): Promise<Repository<any>[]>;
     protected getDataSourceForService(): Promise<DataSource>;

package/constants/index.d.ts

@@ -8,3 +8,4 @@ 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";
+export * from './permissions';