@flusys/nestjs-shared 6.4.1 → 7.0.0

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

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

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

@@ -0,0 +1,39 @@
+"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 createModuleEventsProvider () {
+        return createModuleEventsProvider;
+    },
+    get moduleEventsToken () {
+        return moduleEventsToken;
+    }
+});
+const _eventbusregistry = require("../../classes/event-bus.registry");
+const moduleEventsToken = (moduleName)=>`${moduleName.toUpperCase().replace(/-/g, '_')}_EVENTS_CONFIG`;
+const providerCache = new Map();
+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.EventBusRegistry.configureModule(moduleName, events);
+            return events;
+        },
+        inject: [
+            optionsToken
+        ]
+    };
+    providerCache.set(cacheKey, provider);
+    return provider;
+}

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _eventbusregistry = require("../../classes/event-bus.registry");
+const _moduleeventsprovider = require("./module-events.provider");
+describe('moduleEventsToken', ()=>{
+    it('should build an upper snake case token', ()=>{
+        expect((0, _moduleeventsprovider.moduleEventsToken)('storage')).toBe('STORAGE_EVENTS_CONFIG');
+        expect((0, _moduleeventsprovider.moduleEventsToken)('form-builder')).toBe('FORM_BUILDER_EVENTS_CONFIG');
+    });
+});
+describe('createModuleEventsProvider', ()=>{
+    beforeEach(()=>{
+        _eventbusregistry.EventBusRegistry.reset();
+    });
+    it('should inject the module options token', ()=>{
+        const provider = (0, _moduleeventsprovider.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 = (0, _moduleeventsprovider.createModuleEventsProvider)('storage', 'STORAGE_MODULE_OPTIONS');
+        const result = provider.useFactory({
+            config: {
+                events: {
+                    enabled: true
+                }
+            }
+        });
+        expect(result).toEqual({
+            enabled: true
+        });
+        expect(_eventbusregistry.EventBusRegistry.getModuleConfig('storage')).toEqual({
+            enabled: true
+        });
+    });
+    it('should register an empty config when the module supplies no events block', ()=>{
+        const provider = (0, _moduleeventsprovider.createModuleEventsProvider)('auth', 'AUTH_MODULE_OPTIONS');
+        provider.useFactory({
+            config: {}
+        });
+        expect(_eventbusregistry.EventBusRegistry.getModuleConfig('auth')).toEqual({});
+    });
+    it('should return the same provider for repeated calls so module comparisons stay stable', ()=>{
+        const first = (0, _moduleeventsprovider.createModuleEventsProvider)('event-manager', 'EVENT_MANAGER_MODULE_OPTIONS');
+        const second = (0, _moduleeventsprovider.createModuleEventsProvider)('event-manager', 'EVENT_MANAGER_MODULE_OPTIONS');
+        expect(first).toBe(second);
+    });
+    it('should tolerate missing options', ()=>{
+        const provider = (0, _moduleeventsprovider.createModuleEventsProvider)('iam', 'IAM_MODULE_OPTIONS');
+        expect(provider.useFactory(undefined)).toEqual({});
+    });
+});

package/cjs/modules/index.js

@@ -4,6 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 _export_star(require("./cache/cache.module"), exports);
 _export_star(require("./datasource"), exports);
+_export_star(require("./event-bus/event-bus.explorer"), exports);
+_export_star(require("./event-bus/event-bus.module"), exports);
+_export_star(require("./event-bus/module-events.provider"), exports);
 _export_star(require("./shared-permission-cache/shared-permission-cache.module"), exports);
 _export_star(require("./shared-permission-cache/shared-permission-cache.service"), exports);
 _export_star(require("./utils/utils.module"), exports);

package/cjs/utils/event-pattern.util.js

@@ -0,0 +1,98 @@
+"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 isMultiWildcard () {
+        return isMultiWildcard;
+    },
+    get matchEventPattern () {
+        return matchEventPattern;
+    },
+    get sanitizeEventPayload () {
+        return sanitizeEventPayload;
+    }
+});
+const SENSITIVE_KEYS = [
+    'password',
+    'secret',
+    'token',
+    'apikey',
+    'authorization',
+    'salt',
+    'hash',
+    'credential',
+    'accesskey',
+    'accountkey',
+    'privatekey',
+    'connectionstring',
+    'passphrase'
+];
+/**
+ * Matched whole, not as a substring - `pass` must be redacted without also
+ * redacting `bypassCache`, and a storage row's `key` is a path, not a secret.
+ */ const SENSITIVE_EXACT_KEYS = [
+    'pass',
+    'pwd'
+];
+const REDACTED = '[REDACTED]';
+const CIRCULAR = '[CIRCULAR]';
+const TRUNCATED = '[TRUNCATED]';
+const BINARY = '[BINARY]';
+const MAX_DEPTH = 8;
+function matchEventPattern(pattern, eventName) {
+    if (pattern === eventName) return true;
+    const patternSegments = pattern.split('.');
+    const nameSegments = eventName.split('.');
+    return matchSegments(patternSegments, 0, nameSegments, 0);
+}
+function isMultiWildcard(segment) {
+    return segment === '#' || segment === '**';
+}
+function matchSegments(pattern, patternIndex, name, nameIndex) {
+    if (patternIndex === pattern.length) return nameIndex === name.length;
+    const segment = pattern[patternIndex];
+    if (isMultiWildcard(segment)) {
+        for(let skip = nameIndex; skip <= name.length; skip++){
+            if (matchSegments(pattern, patternIndex + 1, name, skip)) return true;
+        }
+        return false;
+    }
+    if (nameIndex === name.length) return false;
+    if (segment !== '*' && segment !== name[nameIndex]) return false;
+    return matchSegments(pattern, patternIndex + 1, name, nameIndex + 1);
+}
+function sanitizeEventPayload(value) {
+    return sanitizeValue(value, new WeakSet(), 0);
+}
+function sanitizeValue(value, ancestors, depth) {
+    if (value === null || typeof value !== 'object') return value;
+    if (value instanceof Date) return value;
+    if (Buffer.isBuffer(value)) return BINARY;
+    if (ancestors.has(value)) return CIRCULAR;
+    if (depth >= MAX_DEPTH) return TRUNCATED;
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return value.map((item)=>sanitizeValue(item, ancestors, depth + 1));
+        }
+        const sanitized = {};
+        for (const [key, entry] of Object.entries(value)){
+            sanitized[key] = isSensitiveKey(key) ? REDACTED : sanitizeValue(entry, ancestors, depth + 1);
+        }
+        return sanitized;
+    } finally{
+        ancestors.delete(value);
+    }
+}
+function isSensitiveKey(key) {
+    const lowered = key.toLowerCase();
+    if (SENSITIVE_EXACT_KEYS.includes(lowered)) return true;
+    return SENSITIVE_KEYS.some((sensitive)=>lowered.includes(sensitive));
+}

