@flusys/nestjs-shared 7.0.0 → 7.0.2

package/README.md

@@ -59,19 +59,21 @@ export class Product extends Identity {
 }
 ```
 
-## 3. Generic CRUD — `createApiController` + `RequestScopedApiService`
+## 3. Generic CRUD — `createApiController` + `ApiService`
 
 ### Service (REQUEST-scoped, DataSource Provider pattern)
 
+The constructor takes the event entity name, the cache, `UtilsService`, the logger
+name, whether reads are cacheable, the event module name, the DataSource provider
+and the entity. All of them are required, so a service cannot silently skip one.
+
 ```typescript
-import { Injectable, Scope, Inject } from '@nestjs/common';
-import { EntityTarget, Repository } from 'typeorm';
-import { RequestScopedApiService } from '@flusys/nestjs-shared/classes';
-import { HybridCache } from '@flusys/nestjs-shared/classes';
+import { Inject, Injectable, Scope } from '@nestjs/common';
+import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 
 @Injectable({ scope: Scope.REQUEST }) // required
-export class ProductService extends RequestScopedApiService<
+export class ProductService extends ApiService<
   CreateProductDto,
   UpdateProductDto,
   IProduct,
@@ -80,23 +82,49 @@ export class ProductService extends RequestScopedApiService<
   constructor(
     @Inject('CACHE_INSTANCE') protected override cacheManager: HybridCache,
     @Inject(UtilsService) protected override utilsService: UtilsService,
-    @Inject(ProductConfigService) private readonly config: ProductConfigService,
-    @Inject(ProductDataSourceProvider) private readonly dsp: ProductDataSourceProvider,
+    @Inject(ProductDataSourceProvider) dataSourceProvider: ProductDataSourceProvider,
   ) {
-    super('product', null as any, cacheManager, utilsService, ProductService.name, true);
+    super(
+      PRODUCT_EVENT_ENTITIES.PRODUCT,
+      cacheManager,
+      utilsService,
+      ProductService.name,
+      true,
+      PRODUCT_EVENT_MODULE,
+      dataSourceProvider,
+      Product,
+    );
   }
+}
+```
 
-  // Required: tell the base class which entity and which datasource to use
-  protected resolveEntity(): EntityTarget<Product> {
-    return this.config.isCompanyFeatureEnabled() ? ProductWithCompany : Product;
-  }
+A service whose table depends on runtime configuration passes the choice in the
+same argument. Read the injected config through the **constructor parameter**, not
+`this` - `this` is not available until `super()` returns:
 
-  protected getDataSourceProvider() {
-    return this.dsp;
+```typescript
+  constructor(
+    @Inject('CACHE_INSTANCE') protected override cacheManager: HybridCache,
+    @Inject(UtilsService) protected override utilsService: UtilsService,
+    @Inject(ProductConfigService) private readonly config: ProductConfigService,
+    @Inject(ProductDataSourceProvider) dataSourceProvider: ProductDataSourceProvider,
+  ) {
+    super(
+      PRODUCT_EVENT_ENTITIES.PRODUCT,
+      cacheManager,
+      utilsService,
+      ProductService.name,
+      true,
+      PRODUCT_EVENT_MODULE,
+      dataSourceProvider,
+      config.isCompanyFeatureEnabled() ? ProductWithCompany : Product,
+    );
   }
-}
 ```
 
+Services are `Scope.REQUEST`, so the configuration is read once per request either
+way. The repository itself is still created lazily, on first use.
+
 ### Controller (factory function)
 
 ```typescript
