@flusys/nestjs-shared 7.0.2 → 8.0.0-beta.1

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

@@ -1,114 +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, Logger, Optional } from '@nestjs/common';
-import { DiscoveryService, MetadataScanner } from '@nestjs/core';
-import { DOMAIN_EVENT_HANDLER_KEY, EVENT_BUS_INSTANCE } from '../../constants';
-export class EventBusExplorer {
-    async onApplicationBootstrap() {
-        const bus = this.eventBus;
-        if (!bus) return;
-        const wrappers = [
-            ...this.discovery.getProviders(),
-            ...this.discovery.getControllers()
-        ];
-        // The same provider is returned once per module that registers it; binding
-        // it twice would run every handler twice for a single event.
-        const seen = new Set();
-        let bound = 0;
-        for (const wrapper of wrappers){
-            const instance = wrapper.instance;
-            if (!instance || typeof instance !== 'object' || wrapper.isNotMetatype) {
-                this.warnIfUnreachableConsumer(wrapper);
-                continue;
-            }
-            if (seen.has(instance)) continue;
-            seen.add(instance);
-            bound += await this.bindInstance(instance, bus);
-        }
-        if (bound) {
-            const active = bus.getActiveTransports();
-            this.logger.log(`Bound ${bound} domain event handler(s); transport '${bus.getTransportLabel()}' ` + `live over ${active.length ? active.join(', ') : 'no transport'}`);
-        }
-    }
-    async bindInstance(instance, bus) {
-        const prototype = Object.getPrototypeOf(instance);
-        if (!prototype) return 0;
-        let bound = 0;
-        for (const methodName of this.metadataScanner.getAllMethodNames(prototype)){
-            const method = instance[methodName];
-            const patterns = this.readPatterns(method);
-            if (!patterns.length) continue;
-            const handler = method;
-            for (const pattern of patterns){
-                await bus.subscribe(pattern, (event)=>handler.call(instance, event));
-                bound++;
-            }
-        }
-        return bound;
-    }
-    /**
-   * A request scoped provider has no singleton instance to bind, so its
-   * handlers would never run - that must not fail silently.
-   */ warnIfUnreachableConsumer(wrapper) {
-        const prototype = wrapper.metatype?.prototype;
-        if (wrapper.instance || !prototype) return;
-        const hasHandler = this.metadataScanner.getAllMethodNames(prototype).some((methodName)=>this.readPatterns(prototype[methodName]).length > 0);
-        if (hasHandler) {
-            this.logger.warn(`${wrapper.name} declares @OnDomainEvent methods but has no singleton instance ` + `(request scoped providers cannot consume events) - move the handler to a default scoped provider`);
-        }
-    }
-    readPatterns(method) {
-        if (typeof method !== 'function') return [];
-        return Reflect.getMetadata(DOMAIN_EVENT_HANDLER_KEY, method) ?? [];
-    }
-    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
-    // @Optional() so nothing here is a hard dependency on EventBusModule being registered
-    constructor(eventBus, discovery, metadataScanner){
-        _define_property(this, "eventBus", void 0);
-        _define_property(this, "discovery", void 0);
-        _define_property(this, "metadataScanner", void 0);
-        _define_property(this, "logger", void 0);
-        this.eventBus = eventBus;
-        this.discovery = discovery;
-        this.metadataScanner = metadataScanner;
-        this.logger = new Logger(EventBusExplorer.name);
-    }
-}
-EventBusExplorer = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Optional()),
-    _ts_param(0, Inject(EVENT_BUS_INSTANCE)),
-    _ts_param(1, Inject(DiscoveryService)),
-    _ts_param(2, Inject(MetadataScanner)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Object,
-        typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
-        typeof MetadataScanner === "undefined" ? Object : MetadataScanner
-    ])
-], EventBusExplorer);

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

