@flusys/nestjs-shared 1.0.0-beta → 1.0.0

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 './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,78 @@
+import { BadRequestException } from '@nestjs/common';
+/**
+ * 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(`${entityName} belongs to another company`);
+        }
+    }
+}

package/fesm/utils/request.util.js

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

package/fesm/utils/string.util.js

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

package/guards/permission.guard.d.ts

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

package/interceptors/index.d.ts

@@ -2,7 +2,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,5 +1,5 @@
-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>>;

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/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,7 @@
 export * from './api.interface';
-export * from './base-query.interface';
+export * from './datasource.interface';
 export * from './identity.interface';
 export * from './logged-user-info.interface';
 export * from './logger.interface';
+export * from './module-config.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/permission.interface.d.ts

@@ -11,7 +11,6 @@ export interface LegacyPermissionConfig {
 export type PermissionConfig = PermissionCondition | LegacyPermissionConfig | 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/datasource.module.d.ts

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

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

@@ -28,7 +28,6 @@ export declare class MultiTenantDataSourceService implements OnModuleDestroy {
     getDataSourceForTenant(tenantId: string): Promise<DataSource>;
     setDataSource(dataSource: DataSource): void;
     getRepository<T extends ObjectLiteral>(entity: EntityTarget<T>): Promise<Repository<T>>;
-    getRepositoryForTenant<T extends ObjectLiteral>(entity: EntityTarget<T>, tenantId: string): Promise<Repository<T>>;
     withTenant<T>(tenantId: string, callback: (ds: DataSource) => Promise<T>): Promise<T>;
     forAllTenants<T>(callback: (tenant: ITenantDatabaseConfig, ds: DataSource) => Promise<T>): Promise<Map<string, T>>;
     registerTenant(tenant: ITenantDatabaseConfig): void;

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

@@ -1,21 +1,11 @@
-import { HybridCache } from '@flusys/nestjs-shared/classes';
+import { HybridCache } from '../../classes/hybrid-cache.class';
 export declare class UtilsService {
-    constructor();
+    private readonly logger;
     getCacheKey(entityName: string, params: any, entityId?: string, tenantId?: string): string;
     trackCacheKey(cacheKey: string, entityName: string, cacheManager: HybridCache, entityId?: string, tenantId?: string): Promise<void>;
     clearCache(entityName: string, cacheManager: HybridCache, entityId?: string, tenantId?: string): Promise<void>;
-    checkPhoneOrEmail(value: string): {
-        value: string | null;
-        type: 'phone' | 'email' | null;
-    };
     transformToSlug(value: string, salt?: boolean): string;
     getRandomInt(min: number, max: number): number;
-    generateRandomId(length: number): string;
-    getRandomOtpCode(): number;
-    extractColumnNameFromError(detail: string): {
-        columnName: string;
-        value: string;
-    };
-    getOtpEmailFormat(otp: number, userName?: string | null | undefined): string;
-    getResetPasswordEmailFormat(resetLink: string, userName?: string | null | undefined): string;
+    private buildTenantPrefix;
+    private buildTrackingKey;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-shared",
-  "version": "1.0.0-beta",
+  "version": "1.0.0",
   "description": "Common shared utilities for Flusys NestJS applications",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -88,7 +88,7 @@
     }
   },
   "peerDependencies": {
-    "@keyv/redis": "^3.0.0",
+    "@keyv/redis": "^5.0.0",
     "@nestjs/common": "^10.0.0 || ^11.0.0",
     "@nestjs/config": "^3.0.0 || ^4.0.0",
     "@nestjs/core": "^10.0.0 || ^11.0.0",
@@ -96,7 +96,7 @@
     "@nestjs/passport": "^10.0.0 || ^11.0.0",
     "@nestjs/swagger": "^7.0.0 || ^11.0.0",
     "@nestjs/typeorm": "^10.0.0 || ^11.0.0",
-    "cacheable": "^1.0.0",
+    "cacheable": "^2.0.0",
     "class-transformer": "^0.5.0",
     "class-validator": "^0.14.0",
     "keyv": "^5.0.0",
@@ -105,6 +105,6 @@
     "winston-daily-rotate-file": "^5.0.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "1.0.0-beta"
+    "@flusys/nestjs-core": "1.0.0"
   }
 }

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

@@ -1,24 +1,19 @@
 import { Logger } from '@nestjs/common';
+export interface IErrorContext {
+    operation?: string;
+    entity?: string;
+    userId?: string;
+    id?: string;
+    companyId?: string;
+    branchId?: string;
+    sectionId?: string;
+    data?: Record<string, unknown>;
+}
 export declare class ErrorHandler {
     static getErrorMessage(error: unknown): string;
-    static getErrorStack(error: unknown): string | undefined;
-    static createErrorContext(error: unknown, context?: {
-        operation?: string;
-        entity?: string;
-        userId?: string;
-        [key: string]: unknown;
-    }): {
-        error: {
-            message: string;
-            stack?: string;
-            name?: string;
-        };
-        context?: Record<string, unknown>;
-    };
-    static logError(logger: Logger, error: unknown, operation: string, context?: {
-        entity?: string;
-        userId?: string;
-        [key: string]: unknown;
-    }): void;
+    private static sanitizeContextForLogging;
+    private static createErrorContext;
+    static logError(logger: Logger, error: unknown, operation: string, context?: Omit<IErrorContext, 'operation'>): void;
     static rethrowError(error: unknown): never;
+    static logAndRethrow(logger: Logger, error: unknown, operation: string, context?: Omit<IErrorContext, 'operation'>): never;
 }

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

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

package/utils/index.d.ts

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

package/utils/query-helpers.util.d.ts

@@ -0,0 +1,16 @@
+import { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+import { ILoggedUserInfo } from '../interfaces';
+export interface ICompanyFilterConfig {
+    isCompanyFeatureEnabled: boolean;
+    entityAlias: string;
+    columnName?: string;
+}
+export declare function applyCompanyFilter<T extends ObjectLiteral>(query: SelectQueryBuilder<T>, config: ICompanyFilterConfig, user: ILoggedUserInfo | null | undefined): SelectQueryBuilder<T>;
+export declare function buildCompanyWhereCondition<T extends Record<string, unknown>>(baseWhere: T, isCompanyFeatureEnabled: boolean, user: ILoggedUserInfo | null | undefined): T & {
+    companyId?: string;
+};
+export interface ICompanyEnabled {
+    companyId?: string | null;
+}
+export declare function hasCompanyId<T>(entity: T): entity is T & ICompanyEnabled;
+export declare function validateCompanyOwnership<T>(entity: T, user: ILoggedUserInfo | null | undefined, isCompanyFeatureEnabled: boolean, entityName: string): void;

package/utils/request.util.d.ts

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

package/utils/string.util.d.ts

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

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

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "SetCreatedByOnBody", {
-    enumerable: true,
-    get: function() {
-        return SetCreatedByOnBody;
-    }
-});
-const _common = require("@nestjs/common");
-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;
-}
-let SetCreatedByOnBody = class SetCreatedByOnBody {
-    intercept(context, next) {
-        const request = context.switchToHttp().getRequest();
-        const user = request?.user;
-        if (user) {
-            if (Array.isArray(request.body)) {
-                request.body = request.body.map((item)=>({
-                        ...item,
-                        createdById: user.id
-                    }));
-            } else if (typeof request.body === 'object' && request.body !== null) {
-                request.body = {
-                    ...request.body,
-                    createdById: user.id
-                };
-            }
-        }
-        return next.handle();
-    }
-};
-SetCreatedByOnBody = _ts_decorate([
-    (0, _common.Injectable)()
-], SetCreatedByOnBody);

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

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "SetDeletedByOnBody", {
-    enumerable: true,
-    get: function() {
-        return SetDeletedByOnBody;
-    }
-});
-const _common = require("@nestjs/common");
-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;
-}
-let SetDeletedByOnBody = class SetDeletedByOnBody {
-    intercept(context, next) {
-        const request = context.switchToHttp().getRequest();
-        const user = request?.user;
-        if (user) {
-            if (Array.isArray(request.body)) {
-                request.body = request.body.map((item)=>({
-                        ...item,
-                        deletedById: user.id
-                    }));
-            } else if (typeof request.body === 'object' && request.body !== null) {
-                request.body = {
-                    ...request.body,
-                    deletedById: user.id
-                };
-            }
-        }
-        return next.handle();
-    }
-};
-SetDeletedByOnBody = _ts_decorate([
-    (0, _common.Injectable)()
-], SetDeletedByOnBody);