@flusys/nestjs-shared 7.1.0 → 8.0.0

package/fesm/modules/event-bus/event-bus.module.spec.js

@@ -1,145 +0,0 @@
-import { DisabledEventBus } from '../../classes/disabled-event-bus.class';
-import { EventBusRegistry } from '../../classes/event-bus.registry';
-import { HybridEventBus } from '../../classes/hybrid-event-bus.class';
-import { EVENT_BUS_INSTANCE, EVENT_BUS_MODULE_OPTIONS } from '../../constants';
-import { EventBusExplorer } from './event-bus.explorer';
-import { EventBusModule } from './event-bus.module';
-function getBusProvider(providers) {
-    return providers.find((provider)=>provider.provide === EVENT_BUS_INSTANCE);
-}
-describe('EventBusModule', ()=>{
-    const originalFlag = process.env.ENABLE_DOMAIN_EVENTS;
-    afterEach(()=>{
-        EventBusRegistry.reset();
-        if (originalFlag === undefined) {
-            delete process.env.ENABLE_DOMAIN_EVENTS;
-        } else {
-            process.env.ENABLE_DOMAIN_EVENTS = originalFlag;
-        }
-    });
-    describe('when enabled', ()=>{
-        it('should default to a global module', ()=>{
-            const dynamicModule = EventBusModule.forRoot({
-                enabled: true
-            });
-            expect(dynamicModule.module).toBe(EventBusModule);
-            expect(dynamicModule.global).toBe(true);
-        });
-        it('should respect global=false', ()=>{
-            expect(EventBusModule.forRoot({
-                enabled: true,
-                global: false
-            }).global).toBe(false);
-        });
-        it('should export the bus instance and the module options', ()=>{
-            const dynamicModule = EventBusModule.forRoot({
-                enabled: true
-            });
-            expect(dynamicModule.exports).toEqual([
-                EVENT_BUS_INSTANCE,
-                EVENT_BUS_MODULE_OPTIONS
-            ]);
-        });
-        it('should register the explorer so handlers get bound', ()=>{
-            const dynamicModule = EventBusModule.forRoot({
-                enabled: true
-            });
-            expect(dynamicModule.providers).toContain(EventBusExplorer);
-        });
-        it('should build a HybridEventBus and register it for ApiService', ()=>{
-            const dynamicModule = EventBusModule.forRoot({
-                enabled: true,
-                transport: 'memory'
-            });
-            const bus = getBusProvider(dynamicModule.providers).useFactory();
-            expect(bus).toBeInstanceOf(HybridEventBus);
-            expect(EventBusRegistry.getBus()).toBe(bus);
-        });
-        it('should apply the default module events config', ()=>{
-            const dynamicModule = EventBusModule.forRoot({
-                enabled: true,
-                transport: 'memory',
-                defaultModuleEvents: {
-                    enabled: true
-                }
-            });
-            getBusProvider(dynamicModule.providers).useFactory();
-            expect(EventBusRegistry.getModuleConfig('anything')).toEqual({
-                enabled: true
-            });
-        });
-        it('should close the bus and clear the registry on shutdown', async ()=>{
-            const dynamicModule = EventBusModule.forRoot({
-                enabled: true,
-                transport: 'memory'
-            });
-            const bus = getBusProvider(dynamicModule.providers).useFactory();
-            const closeSpy = jest.spyOn(bus, 'close');
-            await new EventBusModule().onApplicationShutdown();
-            expect(closeSpy).toHaveBeenCalled();
-            expect(EventBusRegistry.getBus()).toBeUndefined();
-        });
-    });
-    describe('when disabled', ()=>{
-        it('should still export the bus instance so injecting it keeps working', ()=>{
-            const dynamicModule = EventBusModule.forRoot({
-                enabled: false
-            });
-            expect(dynamicModule.exports).toEqual([
-                EVENT_BUS_INSTANCE,
-                EVENT_BUS_MODULE_OPTIONS
-            ]);
-        });
-        it('should provide an inert bus', ()=>{
-            const dynamicModule = EventBusModule.forRoot({
-                enabled: false
-            });
-            const bus = getBusProvider(dynamicModule.providers).useFactory();
-            expect(bus).toBeInstanceOf(DisabledEventBus);
-        });
-        it('should not register the explorer, so no handler is ever bound', ()=>{
-            const dynamicModule = EventBusModule.forRoot({
-                enabled: false
-            });
-            expect(dynamicModule.providers).not.toContain(EventBusExplorer);
-        });
-        it('should not import DiscoveryModule', ()=>{
-            expect(EventBusModule.forRoot({
-                enabled: false
-            }).imports).toBeUndefined();
-        });
-        it('should leave the registry empty so every publish becomes a no-op', ()=>{
-            const dynamicModule = EventBusModule.forRoot({
-                enabled: false
-            });
-            getBusProvider(dynamicModule.providers).useFactory();
-            expect(EventBusRegistry.getBus()).toBeUndefined();
-        });
-        it('should shut down cleanly with no bus registered', async ()=>{
-            EventBusModule.forRoot({
-                enabled: false
-            });
-            await expect(new EventBusModule().onApplicationShutdown()).resolves.toBeUndefined();
-        });
-    });
-    describe('default from the environment', ()=>{
-        it('should be enabled when ENABLE_DOMAIN_EVENTS is true', ()=>{
-            process.env.ENABLE_DOMAIN_EVENTS = 'true';
-            expect(EventBusModule.forRoot().providers).toContain(EventBusExplorer);
-        });
-        it('should be disabled when ENABLE_DOMAIN_EVENTS is false', ()=>{
-            process.env.ENABLE_DOMAIN_EVENTS = 'false';
-            expect(EventBusModule.forRoot().providers).not.toContain(EventBusExplorer);
-        });
-        it('should be disabled when ENABLE_DOMAIN_EVENTS is not set', ()=>{
-            delete process.env.ENABLE_DOMAIN_EVENTS;
-            expect(EventBusModule.forRoot().providers).not.toContain(EventBusExplorer);
-        });
-        it('should let an explicit option override the environment', ()=>{
-            process.env.ENABLE_DOMAIN_EVENTS = 'false';
-            expect(EventBusModule.forRoot({
-                enabled: true
-            }).providers).toContain(EventBusExplorer);
-        });
-    });
-});