package/cjs/utils/event-pattern.util.spec.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _eventpatternutil = require("./event-pattern.util");
+describe('matchEventPattern', ()=>{
+    it('should match an exact event name', ()=>{
+        expect((0, _eventpatternutil.matchEventPattern)('storage.folder.created', 'storage.folder.created')).toBe(true);
+    });
+    it('should not match a different event name', ()=>{
+        expect((0, _eventpatternutil.matchEventPattern)('storage.folder.created', 'storage.folder.updated')).toBe(false);
+    });
+    it('should treat * as exactly one segment', ()=>{
+        expect((0, _eventpatternutil.matchEventPattern)('storage.*.created', 'storage.folder.created')).toBe(true);
+        expect((0, _eventpatternutil.matchEventPattern)('storage.*', 'storage.folder.created')).toBe(false);
+    });
+    it('should treat # and ** as any number of segments', ()=>{
+        expect((0, _eventpatternutil.matchEventPattern)('storage.#', 'storage.folder.created')).toBe(true);
+        expect((0, _eventpatternutil.matchEventPattern)('**', 'auth.appuser.deleted')).toBe(true);
+        expect((0, _eventpatternutil.matchEventPattern)('storage.**', 'storage.folder.created')).toBe(true);
+    });
+    it('should let a multi wildcard match zero segments', ()=>{
+        expect((0, _eventpatternutil.matchEventPattern)('storage.folder.created.#', 'storage.folder.created')).toBe(true);
+    });
+    it('should not match across a different module', ()=>{
+        expect((0, _eventpatternutil.matchEventPattern)('storage.#', 'auth.appuser.created')).toBe(false);
+    });
+});
+describe('isMultiWildcard', ()=>{
+    it.each([
+        [
+            '#',
+            true
+        ],
+        [
+            '**',
+            true
+        ],
+        [
+            '*',
+            false
+        ],
+        [
+            'folder',
+            false
+        ]
+    ])('should classify %s as %s', (segment, expected)=>{
+        expect((0, _eventpatternutil.isMultiWildcard)(segment)).toBe(expected);
+    });
+});
+describe('sanitizeEventPayload', ()=>{
+    it('should redact credential-like fields', ()=>{
+        const result = (0, _eventpatternutil.sanitizeEventPayload)({
+            id: '1',
+            password: 'secret',
+            apiKey: 'k'
+        });
+        expect(result).toEqual({
+            id: '1',
+            password: '[REDACTED]',
+            apiKey: '[REDACTED]'
+        });
+    });
+    it('should redact the credential keys used by the storage and email providers', ()=>{
+        const result = (0, _eventpatternutil.sanitizeEventPayload)({
+            name: 'primary-s3',
+            config: {
+                region: 'us-east-1',
+                bucket: 'assets',
+                accessKeyId: 'AKIA...',
+                secretAccessKey: 's3cr3t',
+                accountKey: 'azure-key',
+                privateKey: '-----BEGIN...',
+                connectionString: 'DefaultEndpointsProtocol=...;AccountKey=abc',
+                auth: {
+                    user: 'mailer',
+                    pass: 'hunter2'
+                }
+            }
+        });
+        expect(result).toEqual({
+            name: 'primary-s3',
+            config: {
+                region: 'us-east-1',
+                bucket: 'assets',
+                accessKeyId: '[REDACTED]',
+                secretAccessKey: '[REDACTED]',
+                accountKey: '[REDACTED]',
+                privateKey: '[REDACTED]',
+                connectionString: '[REDACTED]',
+                auth: {
+                    user: 'mailer',
+                    pass: '[REDACTED]'
+                }
+            }
+        });
+    });
+    it('should not over-redact keys that merely contain a credential word', ()=>{
+        const result = (0, _eventpatternutil.sanitizeEventPayload)({
+            key: 'uploads/2026/report.pdf',
+            bypassCache: true,
+            passengerCount: 4
+        });
+        expect(result).toEqual({
+            key: 'uploads/2026/report.pdf',
+            bypassCache: true,
+            passengerCount: 4
+        });
+    });
+    it('should redact nested fields', ()=>{
+        const result = (0, _eventpatternutil.sanitizeEventPayload)({
+            user: {
+                name: 'Ada',
+                passwordHash: 'x'
+            }
+        });
+        expect(result).toEqual({
+            user: {
+                name: 'Ada',
+                passwordHash: '[REDACTED]'
+            }
+        });
+    });
+    it('should map over arrays', ()=>{
+        const result = (0, _eventpatternutil.sanitizeEventPayload)([
+            {
+                token: 't'
+            },
+            {
+                token: 'u'
+            }
+        ]);
+        expect(result).toEqual([
+            {
+                token: '[REDACTED]'
+            },
+            {
+                token: '[REDACTED]'
+            }
+        ]);
+    });
+    it('should leave dates and primitives untouched', ()=>{
+        const date = new Date('2026-01-01T00:00:00.000Z');
+        expect((0, _eventpatternutil.sanitizeEventPayload)({
+            createdAt: date,
+            count: 3
+        })).toEqual({
+            createdAt: date,
+            count: 3
+        });
+    });
+    it('should mark a circular relation instead of recursing forever', ()=>{
+        const folder = {
+            id: 'folder-1',
+            name: 'Docs'
+        };
+        const file = {
+            id: 'file-1',
+            folder
+        };
+        folder.files = [
+            file
+        ];
+        expect((0, _eventpatternutil.sanitizeEventPayload)(folder)).toEqual({
+            id: 'folder-1',
+            name: 'Docs',
+            files: [
+                {
+                    id: 'file-1',
+                    folder: '[CIRCULAR]'
+                }
+            ]
+        });
+    });
+    it('should survive a self referencing row', ()=>{
+        const row = {
+            id: '1'
+        };
+        row.self = row;
+        expect(()=>(0, _eventpatternutil.sanitizeEventPayload)(row)).not.toThrow();
+        expect((0, _eventpatternutil.sanitizeEventPayload)(row)).toEqual({
+            id: '1',
+            self: '[CIRCULAR]'
+        });
+    });
+    it('should repeat a shared row rather than calling the second one circular', ()=>{
+        const shared = {
+            id: 'shared'
+        };
+        expect((0, _eventpatternutil.sanitizeEventPayload)([
+            {
+                a: shared
+            },
+            {
+                b: shared
+            }
+        ])).toEqual([
+            {
+                a: {
+                    id: 'shared'
+                }
+            },
+            {
+                b: {
+                    id: 'shared'
+                }
+            }
+        ]);
+    });
+    it('should truncate a graph deeper than the depth cap', ()=>{
+        const deep = {};
+        let cursor = deep;
+        for(let level = 0; level < 12; level++){
+            const next = {};
+            cursor.child = next;
+            cursor = next;
+        }
+        let result = (0, _eventpatternutil.sanitizeEventPayload)(deep);
+        for(let level = 0; level < 7; level++){
+            result = result.child;
+        }
+        expect(result.child).toBe('[TRUNCATED]');
+    });
+    it('should replace a buffer with a marker instead of exploding it into indexes', ()=>{
+        const result = (0, _eventpatternutil.sanitizeEventPayload)({
+            id: '1',
+            content: Buffer.from('hello')
+        });
+        expect(result).toEqual({
+            id: '1',
+            content: '[BINARY]'
+        });
+    });
+});

