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

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

@@ -0,0 +1,70 @@
+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;
+}
+export 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;
+}
+export 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)
+    };
+}
+export 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);
+}
+export function getTodayInTimezone(timezone) {
+    return utcToLocal(new Date(), timezone).date;
+}

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

@@ -0,0 +1,69 @@
+/**
+ * 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;
+/**
+ * Escapes HTML special characters to prevent XSS attacks.
+ *
+ * @param str - The string to escape
+ * @returns The escaped string safe for HTML insertion
+ *
+ * @example
+ * ```typescript
+ * escapeHtml('<script>alert("xss")</script>')
+ * // Returns: '&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;'
+ * ```
+ */ export function escapeHtml(str) {
+    if (!str || typeof str !== 'string') {
+        return str ?? '';
+    }
+    return str.replace(HTML_ESCAPE_REGEX, (char)=>HTML_ESCAPE_MAP[char]);
+}
+/**
+ * Escapes all string values in a variables object for safe HTML interpolation.
+ * Non-string values are converted to strings and escaped.
+ *
+ * @param variables - Object containing template variables
+ * @returns New object with all string values HTML-escaped
+ *
+ * @example
+ * ```typescript
+ * escapeHtmlVariables({ name: '<script>xss</script>', count: 5 })
+ * // Returns: { name: '&lt;script&gt;xss&lt;/script&gt;', count: '5' }
+ * ```
+ */ export 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/fesm/utils/index.js

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

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

@@ -0,0 +1,85 @@
+import { BadRequestException } from '@nestjs/common';
+import { AUTH_MESSAGES } from '../constants';
+/**
+ * Apply company filter to a query builder if company feature is enabled.
+ * Centralizes the common pattern of filtering by user's company.
+ *
+ * @param query - TypeORM SelectQueryBuilder
+ * @param config - Company filter configuration
+ * @param user - Current logged user (may be null)
+ * @returns The modified query builder
+ *
+ * @example
+ * ```typescript
+ * applyCompanyFilter(query, {
+ *   isCompanyFeatureEnabled: this.config.isCompanyFeatureEnabled(),
+ *   entityAlias: 'file_manager',
+ * }, user);
+ * ```
+ */ export 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;
+}
+/**
+ * Build a where condition object with optional company filter.
+ *
+ * @param baseWhere - Base where condition object
+ * @param isCompanyFeatureEnabled - Whether company feature is enabled
+ * @param user - Current logged user
+ * @returns Where condition with companyId added if applicable
+ *
+ * @example
+ * ```typescript
+ * const where = buildCompanyWhereCondition(
+ *   { id: dto.id },
+ *   this.config.isCompanyFeatureEnabled(),
+ *   user
+ * );
+ * // Returns { id: dto.id, companyId: user.companyId } if company feature enabled
+ * ```
+ */ export function buildCompanyWhereCondition(baseWhere, isCompanyFeatureEnabled, user) {
+    if (isCompanyFeatureEnabled && user?.companyId) {
+        return {
+            ...baseWhere,
+            companyId: user.companyId
+        };
+    }
+    return baseWhere;
+}
+/**
+ * Type guard to check if entity has companyId property
+ */ export function hasCompanyId(entity) {
+    return entity !== null && typeof entity === 'object' && 'companyId' in entity;
+}
+/**
+ * Validates that an entity with companyId belongs to the user's company.
+ * Throws BadRequestException if the entity belongs to another company.
+ *
+ * @param entity - Entity to validate
+ * @param user - Current logged user
+ * @param isCompanyFeatureEnabled - Whether company feature is enabled
+ * @param entityName - Name of entity for error message (e.g., 'Email configuration')
+ * @throws BadRequestException if entity belongs to another company
+ *
+ * @example
+ * ```typescript
+ * validateCompanyOwnership(config, user, this.config.isCompanyFeatureEnabled(), 'Email configuration');
+ * ```
+ */ export function validateCompanyOwnership(entity, user, isCompanyFeatureEnabled, entityName) {
+    if (isCompanyFeatureEnabled && user?.companyId && hasCompanyId(entity)) {
+        if (entity.companyId && entity.companyId !== user.companyId) {
+            throw new BadRequestException({
+                message: `${entityName} belongs to another company`,
+                messageKey: AUTH_MESSAGES.ENTITY_BELOG_ANOTHER_COMPANY,
+                messageVariables: {
+                    entity: entityName
+                }
+            });
+        }
+    }
+}

package/fesm/utils/request.util.js

