@flusys/nestjs-shared 7.0.0 → 7.0.2

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

@@ -1,13 +1,12 @@
-import { DataSource, EntityTarget, QueryRunner, Repository, SelectQueryBuilder } from 'typeorm';
+import { EntityTarget, QueryRunner, Repository, SelectQueryBuilder } from 'typeorm';
 import { DeleteDto, FilterAndPaginationDto } from '../dtos';
 import { Identity, RawEntity } from '../entities';
-import { EventAction } from '../enums/event-action.enum';
-import { DomainEventActionName, IDataSourceProvider, ILoggedUserInfo, IService } from '../interfaces';
+import { CrudEventActionName, 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;
+    action: CrudEventActionName;
     entities: T[];
     idsOnly?: boolean;
 }
@@ -19,17 +18,15 @@ export declare abstract class ApiService<CreateDtoT extends object, UpdateDtoT e
     protected utilsService: UtilsService;
     protected _loggerName: string;
     protected isCacheable: boolean;
-    protected moduleName?: string | undefined;
+    protected moduleName: string;
     protected repository: Repository<EntityT>;
     private repositoryInitialized;
-    private _entity?;
-    private _dataSourceProvider?;
-    constructor(entityName: string, cacheManager: HybridCache, utilsService: UtilsService, _loggerName: string, isCacheable?: boolean, moduleName?: string | undefined, entity?: EntityTarget<EntityT>, dataSourceProvider?: IDataSourceProvider);
-    protected resolveEntity(): EntityTarget<EntityT>;
+    private readonly _entity;
+    private readonly _dataSourceProvider;
+    constructor(entityName: string, cacheManager: HybridCache, utilsService: UtilsService, _loggerName: string, isCacheable: boolean | undefined, moduleName: string, dataSourceProvider: IDataSourceProvider, entity: EntityTarget<EntityT>);
     protected getDataSourceProvider(): IDataSourceProvider;
     protected ensureDataSourceRepository(): Promise<void>;
     protected resolveRepositories(entities: EntityTarget<any>[]): Promise<Repository<any>[]>;
-    protected getDataSourceForService(): Promise<DataSource>;
     insert(dto: CreateDtoT, user: ILoggedUserInfo | null): Promise<InterfaceT>;
     insertMany(dtos: Array<CreateDtoT>, user: ILoggedUserInfo | null): Promise<InterfaceT[]>;
     update(dto: UpdateDtoT, user: ILoggedUserInfo | null): Promise<InterfaceT>;
@@ -43,7 +40,7 @@ export declare abstract class ApiService<CreateDtoT extends object, UpdateDtoT e
     }>;
     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>;
+    protected publishDomainAction(action: string, input?: Omit<IPublishDomainEventInput, 'module' | 'entity' | 'action'>): Promise<void>;
     clearCacheForAll(): Promise<void>;
     clearCacheForId(entities: EntityT[]): Promise<void>;
     private handleError;
@@ -82,6 +79,5 @@ export declare abstract class ApiService<CreateDtoT extends object, UpdateDtoT e
     protected convertArrayDtoToEntities(dtos: Array<CreateDtoT | UpdateDtoT>, user: ILoggedUserInfo | null): Promise<Array<EntityT>>;
     protected convertEntityToResponseDto(entity: EntityT | RawEntity, _isRaw: boolean): InterfaceT;
     protected convertEntityListToResponseListDto(entities: EntityT[] | RawEntity[], _isRaw: boolean): InterfaceT[];
-    protected getEntityClass(): Promise<EntityT>;
 }
 export {};

package/classes/domain-event.publisher.d.ts