package/fesm/modules/event-bus/module-events.provider.js

@@ -1,26 +0,0 @@
-import { EventBusRegistry } from '../../classes/event-bus.registry';
-export const moduleEventsToken = (moduleName)=>`${moduleName.toUpperCase().replace(/-/g, '_')}_EVENTS_CONFIG`;
-const providerCache = new Map();
-/**
- * Registers a feature package's `events` block so every ApiService in that
- * module starts publishing. Add it to the module's own providers:
- *
- *   providers: [createModuleEventsProvider('storage', STORAGE_MODULE_OPTIONS)]
- */ export function createModuleEventsProvider(moduleName, optionsToken) {
-    const cacheKey = `${moduleName}|${optionsToken}`;
-    const cached = providerCache.get(cacheKey);
-    if (cached) return cached;
-    const provider = {
-        provide: moduleEventsToken(moduleName),
-        useFactory: (options)=>{
-            const events = options?.config?.events ?? {};
-            EventBusRegistry.configureModule(moduleName, events);
-            return events;
-        },
-        inject: [
-            optionsToken
-        ]
-    };
-    providerCache.set(cacheKey, provider);
-    return provider;
-}

package/fesm/modules/event-bus/module-events.provider.spec.js

@@ -1,52 +0,0 @@
-import { EventBusRegistry } from '../../classes/event-bus.registry';
-import { createModuleEventsProvider, moduleEventsToken } from './module-events.provider';
-describe('moduleEventsToken', ()=>{
-    it('should build an upper snake case token', ()=>{
-        expect(moduleEventsToken('storage')).toBe('STORAGE_EVENTS_CONFIG');
-        expect(moduleEventsToken('form-builder')).toBe('FORM_BUILDER_EVENTS_CONFIG');
-    });
-});
-describe('createModuleEventsProvider', ()=>{
-    beforeEach(()=>{
-        EventBusRegistry.reset();
-    });
-    it('should inject the module options token', ()=>{
-        const provider = createModuleEventsProvider('storage', 'STORAGE_MODULE_OPTIONS');
-        expect(provider.provide).toBe('STORAGE_EVENTS_CONFIG');
-        expect(provider.inject).toEqual([
-            'STORAGE_MODULE_OPTIONS'
-        ]);
-    });
-    it('should register the events block from the module config', ()=>{
-        const provider = createModuleEventsProvider('storage', 'STORAGE_MODULE_OPTIONS');
-        const result = provider.useFactory({
-            config: {
-                events: {
-                    enabled: true
-                }
-            }
-        });
-        expect(result).toEqual({
-            enabled: true
-        });
-        expect(EventBusRegistry.getModuleConfig('storage')).toEqual({
-            enabled: true
-        });
-    });
-    it('should register an empty config when the module supplies no events block', ()=>{
-        const provider = createModuleEventsProvider('auth', 'AUTH_MODULE_OPTIONS');
-        provider.useFactory({
-            config: {}
-        });
-        expect(EventBusRegistry.getModuleConfig('auth')).toEqual({});
-    });
-    it('should return the same provider for repeated calls so module comparisons stay stable', ()=>{
-        const first = createModuleEventsProvider('event-manager', 'EVENT_MANAGER_MODULE_OPTIONS');
-        const second = createModuleEventsProvider('event-manager', 'EVENT_MANAGER_MODULE_OPTIONS');
-        expect(first).toBe(second);
-    });
-    it('should tolerate missing options', ()=>{
-        const provider = createModuleEventsProvider('iam', 'IAM_MODULE_OPTIONS');
-        expect(provider.useFactory(undefined)).toEqual({});
-    });
-});

