@apso/cli 0.17.0 → 0.18.0

package/dist/commands/mcp/serve.js

@@ -939,12 +939,12 @@ state changes. A top-level \`emitEvents: true\` enables it for every entity; an
 individual entity can opt out with \`emitEvents: false\` (effective value is
 \`entity.emitEvents ?? <top-level emitEvents> ?? false\`).
 
-When at least one entity opts in, the generator emits a \`DomainEvent\` spine
-under \`autogen/events/\`: a \`DomainEvent\` entity (table \`events\`), a TypeORM
-\`DomainEventSubscriber\` that writes events in the SAME DB transaction as the
-change, an app-overridable \`DomainEventMapper\` (event-type + payload), and a
-\`DomainEventRelay\` whose \`publish()\` you override to deliver events. The
-\`DomainEventsModule\` is wired into the generated module list automatically.
+When at least one entity opts in, the generator emits a single schema-derived
+manifest at \`autogen/events/event-emitting.entities.ts\` exporting
+\`EVENT_EMITTING_ENTITIES\` (the opted-in entity classes) and
+\`EVENT_EMITTING_ENTITY_NAMES\`. The domain-event engine itself ships in the
+\`@apso/domain-events\` library and is wired by the \`domain-events\` skill; the
+CLI no longer generates the engine code.
 
 ## Relationship Types
 - OneToMany: parent has many children

package/dist/lib/events.d.ts

@@ -2,9 +2,10 @@ import { Entity } from "./types";
 /**
  * Helpers for the opt-in DomainEvent ("emitEvents") feature.
  *
- * This implements the standard transactional-outbox pattern for durability, but
- * is surfaced with generic "domain event" naming (the user found "outbox"
- * unintuitive). No public artifact is named "outbox".
+ * Under the Apso Distribution Model the domain-event engine ships in the
+ * `@apso/domain-events` library (wired by the `domain-events` skill). The CLI
+ * only uses these helpers to compute which entities opted in, and emits a
+ * schema-derived manifest (`events/event-emitting.entities.ts`).
  *
  * Flag resolution: the effective per-entity value is
  *   `entity.emitEvents ?? globalEmitEvents ?? false`
@@ -25,7 +26,7 @@ export declare function isEmitEventsEnabled(entity: Entity, globalEmitEvents?: b
 export declare function getEventEmittingEntities(entities: Entity[], globalEmitEvents?: boolean): Entity[];
 /**
  * Returns true when at least one entity has domain events enabled, meaning the
- * DomainEvent spine (entity, subscriber, mapper, relay, module) should be
+ * event-emitting manifest (`events/event-emitting.entities.ts`) should be
  * generated.
  */
 export declare function hasEventEmittingEntities(entities: Entity[], globalEmitEvents?: boolean): boolean;

package/dist/lib/events.js

@@ -4,9 +4,10 @@ exports.hasEventEmittingEntities = exports.getEventEmittingEntities = exports.is
 /**
  * Helpers for the opt-in DomainEvent ("emitEvents") feature.
  *
- * This implements the standard transactional-outbox pattern for durability, but
- * is surfaced with generic "domain event" naming (the user found "outbox"
- * unintuitive). No public artifact is named "outbox".
+ * Under the Apso Distribution Model the domain-event engine ships in the
+ * `@apso/domain-events` library (wired by the `domain-events` skill). The CLI
+ * only uses these helpers to compute which entities opted in, and emits a
+ * schema-derived manifest (`events/event-emitting.entities.ts`).
  *
  * Flag resolution: the effective per-entity value is
  *   `entity.emitEvents ?? globalEmitEvents ?? false`
@@ -34,7 +35,7 @@ function getEventEmittingEntities(entities, globalEmitEvents) {
 exports.getEventEmittingEntities = getEventEmittingEntities;
 /**
  * Returns true when at least one entity has domain events enabled, meaning the
- * DomainEvent spine (entity, subscriber, mapper, relay, module) should be
+ * event-emitting manifest (`events/event-emitting.entities.ts`) should be
  * generated.
  */
 function hasEventEmittingEntities(entities, globalEmitEvents) {

package/dist/lib/generators/base.d.ts

@@ -65,8 +65,9 @@ export declare abstract class BaseGenerator implements LanguageGenerator {
      */
     generateQueryUtils(_entities: Entity[], _apiType: string): Promise<GeneratedFile[]>;
     /**
-     * Generate the durable DomainEvent spine for entities that opt in to
-     * `emitEvents` (transactional-outbox pattern, generic domain-event naming).
+     * Emit a schema-derived manifest of entities that opt in to `emitEvents`.
+     * The domain-event engine ships in the `@apso/domain-events` library (wired
+     * by the `domain-events` skill); the generator only declares participants.
      * Default no-op. Override in language generators that support it.
      */
     generateDomainEvents(_entities: Entity[], _apiType?: string, _opts?: {

package/dist/lib/generators/base.js

@@ -28,8 +28,9 @@ class BaseGenerator {
         return [];
     }
     /**
-     * Generate the durable DomainEvent spine for entities that opt in to
-     * `emitEvents` (transactional-outbox pattern, generic domain-event naming).
+     * Emit a schema-derived manifest of entities that opt in to `emitEvents`.
+     * The domain-event engine ships in the `@apso/domain-events` library (wired
+     * by the `domain-events` skill); the generator only declares participants.
      * Default no-op. Override in language generators that support it.
      */
     async generateDomainEvents(_entities, _apiType, _opts) {

package/dist/lib/generators/typescript.d.ts

@@ -16,14 +16,19 @@ export declare class TypeScriptGenerator extends BaseGenerator {
     generateModule(options: EntityGenerationOptions): Promise<GeneratedFile[]>;
     generateMigration(_options: MigrationGenerationOptions): Promise<GeneratedFile[]>;
     generateEnums(entities: Entity[], apiType: string): Promise<GeneratedFile[]>;
-    generateIndexModule(entities: Entity[], apiType: string, opts?: {
+    generateIndexModule(entities: Entity[], apiType: string, _opts?: {
         emitEvents?: boolean;
     }): Promise<GeneratedFile[]>;
     generateGuards(entities: Entity[], auth?: AuthConfig): Promise<GeneratedFile[]>;
     /**
-     * Generates the durable DomainEvent spine (transactional-outbox pattern,
-     * surfaced with generic domain-event naming) when at least one entity has
-     * opted in to `emitEvents`.
+     * Emits a schema-derived manifest of the entities that have opted in to
+     * domain-event emission (`.apsorc` `emitEvents`).
+     *
+     * Under the Apso Distribution Model the domain-event engine no longer ships
+     * as generated code; it lives in the `@apso/domain-events` library and is
+     * wired by the `domain-events` skill. The CLI's only responsibility is to
+     * declare WHICH entities participate, via a single generated file:
+     * `events/event-emitting.entities.ts`.
      *
      * Returns an empty array when no entity is opted in, so callers can skip
      * wiring entirely.

package/dist/lib/generators/typescript.js

@@ -303,9 +303,8 @@ class TypeScriptGenerator extends base_1.BaseGenerator {
             },
         ];
     }
-    async generateIndexModule(entities, apiType, opts) {
-        const emitDomainEvents = (0, events_1.getEventEmittingEntities)(entities, opts === null || opts === void 0 ? void 0 : opts.emitEvents).length > 0;
-        const content = await this.renderTemplate(`./${apiType}/index-module-${apiType}`, { entities, emitDomainEvents });
+    async generateIndexModule(entities, apiType, _opts) {
+        const content = await this.renderTemplate(`./${apiType}/index-module-${apiType}`, { entities });
         return [
             {
                 path: "index.ts",
@@ -358,9 +357,14 @@ class TypeScriptGenerator extends base_1.BaseGenerator {
         return files;
     }
     /**
-     * Generates the durable DomainEvent spine (transactional-outbox pattern,
-     * surfaced with generic domain-event naming) when at least one entity has
-     * opted in to `emitEvents`.
+     * Emits a schema-derived manifest of the entities that have opted in to
+     * domain-event emission (`.apsorc` `emitEvents`).
+     *
+     * Under the Apso Distribution Model the domain-event engine no longer ships
+     * as generated code; it lives in the `@apso/domain-events` library and is
+     * wired by the `domain-events` skill. The CLI's only responsibility is to
+     * declare WHICH entities participate, via a single generated file:
+     * `events/event-emitting.entities.ts`.
      *
      * Returns an empty array when no entity is opted in, so callers can skip
      * wiring entirely.
@@ -374,46 +378,17 @@ class TypeScriptGenerator extends base_1.BaseGenerator {
         if (emittingEntities.length === 0) {
             return [];
         }
-        const templateData = {
+        const content = await this.renderTemplate("./events/event-emitting.entities.eta", {
             emittingEntities: emittingEntities.map((entity) => ({
                 name: entity.name,
             })),
-            generatedAt: new Date().toISOString(),
-            generatedBy: "Apso CLI",
-        };
-        const files = [];
-        const targets = [
-            {
-                template: "./events/domain-event.entity.eta",
-                path: "events/domain-event.entity.ts",
-            },
-            {
-                template: "./events/domain-event.mapper.eta",
-                path: "events/domain-event.mapper.ts",
-            },
-            {
-                template: "./events/domain-event.subscriber.eta",
-                path: "events/domain-event.subscriber.ts",
-            },
-            {
-                template: "./events/domain-event.relay.eta",
-                path: "events/domain-event.relay.ts",
-            },
-            {
-                template: "./events/domain-events.module.eta",
-                path: "events/domain-events.module.ts",
-            },
+        });
+        return [
             {
-                template: "./events/index.eta",
-                path: "events/index.ts",
+                path: "events/event-emitting.entities.ts",
+                content,
             },
         ];
-        for (const target of targets) {
-            // eslint-disable-next-line no-await-in-loop
-            const content = await this.renderTemplate(target.template, templateData);
-            files.push({ path: target.path, content });
-        }
-        return files;
     }
     /**
      * Normalizes auth config by applying defaults for DB session providers

package/dist/lib/templates/events/event-emitting.entities.eta

@@ -0,0 +1,23 @@
+<%~ includeFile('../header.eta') %>
+
+<% it.emittingEntities.forEach((entity) => { %>
+import { <%= entity.name %> } from '../<%= entity.name %>/<%= entity.name %>.entity';
+<%}) %>
+
+/**
+ * Schema-derived manifest of entities that opted in to domain-event emission
+ * (`.apsorc` `emitEvents`). The domain-event engine itself lives in the
+ * `@apso/domain-events` library and is wired by the `domain-events` skill;
+ * this file only declares WHICH entities participate.
+ */
+export const EVENT_EMITTING_ENTITIES = [
+<% it.emittingEntities.forEach((entity) => { %>
+  <%= entity.name %>,
+<%}) %>
+];
+
+export const EVENT_EMITTING_ENTITY_NAMES = [
+<% it.emittingEntities.forEach((entity) => { %>
+  '<%= entity.name %>',
+<%}) %>
+];

package/dist/lib/templates/graphql/index-module-graphql.eta

@@ -3,9 +3,6 @@
 <% it.entities.forEach((entity) => { %>
 import {<%= entity.name %>Module} from './<%= entity.name %>/<%= entity.name %>.module'
 <%}) %>
-<% if (it.emitDomainEvents) { %>
-import { DomainEventsModule } from './events'
-<% } %>
 import { JSONResolver } from 'graphql-scalars';
 
 <% const scalars = [] %>
@@ -26,7 +23,4 @@ export default [
 <% it.entities.forEach((entity) => { %>
 <%= entity.name %>Module,
 <%}) %>
-<% if (it.emitDomainEvents) { %>
-DomainEventsModule,
-<% } %>
 ]

package/dist/lib/templates/rest/index-module-rest.eta

@@ -3,15 +3,9 @@
 <% it.entities.forEach((entity) => { %>
 import {<%= entity.name %>Module} from './<%= entity.name %>/<%= entity.name %>.module'
 <%}) %>
-<% if (it.emitDomainEvents) { %>
-import { DomainEventsModule } from './events'
-<% } %>
 
 export default [
 <% it.entities.forEach((entity) => { %>
 <%= entity.name %>Module,
 <%}) %>
-<% if (it.emitDomainEvents) { %>
-DomainEventsModule,
-<% } %>
 ]

package/dist/lib/types/generator.d.ts

@@ -246,8 +246,8 @@ export interface LanguageGenerator {
      */
     generateQueryUtils(entities: Entity[], apiType: string): Promise<GeneratedFile[]>;
     /**
-     * Generate the durable DomainEvent spine for entities that opt in to
-     * `emitEvents`. Returns [] when no entity is opted in.
+     * Emit a schema-derived manifest of entities that opt in to `emitEvents`
+     * (engine lives in `@apso/domain-events`). Returns [] when none are opted in.
      */
     generateDomainEvents(entities: Entity[], apiType?: string, opts?: {
         emitEvents?: boolean;

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@apso/cli",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@apso/cli",
-      "version": "0.17.0",
+      "version": "0.18.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@electric-sql/pglite": "^0.2.17",

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.17.0",
+  "version": "0.18.0",
   "commands": {
     "config": {
       "id": "config",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apso/cli",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "mcpName": "io.github.apsoai/apso",
   "description": "Apso CLI",
   "author": "Apso by Mavric - @mavric",

package/dist/lib/templates/events/domain-event.entity.eta

@@ -1,51 +0,0 @@
-<%~ includeFile('../header.eta') %>
-
-import {
-  Entity,
-  PrimaryGeneratedColumn,
-  Column,
-  CreateDateColumn,
-  Index,
-} from 'typeorm';
-
-/**
- * DomainEvent is a durable, append-only log of domain state changes.
- *
- * Rows are written in the SAME database transaction as the state change that
- * produced them (see DomainEventSubscriber), which is what makes delivery
- * durable. This implements the standard "transactional outbox" pattern, but is
- * surfaced with generic domain-event naming.
- *
- * A separate DomainEventRelay polls pending rows and delivers them. Because the
- * stable `id` is preserved across delivery attempts, consumers can dedupe on it
- * for at-least-once delivery semantics.
- */
-@Index(['status', 'created_at'])
-@Entity('events')
-export class DomainEvent {
-  @PrimaryGeneratedColumn('uuid')
-  id: string;
-
-  /** Event type, e.g. "product.created". */
-  @Column({ type: 'varchar' })
-  type: string;
-
-  /** Serialized event payload. */
-  @Column({ type: 'jsonb' })
-  payload: Record<string, unknown>;
-
-  /** Delivery lifecycle: pending -> published, or failed after max attempts. */
-  @Column({ type: 'varchar', default: 'pending' })
-  status: 'pending' | 'published' | 'failed';
-
-  /** Number of delivery attempts made by the relay. */
-  @Column({ type: 'int', default: 0 })
-  attempts: number;
-
-  @CreateDateColumn({ type: 'timestamptz' })
-  created_at: Date;
-
-  /** When the event was successfully published; null until then. */
-  @Column({ type: 'timestamptz', nullable: true })
-  publishedAt: Date | null;
-}

package/dist/lib/templates/events/domain-event.mapper.eta

@@ -1,62 +0,0 @@
-<%~ includeFile('../header.eta') %>
-
-import { Injectable } from '@nestjs/common';
-
-/**
- * Action that produced a domain event.
- */
-export type DomainEventAction = 'created' | 'updated' | 'removed';
-
-/**
- * DI token for the DomainEventMapper.
- *
- * The generated DomainEventsModule binds this token to DefaultDomainEventMapper.
- * Your application can override it by providing its own implementation:
- *
- *   { provide: DOMAIN_EVENT_MAPPER, useClass: MyDomainEventMapper }
- */
-export const DOMAIN_EVENT_MAPPER = 'DOMAIN_EVENT_MAPPER';
-
-/**
- * DomainEventMapper is the extension point that keeps application semantics
- * (event-type taxonomy, payload shape) OUT of the generated code. Provide your
- * own implementation under DOMAIN_EVENT_MAPPER to customize.
- */
-export interface DomainEventMapper {
-  /**
-   * Maps an entity name + action to an event type string, e.g.
-   * ("Product", "created") -> "product.created".
-   */
-  eventType(entityName: string, action: DomainEventAction): string;
-
-  /**
-   * Builds the serializable payload for an event from the changed entity.
-   */
-  toPayload(
-    entity: unknown,
-    action: DomainEventAction
-  ): Record<string, unknown>;
-}
-
-/**
- * Default mapper. Uses an `entity.action` type taxonomy (entity name
- * lower-camel-cased) and returns the entity as-is (shallow) as the payload.
- *
- * Override by providing your own DomainEventMapper under DOMAIN_EVENT_MAPPER.
- */
-@Injectable()
-export class DefaultDomainEventMapper implements DomainEventMapper {
-  eventType(entityName: string, action: DomainEventAction): string {
-    const normalized = entityName
-      ? entityName.charAt(0).toLowerCase() + entityName.slice(1)
-      : entityName;
-    return `${normalized}.${action}`;
-  }
-
-  toPayload(
-    entity: unknown,
-    _action: DomainEventAction
-  ): Record<string, unknown> {
-    return { ...(entity as Record<string, unknown>) };
-  }
-}

package/dist/lib/templates/events/domain-event.relay.eta

@@ -1,86 +0,0 @@
-<%~ includeFile('../header.eta') %>
-
-import { Injectable, Logger } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
-import { DomainEvent } from './domain-event.entity';
-
-/**
- * Maximum number of delivery attempts before an event is marked 'failed'.
- */
-const MAX_ATTEMPTS = 5;
-
-/**
- * DomainEventRelay drains the durable `events` table and delivers pending
- * events. It is the consumer side of the transactional-outbox pattern: the
- * subscriber writes events transactionally, the relay publishes them
- * asynchronously with at-least-once semantics.
- *
- * DELIVERY is the extension point: override `publish()` (see below) to send
- * events anywhere — webhooks, Kafka, SNS, an internal event bus, etc. The
- * generated code intentionally does NOT implement any specific transport.
- */
-@Injectable()
-export class DomainEventRelay {
-  private readonly logger = new Logger(DomainEventRelay.name);
-
-  constructor(
-    @InjectRepository(DomainEvent)
-    private readonly events: Repository<DomainEvent>
-  ) {}
-
-  /**
-   * Schedule this from your app, e.g. with @nestjs/schedule:
-   *
-   *   // import { Interval } from '@nestjs/schedule';
-   *   // @Interval(5000)
-   *   // async tick() { await this.relay.processPending(); }
-   *
-   * (@nestjs/schedule is intentionally NOT imported here so no dependency is
-   * forced on your project.)
-   */
-  async processPending(limit = 50): Promise<void> {
-    const pending = await this.events.find({
-      where: { status: 'pending' },
-      order: { created_at: 'ASC' },
-      take: limit,
-    });
-
-    for (const event of pending) {
-      try {
-        // eslint-disable-next-line no-await-in-loop
-        await this.publish(event);
-        event.status = 'published';
-        event.publishedAt = new Date();
-        // eslint-disable-next-line no-await-in-loop
-        await this.events.save(event);
-      } catch (error) {
-        event.attempts += 1;
-        if (event.attempts >= MAX_ATTEMPTS) {
-          event.status = 'failed';
-          this.logger.error(
-            `DomainEvent ${event.id} (${event.type}) failed after ${event.attempts} attempts`,
-            error instanceof Error ? error.stack : undefined
-          );
-        }
-        // eslint-disable-next-line no-await-in-loop
-        await this.events.save(event);
-      }
-    }
-  }
-
-  /**
-   * EXTENSION POINT — deliver a single domain event.
-   *
-   * Override (subclass or re-provide) this method to actually publish events to
-   * your transport of choice (webhooks, Kafka, SNS, internal bus, ...). On
-   * success the relay marks the event published; on a thrown error it retries
-   * up to MAX_ATTEMPTS and then marks it failed.
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async publish(event: DomainEvent): Promise<void> {
-    throw new Error(
-      'DomainEventRelay.publish() not implemented — override to deliver events'
-    );
-  }
-}

package/dist/lib/templates/events/domain-event.subscriber.eta

@@ -1,118 +0,0 @@
-<%~ includeFile('../header.eta') %>
-
-import { Inject, Injectable, Optional } from '@nestjs/common';
-import {
-  DataSource,
-  EntitySubscriberInterface,
-  EventSubscriber,
-  InsertEvent,
-  UpdateEvent,
-  RemoveEvent,
-} from 'typeorm';
-import { DomainEvent } from './domain-event.entity';
-import {
-  DOMAIN_EVENT_MAPPER,
-  DomainEventAction,
-  DomainEventMapper,
-} from './domain-event.mapper';
-<% it.emittingEntities.forEach((entity) => { %>
-import { <%= entity.name %> } from '../<%= entity.name %>/<%= entity.name %>.entity';
-<% }) %>
-
-/**
- * Entity classes that have opted in to domain-event emission. Only state
- * changes to these entities produce DomainEvent rows; everything else is
- * skipped.
- */
-const EMITTING_ENTITIES: Function[] = [
-<% it.emittingEntities.forEach((entity) => { %>
-  <%= entity.name %>,
-<% }) %>
-];
-
-/**
- * DomainEventSubscriber writes a DomainEvent row for every insert/update/remove
- * of an opted-in entity.
- *
- * DURABILITY: each row is written via `event.manager` (the EntityManager of the
- * in-flight transaction), so the event is committed atomically WITH the state
- * change. This is the durability lever behind the transactional-outbox pattern.
- *
- * RECURSION GUARD: we never emit events for DomainEvent itself, otherwise each
- * emitted row would itself trigger another emission. Any other bookkeeping
- * tables you do not want logged should likewise be excluded from
- * EMITTING_ENTITIES (this scoping handles that — only opted-in entities emit).
- */
-@Injectable()
-@EventSubscriber()
-export class DomainEventSubscriber implements EntitySubscriberInterface {
-  constructor(
-    @Inject(DOMAIN_EVENT_MAPPER) private readonly mapper: DomainEventMapper,
-    // MULTI-DATASOURCE: Nest auto-registers @EventSubscriber() providers on the
-    // DEFAULT DataSource. We ALSO push ourselves onto any injected DataSource
-    // here so registration is robust for named/non-default DataSources too. For
-    // multiple DataSources, register DomainEventsModule per DataSource.
-    @Optional() dataSource?: DataSource
-  ) {
-    dataSource?.subscribers?.push(this);
-  }
-
-  private isEmitting(target: Function | string): boolean {
-    // RECURSION GUARD: never emit for DomainEvent itself.
-    if (target === DomainEvent || target === 'DomainEvent') {
-      return false;
-    }
-    return EMITTING_ENTITIES.some(
-      (cls) => target === cls || target === cls.name
-    );
-  }
-
-  private async emit(
-    manager: InsertEvent<unknown>['manager'],
-    entityClass: Function,
-    entity: unknown,
-    action: DomainEventAction
-  ): Promise<void> {
-    const entityName = entityClass.name;
-    const repo = manager.getRepository(DomainEvent);
-    // event.manager keeps us inside the active transaction.
-    await repo.save(
-      repo.create({
-        type: this.mapper.eventType(entityName, action),
-        payload: this.mapper.toPayload(entity, action),
-        status: 'pending',
-        attempts: 0,
-      })
-    );
-  }
-
-  async afterInsert(event: InsertEvent<unknown>): Promise<void> {
-    if (!this.isEmitting(event.metadata.target)) return;
-    await this.emit(
-      event.manager,
-      event.metadata.target as Function,
-      event.entity,
-      'created'
-    );
-  }
-
-  async afterUpdate(event: UpdateEvent<unknown>): Promise<void> {
-    if (!this.isEmitting(event.metadata.target)) return;
-    await this.emit(
-      event.manager,
-      event.metadata.target as Function,
-      event.entity ?? event.databaseEntity,
-      'updated'
-    );
-  }
-
-  async afterRemove(event: RemoveEvent<unknown>): Promise<void> {
-    if (!this.isEmitting(event.metadata.target)) return;
-    await this.emit(
-      event.manager,
-      event.metadata.target as Function,
-      event.entity ?? event.databaseEntity,
-      'removed'
-    );
-  }
-}

package/dist/lib/templates/events/domain-events.module.eta

@@ -1,40 +0,0 @@
-<%~ includeFile('../header.eta') %>
-
-import { Global, Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { DomainEvent } from './domain-event.entity';
-import { DomainEventSubscriber } from './domain-event.subscriber';
-import { DomainEventRelay } from './domain-event.relay';
-import {
-  DOMAIN_EVENT_MAPPER,
-  DefaultDomainEventMapper,
-} from './domain-event.mapper';
-
-/**
- * DomainEventsModule wires the durable domain-event spine (transactional-outbox
- * pattern, surfaced as generic domain events).
- *
- * - DomainEventSubscriber writes events in-transaction with state changes.
- * - DomainEventRelay drains and delivers pending events (override
- *   DomainEventRelay.publish()).
- * - DOMAIN_EVENT_MAPPER controls event-type/payload semantics; override by
- *   re-providing the token with your own DomainEventMapper.
- *
- * MULTI-DATASOURCE: @EventSubscriber() auto-registers on the default DataSource;
- * for additional named DataSources, register this module (or the subscriber)
- * per DataSource.
- */
-@Global()
-@Module({
-  imports: [TypeOrmModule.forFeature([DomainEvent])],
-  providers: [
-    DomainEventSubscriber,
-    DomainEventRelay,
-    {
-      provide: DOMAIN_EVENT_MAPPER,
-      useClass: DefaultDomainEventMapper,
-    },
-  ],
-  exports: [DomainEventRelay, DOMAIN_EVENT_MAPPER],
-})
-export class DomainEventsModule {}

package/dist/lib/templates/events/index.eta

@@ -1,7 +0,0 @@
-<%~ includeFile('../header.eta') %>
-
-export * from './domain-event.entity';
-export * from './domain-event.subscriber';
-export * from './domain-event.mapper';
-export * from './domain-event.relay';
-export * from './domain-events.module';