@@ -1,185 +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);
-}
-import { Logger } from '@nestjs/common';
-import { MetadataScanner } from '@nestjs/core';
-import { OnDomainEvent } from '../../decorators/on-domain-event.decorator';
-import { EventBusExplorer } from './event-bus.explorer';
-let Consumer = class Consumer {
-    onCreated(event) {
-        this.received.push(event.name);
-    }
-    onAuthOrIam() {}
-    notAHandler() {}
-    constructor(){
-        _define_property(this, "received", []);
-    }
-};
-_ts_decorate([
-    OnDomainEvent('storage.*.created'),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Object
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], Consumer.prototype, "onCreated", null);
-_ts_decorate([
-    OnDomainEvent('auth.#', 'iam.#'),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", []),
-    _ts_metadata("design:returntype", void 0)
-], Consumer.prototype, "onAuthOrIam", null);
-function createExplorer(wrappers) {
-    const eventBus = {
-        subscribe: jest.fn().mockResolvedValue(undefined),
-        getTransportLabel: ()=>'memory',
-        getActiveTransports: ()=>[
-                'memory'
-            ]
-    };
-    const discovery = {
-        getProviders: ()=>wrappers.map((wrapper)=>wrapper && typeof wrapper === 'object' && 'instance' in wrapper ? wrapper : {
-                    instance: wrapper,
-                    isNotMetatype: false
-                }),
-        getControllers: ()=>[]
-    };
-    return {
-        eventBus,
-        explorer: new EventBusExplorer(eventBus, discovery, new MetadataScanner())
-    };
-}
-describe('EventBusExplorer', ()=>{
-    it('should subscribe every decorated method with all of its patterns', async ()=>{
-        const { eventBus, explorer } = createExplorer([
-            new Consumer()
-        ]);
-        await explorer.onApplicationBootstrap();
-        expect(eventBus.subscribe).toHaveBeenCalledTimes(3);
-        expect(eventBus.subscribe.mock.calls.map(([pattern])=>pattern)).toEqual([
-            'storage.*.created',
-            'auth.#',
-            'iam.#'
-        ]);
-    });
-    it('should bind a handler that calls back into the owning instance', async ()=>{
-        const consumer = new Consumer();
-        const { eventBus, explorer } = createExplorer([
-            consumer
-        ]);
-        await explorer.onApplicationBootstrap();
-        const [, handler] = eventBus.subscribe.mock.calls[0];
-        handler({
-            name: 'storage.folder.created'
-        });
-        expect(consumer.received).toEqual([
-            'storage.folder.created'
-        ]);
-    });
-    it('should ignore providers without decorated methods', async ()=>{
-        const { eventBus, explorer } = createExplorer([
-            {
-                plain: ()=>undefined
-            }
-        ]);
-        await explorer.onApplicationBootstrap();
-        expect(eventBus.subscribe).not.toHaveBeenCalled();
-    });
-    it('should ignore null instances', async ()=>{
-        const { eventBus, explorer } = createExplorer([
-            null,
-            undefined
-        ]);
-        await explorer.onApplicationBootstrap();
-        expect(eventBus.subscribe).not.toHaveBeenCalled();
-    });
-    it('should bind an instance once even when several modules expose it', async ()=>{
-        const consumer = new Consumer();
-        const { eventBus, explorer } = createExplorer([
-            consumer,
-            consumer
-        ]);
-        await explorer.onApplicationBootstrap();
-        expect(eventBus.subscribe).toHaveBeenCalledTimes(3);
-    });
-    it('should deliver an event once to a provider shared by several modules', async ()=>{
-        const consumer = new Consumer();
-        const { eventBus, explorer } = createExplorer([
-            consumer,
-            consumer
-        ]);
-        await explorer.onApplicationBootstrap();
-        const handlers = eventBus.subscribe.mock.calls.filter(([pattern])=>pattern === 'storage.*.created').map(([, handler])=>handler);
-        handlers.forEach((handler)=>handler({
-                name: 'storage.folder.created'
-            }));
-        expect(consumer.received).toEqual([
-            'storage.folder.created'
-        ]);
-    });
-    it('should warn about a consumer that has no singleton instance to bind', async ()=>{
-        const warn = jest.spyOn(Logger.prototype, 'warn').mockImplementation(()=>undefined);
-        const { eventBus, explorer } = createExplorer([
-            {
-                instance: undefined,
-                name: 'ScopedConsumer',
-                metatype: Consumer,
-                isNotMetatype: false
-            }
-        ]);
-        await explorer.onApplicationBootstrap();
-        expect(eventBus.subscribe).not.toHaveBeenCalled();
-        expect(warn).toHaveBeenCalledWith(expect.stringContaining('ScopedConsumer'));
-        warn.mockRestore();
-    });
-    it('should stay quiet about a scoped provider that declares no handler', async ()=>{
-        const warn = jest.spyOn(Logger.prototype, 'warn').mockImplementation(()=>undefined);
-        let Plain = class Plain {
-            doWork() {}
-        };
-        const { explorer } = createExplorer([
-            {
-                instance: undefined,
-                name: 'Plain',
-                metatype: Plain,
-                isNotMetatype: false
-            }
-        ]);
-        await explorer.onApplicationBootstrap();
-        expect(warn).not.toHaveBeenCalled();
-        warn.mockRestore();
-    });
-    it('should do nothing when no event bus is provided', async ()=>{
-        const discovery = {
-            getProviders: jest.fn(()=>[
-                    {
-                        instance: new Consumer(),
-                        isNotMetatype: false
-                    }
-                ]),
-            getControllers: ()=>[]
-        };
-        const explorer = new EventBusExplorer(undefined, discovery, new MetadataScanner());
-        await expect(explorer.onApplicationBootstrap()).resolves.toBeUndefined();
-        expect(discovery.getProviders).not.toHaveBeenCalled();
-    });
-});

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