@@ -0,0 +1,81 @@
+import { envConfig } from '@flusys/nestjs-core/config';
+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 = 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
+        }
+    };
+}
+/**
+ * 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);
+}
+/**
+ * Determine the frontend base URL for auth-related links.
+ * Uses allowed origins from envConfig first, then falls back to request host.
+ */ export function extractFrontendUrl(req) {
+    const allowedOrigins = 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}`;
+}
+export function buildFrontendUrl(req, path) {
+    const baseUrl = extractFrontendUrl(req);
+    return `${baseUrl}${path}`;
+}

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/filters/global-exception.filter.d.ts

@@ -0,0 +1,9 @@
+import { ArgumentsHost, ExceptionFilter } from '@nestjs/common';
+export declare class GlobalExceptionFilter implements ExceptionFilter {
+    private readonly logger;
+    catch(exception: unknown, host: ArgumentsHost): void;
+    private resolveException;
+    private resolveHttpException;
+    private resolveQueryFailedError;
+    private toHumanReadable;
+}

package/filters/index.d.ts

@@ -0,0 +1 @@
+export * from './global-exception.filter';

package/guards/permission.guard.d.ts

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

package/index.d.ts

@@ -3,7 +3,9 @@ export * from './constants';
 export * from './decorators';
 export * from './dtos';
 export * from './entities';
+export * from './enums';
 export * from './exceptions';
+export * from './filters';
 export * from './guards';
 export * from './interceptors';
 export * from './interfaces';

package/interceptors/idempotency.interceptor.d.ts

@@ -5,6 +5,6 @@ export declare class IdempotencyInterceptor implements NestInterceptor {
     private readonly cache?;
     private readonly CACHE_TTL;
     private readonly PROCESSING_MARKER;
-    constructor(cache?: HybridCache);
+    constructor(cache?: HybridCache | undefined);
     intercept<T = any>(context: ExecutionContext, next: CallHandler<T>): Promise<Observable<T>>;
 }

package/interceptors/index.d.ts

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

package/interceptors/set-user-field-on-body.interceptor.d.ts

@@ -0,0 +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/interceptors/slug.interceptor.d.ts

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

package/interfaces/api.interface.d.ts

@@ -1,14 +1,16 @@
-import { DeleteDto, FilterAndPaginationDto } from '@flusys/nestjs-shared/dtos';
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { DeleteDto, FilterAndPaginationDto } from '../dtos';
+import { ILoggedUserInfo } from './logged-user-info.interface';
 export interface IService<CreateDtoT, UpdateDtoT, InterfaceT> {
     insert(addDto: CreateDtoT, user: ILoggedUserInfo | null): Promise<InterfaceT>;
     insertMany(addDto: Array<CreateDtoT>, user: ILoggedUserInfo | null): Promise<Array<InterfaceT>>;
     findById(id: string, user: ILoggedUserInfo | null, select?: string[]): Promise<InterfaceT>;
+    findByIds(ids: string[], user: ILoggedUserInfo | null, select?: string[] | string): Promise<Array<InterfaceT>>;
     getAll(search: string, filterAndPaginationDto: FilterAndPaginationDto, user: ILoggedUserInfo | null): Promise<{
         data: Array<InterfaceT>;
         total: number;
     }>;
     update(updateDto: UpdateDtoT, user: ILoggedUserInfo | null): Promise<InterfaceT>;
     updateMany(updateDto: Array<UpdateDtoT>, user: ILoggedUserInfo | null): Promise<Array<InterfaceT>>;
+    bulkUpsert(toInsert: Array<CreateDtoT>, toUpdate: Array<UpdateDtoT>, user: ILoggedUserInfo | null): Promise<Array<InterfaceT>>;
     delete(deleteDto: DeleteDto, user: ILoggedUserInfo | null): Promise<null>;
 }

package/interfaces/datasource.interface.d.ts

@@ -0,0 +1,5 @@
+import { DataSource, EntityTarget, ObjectLiteral, Repository } from 'typeorm';
+export interface IDataSourceProvider {
+    getRepository<T extends ObjectLiteral>(entity: EntityTarget<T>): Promise<Repository<T>>;
+    getDataSource(): Promise<DataSource>;
+}

package/interfaces/event-manager-adapter.interface.d.ts

@@ -0,0 +1,43 @@
+import { ParticipantStatus } from '../enums/participant-status.enum';
+import { RecurrenceType } from '../enums/recurrence-type.enum';
+export interface IEventManagerAdapter {
+    createEvent(options: CreateEventOptions): Promise<EventResult>;
+    updateParticipantStatus(participantId: string, status: ParticipantStatus): Promise<void>;
+    getEventsForUser?(userId: string, startDate: Date, endDate: Date, companyId?: string): Promise<EventResult[]>;
+    getEventById?(eventId: string): Promise<EventResult | null>;
+}
+export interface CreateEventOptions {
+    title: string;
+    description?: string;
+    eventDate: string;
+    startTime: string;
+    endTime: string;
+    isAllDay?: boolean;
+    recurrenceType?: RecurrenceType;
+    recurrenceEndDate?: string | null;
+    weekDays?: string[] | null;
+    color?: string;
+    meetingLink?: string | null;
+    participantIds?: string[];
+    organizerId?: string;
+    companyId?: string;
+}
+export interface EventResult {
+    id: string;
+    title: string;
+    description?: string | null;
+    eventDate: string;
+    startTime: string;
+    endTime: string;
+    isAllDay: boolean;
+    recurrenceType: string;
+    recurrenceEndDate?: string | null;
+    weekDays?: string[] | null;
+    color: string;
+    meetingLink?: string | null;
+    isActive: boolean;
+    companyId?: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare const EVENT_MANAGER_ADAPTER = "EVENT_MANAGER_ADAPTER";

package/interfaces/identity.interface.d.ts

@@ -2,8 +2,8 @@ export interface IIdentity {
     id: string;
     createdAt: Date;
     updatedAt: Date;
-    deletedAt: Date;
-    createdById: string;
-    updatedById: string;
-    deletedById: string;
+    deletedAt: Date | null;
+    createdById: string | null;
+    updatedById: string | null;
+    deletedById: string | null;
 }

package/interfaces/index.d.ts

@@ -1,6 +1,8 @@
 export * from './api.interface';
-export * from './base-query.interface';
+export * from './datasource.interface';
+export * from './event-manager-adapter.interface';
 export * from './identity.interface';
 export * from './logged-user-info.interface';
-export * from './logger.interface';
+export * from './module-config.interface';
+export * from './notification-adapter.interface';
 export * from './permission.interface';

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/interfaces/module-config.interface.d.ts

@@ -0,0 +1,6 @@
+import { DatabaseMode } from '@flusys/nestjs-core';
+export interface IModuleConfigService {
+    getDatabaseMode(): DatabaseMode;
+    isMultiTenant(): boolean;
+    isCompanyFeatureEnabled(): boolean;
+}

package/interfaces/notification-adapter.interface.d.ts

@@ -0,0 +1,21 @@
+import { NotificationType } from '../enums/notification-type.enum';
+export declare const NOTIFICATION_ADAPTER = "NOTIFICATION_ADAPTER";
+export interface INotificationContent {
+    title: string;
+    message?: string | null;
+    type?: NotificationType;
+    data?: Record<string, unknown> | null;
+    companyId?: string | null;
+    realtime?: boolean;
+}
+export interface INotificationSendOptions extends INotificationContent {
+    userId: string;
+}
+export interface INotificationBulkSendOptions extends INotificationContent {
+    userIds: string[];
+}
+export interface INotificationAdapter {
+    send(options: INotificationSendOptions): Promise<void>;
+    sendToMany(options: INotificationBulkSendOptions): Promise<void>;
+    isUserOnline?(userId: string): boolean;
+}

package/interfaces/permission.interface.d.ts

@@ -1,17 +1,21 @@
-export type PermissionOperator = 'and' | 'or';
-export interface PermissionCondition {
-    permissions?: string[];
-    operator: PermissionOperator;
-    children?: PermissionCondition[];
+export interface IActionNode {
+    type: 'action';
+    actionId: string;
 }
-export interface LegacyPermissionConfig {
+export interface IGroupNode {
+    type: 'group';
+    operator: 'AND' | 'OR';
+    children: ILogicNode[];
+}
+export type ILogicNode = IActionNode | IGroupNode;
+export type IPermissionLogic = string | ILogicNode;
+export interface SimplePermissionConfig {
     permissions: string[];
-    operator: PermissionOperator;
+    operator: 'AND' | 'OR';
 }
-export type PermissionConfig = PermissionCondition | LegacyPermissionConfig | string[];
+export type PermissionConfig = IPermissionLogic | SimplePermissionConfig | string[];
 export interface PermissionGuardConfig {
     enableCompanyFeature?: boolean;
-    cacheKeyPrefix?: string;
     userPermissionKeyFormat?: string;
     companyPermissionKeyFormat?: 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/index.d.ts

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