@@ -1,9 +1,9 @@
-import { DomainEventActionName, IDomainEvent, IDomainEventPayload, IEventBus, ILoggedUserInfo } from '../interfaces';
+import { IDomainEvent, IDomainEventPayload, IEventBus, ILoggedUserInfo } from '../interfaces';
 export declare const DOMAIN_EVENT_VERSION = 1;
 export interface IPublishDomainEventInput<T = Record<string, unknown>> {
     module: string;
     entity: string;
-    action: DomainEventActionName;
+    action: string;
     ids?: string[];
     data?: T | T[];
     metadata?: Record<string, unknown>;

package/classes/event-bus.registry.d.ts

@@ -1,4 +1,4 @@
-import { DomainEventActionName, IEventBus, IModuleEventsConfig } from '../interfaces/event-bus.interface';
+import { IEventBus, IModuleEventsConfig } from '../interfaces/event-bus.interface';
 export declare class EventBusRegistry {
     private static bus?;
     private static moduleConfigs;
@@ -8,7 +8,7 @@ export declare class EventBusRegistry {
     static setDefaultModuleEvents(config: IModuleEventsConfig): void;
     static configureModule(moduleName: string, config?: IModuleEventsConfig): void;
     static getModuleConfig(moduleName?: string): IModuleEventsConfig;
-    static isEnabled(moduleName: string | undefined, entity: string, action: DomainEventActionName): boolean;
+    static isEnabled(moduleName: string | undefined, entity: string, action: string): boolean;
     static shouldIncludePayload(moduleName?: string): boolean;
     static reset(): void;
 }

package/classes/event-transports/memory-transport.d.ts

@@ -3,7 +3,7 @@ export declare class MemoryTransport implements IEventTransport {
     readonly name = "memory";
     private readonly emitter;
     private ready;
-    constructor(maxListeners?: number);
+    constructor();
     connect(): Promise<void>;
     publish(event: IDomainEvent): Promise<void>;
     bind(_pattern: string): Promise<void>;

package/classes/hybrid-event-bus.class.d.ts

@@ -4,6 +4,7 @@ export declare class HybridEventBus implements IEventBus {
     private readonly logger;
     private readonly subscriptions;
     private readonly transports;
+    private readonly boundPatterns;
     private readonly seenIds;
     private readonly seenOrder;
     private readonly label;
@@ -21,6 +22,7 @@ export declare class HybridEventBus implements IEventBus {
     private ensureConnected;
     private resolveLabelFromEnv;
     private buildTransports;
+    private bindSubscriptions;
     private createBrokerTransport;
     private resolveHybridBrokerName;
     private loadOptionalTransport;

package/enums/index.d.ts

@@ -1,4 +1,3 @@
-export * from './event-action.enum';
 export * from './notification-type.enum';
 export * from './participant-status.enum';
 export * from './recurrence-type.enum';

package/fesm/classes/api-service.class.js

@@ -25,35 +25,23 @@ import { EntityTarget, In } from 'typeorm';
 import { ERROR_MESSAGES, SYSTEM_MESSAGES } from '../constants';
 import { LogAction } from '../decorators/log-action.decorator';
 import { DeleteDto } from '../dtos';
-import { EventAction } from '../enums/event-action.enum';
 import { IDataSourceProvider } from '../interfaces';
 import { UtilsService } from '../modules/utils/utils.service';
 import { publishDomainEvent } from './domain-event.publisher';
 import { HybridCache } from './hybrid-cache.class';
-const DEFAULT_EVENT_MODULE = 'app';
-const OPERATION_EVENT_ACTIONS = {
-    insert: EventAction.CREATED,
-    insertMany: EventAction.CREATED,
-    update: EventAction.UPDATED,
-    updateMany: EventAction.UPDATED,
-    bulkUpsert: EventAction.UPDATED
-};
 const DELETE_EVENT_ACTIONS = {
-    delete: EventAction.DELETED,
-    restore: EventAction.RESTORED
+    delete: 'deleted',
+    restore: 'restored',
+    permanent: 'purged'
 };
 export class ApiService {
-    resolveEntity() {
-        return this._entity;
-    }
     getDataSourceProvider() {
         return this._dataSourceProvider;
     }
     async ensureDataSourceRepository() {
         if (!this.repositoryInitialized) {
-            const entity = this.resolveEntity();
             const provider = this.getDataSourceProvider();
-            this.repository = await provider.getRepository(entity);
+            this.repository = await provider.getRepository(this._entity);
             this.repositoryInitialized = true;
         }
     }
@@ -65,11 +53,8 @@ export class ApiService {
         }
         return repositories;
     }
-    async getDataSourceForService() {
-        return this.getDataSourceProvider().getDataSource();
-    }
     async insert(dto, user) {
-        return this.executeInTransaction('insert', async (qr)=>{
+        return this.executeInTransaction('created', async (qr)=>{
             await this.beforeInsertOperation(dto, user, qr);
             const entities = await this.convertRequestDtoToEntity(dto, user);
             const saved = await qr.manager.save(this.repository.target, entities);
@@ -81,7 +66,7 @@ export class ApiService {
         }, user);
     }
     async insertMany(dtos, user) {
-        return this.executeInTransaction('insertMany', async (qr)=>{
+        return this.executeInTransaction('created', async (qr)=>{
             await this.beforeInsertOperation(dtos, user, qr);
             const entities = await this.convertRequestDtoToEntity(dtos, user);
             const saved = await qr.manager.save(this.repository.target, entities);
@@ -93,7 +78,7 @@ export class ApiService {
         }, user);
     }
     async update(dto, user) {
-        return this.executeInTransaction('update', async (qr)=>{
+        return this.executeInTransaction('updated', async (qr)=>{
             await this.beforeUpdateOperation(dto, user, qr);
             const entities = await this.convertRequestDtoToEntity(dto, user);
             const saved = await qr.manager.save(this.repository.target, entities);
@@ -105,7 +90,7 @@ export class ApiService {
         }, user);
     }
     async updateMany(dtos, user) {
-        return this.executeInTransaction('updateMany', async (qr)=>{
+        return this.executeInTransaction('updated', async (qr)=>{
             await this.beforeUpdateOperation(dtos, user, qr);
             const entities = await this.convertRequestDtoToEntity(dtos, user);
             const saved = await qr.manager.save(this.repository.target, entities);
@@ -117,7 +102,7 @@ export class ApiService {
         }, user);
     }
     async bulkUpsert(toInsert, toUpdate, user) {
-        return this.executeInTransaction('bulkUpsert', async (qr)=>{
+        return this.executeInTransaction(undefined, async (qr)=>{
             const allResults = [];
             const eventGroups = [];
             if (toInsert.length > 0) {
@@ -127,7 +112,7 @@ export class ApiService {
                 await this.afterInsertOperation(this.ensureArray(insertedSaved), toInsert, user, qr);
                 allResults.push(...this.ensureArray(insertedSaved));
                 eventGroups.push({
-                    action: EventAction.CREATED,
+                    action: 'created',
                     entities: this.ensureArray(insertedSaved)
                 });
             }
@@ -138,7 +123,7 @@ export class ApiService {
                 await this.afterUpdateOperation(this.ensureArray(updatedSaved), toUpdate, user, qr);
                 allResults.push(...this.ensureArray(updatedSaved));
                 eventGroups.push({
-                    action: EventAction.UPDATED,
+                    action: 'updated',
                     entities: this.ensureArray(updatedSaved)
                 });
             }
@@ -174,7 +159,7 @@ export class ApiService {
             if (error instanceof NotFoundException) {
                 throw error;
             }
-            this.handleError(error, 'findByIds');
+            this.handleError(error);
         }
     }
     async findById(id, user, select) {
@@ -214,7 +199,7 @@ export class ApiService {
             if (error instanceof NotFoundException) {
                 throw error;
             }
-            this.handleError(error, 'findById');
+            this.handleError(error);
         }
     }
     async getAll(search, filterAndPaginationDto, user) {
@@ -313,7 +298,7 @@ export class ApiService {
             }
             return finalResponse;
         } catch (error) {
-            this.handleError(error, 'getAll');
+            this.handleError(error);
         }
     }
     async delete(option, user) {
@@ -351,7 +336,7 @@ export class ApiService {
             ]);
             await this.publishLifecycleEvents([
                 {
-                    action: DELETE_EVENT_ACTIONS[option.type] ?? EventAction.PURGED,
+                    action: DELETE_EVENT_ACTIONS[option.type],
                     entities: ids,
                     idsOnly: true
                 }
@@ -359,7 +344,7 @@ export class ApiService {
             return null;
         } catch (error) {
             await queryRunner.rollbackTransaction();
-            this.handleError(error, 'delete');
+            this.handleError(error);
         } finally{
             await queryRunner.release();
         }
@@ -368,7 +353,7 @@ export class ApiService {
         for (const group of groups){
             if (!group.entities.length) continue;
             await publishDomainEvent({
-                module: this.moduleName ?? DEFAULT_EVENT_MODULE,
+                module: this.moduleName,
                 entity: this.entityName,
                 action: group.action,
                 ids: group.entities.map((entity)=>entity.id),
@@ -385,7 +370,7 @@ export class ApiService {
    */ async publishDomainAction(action, input = {}) {
         await publishDomainEvent({
             ...input,
-            module: this.moduleName ?? DEFAULT_EVENT_MODULE,
+            module: this.moduleName,
             entity: this.entityName,
             action
         });
@@ -396,7 +381,7 @@ export class ApiService {
     async clearCacheForId(entities) {
         await Promise.all(entities.map((item)=>this.utilsService.clearCache(this.entityName, this.cacheManager, item.id)));
     }
-    handleError(error, _operation) {
+    handleError(error) {
         if (error instanceof Error) {
             throw error;
         }
@@ -410,7 +395,11 @@ export class ApiService {
             value
         ];
     }
-    async executeInTransaction(operation, fn, user) {
+    /**
+   * `action` is the lifecycle action to publish for the whole batch; an
+   * operation that saves more than one kind of row - a bulk upsert - passes
+   * `undefined` and returns its own `eventGroups` instead.
+   */ async executeInTransaction(action, fn, user) {
         await this.ensureDataSourceRepository();
         const qr = this.repository.manager.connection.createQueryRunner();
         await qr.connect();
@@ -425,19 +414,19 @@ export class ApiService {
                     this.clearCacheForId(savedArray)
                 ]);
             }
-            await this.publishLifecycleEvents(eventGroups ?? [
+            await this.publishLifecycleEvents(eventGroups ?? (action ? [
                 {
-                    action: OPERATION_EVENT_ACTIONS[operation],
+                    action,
                     entities: savedArray
                 }
-            ], user ?? null);
+            ] : []), user ?? null);
             if (returnFirst) {
                 return this.convertEntityToResponseDto(savedArray[0], false);
             }
             return savedArray.map((e)=>this.convertEntityToResponseDto(e, false));
         } catch (error) {
             await qr.rollbackTransaction();
-            this.handleError(error, operation);
+            this.handleError(error);
         } finally{
             await qr.release();
         }
@@ -510,7 +499,7 @@ export class ApiService {
             return Object.assign(existing, d);
         }
         delete d.id;
-        return Object.assign(await this.getEntityClass(), d);
+        return Object.assign(this.repository.create(), d);
     }
     async convertArrayDtoToEntities(dtos, user) {
         return await Promise.all(dtos.map((dto)=>this.convertSingleDtoToEntity(dto, user)));
@@ -521,10 +510,11 @@ export class ApiService {
     convertEntityListToResponseListDto(entities, _isRaw) {
         return entities.map((entity)=>this.convertEntityToResponseDto(entity, _isRaw));
     }
-    async getEntityClass() {
-        return this.repository.create();
-    }
-    constructor(entityName, cacheManager, utilsService, _loggerName, isCacheable = false, moduleName, entity, dataSourceProvider){
+    /**
+   * `entity` is the table this service reads and writes. A service whose table
+   * depends on runtime config - the company feature, say - passes the ternary
+   * here, reading the injected config through the constructor parameter.
+   */ constructor(entityName, cacheManager, utilsService, _loggerName, isCacheable = false, moduleName, dataSourceProvider, entity){
         _define_property(this, "entityName", void 0);
         _define_property(this, "cacheManager", void 0);
         _define_property(this, "utilsService", void 0);
@@ -542,8 +532,8 @@ export class ApiService {
         this.isCacheable = isCacheable;
         this.moduleName = moduleName;
         this.repositoryInitialized = false;
-        this._entity = entity;
         this._dataSourceProvider = dataSourceProvider;
+        this._entity = entity;
     }
 }
 _ts_decorate([
@@ -625,7 +615,7 @@ ApiService = _ts_decorate([
         String,
         Boolean,
         String,
-        typeof EntityTarget === "undefined" ? Object : EntityTarget,
-        typeof IDataSourceProvider === "undefined" ? Object : IDataSourceProvider
+        typeof IDataSourceProvider === "undefined" ? Object : IDataSourceProvider,
+        typeof EntityTarget === "undefined" ? Object : EntityTarget
     ])
 ], ApiService);

package/fesm/classes/api-service.class.spec.js

@@ -16,7 +16,6 @@ import { createMockRepository, createMockDataSourceProvider } from '@test-utils/
 import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
 import { ApiService } from './api-service.class';
 import { EventBusRegistry } from './event-bus.registry';
-import { EventAction } from '../enums/event-action.enum';
 import { UtilsService } from '../modules/utils/utils.service';
 import { Identity } from '../entities';
 let TestEntity = class TestEntity extends Identity {
@@ -25,6 +24,14 @@ let TestEntity = class TestEntity extends Identity {
     }
 };
 let TestApiService = class TestApiService extends ApiService {
+    /** `publishDomainAction` is protected - feature services reach it as subclasses do */ publishAction(action, metadata) {
+        return this.publishDomainAction(action, {
+            ids: [
+                '1'
+            ],
+            metadata
+        });
+    }
 };
 function createMockQueryRunner() {
     return {
@@ -52,7 +59,7 @@ describe('ApiService', ()=>{
     let errorLogSpy;
     function makeService(isCacheable = false) {
         const dataSourceProvider = createMockDataSourceProvider(mockRepo);
-        return new TestApiService('test-entity', mockCache, utilsService, 'TestApiService', isCacheable, undefined, TestEntity, dataSourceProvider);
+        return new TestApiService('test-entity', mockCache, utilsService, 'TestApiService', isCacheable, 'app', dataSourceProvider, TestEntity);
     }
     beforeEach(()=>{
         mockRepo = createMockRepository();
@@ -641,7 +648,7 @@ describe('ApiService', ()=>{
             function makeRawService(dbType) {
                 mockRepo.manager.connection.options.type = dbType;
                 const dataSourceProvider = createMockDataSourceProvider(mockRepo);
-                return new RawTestApiService('test-entity', mockCache, utilsService, 'RawTestApiService', false, undefined, TestEntity, dataSourceProvider);
+                return new RawTestApiService('test-entity', mockCache, utilsService, 'RawTestApiService', false, 'app', dataSourceProvider, TestEntity);
             }
             function primeRawQueryBuilder(qb) {
                 qb.expressionMap = {
@@ -808,7 +815,7 @@ describe('ApiService', ()=>{
         let publish;
         function makeEventService(moduleName = 'test-module') {
             const dataSourceProvider = createMockDataSourceProvider(mockRepo);
-            return new TestApiService('test-entity', mockCache, utilsService, 'TestApiService', false, moduleName, TestEntity, dataSourceProvider);
+            return new TestApiService('test-entity', mockCache, utilsService, 'TestApiService', false, moduleName, dataSourceProvider, TestEntity);
         }
         beforeEach(()=>{
             publish = jest.fn().mockResolvedValue(undefined);
@@ -839,7 +846,7 @@ describe('ApiService', ()=>{
                 name: 'test-module.test-entity.created',
                 module: 'test-module',
                 entity: 'test-entity',
-                action: EventAction.CREATED,
+                action: 'created',
                 payload: expect.objectContaining({
                     ids: [
                         'new-1'
@@ -860,6 +867,74 @@ describe('ApiService', ()=>{
                 userId: mockUser.id
             }));
         });
+        it('should publish one created event carrying every id for insertMany', async ()=>{
+            const service = makeEventService();
+            mockQueryRunner.manager.save.mockResolvedValue([
+                {
+                    id: 'new-1',
+                    name: 'A'
+                },
+                {
+                    id: 'new-2',
+                    name: 'B'
+                }
+            ]);
+            await service.insertMany([
+                {
+                    name: 'A'
+                },
+                {
+                    name: 'B'
+                }
+            ], mockUser);
+            expect(publish).toHaveBeenCalledTimes(1);
+            expect(publish.mock.calls[0][0]).toEqual(expect.objectContaining({
+                action: 'created',
+                payload: expect.objectContaining({
+                    ids: [
+                        'new-1',
+                        'new-2'
+                    ]
+                })
+            }));
+        });
+        it('should publish one updated event carrying every id for updateMany', async ()=>{
+            const service = makeEventService();
+            mockRepo.findOne.mockResolvedValue({
+                id: '1',
+                name: 'Old'
+            });
+            mockQueryRunner.manager.save.mockResolvedValue([
+                {
+                    id: '1',
+                    name: 'A'
+                },
+                {
+                    id: '2',
+                    name: 'B'
+                }
+            ]);
+            await service.updateMany([
+                {
+                    id: '1',
+                    name: 'A'
+                },
+                {
+                    id: '2',
+                    name: 'B'
+                }
+            ], mockUser);
+            expect(publish).toHaveBeenCalledTimes(1);
+            expect(publish.mock.calls[0][0]).toEqual(expect.objectContaining({
+                action: 'updated',
+                payload: expect.objectContaining({
+                    ids: [
+                        '1',
+                        '2'
+                    ]
+                })
+            }));
+        });
         it('should publish an updated event after update commits', async ()=>{
             const service = makeEventService();
             mockRepo.findOne.mockResolvedValue({
@@ -875,7 +950,7 @@ describe('ApiService', ()=>{
                 name: 'New'
             }, mockUser);
             expect(publish.mock.calls[0][0]).toEqual(expect.objectContaining({
-                action: EventAction.UPDATED
+                action: 'updated'
             }));
         });
         it('should publish created and updated separately for a bulk upsert', async ()=>{
@@ -906,22 +981,22 @@ describe('ApiService', ()=>{
                 }
             ], mockUser);
             expect(publish.mock.calls.map(([event])=>event.action)).toEqual([
-                EventAction.CREATED,
-                EventAction.UPDATED
+                'created',
+                'updated'
             ]);
         });
         it.each([
             [
                 'delete',
-                EventAction.DELETED
+                'deleted'
             ],
             [
                 'restore',
-                EventAction.RESTORED
+                'restored'
             ],
             [
                 'permanent',
-                EventAction.PURGED
+                'purged'
             ]
         ])('should publish %s as the %s action', async (type, action)=>{
             const service = makeEventService();
@@ -945,6 +1020,39 @@ describe('ApiService', ()=>{
                 ]
             });
         });
+        it('should publish a domain action under this service module and entity', async ()=>{
+            const service = makeEventService();
+            await service.publishAction('submitted', {
+                formId: 'form-1'
+            });
+            expect(publish.mock.calls[0][0]).toEqual(expect.objectContaining({
+                name: 'test-module.test-entity.submitted',
+                module: 'test-module',
+                entity: 'test-entity',
+                action: 'submitted',
+                payload: {
+                    ids: [
+                        '1'
+                    ],
+                    metadata: {
+                        formId: 'form-1'
+                    }
+                }
+            }));
+        });
+        it('should hold a domain action to the same allowlist as the CRUD actions', async ()=>{
+            EventBusRegistry.configureModule('test-module', {
+                enabled: true,
+                actions: [
+                    'test-entity.submitted'
+                ]
+            });
+            const service = makeEventService();
+            await service.publishAction('submitted');
+            await service.publishAction('draft-saved');
+            expect(publish).toHaveBeenCalledTimes(1);
+            expect(publish.mock.calls[0][0].action).toBe('submitted');
+        });
         it('should not publish when the module has events disabled', async ()=>{
             EventBusRegistry.configureModule('test-module', {
                 enabled: false
@@ -963,7 +1071,7 @@ describe('ApiService', ()=>{
             EventBusRegistry.configureModule('test-module', {
                 enabled: true,
                 actions: [
-                    EventAction.DELETED
+                    'deleted'
                 ]
             });
             const service = makeEventService();

package/fesm/classes/event-bus.registry.js

@@ -11,6 +11,7 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
+import { matchEventPattern } from '../utils/event-pattern.util';
 const DISABLED = {
     enabled: false
 };
@@ -44,12 +45,10 @@ const DISABLED = {
    */ static isEnabled(moduleName, entity, action) {
         const config = this.getModuleConfig(moduleName);
         if (!config.enabled) return false;
-        if (config.excludeEntities?.includes(entity)) return false;
-        if (config.entities?.length && !config.entities.includes(entity)) return false;
         // Without an explicit allowlist, CRUD lifecycle actions and every domain
         // action a package defines are all published.
         if (!config.actions?.length) return true;
-        return config.actions.includes(action);
+        return config.actions.some((entry)=>entry.includes('.') ? matchEventPattern(entry, `${entity}.${action}`) : matchEventPattern(entry, action));
     }
     static shouldIncludePayload(moduleName) {
         return this.getModuleConfig(moduleName).includePayload ?? true;