@@ -1,249 +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);
-}
-import { Injectable, Module } from '@nestjs/common';
-import { Test } from '@nestjs/testing';
-import { publishDomainEvent } from '../../classes/domain-event.publisher';
-import { EventBusRegistry } from '../../classes/event-bus.registry';
-import { EVENT_BUS_INSTANCE } from '../../constants';
-import { OnDomainEvent } from '../../decorators/on-domain-event.decorator';
-import { DomainEvent } from '../../interfaces';
-import { EventBusModule } from './event-bus.module';
-import { createModuleEventsProvider } from './module-events.provider';
-const STORAGE_MODULE_OPTIONS = 'STORAGE_MODULE_OPTIONS';
-let AuditConsumer = class AuditConsumer {
-    onAny(event) {
-        this.everything.push(event.name);
-    }
-    onUploaded(event) {
-        this.uploads.push(String(event.payload.metadata?.location));
-    }
-    onCreated(event) {
-        this.creates.push(event.name);
-    }
-    constructor(){
-        _define_property(this, "everything", []);
-        _define_property(this, "uploads", []);
-        _define_property(this, "creates", []);
-    }
-};
-_ts_decorate([
-    OnDomainEvent('**'),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof DomainEvent === "undefined" ? Object : DomainEvent
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], AuditConsumer.prototype, "onAny", null);
-_ts_decorate([
-    OnDomainEvent('storage.file_manager.uploaded'),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof DomainEvent === "undefined" ? Object : DomainEvent
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], AuditConsumer.prototype, "onUploaded", null);
-_ts_decorate([
-    OnDomainEvent('storage.*.created', 'auth.*.created'),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof DomainEvent === "undefined" ? Object : DomainEvent
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], AuditConsumer.prototype, "onCreated", null);
-AuditConsumer = _ts_decorate([
-    Injectable()
-], AuditConsumer);
-function buildStorageModule(events) {
-    let FakeStorageModule = class FakeStorageModule {
-    };
-    FakeStorageModule = _ts_decorate([
-        Module({
-            providers: [
-                {
-                    provide: STORAGE_MODULE_OPTIONS,
-                    useValue: {
-                        config: {
-                            events
-                        }
-                    }
-                },
-                createModuleEventsProvider('storage', STORAGE_MODULE_OPTIONS)
-            ]
-        })
-    ], FakeStorageModule);
-    return FakeStorageModule;
-}
-async function bootstrap(events) {
-    const app = await Test.createTestingModule({
-        imports: [
-            EventBusModule.forRoot({
-                transport: 'memory'
-            }),
-            buildStorageModule(events)
-        ],
-        providers: [
-            AuditConsumer
-        ]
-    }).compile();
-    await app.init();
-    return {
-        app,
-        consumer: app.get(AuditConsumer),
-        bus: app.get(EVENT_BUS_INSTANCE)
-    };
-}
-describe('EventBusModule (integration)', ()=>{
-    let app;
-    afterEach(async ()=>{
-        await app?.close();
-        app = undefined;
-        EventBusRegistry.reset();
-    });
-    it('delivers a published event to every matching decorated handler', async ()=>{
-        const started = await bootstrap({
-            enabled: true
-        });
-        app = started.app;
-        await publishDomainEvent({
-            module: 'storage',
-            entity: 'file_manager',
-            action: 'uploaded',
-            ids: [
-                'key-1'
-            ],
-            metadata: {
-                location: 'local'
-            }
-        });
-        expect(started.consumer.uploads).toEqual([
-            'local'
-        ]);
-        expect(started.consumer.everything).toEqual([
-            'storage.file_manager.uploaded'
-        ]);
-        expect(started.consumer.creates).toEqual([]);
-    });
-    it('routes a single segment wildcard to the right handler', async ()=>{
-        const started = await bootstrap({
-            enabled: true
-        });
-        app = started.app;
-        await publishDomainEvent({
-            module: 'storage',
-            entity: 'folder',
-            action: 'created',
-            ids: [
-                'folder-1'
-            ]
-        });
-        expect(started.consumer.creates).toEqual([
-            'storage.folder.created'
-        ]);
-        expect(started.consumer.uploads).toEqual([]);
-    });
-    it('publishes nothing when the feature module did not enable events', async ()=>{
-        const started = await bootstrap({
-            enabled: false
-        });
-        app = started.app;
-        await publishDomainEvent({
-            module: 'storage',
-            entity: 'file_manager',
-            action: 'uploaded',
-            ids: [
-                'key-1'
-            ]
-        });
-        expect(started.consumer.everything).toEqual([]);
-    });
-    it('registers the feature module config supplied through its own options', async ()=>{
-        const started = await bootstrap({
-            enabled: true,
-            includePayload: false
-        });
-        app = started.app;
-        expect(EventBusRegistry.getModuleConfig('storage')).toEqual({
-            enabled: true,
-            includePayload: false
-        });
-        expect(EventBusRegistry.shouldIncludePayload('storage')).toBe(false);
-    });
-    it('exposes the bus for direct publish and subscribe', async ()=>{
-        const started = await bootstrap({
-            enabled: true
-        });
-        app = started.app;
-        const received = [];
-        await started.bus.subscribe('billing.#', (event)=>{
-            received.push(event.name);
-        });
-        await publishDomainEvent({
-            module: 'billing',
-            entity: 'invoice',
-            action: 'settled'
-        });
-        expect(received).toEqual([]);
-        EventBusRegistry.configureModule('billing', {
-            enabled: true
-        });
-        await publishDomainEvent({
-            module: 'billing',
-            entity: 'invoice',
-            action: 'settled'
-        });
-        expect(received).toEqual([
-            'billing.invoice.settled'
-        ]);
-    });
-    it('tears the bus down when the application shuts down', async ()=>{
-        const started = await bootstrap({
-            enabled: true
-        });
-        await started.app.close();
-        expect(EventBusRegistry.getBus()).toBeUndefined();
-    });
-    it('boots an app that never registers EventBusModule and publishes nothing', async ()=>{
-        app = await Test.createTestingModule({
-            imports: [
-                buildStorageModule({
-                    enabled: true
-                })
-            ],
-            providers: [
-                AuditConsumer
-            ]
-        }).compile();
-        await app.init();
-        const consumer = app.get(AuditConsumer);
-        await publishDomainEvent({
-            module: 'storage',
-            entity: 'file_manager',
-            action: 'uploaded',
-            ids: [
-                'key-1'
-            ]
-        });
-        expect(EventBusRegistry.getBus()).toBeUndefined();
-        expect(consumer.everything).toEqual([]);
-    });
-});

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

@@ -1,84 +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 { 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);