@apso/cli 0.17.0 → 0.19.0

package/dist/commands/generate.js

@@ -10,10 +10,11 @@ const perf_hooks_1 = require("perf_hooks");
 const file_system_1 = require("../lib/utils/file-system");
 class Generate extends base_command_1.default {
     async run() {
+        var _a, _b;
         const { flags } = await this.parse(Generate);
         const skipFormat = flags["skip-format"];
         const totalBuildStart = perf_hooks_1.performance.now();
-        const { rootFolder, entities, relationshipMap, apiType, auth, emitEvents, language: configLanguage } = (0, lib_1.parseApsorc)();
+        const { rootFolder, entities, relationshipMap, apiType, auth, emitEvents, http, language: configLanguage } = (0, lib_1.parseApsorc)();
         // Resolve language: flag > .apsorc > prompt
         let language;
         if (flags.language) {
@@ -64,6 +65,7 @@ class Generate extends base_command_1.default {
             relationshipMap,
             auth,
             emitEvents,
+            http,
         };
         const generator = (0, lib_1.createGenerator)(generatorConfig);
         const validationResult = generator.validateConfig(generatorConfig);
@@ -94,8 +96,21 @@ class Generate extends base_command_1.default {
             console.log(`[apso] Building... ${entity.name}`);
             const entityBuildStart = perf_hooks_1.performance.now();
             const entityRelationships = relationshipMap[entity.name] || [];
-            // eslint-disable-next-line no-await-in-loop
-            const allFiles = await Promise.all([
+            // Effective HTTP-controller flag (TypeScript REST only for now): entity
+            // overrides the top-level default, which defaults to true. When false, the
+            // controller is neither generated nor wired into the module (a hand-written
+            // controller owns the route). GraphQL uses resolvers, so the flag doesn't
+            // apply there. Python (FastAPI) and Go (Gin) wire routers differently and
+            // don't yet honor this flag — keep it a no-op for them (controllers always
+            // generated) so we never emit broken wiring (a skipped router still
+            // referenced by the index module). Tracked separately for Python/Go.
+            const includeController = language === "typescript" && lowerCaseApiType === "rest"
+                ? ((_b = (_a = entity.http) !== null && _a !== void 0 ? _a : http) !== null && _b !== void 0 ? _b : true)
+                : true;
+            if (!includeController) {
+                console.log(`[apso]   ${entity.name}: http=false — skipping generated controller`);
+            }
+            const generationTasks = [
                 generator.generateEntity({
                     entity,
                     relationships: entityRelationships,
@@ -115,20 +130,25 @@ class Generate extends base_command_1.default {
                     apiType: lowerCaseApiType,
                     relationshipMap,
                 }),
-                generator.generateController({
+                generator.generateModule({
                     entity,
                     relationships: entityRelationships,
                     allEntities: entities,
                     apiType: lowerCaseApiType,
-                    relationshipMap,
+                    includeController,
                 }),
-                generator.generateModule({
+            ];
+            if (includeController) {
+                generationTasks.push(generator.generateController({
                     entity,
                     relationships: entityRelationships,
                     allEntities: entities,
                     apiType: lowerCaseApiType,
-                }),
-            ]);
+                    relationshipMap,
+                }));
+            }
+            // eslint-disable-next-line no-await-in-loop
+            const allFiles = await Promise.all(generationTasks);
             // eslint-disable-next-line no-await-in-loop
             for (const files of allFiles) {
                 for (const file of files) {

package/dist/commands/mcp/serve.js

@@ -924,6 +924,7 @@ const INLINE_SCHEMA_REFERENCE = `# Schema Quick Reference
   "primaryKeyType": "serial",
   "scopeBy": "organizationId",
   "emitEvents": true,
+  "http": false,
   "fields": [
     { "name": "fieldName", "type": "text", "length": 100 }
   ],
@@ -939,12 +940,26 @@ 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.
+
+## HTTP controllers (http)
+Controllers are generated by default. Set \`http: false\` on an entity (or a
+top-level \`http: false\` default) to NOT generate/mount its HTTP controller while
+still generating the entity, service, DTOs, and module (\`TypeOrmModule.forFeature\`
++ the service). Use this when a hand-written controller owns the route for that
+entity (e.g. a custom/Stripe-shaped surface). Effective value is
+\`entity.http ?? <top-level http> ?? true\`.
+
+Per framework: NestJS and Gin (Go) actually suppress the controller — those
+frameworks can't cleanly override a generated route. For FastAPI it's a no-op:
+override by registering your router ahead of the generated \`autogen_router\`
+(FastAPI matches in registration order). Currently implemented for NestJS; Go
+is tracked separately.
 
 ## Relationship Types
 - OneToMany: parent has many children

package/dist/lib/apsorc-parser.d.ts

@@ -20,6 +20,11 @@ export type ApsorcType = {
      * its own `emitEvents: false`.
      */
     emitEvents?: boolean;
+    /**
+     * Top-level default for HTTP controller generation. When false, no entity
+     * gets a generated controller unless it opts back in with `http: true`.
+     */
+    http?: boolean;
 };
 type ParsedApsorcData = {
     entities: Entity[];
@@ -34,6 +39,8 @@ type ParsedApsorc = {
     language?: TargetLanguage;
     /** Top-level default for the DomainEvent ("emitEvents") feature. */
     emitEvents?: boolean;
+    /** Top-level default for HTTP controller generation. */
+    http?: boolean;
 };
 export declare const parseApsorcV1: (apsorc: ApsorcType) => ParsedApsorcData;
 export declare const parseApsorcV2: (apsorc: ApsorcType) => ParsedApsorcData;

package/dist/lib/apsorc-parser.js

@@ -37,6 +37,7 @@ const parseRc = () => {
     const auth = apsoConfig.auth;
     const language = apsoConfig.language;
     const emitEvents = apsoConfig.emitEvents;
+    const http = apsoConfig.http;
     return {
         rootFolder,
         apiType,
@@ -46,6 +47,7 @@ const parseRc = () => {
         auth,
         language,
         emitEvents,
+        http,
     };
 };
 const parseApsorc = () => {
@@ -66,6 +68,7 @@ const parseApsorc = () => {
                     auth: apsoConfig.auth,
                     language: apsoConfig.language,
                     emitEvents: apsoConfig.emitEvents,
+                    http: apsoConfig.http,
                     ...(0, exports.parseApsorcV1)(apsoConfig),
                 };
                 if (debug) {
@@ -83,6 +86,7 @@ const parseApsorc = () => {
                     auth: apsoConfig.auth,
                     language: apsoConfig.language,
                     emitEvents: apsoConfig.emitEvents,
+                    http: apsoConfig.http,
                     ...(() => {
                         const relStart = perf_hooks_1.performance.now();
                         const parsed = (0, exports.parseApsorcV2)(apsoConfig);

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

@@ -249,7 +249,7 @@ class TypeScriptGenerator extends base_1.BaseGenerator {
         ];
     }
     async generateModule(options) {
-        const { entity, apiType } = options;
+        const { entity, apiType, includeController = true } = options;
         const { name: entityName } = entity;
         const moduleName = `${entityName}Module`;
         const svcName = `${entityName}Service`;
@@ -261,6 +261,7 @@ class TypeScriptGenerator extends base_1.BaseGenerator {
             ctrlName,
             resolverName,
             entityName,
+            includeController,
         };
         const templatePath = apiType === "graphql"
             ? "./graphql/gql-module-graphql"
@@ -303,9 +304,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 +358,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 +379,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/templates/rest/module-rest.eta

@@ -4,13 +4,12 @@ import { Module } from "@nestjs/common";
 import {<%= it.entityName %>} from './<%= it.entityName%>.entity'
 import { TypeOrmModule } from "@nestjs/typeorm";
 import {<%= it.svcName %>} from "./<%= it.entityName %>.service";
-import {<%= it.ctrlName %>} from "./<%= it.entityName %>.controller";
-
+<% if (it.includeController) { %>import {<%= it.ctrlName %>} from "./<%= it.entityName %>.controller";
+<% } %>
 @Module({
   imports: [TypeOrmModule.forFeature([<%= it.entityName %>])],
   providers: [<%= it.svcName %>],
   exports: [<%= it.svcName %>],
-  controllers: [<%= it.ctrlName %>],
-})
+<% if (it.includeController) { %>  controllers: [<%= it.ctrlName %>],
+<% } %>})
 export class <%= it.moduleName %> {}
-  

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

@@ -55,5 +55,26 @@ export interface Entity {
      * an individual entity can opt out with `emitEvents: false`.
      */
     emitEvents?: boolean;
+    /**
+     * Whether to generate the HTTP controller for this entity. Defaults to true.
+     * When false, the generator still emits the entity, service, DTOs, and a module
+     * (with `TypeOrmModule.forFeature` + the service), but omits the controller —
+     * leaving the HTTP surface to a hand-written controller without a route
+     * collision with the generated CRUD.
+     *
+     * Per-framework behavior (the flag is generic, but only matters where a
+     * generated route can't be cleanly overridden):
+     * - **NestJS** and **Gin (Go)**: actually suppresses the controller/route —
+     *   these frameworks can't override a generated route (Nest controllers aren't
+     *   DI-swappable; Gin panics on duplicate paths). Implemented for NestJS;
+     *   Go is tracked separately.
+     * - **FastAPI**: effectively a **no-op** — FastAPI matches routes in
+     *   registration order, so an app overrides by registering its router ahead of
+     *   the generated `autogen_router` (no suppression needed).
+     *
+     * Resolution: the effective value is `entity.http ?? <global http> ?? true`, so
+     * controllers are on by default and opted out per entity (or globally).
+     */
+    http?: boolean;
     associations?: Association[];
 }

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

@@ -109,6 +109,11 @@ export interface GeneratorConfig {
      * Effective per-entity value is `entity.emitEvents ?? emitEvents ?? false`.
      */
     emitEvents?: boolean;
+    /**
+     * Top-level default for HTTP controller generation.
+     * Effective per-entity value is `entity.http ?? http ?? true`.
+     */
+    http?: boolean;
     /**
      * Language-specific configuration options
      */
@@ -134,6 +139,11 @@ export interface EntityGenerationOptions {
      * API type being generated
      */
     apiType: string;
+    /**
+     * Whether the entity's HTTP controller is generated/wired. Defaults to true.
+     * When false, the module omits the controller (see Entity.http).
+     */
+    includeController?: boolean;
 }
 /**
  * Options for generating controllers/routers
@@ -246,8 +256,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.19.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@apso/cli",
-      "version": "0.17.0",
+      "version": "0.19.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.19.0",
   "commands": {
     "config": {
       "id": "config",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apso/cli",
-  "version": "0.17.0",
+  "version": "0.19.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';