package/fesm/modules/shared-permission-cache/shared-permission-cache.module.js

@@ -1,22 +0,0 @@
-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;
-}
-import { Global, Module } from '@nestjs/common';
-import { SharedPermissionCacheService } from './shared-permission-cache.service';
-export class SharedPermissionCacheModule {
-}
-SharedPermissionCacheModule = _ts_decorate([
-    Global(),
-    Module({
-        imports: [],
-        providers: [
-            SharedPermissionCacheService
-        ],
-        exports: [
-            SharedPermissionCacheService
-        ]
-    })
-], SharedPermissionCacheModule);

package/fesm/modules/shared-permission-cache/shared-permission-cache.service.js

@@ -1,91 +0,0 @@
-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);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { Inject, Injectable, Optional } from '@nestjs/common';
-import { HybridCache } from '../../classes/hybrid-cache.class';
-import { CACHE_INSTANCE, PERMISSION_GUARD_CONFIG } from '../../constants';
-import { PermissionGuardConfig } from '../../interfaces';
-import { buildPermissionCacheKey, DEFAULT_COMPANY_PERMISSION_KEY_FORMAT, DEFAULT_USER_PERMISSION_KEY_FORMAT } from '../../utils/permission-cache-key.util';
-export class SharedPermissionCacheService {
-    /** Read the cached permission codes for a user; empty array when cache is unavailable or unset */ async getPermissions(options) {
-        if (!this.cache) return [];
-        const cacheKey = buildPermissionCacheKey(options, this.config);
-        const cached = await this.cache.get(cacheKey);
-        if (!cached) return [];
-        return Array.isArray(cached) ? cached : cached.backendCodes || [];
-    }
-    /** Overwrite the cached permission codes for a user with a fixed list */ async setPermissions(options, permissions, ttl) {
-        if (!this.cache) return;
-        const cacheKey = buildPermissionCacheKey(options, this.config);
-        await this.cache.set(cacheKey, permissions, ttl);
-    }
-    /** Clear the cached permission codes for a user */ async clearPermissions(options) {
-        if (!this.cache) return;
-        const cacheKey = buildPermissionCacheKey(options, this.config);
-        await this.cache.del(cacheKey);
-    }
-    /** Check a single permission against the cached list, honoring `*` and `prefix.*` wildcards */ async hasPermission(options, requiredPermission) {
-        const permissions = await this.getPermissions(options);
-        return this.matchPermission(permissions, requiredPermission);
-    }
-    /** Whether a cache instance is wired up; false means permission checks can't be served at all */ isCacheConfigured() {
-        return !!this.cache;
-    }
-    /** Match an already-fetched permission list against a required permission, honoring `*` and `prefix.*` wildcards */ matchPermission(userPermissions, requiredPermission) {
-        if (userPermissions.includes(requiredPermission)) return true;
-        for (const permission of userPermissions){
-            if (permission === '*') return true;
-            if (permission.endsWith('.*') && requiredPermission.startsWith(permission.slice(0, -1))) {
-                return true;
-            }
-        }
-        return false;
-    }
-    constructor(cache, config){
-        _define_property(this, "cache", void 0);
-        _define_property(this, "config", void 0);
-        this.cache = cache;
-        this.config = {
-            enableCompanyFeature: false,
-            userPermissionKeyFormat: DEFAULT_USER_PERMISSION_KEY_FORMAT,
-            companyPermissionKeyFormat: DEFAULT_COMPANY_PERMISSION_KEY_FORMAT,
-            ...config
-        };
-    }
-}
-SharedPermissionCacheService = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Optional()),
-    _ts_param(0, Inject(CACHE_INSTANCE)),
-    _ts_param(1, Optional()),
-    _ts_param(1, Inject(PERMISSION_GUARD_CONFIG)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HybridCache === "undefined" ? Object : HybridCache,
-        typeof PermissionGuardConfig === "undefined" ? Object : PermissionGuardConfig
-    ])
-], SharedPermissionCacheService);