@@ -297,7 +325,7 @@ events — no per-service code. Turn it on in the module's own config:
 StorageModule.forRoot({
   config: {
     ...dbConfig,
-    events: { enabled: true, includePayload: true },
+    events: { enabled: true },
   },
 });
 ```
@@ -307,22 +335,45 @@ StorageModule.forRoot({
 | Option            | Type                        | Default | Effect                                                                 |
 | ----------------- | --------------------------- | ------- | ---------------------------------------------------------------------- |
 | `enabled`         | `boolean`                   | `false` | Master switch for the module. Everything else is ignored when off.     |
-| `actions`         | `(EventAction \| string)[]` | all     | Allowlist of action names. Omit to publish every action.               |
-| `entities`        | `string[]`                  | all     | Allowlist of entity names. Omit to publish every entity.               |
-| `excludeEntities` | `string[]`                  | `[]`    | Denylist, applied before `entities`.                                   |
+| `actions`         | `string[]`                  | all     | Allowlist of `entity.action` or bare `action` entries. Omit to publish all. |
 | `includePayload`  | `boolean`                   | `true`  | Attach the saved rows as `payload.data`. Ids and metadata always ride. |
 
-Three rules that decide what actually reaches a consumer:
+Two rules decide what actually reaches a consumer:
 
 1. `actions` is **one allowlist covering CRUD and domain actions together**. Listing only
    `['logged-in']` silences that module's `created`/`updated`/`deleted` too - name
    everything you want kept, or omit `actions` entirely.
-2. `entities` matches the entity **in the event name**, which for a domain action is not
-   always the table you expect: `auth.session.logged-in` is filtered by `session`, not
-   `appuser`.
-3. Entity names are the ones the services register, so some are `snake_case`
-   (`form_result`, `file_manager`) and some are `camelCase` (`storageConfig`,
-   `emailConfig`, `translationKey`). The per-module tables below list them verbatim.
+2. An entry is either `entity.action`, which covers that one entity, or a bare action,
+   which covers every entity of the module. So `role.updated` keeps role updates and
+   drops `action.updated`, while `updated` keeps every entity's updates. Entries are
+   matched as routing patterns, so `role.*` and `*.purged` work as well.
+
+There is no separate entity filter: an enabled module publishes under every entity it has
+unless an entry narrows it, so a package gaining one is picked up with no config change.
+
+Mixing the two forms narrows one entity without touching the others:
+
+```typescript
+import { IAM_EVENT_ACTIONS } from '@flusys/nestjs-iam/config';
+
+IAMModule.forRoot({
+  config: {
+    ...dbConfig,
+    events: {
+      enabled: true,
+      actions: [
+        'created',
+        'deleted',
+        'role.updated',
+        `user_role.${IAM_EVENT_ACTIONS.PERMISSIONS_ASSIGNED}`,
+      ],
+    },
+  },
+});
+```
+
+`iam.role.updated` publishes; `iam.action.updated` does not; both still publish `created`
+and `deleted`.
 
 Event names are always `<module>.<entity>.<action>`. CRUD lifecycle actions are
 `created`, `updated`, `deleted`, `restored`, `purged`. Events are published after the
@@ -336,15 +387,21 @@ there is no row left to attach.
 Payloads are walked before they leave the process: credential-like fields become
 `[REDACTED]`, a relation that loops back becomes `[CIRCULAR]`, anything past 8 levels deep
 becomes `[TRUNCATED]`, and a Buffer becomes `[BINARY]`. Saved TypeORM rows with
-bidirectional relations are therefore safe to publish.
+bidirectional relations are therefore safe to publish. The `config` blob on a
+`storageConfig` or `emailConfig` row is redacted whole - S3, Azure, SFTP and SMTP
+credentials live in it - so those rows publish their id, name and provider and nothing
+else. Redaction is a package default, not something an application configures, so it
+cannot be switched off by a config edit.
 
 ### Registering each module
 
 Every feature module takes the same `events` block in its own config, and every one of
 them also has a `forRootAsync` variant that returns the identical `config`. The blocks
 below spell out all options with that module's real entity and action names, so each is
-copy-pasteable. `EventAction` comes from `@flusys/nestjs-shared/enums`; the action and
-entity constants come from each package's own `config` entry point.
+copy-pasteable. Write the CRUD half as literals - `created`, `updated`, `deleted`,
+`restored`, `purged` never change - and take every other action from its package's own
+`*_EVENT_ACTIONS` constant, so a rename there fails the build instead of silently muting
+the event. Each package exports its entity names the same way (`STORAGE_EVENT_ENTITIES`).
 
 In an application, keep the per-module blocks in one map rather than scattering them
 across registrations - `flusysnest/src/config/modules.config.ts` is the reference:
@@ -355,14 +412,17 @@ const domainEventsEnabled = envConfig.getBoolean('ENABLE_DOMAIN_EVENTS', false);
 export const moduleEventsConfig: Record<FeatureModuleName, IModuleEventsConfig> = {
   storage: {
     enabled: domainEventsEnabled,
-    actions: [...CRUD_EVENT_ACTIONS, STORAGE_EVENT_ACTIONS.UPLOADED, STORAGE_EVENT_ACTIONS.REMOVED],
-    entities: [
-      STORAGE_EVENT_ENTITIES.FILE,
-      STORAGE_EVENT_ENTITIES.FOLDER,
-      STORAGE_EVENT_ENTITIES.STORAGE_CONFIG,
+    actions: [
+      'file_manager.created',
+      'file_manager.updated',
+      'file_manager.deleted',
+      'file_manager.restored',
+      'file_manager.purged',
+      `file_manager.${STORAGE_EVENT_ACTIONS.UPLOADED}`,
+      `file_manager.${STORAGE_EVENT_ACTIONS.REMOVED}`,
+      'folder.created',
+      // ...one line per entity and action the module can publish
     ],
-    excludeEntities: [STORAGE_EVENT_ENTITIES.STORAGE_CONFIG],
-    includePayload: true,
   },
   // ...one entry per feature module
 };
@@ -374,28 +434,26 @@ export function getBaseModuleConfig(moduleName: FeatureModuleName) {
 AuthModule.forRoot({ config: { ...authConfig, ...getBaseModuleConfig('auth') } });
 ```
 