package/cjs/utils/index.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./date-time.util"), exports);
+_export_star(require("./event-pattern.util"), exports);
 _export_star(require("./html-sanitizer.util"), exports);
+_export_star(require("./optional-module.util"), exports);
 _export_star(require("./permission-cache-key.util"), exports);
 _export_star(require("./query-helpers.util"), exports);
 _export_star(require("./request.util"), exports);

package/cjs/utils/optional-module.util.js

@@ -0,0 +1,35 @@
+/**
+ * Loads an optional peer dependency at runtime.
+ *
+ * The specifier has to stay invisible to the bundler. A plain `import(name)`
+ * looks dynamic in source but webpack rewrites it into a context module rooted
+ * at this directory - one that can only ever resolve files sitting next to this
+ * one - so `amqplib` and `kafkajs` fail to load in the bundled app no matter how
+ * correctly they are installed. Both lookups below are assembled at runtime,
+ * where no bundler can rewrite them.
+ *
+ * `require` is used first because it is what the CommonJS builds actually run
+ * on; native ESM has no `require`, and there `import()` is the only way in.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "loadOptionalModule", {
+    enumerable: true,
+    get: function() {
+        return loadOptionalModule;
+    }
+});
+async function loadOptionalModule(name) {
+    const runtimeRequire = resolveRuntimeRequire();
+    if (runtimeRequire) return runtimeRequire(name);
+    const runtimeImport = new Function('specifier', 'return import(specifier);');
+    return runtimeImport(name);
+}
+/** Undefined under native ESM and inside a bundle that shadows nothing back */ function resolveRuntimeRequire() {
+    try {
+        return eval('typeof require === "function" ? require : undefined');
+    } catch  {
+        return undefined;
+    }
+}

