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

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/html-sanitizer.util.js

@@ -0,0 +1,64 @@
+"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 escapeHtml () {
+        return escapeHtml;
+    },
+    get escapeHtmlVariables () {
+        return escapeHtmlVariables;
+    }
+});
+/**
+ * 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
+ */ 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]);
+}
+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;
+}

package/cjs/utils/index.js

@@ -2,7 +2,11 @@
 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);
+_export_star(require("./string.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,60 @@
+"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");
+const _constants = require("../constants");
+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({
+                message: `${entityName} belongs to another company`,
+                messageKey: _constants.AUTH_MESSAGES.ENTITY_BELOG_ANOTHER_COMPANY,
+                messageVariables: {
+                    entity: entityName
+                }
+            });
+        }
+    }
+}

package/cjs/utils/request.util.js

@@ -0,0 +1,96 @@
+"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 buildCookieOptions () {
+        return buildCookieOptions;
+    },
+    get buildFrontendUrl () {
+        return buildFrontendUrl;
+    },
+    get extractFrontendUrl () {
+        return extractFrontendUrl;
+    },
+    get isBrowserRequest () {
+        return isBrowserRequest;
+    },
+    get parseDurationToMs () {
+        return parseDurationToMs;
+    }
+});
+const _config = require("@flusys/nestjs-core/config");
+const _constants = require("../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[_constants.CLIENT_TYPE_HEADER];
+    return clientType ? clientType.toLowerCase() : null;
+}
+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');
+}
+function buildCookieOptions(req) {
+    const hostname = req.hostname || '';
+    const origin = req.headers.origin || '';
+    const isProduction = _config.envConfig.isProduction();
+    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
+        }
+    };
+}
+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);
+}
+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/cjs/utils/string.util.js

@@ -0,0 +1,63 @@
+/**
+ * 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'
+ */ "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 generateSlug () {
+        return generateSlug;
+    },
+    get generateUniqueSlug () {
+        return generateUniqueSlug;
+    }
+});
+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);
+}
+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/classes/api-controller.class.d.ts

@@ -1,30 +1,38 @@
-import { BulkResponseDto, DeleteDto, FilterAndPaginationDto, GetByIdBodyDto, ListResponseDto, MessageResponseDto, SingleResponseDto } from '@flusys/nestjs-shared/dtos';
-import { Identity } from '@flusys/nestjs-shared/entities';
-import { ILoggedUserInfo, IService, PermissionCondition, PermissionOperator } from '@flusys/nestjs-shared/interfaces';
 import { Type } from '@nestjs/common';
-export type ApiEndpoint = 'insert' | 'insertMany' | 'getById' | 'getAll' | 'update' | 'updateMany' | 'delete';
+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 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) => {
+    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>;
 };

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