-Spelling `actions` and `entities` out in full is the same as omitting them, and makes the
-file a readable inventory of what each module can publish - delete a line to stop
-publishing it. The trade-off is that a package gaining a new entity or action stays silent
-until it is added here, so keep a test asserting these lists cover each package's own
-`*_EVENT_ACTIONS` / `*_EVENT_ENTITIES` constants. One env flag still arms every module, but
-each keeps its own block, so narrowing one module never touches the others. Note the two `excludeEntities` entries that ship by
-default: `storageConfig` and `emailConfig` rows hold S3, Azure, SFTP and SMTP credentials
-in a `config` blob, so they stay off the bus entirely.
+Spelling every `entity.action` pair out in full - CRUD lifecycle ones included, rather
+than spreading a shared array or leaning on bare actions - is the same as omitting the
+option, and makes the file a readable inventory of what each module publishes: delete one
+line to stop publishing that one pair. The trade-off is that a package gaining an entity
+or an action stays silent until it is listed, so keep a test asserting the list covers
+each package's own `*_EVENT_ENTITIES` and `*_EVENT_ACTIONS` constants. One env flag still
+arms every module, but each keeps its own block, so narrowing one module never touches
+the others.
 
 #### auth
 
 ```typescript
-import { AUTH_EVENT_ACTIONS, AUTH_EVENT_ENTITIES } from '@flusys/nestjs-auth/config';
+import { AUTH_EVENT_ACTIONS } from '@flusys/nestjs-auth/config';
 
 AuthModule.forRoot({
   config: {
     ...dbConfig,
     events: {
       enabled: true,
-      actions: [EventAction.CREATED, AUTH_EVENT_ACTIONS.LOGGED_IN],
-      entities: [AUTH_EVENT_ENTITIES.USER, AUTH_EVENT_ENTITIES.SESSION],
-      excludeEntities: ['company_branch'],
+      actions: ['appuser.created', `session.${AUTH_EVENT_ACTIONS.LOGGED_IN}`],
       includePayload: false,
     },
   },
@@ -413,17 +471,18 @@ AuthModule.forRoot({
 #### iam
 
 ```typescript
