@flusys/nestjs-shared 6.4.1 → 7.0.0-beta.1

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

@@ -0,0 +1,84 @@
+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 { envConfig } from '@flusys/nestjs-core/config';
+import { Logger, Module } from '@nestjs/common';
+import { DiscoveryModule } from '@nestjs/core';
+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';
+export class EventBusModule {
+    static forRoot(options = {}) {
+        const enabled = options.enabled ?? envConfig.getBoolean('ENABLE_DOMAIN_EVENTS', false);
+        return enabled ? this.enabledModule(options) : this.disabledModule(options);
+    }
+    static enabledModule(options) {
+        return {
+            module: EventBusModule,
+            global: options.global ?? true,
+            imports: [
+                DiscoveryModule
+            ],
+            providers: [
+                {
+                    provide: EVENT_BUS_MODULE_OPTIONS,
+                    useValue: options
+                },
+                {
+                    provide: EVENT_BUS_INSTANCE,
+                    useFactory: ()=>{
+                        const bus = new HybridEventBus(options);
+                        EventBusRegistry.setBus(bus);
+                        EventBusRegistry.setDefaultModuleEvents(options.defaultModuleEvents ?? {});
+                        return bus;
+                    }
+                },
+                EventBusExplorer
+            ],
+            exports: [
+                EVENT_BUS_INSTANCE,
+                EVENT_BUS_MODULE_OPTIONS
+            ]
+        };
+    }
+    /**
+   * The explorer is left out, so no handler is bound and nothing ever calls
+   * `subscribe` - which is what would otherwise open a broker connection. The
+   * bus is not registered either, so every `publishDomainEvent` call is a no-op
+   * rather than an error.
+   */ static disabledModule(options) {
+        return {
+            module: EventBusModule,
+            global: options.global ?? true,
+            providers: [
+                {
+                    provide: EVENT_BUS_MODULE_OPTIONS,
+                    useValue: options
+                },
+                {
+                    provide: EVENT_BUS_INSTANCE,
+                    useFactory: ()=>{
+                        new Logger(EventBusModule.name).log('Domain events are disabled - set ENABLE_DOMAIN_EVENTS=true to publish and consume them');
+                        return new DisabledEventBus();
+                    }
+                }
+            ],
+            exports: [
+                EVENT_BUS_INSTANCE,
+                EVENT_BUS_MODULE_OPTIONS
+            ]
+        };
+    }
+    async onApplicationShutdown() {
+        await EventBusRegistry.getBus()?.close();
+        EventBusRegistry.reset();
+    }
+}
+EventBusModule = _ts_decorate([
+    Module({})
+], EventBusModule);

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

@@ -0,0 +1,145 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,52 @@
+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/index.js

@@ -1,5 +1,8 @@
 export * from './cache/cache.module';
 export * from './datasource';
+export * from './event-bus/event-bus.explorer';
+export * from './event-bus/event-bus.module';
+export * from './event-bus/module-events.provider';
 export * from './shared-permission-cache/shared-permission-cache.module';
 export * from './shared-permission-cache/shared-permission-cache.service';
 export * from './utils/utils.module';

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

@@ -0,0 +1,86 @@
+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;
+/**
+ * Matches a dot separated event name against a routing pattern.
+ * `*` matches exactly one segment, `#` and `**` match zero or more segments.
+ */ export function matchEventPattern(pattern, eventName) {
+    if (pattern === eventName) return true;
+    const patternSegments = pattern.split('.');
+    const nameSegments = eventName.split('.');
+    return matchSegments(patternSegments, 0, nameSegments, 0);
+}
+export 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);
+}
+/**
+ * Strips credential-like fields before a row leaves the process on an event.
+ *
+ * Saved TypeORM rows routinely carry bidirectional relations, so the walk
+ * tracks the current path and caps its depth - a cycle or a very deep graph
+ * must never turn an event into a stack overflow.
+ */ export 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/fesm/utils/event-pattern.util.spec.js

@@ -0,0 +1,230 @@
+import { isMultiWildcard, matchEventPattern, sanitizeEventPayload } from './event-pattern.util';
+describe('matchEventPattern', ()=>{
+    it('should match an exact event name', ()=>{
+        expect(matchEventPattern('storage.folder.created', 'storage.folder.created')).toBe(true);
+    });
+    it('should not match a different event name', ()=>{
+        expect(matchEventPattern('storage.folder.created', 'storage.folder.updated')).toBe(false);
+    });
+    it('should treat * as exactly one segment', ()=>{
+        expect(matchEventPattern('storage.*.created', 'storage.folder.created')).toBe(true);
+        expect(matchEventPattern('storage.*', 'storage.folder.created')).toBe(false);
+    });
+    it('should treat # and ** as any number of segments', ()=>{
+        expect(matchEventPattern('storage.#', 'storage.folder.created')).toBe(true);
+        expect(matchEventPattern('**', 'auth.appuser.deleted')).toBe(true);
+        expect(matchEventPattern('storage.**', 'storage.folder.created')).toBe(true);
+    });
+    it('should let a multi wildcard match zero segments', ()=>{
+        expect(matchEventPattern('storage.folder.created.#', 'storage.folder.created')).toBe(true);
+    });
+    it('should not match across a different module', ()=>{
+        expect(matchEventPattern('storage.#', 'auth.appuser.created')).toBe(false);
+    });
+});
+describe('isMultiWildcard', ()=>{
+    it.each([
+        [
+            '#',
+            true
+        ],
+        [
+            '**',
+            true
+        ],
+        [
+            '*',
+            false
+        ],
+        [
+            'folder',
+            false
+        ]
+    ])('should classify %s as %s', (segment, expected)=>{
+        expect(isMultiWildcard(segment)).toBe(expected);
+    });
+});
+describe('sanitizeEventPayload', ()=>{
+    it('should redact credential-like fields', ()=>{
+        const result = 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 = 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 = 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 = sanitizeEventPayload({
+            user: {
+                name: 'Ada',
+                passwordHash: 'x'
+            }
+        });
+        expect(result).toEqual({
+            user: {
+                name: 'Ada',
+                passwordHash: '[REDACTED]'
+            }
+        });
+    });
+    it('should map over arrays', ()=>{
+        const result = 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(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(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(()=>sanitizeEventPayload(row)).not.toThrow();
+        expect(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(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 = 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 = sanitizeEventPayload({
+            id: '1',
+            content: Buffer.from('hello')
+        });
+        expect(result).toEqual({
+            id: '1',
+            content: '[BINARY]'
+        });
+    });
+});

package/fesm/utils/index.js

@@ -1,5 +1,7 @@
 export * from './date-time.util';
+export * from './event-pattern.util';
 export * from './html-sanitizer.util';
+export * from './optional-module.util';
 export * from './permission-cache-key.util';
 export * from './query-helpers.util';
 export * from './request.util';

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

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ */ export 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/fesm/utils/optional-module.util.spec.js

@@ -0,0 +1,10 @@
+import { loadOptionalModule } from './optional-module.util';
+describe('loadOptionalModule', ()=>{
+    it('should resolve an installed module', async ()=>{
+        const events = await loadOptionalModule('events');
+        expect(typeof events.EventEmitter).toBe('function');
+    });
+    it('should reject for a module that is not installed', async ()=>{
+        await expect(loadOptionalModule('definitely-not-installed-pkg')).rejects.toThrow();
+    });
+});