package/cjs/utils/optional-module.util.spec.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _optionalmoduleutil = require("./optional-module.util");
+describe('loadOptionalModule', ()=>{
+    it('should resolve an installed module', async ()=>{
+        const events = await (0, _optionalmoduleutil.loadOptionalModule)('events');
+        expect(typeof events.EventEmitter).toBe('function');
+    });
+    it('should reject for a module that is not installed', async ()=>{
+        await expect((0, _optionalmoduleutil.loadOptionalModule)('definitely-not-installed-pkg')).rejects.toThrow();
+    });
+});

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

@@ -1,9 +1,16 @@
 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 { EventAction } from '../enums/event-action.enum';
+import { DomainEventActionName, IDataSourceProvider, ILoggedUserInfo, IService } from '../interfaces';
 import { UtilsService } from '../modules/utils/utils.service';
+import { IPublishDomainEventInput } from './domain-event.publisher';
 import { HybridCache } from './hybrid-cache.class';
+interface IEventGroup<T> {
+    action: EventAction;
+    entities: T[];
+    idsOnly?: boolean;
+}
 export declare abstract class ApiService<CreateDtoT extends object, UpdateDtoT extends {
     id: string;
 }, InterfaceT extends Identity, EntityT extends Identity> implements IService<CreateDtoT, UpdateDtoT, InterfaceT> {
@@ -35,6 +42,8 @@ export declare abstract class ApiService<CreateDtoT extends object, UpdateDtoT e
         total: number;
     }>;
     delete(option: DeleteDto, user: ILoggedUserInfo | null): Promise<null>;
+    protected publishLifecycleEvents(groups: IEventGroup<EntityT>[], user: ILoggedUserInfo | null): Promise<void>;
+    protected publishDomainAction(action: DomainEventActionName, input?: Omit<IPublishDomainEventInput, 'module' | 'entity' | 'action'>): Promise<void>;
     clearCacheForAll(): Promise<void>;
     clearCacheForId(entities: EntityT[]): Promise<void>;
     private handleError;
@@ -75,3 +84,4 @@ export declare abstract class ApiService<CreateDtoT extends object, UpdateDtoT e
     protected convertEntityListToResponseListDto(entities: EntityT[] | RawEntity[], _isRaw: boolean): InterfaceT[];
     protected getEntityClass(): Promise<EntityT>;
 }
+export {};