package/fesm/modules/shared-permission-cache/shared-permission-cache.service.spec.js

@@ -1,161 +0,0 @@
-import { SharedPermissionCacheService } from './shared-permission-cache.service';
-describe('SharedPermissionCacheService', ()=>{
-    let service;
-    let mockCache;
-    beforeEach(()=>{
-        mockCache = {
-            get: jest.fn(),
-            set: jest.fn(),
-            del: jest.fn()
-        };
-        service = new SharedPermissionCacheService(mockCache);
-    });
-    describe('getPermissions', ()=>{
-        it('returns an empty array when nothing is cached', async ()=>{
-            mockCache.get.mockResolvedValue(undefined);
-            const permissions = await service.getPermissions({
-                userId: 'user-1'
-            });
-            expect(permissions).toEqual([]);
-            expect(mockCache.get).toHaveBeenCalledWith('my-permissions:user:user-1');
-        });
-        it('returns the cached array as-is', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'file.read',
-                'file.update'
-            ]);
-            const permissions = await service.getPermissions({
-                userId: 'user-1'
-            });
-            expect(permissions).toEqual([
-                'file.read',
-                'file.update'
-            ]);
-        });
-        it('unwraps a { backendCodes } shaped cache value', async ()=>{
-            mockCache.get.mockResolvedValue({
-                backendCodes: [
-                    'file.read'
-                ]
-            });
-            const permissions = await service.getPermissions({
-                userId: 'user-1'
-            });
-            expect(permissions).toEqual([
-                'file.read'
-            ]);
-        });
-        it('scopes the cache key by company and branch when enableCompanyFeature is on', async ()=>{
-            const scopedService = new SharedPermissionCacheService(mockCache, {
-                enableCompanyFeature: true
-            });
-            mockCache.get.mockResolvedValue(undefined);
-            await scopedService.getPermissions({
-                userId: 'user-1',
-                companyId: 'company-1',
-                branchId: 'branch-1'
-            });
-            expect(mockCache.get).toHaveBeenCalledWith('my-permissions:company:company-1:branch:branch-1:user:user-1');
-        });
-        it('returns an empty array when no cache instance is configured', async ()=>{
-            const noCacheService = new SharedPermissionCacheService();
-            await expect(noCacheService.getPermissions({
-                userId: 'user-1'
-            })).resolves.toEqual([]);
-        });
-    });
-    describe('setPermissions', ()=>{
-        it('writes the fixed permission list under the user cache key', async ()=>{
-            await service.setPermissions({
-                userId: 'user-1'
-            }, [
-                'file.read',
-                'file.update'
-            ]);
-            expect(mockCache.set).toHaveBeenCalledWith('my-permissions:user:user-1', [
-                'file.read',
-                'file.update'
-            ], undefined);
-        });
-        it('forwards a ttl when given', async ()=>{
-            await service.setPermissions({
-                userId: 'user-1'
-            }, [
-                'file.read'
-            ], 60);
-            expect(mockCache.set).toHaveBeenCalledWith('my-permissions:user:user-1', [
-                'file.read'
-            ], 60);
-        });
-        it('does nothing when no cache instance is configured', async ()=>{
-            const noCacheService = new SharedPermissionCacheService();
-            await expect(noCacheService.setPermissions({
-                userId: 'user-1'
-            }, [
-                'file.read'
-            ])).resolves.toBeUndefined();
-        });
-    });
-    describe('clearPermissions', ()=>{
-        it('deletes the cache key for the user', async ()=>{
-            await service.clearPermissions({
-                userId: 'user-1'
-            });
-            expect(mockCache.del).toHaveBeenCalledWith('my-permissions:user:user-1');
-        });
-    });
-    describe('hasPermission', ()=>{
-        it('returns true when the exact permission is cached', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'file.view.private'
-            ]);
-            await expect(service.hasPermission({
-                userId: 'user-1'
-            }, 'file.view.private')).resolves.toBe(true);
-        });
-        it('returns false when the permission is missing', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'file.read'
-            ]);
-            await expect(service.hasPermission({
-                userId: 'user-1'
-            }, 'file.view.private')).resolves.toBe(false);
-        });
-        it('honors the global "*" wildcard', async ()=>{
-            mockCache.get.mockResolvedValue([
-                '*'
-            ]);
-            await expect(service.hasPermission({
-                userId: 'user-1'
-            }, 'file.view.private')).resolves.toBe(true);
-        });
-        it('honors a "prefix.*" wildcard', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'file.*'
-            ]);
-            await expect(service.hasPermission({
-                userId: 'user-1'
-            }, 'file.view.private')).resolves.toBe(true);
-        });
-    });
-    describe('matchPermission', ()=>{
-        it('matches an already-fetched list without touching the cache', ()=>{
-            expect(service.matchPermission([
-                'file.read'
-            ], 'file.read')).toBe(true);
-            expect(service.matchPermission([
-                'file.read'
-            ], 'file.write')).toBe(false);
-            expect(mockCache.get).not.toHaveBeenCalled();
-        });
-    });
-    describe('isCacheConfigured', ()=>{
-        it('returns true when a cache instance is injected', ()=>{
-            expect(service.isCacheConfigured()).toBe(true);
-        });
-        it('returns false when no cache instance is injected', ()=>{
-            const noCacheService = new SharedPermissionCacheService();
-            expect(noCacheService.isCacheConfigured()).toBe(false);
-        });
-    });
-});