@@ -1,26 +1,34 @@
-import { DeleteDto, FilterAndPaginationDto } from '@flusys/nestjs-shared/dtos';
-import { Identity } from '@flusys/nestjs-shared/entities';
-import { ILoggedUserInfo, IService } from '@flusys/nestjs-shared/interfaces';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { Logger } from '@nestjs/common';
-import { QueryRunner, Repository, SelectQueryBuilder } from 'typeorm';
+import { DataSource, EntityTarget, QueryRunner, Repository, SelectQueryBuilder } from 'typeorm';
+import { DeleteDto, FilterAndPaginationDto } from '../dtos';
+import { Identity, RawEntity } from '../entities';
+import { IDataSourceProvider, ILoggedUserInfo, IService } from '../interfaces';
+import { UtilsService } from '../modules/utils/utils.service';
 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> {
+}, InterfaceT extends Identity, EntityT extends Identity> implements IService<CreateDtoT, UpdateDtoT, InterfaceT> {
     protected entityName: string;
-    protected repository: RepositoryT;
     protected cacheManager: HybridCache;
     protected utilsService: UtilsService;
-    protected loggerName: string;
+    protected _loggerName: string;
     protected isCacheable: boolean;
-    protected logger: Logger;
-    constructor(entityName: string, repository: RepositoryT, cacheManager: HybridCache, utilsService: UtilsService, loggerName: string, isCacheable?: boolean);
+    protected moduleName?: string | undefined;
+    protected repository: Repository<EntityT>;
+    private repositoryInitialized;
+    private _entity?;
+    private _dataSourceProvider?;
+    constructor(entityName: string, cacheManager: HybridCache, utilsService: UtilsService, _loggerName: string, isCacheable?: boolean, moduleName?: string | undefined, entity?: EntityTarget<EntityT>, dataSourceProvider?: IDataSourceProvider);
+    protected resolveEntity(): EntityTarget<EntityT>;
+    protected getDataSourceProvider(): IDataSourceProvider;
+    protected ensureDataSourceRepository(): Promise<void>;
+    protected resolveRepositories(entities: EntityTarget<any>[]): Promise<Repository<any>[]>;
+    protected getDataSourceForService(): Promise<DataSource>;
     insert(dto: CreateDtoT, user: ILoggedUserInfo | null): Promise<InterfaceT>;
     insertMany(dtos: Array<CreateDtoT>, user: ILoggedUserInfo | null): Promise<InterfaceT[]>;
     update(dto: UpdateDtoT, user: ILoggedUserInfo | null): Promise<InterfaceT>;
     updateMany(dtos: UpdateDtoT[], user: ILoggedUserInfo | null): Promise<InterfaceT[]>;
-    findByIds(ids: string[], user: ILoggedUserInfo | null): Promise<InterfaceT[]>;
+    bulkUpsert(toInsert: CreateDtoT[], toUpdate: UpdateDtoT[], user: ILoggedUserInfo | null): Promise<InterfaceT[]>;
+    findByIds(ids: string[], user: ILoggedUserInfo | null, select?: string[] | string): Promise<InterfaceT[]>;
     findById(id: string, user: ILoggedUserInfo | null, select?: string[]): Promise<InterfaceT>;
     getAll(search: string, filterAndPaginationDto: FilterAndPaginationDto, user: ILoggedUserInfo | null): Promise<{
         data: Array<InterfaceT>;
@@ -30,24 +38,21 @@ export declare abstract class ApiService<CreateDtoT extends Record<string, unkno
     clearCacheForAll(): Promise<void>;
     clearCacheForId(entities: EntityT[]): Promise<void>;
     private handleError;
-    protected ensureRepositoryInitialized(): Promise<void>;
+    private ensureArray;
+    private executeInTransaction;
     protected beforeInsertOperation(_dto: CreateDtoT | Array<CreateDtoT>, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
-    protected afterInsertOperation(_entity: EntityT[], _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
+    protected afterInsertOperation(_entity: EntityT[], _dto: CreateDtoT | Array<CreateDtoT>, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
     protected beforeUpdateOperation(_dto: UpdateDtoT | Array<UpdateDtoT>, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
-    protected afterUpdateOperation(_entity: EntityT[], _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
+    protected afterUpdateOperation(_entity: EntityT[], _dto: UpdateDtoT | Array<UpdateDtoT>, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
     protected beforeDeleteOperation(_dto: DeleteDto, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
     protected afterDeleteOperation(_entity: Array<{
         id: string;
-    }>, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
-    protected getFilterQuery(query: SelectQueryBuilder<EntityT>, filter: {
-        [key: string]: any;
-    }, _user: ILoggedUserInfo | null): Promise<{
+    }>, _dto: DeleteDto, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
+    protected getFilterQuery(query: SelectQueryBuilder<EntityT>, filter: Record<string, unknown>, _user: ILoggedUserInfo | null): Promise<{
         query: SelectQueryBuilder<EntityT>;
         isRaw: boolean;
     }>;
-    protected getSortQuery(query: SelectQueryBuilder<EntityT>, sort: {
-        [key: string]: 'ASC' | 'DESC';
-    }, _user: ILoggedUserInfo | null): Promise<{
+    protected getSortQuery(query: SelectQueryBuilder<EntityT>, sort: Record<string, 'ASC' | 'DESC'>, _user: ILoggedUserInfo | null): Promise<{
         query: SelectQueryBuilder<EntityT>;
         isRaw: boolean;
     }>;
@@ -66,7 +71,7 @@ export declare abstract class ApiService<CreateDtoT extends Record<string, unkno
     protected convertRequestDtoToEntity(dto: CreateDtoT | UpdateDtoT | Array<CreateDtoT | UpdateDtoT>, user: ILoggedUserInfo | null): Promise<Array<EntityT>>;
     protected convertSingleDtoToEntity(dto: CreateDtoT | UpdateDtoT, _user: ILoggedUserInfo | null): Promise<EntityT>;
     protected convertArrayDtoToEntities(dtos: Array<CreateDtoT | UpdateDtoT>, user: ILoggedUserInfo | null): Promise<Array<EntityT>>;
-    protected convertEntityToResponseDto(entity: EntityT, _isRaw: boolean): InterfaceT;
-    protected convertEntityListToResponseListDto(entities: EntityT[], _isRaw: boolean): InterfaceT[];
+    protected convertEntityToResponseDto(entity: EntityT | RawEntity, _isRaw: boolean): InterfaceT;
+    protected convertEntityListToResponseListDto(entities: EntityT[] | RawEntity[], _isRaw: boolean): InterfaceT[];
     protected getEntityClass(): Promise<EntityT>;
 }

package/classes/handle-custome-db.d.ts

@@ -0,0 +1,3 @@
+export declare function getJsonColumnType(): "simple-json" | "json" | "jsonb";
+export declare function getCastIntType(): string;
+export declare function buildQuery(sql: string, dbType: string): string;

package/classes/index.d.ts

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

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

@@ -1,2 +1,3 @@
 import { Logger } from 'winston';
 export declare const instance: Logger;
+export declare function createModuleLogger(moduleName: string): Logger;

package/constants/index.d.ts

@@ -2,9 +2,10 @@ export declare const IS_PUBLIC_KEY = "isPublic";
 export declare const PERMISSIONS_KEY = "permissions";
 export declare const CACHE_INSTANCE = "CACHE_INSTANCE";
 export declare const PERMISSION_GUARD_CONFIG = "PERMISSION_GUARD_CONFIG";
-export declare const LOGGER_INSTANCE = "LOGGER_INSTANCE";
 export declare const IDEMPOTENCY_KEY_HEADER = "x-idempotency-key";
 export declare const REQUEST_ID_HEADER = "x-request-id";
 export declare const CLIENT_TYPE_HEADER = "x-client-type";
 export declare const PERMISSIONS_CACHE_PREFIX = "permissions";
 export declare const IDEMPOTENCY_CACHE_PREFIX = "idempotency";
+export * from './permissions';
+export * from './message-keys';

package/constants/message-keys.d.ts

@@ -0,0 +1,45 @@
+export declare const AUTH_MESSAGES: {
+    readonly TOKEN_REQUIRED: "auth.token.required";
+    readonly TOKEN_INVALID: "auth.token.invalid";
+    readonly ENTITY_BELOG_ANOTHER_COMPANY: "entity.belongs.another.company";
+    readonly COMPANY_NO_ACCESS: "auth.company.no.access";
+};
+export declare const ERROR_MESSAGES: {
+    readonly NOT_FOUND: "error.not.found";
+    readonly VALIDATION: "error.validation";
+    readonly UNAUTHORIZED: "error.unauthorized";
+    readonly FORBIDDEN: "error.forbidden";
+    readonly CONFLICT: "error.conflict";
+    readonly DB_FOREIGN_KEY: "error.db.foreign.key";
+    readonly DB_NOT_NULL: "error.db.not.null";
+    readonly DB_INVALID_INPUT: "error.db.invalid.input";
+    readonly DB_VALUE_TOO_LONG: "error.db.value.too.long";
+    readonly DB_CHECK_CONSTRAINT: "error.db.check.constraint";
+    readonly DB_DEADLOCK: "error.db.deadlock";
+    readonly INTERNAL: "error.internal";
+    readonly SERVICE_UNAVAILABLE: "error.service.unavailable";
+    readonly UNKNOWN: "error.unknown";
+    readonly HTTP: "error.http";
+    readonly GENERIC: "error.generic";
+    readonly PERMISSION_SYSTEM_UNAVAILABLE: "error.permission.system.unavailable";
+    readonly INSUFFICIENT_PERMISSIONS: "error.insufficient.permissions";
+    readonly INSUFFICIENT_PERMISSIONS_OR: "error.insufficient.permissions.or";
+    readonly NO_PERMISSIONS_FOUND: "error.no.permissions.found";
+    readonly ENDPOINT_DISABLED: "error.endpoint.disabled";
+};
+export declare const SYSTEM_MESSAGES: {
+    readonly REPOSITORY_NOT_AVAILABLE: "system.repository.not.available";
+    readonly DATASOURCE_NOT_AVAILABLE: "system.datasource.not.available";
+    readonly DATABASE_CONFIG_NOT_AVAILABLE: "system.database.config.not.available";
+    readonly SERVICE_NOT_AVAILABLE: "system.service.not.available";
+    readonly CONFIG_REQUIRED: "system.config.required";
+    readonly INTERNAL_ERROR: "system.internal.error";
+    readonly DUPLICATE_REQUEST: "system.duplicate.request";
+    readonly INVALID_TENANT_ID: "system.invalid.tenant.id";
+    readonly TENANT_NOT_FOUND: "system.tenant.not.found";
+    readonly TENANT_HEADER_REQUIRED: "system.tenant.header.required";
+    readonly MISSING_PARAMETER: "system.missing.parameter";
+    readonly SDK_NOT_INSTALLED: "system.sdk.not.installed";
+    readonly PATH_TRAVERSAL_DETECTED: "system.path.traversal.detected";
+    readonly INVALID_FILE_KEY: "system.invalid.file.key";
+};