-import { IAM_EVENT_ACTIONS, IAM_EVENT_ENTITIES } from '@flusys/nestjs-iam/config';
+import { IAM_EVENT_ACTIONS } from '@flusys/nestjs-iam/config';
 
 IAMModule.forRoot({
   config: {
     ...dbConfig,
     events: {
       enabled: true,
-      actions: [EventAction.CREATED, EventAction.DELETED, IAM_EVENT_ACTIONS.PERMISSIONS_ASSIGNED],
-      entities: ['role', IAM_EVENT_ENTITIES.USER_ROLE],
-      excludeEntities: ['action'],
-      includePayload: true,
+      actions: [
+        'role.created',
+        'role.deleted',
+        `user_role.${IAM_EVENT_ACTIONS.PERMISSIONS_ASSIGNED}`,
+      ],
     },
   },
 });
@@ -437,17 +496,14 @@ IAMModule.forRoot({
 #### storage
 
 ```typescript
-import { STORAGE_EVENT_ACTIONS, STORAGE_EVENT_ENTITIES } from '@flusys/nestjs-storage/config';
+import { STORAGE_EVENT_ACTIONS } from '@flusys/nestjs-storage/config';
 
 StorageModule.forRoot({
   config: {
     ...dbConfig,
     events: {
       enabled: true,
-      actions: [EventAction.CREATED, EventAction.DELETED, STORAGE_EVENT_ACTIONS.UPLOADED],
-      entities: [STORAGE_EVENT_ENTITIES.FILE, 'folder'],
-      excludeEntities: ['storageConfig'],
-      includePayload: true,
+      actions: ['folder.created', 'folder.deleted', `file_manager.${STORAGE_EVENT_ACTIONS.UPLOADED}`],
     },
   },
 });
@@ -472,9 +528,7 @@ FormBuilderModule.forRoot({
     ...dbConfig,
     events: {
       enabled: true,
-      actions: [FORM_BUILDER_EVENT_ACTIONS.SUBMITTED],
-      entities: ['form_result'],
-      excludeEntities: [],
+      actions: [`form_result.${FORM_BUILDER_EVENT_ACTIONS.SUBMITTED}`],
       includePayload: false,
     },
   },
@@ -492,16 +546,17 @@ audit consumer can work with `includePayload: false` and never see answer data.
 #### email
 
 ```typescript
-import { EMAIL_EVENT_ACTIONS, EMAIL_EVENT_ENTITIES } from '@flusys/nestjs-email/config';
+import { EMAIL_EVENT_ACTIONS } from '@flusys/nestjs-email/config';
 
 EmailModule.forRoot({
   config: {
     ...dbConfig,
     events: {
       enabled: true,
-      actions: [EMAIL_EVENT_ACTIONS.SENT, EMAIL_EVENT_ACTIONS.FAILED],
-      entities: [EMAIL_EVENT_ENTITIES.MESSAGE],
-      excludeEntities: ['emailConfig'],
+      actions: [
+        `email_message.${EMAIL_EVENT_ACTIONS.SENT}`,
+        `email_message.${EMAIL_EVENT_ACTIONS.FAILED}`,
+      ],
       includePayload: false,
     },
   },
@@ -524,10 +579,10 @@ EventManagerModule.forRoot({
     ...dbConfig,
     events: {
       enabled: true,
-      actions: [EventAction.CREATED, EVENT_MANAGER_EVENT_ACTIONS.PARTICIPANT_STATUS_CHANGED],
-      entities: ['event'],
-      excludeEntities: [],
-      includePayload: true,
+      actions: [
+        'event.created',
+        `event.${EVENT_MANAGER_EVENT_ACTIONS.PARTICIPANT_STATUS_CHANGED}`,
+      ],
     },
   },
 });
@@ -543,10 +598,7 @@ The participant event is keyed by the **event** id, with `participantId`,
 #### notification
 
 ```typescript
-import {
-  NOTIFICATION_EVENT_ACTIONS,
-  NOTIFICATION_EVENT_ENTITIES,
-} from '@flusys/nestjs-notification/config';
+import { NOTIFICATION_EVENT_ACTIONS } from '@flusys/nestjs-notification/config';
 
 NotificationModule.forRoot({
   config: {
@@ -554,9 +606,10 @@ NotificationModule.forRoot({
     enableRealtime: true,
     events: {
       enabled: true,
-      actions: [NOTIFICATION_EVENT_ACTIONS.SENT, NOTIFICATION_EVENT_ACTIONS.READ],
-      entities: [NOTIFICATION_EVENT_ENTITIES.NOTIFICATION],
-      excludeEntities: [],
+      actions: [
+        `notification.${NOTIFICATION_EVENT_ACTIONS.SENT}`,
+        `notification.${NOTIFICATION_EVENT_ACTIONS.READ}`,
+      ],
       includePayload: false,
     },
   },
@@ -581,9 +634,7 @@ LocalizationModule.forRoot({
     defaultLanguageCode: 'en',
     events: {
       enabled: true,
-      actions: [LOCALIZATION_EVENT_ACTIONS.BULK_UPDATED],
-      entities: ['translation'],
-      excludeEntities: ['translationKey'],
+      actions: [`translation.${LOCALIZATION_EVENT_ACTIONS.BULK_UPDATED}`],
       includePayload: false,
     },
   },
@@ -609,10 +660,7 @@ TaskManagerModule.forRoot({
     ...dbConfig,
     events: {
       enabled: true,
-      actions: [TASK_MANAGER_EVENT_ACTIONS.MOVED, TASK_MANAGER_EVENT_ACTIONS.ASSIGNED],
-      entities: ['task', 'task_list'],
-      excludeEntities: ['task_comment'],
-      includePayload: true,
+      actions: [`task.${TASK_MANAGER_EVENT_ACTIONS.MOVED}`, `task.${TASK_MANAGER_EVENT_ACTIONS.ASSIGNED}`],
     },
   },
 });

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

@@ -13,7 +13,6 @@ const _typeorm = require("typeorm");
 const _constants = require("../constants");
 const _logactiondecorator = require("../decorators/log-action.decorator");
 const _dtos = require("../dtos");
-const _eventactionenum = require("../enums/event-action.enum");
 const _interfaces = require("../interfaces");
 const _utilsservice = require("../modules/utils/utils.service");
 const _domaineventpublisher = require("./domain-event.publisher");
@@ -40,30 +39,19 @@ function _ts_decorate(decorators, target, key, desc) {
 function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-const DEFAULT_EVENT_MODULE = 'app';
-const OPERATION_EVENT_ACTIONS = {
-    insert: _eventactionenum.EventAction.CREATED,
-    insertMany: _eventactionenum.EventAction.CREATED,
-    update: _eventactionenum.EventAction.UPDATED,
-    updateMany: _eventactionenum.EventAction.UPDATED,
-    bulkUpsert: _eventactionenum.EventAction.UPDATED
-};
 const DELETE_EVENT_ACTIONS = {
-    delete: _eventactionenum.EventAction.DELETED,
-    restore: _eventactionenum.EventAction.RESTORED
+    delete: 'deleted',
+    restore: 'restored',
+    permanent: 'purged'
 };
 let ApiService = 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;
         }
     }
@@ -75,11 +63,8 @@ let ApiService = 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);
@@ -91,7 +76,7 @@ let ApiService = 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);
@@ -103,7 +88,7 @@ let ApiService = 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);
@@ -115,7 +100,7 @@ let ApiService = 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);
@@ -127,7 +112,7 @@ let ApiService = 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) {
@@ -137,7 +122,7 @@ let ApiService = class ApiService {
                 await this.afterInsertOperation(this.ensureArray(insertedSaved), toInsert, user, qr);
                 allResults.push(...this.ensureArray(insertedSaved));
                 eventGroups.push({
-                    action: _eventactionenum.EventAction.CREATED,
+                    action: 'created',
                     entities: this.ensureArray(insertedSaved)
                 });
             }
@@ -148,7 +133,7 @@ let ApiService = class ApiService {
                 await this.afterUpdateOperation(this.ensureArray(updatedSaved), toUpdate, user, qr);
                 allResults.push(...this.ensureArray(updatedSaved));
                 eventGroups.push({
-                    action: _eventactionenum.EventAction.UPDATED,
+                    action: 'updated',
                     entities: this.ensureArray(updatedSaved)
                 });
             }
@@ -184,7 +169,7 @@ let ApiService = class ApiService {
             if (error instanceof _common.NotFoundException) {
                 throw error;
             }
-            this.handleError(error, 'findByIds');
+            this.handleError(error);
         }
     }
     async findById(id, user, select) {
@@ -224,7 +209,7 @@ let ApiService = class ApiService {
             if (error instanceof _common.NotFoundException) {
                 throw error;
             }
-            this.handleError(error, 'findById');
+            this.handleError(error);
         }
     }
     async getAll(search, filterAndPaginationDto, user) {
@@ -323,7 +308,7 @@ let ApiService = class ApiService {
             }
             return finalResponse;
         } catch (error) {
-            this.handleError(error, 'getAll');
+            this.handleError(error);
         }
     }
     async delete(option, user) {
@@ -361,7 +346,7 @@ let ApiService = class ApiService {
             ]);
             await this.publishLifecycleEvents([
                 {
-                    action: DELETE_EVENT_ACTIONS[option.type] ?? _eventactionenum.EventAction.PURGED,
+                    action: DELETE_EVENT_ACTIONS[option.type],
                     entities: ids,
                     idsOnly: true
                 }
@@ -369,7 +354,7 @@ let ApiService = class ApiService {
             return null;
         } catch (error) {
             await queryRunner.rollbackTransaction();
-            this.handleError(error, 'delete');
+            this.handleError(error);
         } finally{
             await queryRunner.release();
         }
@@ -378,7 +363,7 @@ let ApiService = class ApiService {
         for (const group of groups){
             if (!group.entities.length) continue;
             await (0, _domaineventpublisher.publishDomainEvent)({
-                module: this.moduleName ?? DEFAULT_EVENT_MODULE,
+                module: this.moduleName,
                 entity: this.entityName,
                 action: group.action,
                 ids: group.entities.map((entity)=>entity.id),
@@ -395,7 +380,7 @@ let ApiService = class ApiService {
    */ async publishDomainAction(action, input = {}) {
         await (0, _domaineventpublisher.publishDomainEvent)({
             ...input,
-            module: this.moduleName ?? DEFAULT_EVENT_MODULE,
+            module: this.moduleName,
             entity: this.entityName,
             action
         });
@@ -406,7 +391,7 @@ let ApiService = 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;
         }
@@ -420,7 +405,11 @@ let ApiService = 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();
@@ -435,19 +424,19 @@ let ApiService = 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();
         }
@@ -520,7 +509,7 @@ let ApiService = 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)));
@@ -531,10 +520,11 @@ let ApiService = 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);
@@ -552,8 +542,8 @@ let ApiService = class ApiService {
         this.isCacheable = isCacheable;
         this.moduleName = moduleName;
         this.repositoryInitialized = false;
-        this._entity = entity;
         this._dataSourceProvider = dataSourceProvider;
+        this._entity = entity;
     }
 };
 _ts_decorate([
@@ -635,7 +625,7 @@ ApiService = _ts_decorate([
         String,
         Boolean,
         String,
-        typeof _typeorm.EntityTarget === "undefined" ? Object : _typeorm.EntityTarget,
-        typeof _interfaces.IDataSourceProvider === "undefined" ? Object : _interfaces.IDataSourceProvider
+        typeof _interfaces.IDataSourceProvider === "undefined" ? Object : _interfaces.IDataSourceProvider,
+        typeof _typeorm.EntityTarget === "undefined" ? Object : _typeorm.EntityTarget
     ])
 ], ApiService);