package/fesm/modules/utils/utils.module.js

@@ -1,22 +0,0 @@
-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;
-}
-import { Global, Module } from '@nestjs/common';
-import { UtilsService } from './utils.service';
-export class UtilsModule {
-}
-UtilsModule = _ts_decorate([
-    Global(),
-    Module({
-        imports: [],
-        providers: [
-            UtilsService
-        ],
-        exports: [
-            UtilsService
-        ]
-    })
-], UtilsModule);

package/fesm/modules/utils/utils.service.js

@@ -1,66 +0,0 @@
-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;
-}
-import { Injectable } from '@nestjs/common';
-export class UtilsService {
-    // ---------------- CACHE HELPERS ----------------
-    /**
-   * Generate cache key with optional tenant prefix for multi-tenant isolation
-   */ getCacheKey(entityName, params, entityId, tenantId) {
-        const prefix = this.buildTenantPrefix(tenantId);
-        if (entityId) {
-            return `${prefix}entity_${entityName}_id_${entityId}${params ? '_select_' + JSON.stringify(params) : ''}`;
-        }
-        return `${prefix}entity_${entityName}_all_${JSON.stringify(params)}`;
-    }
-    /**
-   * Track cache key for later invalidation with optional tenant prefix
-   */ async trackCacheKey(cacheKey, entityName, cacheManager, entityId, tenantId) {
-        try {
-            const trackingKey = this.buildTrackingKey(entityName, entityId, tenantId);
-            const keys = await cacheManager.get(trackingKey) || [];
-            if (!keys.includes(cacheKey)) keys.push(cacheKey);
-            await cacheManager.set(trackingKey, keys);
-        } catch  {
-        // Silent failure - cache tracking is non-critical
-        }
-    }
-    /**
-   * Clear cache for entity with optional tenant prefix
-   */ async clearCache(entityName, cacheManager, entityId, tenantId) {
-        try {
-            const trackingKey = this.buildTrackingKey(entityName, entityId, tenantId);
-            const keys = await cacheManager.get(trackingKey) || [];
-            await Promise.allSettled(keys.map((key)=>cacheManager.del(key)));
-            await cacheManager.del(trackingKey);
-        } catch  {
-        // Silent failure - cache invalidation is non-critical
-        }
-    }
-    // ---------------- STRING HELPERS ----------------
-    /**
-   * 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;
-    }
-    /**
-   * Generate random integer between min and max (inclusive)
-   */ getRandomInt(min, max) {
-        return Math.floor(Math.random() * (max - min + 1)) + min;
-    }
-    // ---------------- PRIVATE HELPERS ----------------
-    buildTenantPrefix(tenantId) {
-        return tenantId ? `tenant_${tenantId}_` : '';
-    }
-    buildTrackingKey(entityName, entityId, tenantId) {
-        const prefix = this.buildTenantPrefix(tenantId);
-        return entityId ? `${prefix}entity_${entityName}_id_${entityId}_keys` : `${prefix}entity_${entityName}_keys`;
-    }
-}
-UtilsService = _ts_decorate([
-    Injectable()
-], UtilsService);