@pattern-stack/codegen 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pattern-stack/codegen",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Entity-driven code generation for full-stack TypeScript applications",
   "license": "MIT",
   "type": "module",
@@ -62,7 +62,9 @@
     "chalk": "^5.6.2",
     "clipanion": "^4.0.0-rc.4",
     "drizzle-orm": "^0.45.2",
+    "glob": "^13.0.6",
     "ora": "^9.3.0",
+    "pluralize": "^8.0.0",
     "yaml": "^2.8.3",
     "zod": "^3.22.4"
   },
@@ -95,15 +97,22 @@
       "optional": true
     }
   },
+  "workspaces": [
+    "packages/*"
+  ],
   "devDependencies": {
     "@cubejs-client/core": "^1.0.0",
     "@nestjs/common": "10",
     "@nestjs/core": "10",
+    "@nestjs/testing": "^10",
     "@types/bun": "latest",
+    "@types/ejs": "^3.1.5",
     "@types/node": "^25.6.0",
+    "@types/pluralize": "^0.0.33",
     "bullmq": "^5.0.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.0",
+    "ejs": "^5.0.2",
     "hygen": "^6.2.11",
     "ioredis": "^5.3.0",
     "reflect-metadata": "^0.2.2",

package/templates/entity/new/backend/application/commands/create.ejs.t

@@ -21,15 +21,27 @@ import { <%= repositoryToken %> } from '<%= imports.constants %>';
 import type { Create<%= className %>Input, I<%= className %>Repository } from '<%= imports.domain %>';
 import { <%= className %> } from '<%= imports.domain %>';
 import type { Create<%= className %>Dto } from '<%= imports.schemas %>';
+<% if (hasEmits && createEventType) { -%>
+import { TYPED_EVENT_BUS, TypedEventBus } from '<%= eventsTokenImport %>';
+import { DRIZZLE } from '<%= drizzleTokenImport %>';
+import type { DrizzleClient } from '<%= drizzleTypeImport %>';
+<% } -%>
 
 @Injectable()
 export class <%= createCommandClass %> {
 	constructor(
 		@Inject(<%= repositoryToken %>)
 		private readonly <%= camelName %>Repository: I<%= className %>Repository,
+<% if (hasEmits && createEventType) { -%>
+		@Inject(TYPED_EVENT_BUS) private readonly typedEvents: TypedEventBus,
+		@Inject(DRIZZLE) private readonly db: DrizzleClient,
+<% } -%>
 	) {}
 
-	async execute(dto: Create<%= className %>Dto): Promise<<%= className %>> {
+	async execute(
+		dto: Create<%= className %>Dto,
+		<%= hasEmits && createEventType ? 'opts' : '_opts' %>?: { actor?: { tenantId?: string | null; userId?: string } },
+	): Promise<<%= className %>> {
 		// TODO: Add pre-create validation and business rules here
 
 		// Map DTO to domain input
@@ -45,11 +57,36 @@ export class <%= createCommandClass %> {
 <% }) -%>
 		};
 
+<% if (hasEmits && createEventType) { -%>
+		return this.db.transaction(async (tx) => {
+			const entity = await this.<%= camelName %>Repository.create(input, tx);
+			// TODO: verify payload mapping against events/<%= createEventType.type %>.yaml
+			await this.typedEvents.publish(
+				'<%= createEventType.type %>',
+				entity.id,
+				{
+<% createEventType.payloadMap.forEach((p) => { -%>
+					<%= p.camelKey %>: <%- p.expression %>,<% if (p.todo) { %> // TODO: <%= p.todo %><% } %>
+
+<% }) -%>
+				},
+				{
+					tx,
+					metadata: opts?.actor
+						? { tenantId: opts.actor.tenantId, userId: opts.actor.userId }
+						: undefined,
+				},
+			);
+			// TODO: Add post-create side effects here (non-event hooks, notifications, etc.)
+			return entity;
+		});
+<% } else { -%>
 		const created = await this.<%= camelName %>Repository.create(input);
 
 		// TODO: Add post-create side effects here (events, notifications, etc.)
 
 		return created;
+<% } -%>
 	}
 }
 <% } -%>

package/templates/entity/new/backend/application/commands/delete.ejs.t

@@ -20,18 +20,57 @@ import { Inject, Injectable, NotFoundException } from '@nestjs/common';
 import { <%= repositoryToken %> } from '<%= imports.constants %>';
 import type { I<%= className %>Repository } from '<%= imports.domain %>';
 import { <%= className %> } from '<%= imports.domain %>';
+<% if (hasEmits && deleteEventType) { -%>
+import { TYPED_EVENT_BUS, TypedEventBus } from '<%= eventsTokenImport %>';
+import { DRIZZLE } from '<%= drizzleTokenImport %>';
+import type { DrizzleClient } from '<%= drizzleTypeImport %>';
+<% } -%>
 
 @Injectable()
 export class <%= deleteCommandClass %> {
 	constructor(
 		@Inject(<%= repositoryToken %>)
 		private readonly <%= camelName %>Repository: I<%= className %>Repository,
+<% if (hasEmits && deleteEventType) { -%>
+		@Inject(TYPED_EVENT_BUS) private readonly typedEvents: TypedEventBus,
+		@Inject(DRIZZLE) private readonly db: DrizzleClient,
+<% } -%>
 	) {}
 
-	async execute(id: string): Promise<<%= className %>> {
+	async execute(
+		id: string,
+		<%= hasEmits && deleteEventType ? 'opts' : '_opts' %>?: { actor?: { tenantId?: string | null; userId?: string } },
+	): Promise<<%= className %>> {
 		// TODO: Add pre-delete validation here
 		// e.g., check for dependent records, verify user permissions
 
+<% if (hasEmits && deleteEventType) { -%>
+		return this.db.transaction(async (tx) => {
+			const entity = await this.<%= camelName %>Repository.delete(id, tx);
+			if (!entity) {
+				throw new NotFoundException(`<%= className %> with id ${id} not found`);
+			}
+			// TODO: verify payload mapping against events/<%= deleteEventType.type %>.yaml
+			await this.typedEvents.publish(
+				'<%= deleteEventType.type %>',
+				entity.id,
+				{
+<% deleteEventType.payloadMap.forEach((p) => { -%>
+					<%= p.camelKey %>: <%- p.expression %>,<% if (p.todo) { %> // TODO: <%= p.todo %><% } %>
+
+<% }) -%>
+				},
+				{
+					tx,
+					metadata: opts?.actor
+						? { tenantId: opts.actor.tenantId, userId: opts.actor.userId }
+						: undefined,
+				},
+			);
+			// TODO: Add post-delete side effects here (cleanup, etc.)
+			return entity;
+		});
+<% } else { -%>
 		const deleted = await this.<%= camelName %>Repository.delete(id);
 		if (!deleted) {
 			throw new NotFoundException(`<%= className %> with id ${id} not found`);
@@ -40,6 +79,7 @@ export class <%= deleteCommandClass %> {
 		// TODO: Add post-delete side effects here (events, cleanup, etc.)
 
 		return deleted;
+<% } -%>
 	}
 }
 <% } -%>

package/templates/entity/new/backend/application/commands/update.ejs.t

@@ -21,15 +21,28 @@ import { <%= repositoryToken %> } from '<%= imports.constants %>';
 import type { I<%= className %>Repository, Update<%= className %>Input } from '<%= imports.domain %>';
 import { <%= className %> } from '<%= imports.domain %>';
 import type { Update<%= className %>Dto } from '<%= imports.schemas %>';
+<% if (hasEmits && updateEventType) { -%>
+import { TYPED_EVENT_BUS, TypedEventBus } from '<%= eventsTokenImport %>';
+import { DRIZZLE } from '<%= drizzleTokenImport %>';
+import type { DrizzleClient } from '<%= drizzleTypeImport %>';
+<% } -%>
 
 @Injectable()
 export class <%= updateCommandClass %> {
 	constructor(
 		@Inject(<%= repositoryToken %>)
 		private readonly <%= camelName %>Repository: I<%= className %>Repository,
+<% if (hasEmits && updateEventType) { -%>
+		@Inject(TYPED_EVENT_BUS) private readonly typedEvents: TypedEventBus,
+		@Inject(DRIZZLE) private readonly db: DrizzleClient,
+<% } -%>
 	) {}
 
-	async execute(id: string, dto: Update<%= className %>Dto): Promise<<%= className %>> {
+	async execute(
+		id: string,
+		dto: Update<%= className %>Dto,
+		<%= hasEmits && updateEventType ? 'opts' : '_opts' %>?: { actor?: { tenantId?: string | null; userId?: string } },
+	): Promise<<%= className %>> {
 		const existing = await this.<%= camelName %>Repository.findById(id);
 		if (!existing) {
 			throw new NotFoundException(`<%= className %> with id ${id} not found`);
@@ -45,6 +58,33 @@ export class <%= updateCommandClass %> {
 <% }) -%>
 		};
 
+<% if (hasEmits && updateEventType) { -%>
+		return this.db.transaction(async (tx) => {
+			const entity = await this.<%= camelName %>Repository.update(id, input, tx);
+			if (!entity) {
+				throw new NotFoundException(`<%= className %> with id ${id} not found`);
+			}
+			// TODO: verify payload mapping against events/<%= updateEventType.type %>.yaml
+			await this.typedEvents.publish(
+				'<%= updateEventType.type %>',
+				entity.id,
+				{
+<% updateEventType.payloadMap.forEach((p) => { -%>
+					<%= p.camelKey %>: <%- p.expression %>,<% if (p.todo) { %> // TODO: <%= p.todo %><% } %>
+
+<% }) -%>
+				},
+				{
+					tx,
+					metadata: opts?.actor
+						? { tenantId: opts.actor.tenantId, userId: opts.actor.userId }
+						: undefined,
+				},
+			);
+			// TODO: Add post-update side effects here (non-event hooks, cache invalidation, etc.)
+			return entity;
+		});
+<% } else { -%>
 		const updated = await this.<%= camelName %>Repository.update(id, input);
 		if (!updated) {
 			throw new NotFoundException(`<%= className %> with id ${id} not found`);
@@ -53,6 +93,7 @@ export class <%= updateCommandClass %> {
 		// TODO: Add post-update side effects here (events, cache invalidation, etc.)
 
 		return updated;
+<% } -%>
 	}
 }
 <% } -%>

package/templates/entity/new/backend/database/repository.ejs.t

@@ -184,6 +184,9 @@ import { DRIZZLE } from '<%= imports.repositoryToConstants %>';
 <% if (hasEntityRefFields) { -%>
 import type { EntityType } from '<%= locations.dbSchemaServer.import %>';
 <% } -%>
+<% if (hasEmits && (createEventType || updateEventType || deleteEventType)) { -%>
+import type { DrizzleTransaction } from '<%= eventsTokenImport %>';
+<% } -%>
 import type {
 	Create<%= className %>Input,
 	I<%= className %>Repository,
@@ -209,11 +212,16 @@ import { <%= plural %> } from '<%= locations.dbSchemaServer.import %>';
 export class <%= className %>Repository implements I<%= className %>Repository {
 	constructor(@Inject(DRIZZLE) private readonly db: DrizzleDB) {}
 
-	async create(input: Create<%= className %>Input): Promise<<%= className %>> {
+	async create(input: Create<%= className %>Input<%= (hasEmits && createEventType) ? ', tx?: DrizzleTransaction' : '' %>): Promise<<%= className %>> {
 <% if (hasTimestamps) { -%>
 		const now = new Date();
 <% } -%>
+<% if (hasEmits && createEventType) { -%>
+		const runner = tx ?? this.db;
+		const result = await runner
+<% } else { -%>
 		const result = await this.db
+<% } -%>
 			.insert(<%= plural %>)
 			.values({
 <% fields.forEach((field) => { -%>
@@ -261,8 +269,13 @@ export class <%= className %>Repository implements I<%= className %>Repository {
 <% } -%>
 	}
 
-	async update(id: string, input: Update<%= className %>Input): Promise<<%= className %> | null> {
+	async update(id: string, input: Update<%= className %>Input<%= (hasEmits && updateEventType) ? ', tx?: DrizzleTransaction' : '' %>): Promise<<%= className %> | null> {
+<% if (hasEmits && updateEventType) { -%>
+		const runner = tx ?? this.db;
+		const result = await runner
+<% } else { -%>
 		const result = await this.db
+<% } -%>
 			.update(<%= plural %>)
 			.set({
 				...input,
@@ -277,7 +290,23 @@ export class <%= className %>Repository implements I<%= className %>Repository {
 		return record ? <%= className %>.fromRecord(record) : null;
 	}
 
-	async delete(id: string): Promise<<%= className %> | null> {
+	async delete(id: string<%= (hasEmits && deleteEventType) ? ', tx?: DrizzleTransaction' : '' %>): Promise<<%= className %> | null> {
+<% if (hasEmits && deleteEventType) { -%>
+		const runner = tx ?? this.db;
+<% if (hasSoftDelete) { -%>
+		// Soft delete - set deletedAt timestamp
+		const result = await runner
+			.update(<%= plural %>)
+			.set({ deletedAt: new Date() })
+			.where(eq(<%= plural %>.id, id))
+			.returning();
+<% } else { -%>
+		const result = await runner
+			.delete(<%= plural %>)
+			.where(eq(<%= plural %>.id, id))
+			.returning();
+<% } -%>
+<% } else { -%>
 <% if (hasSoftDelete) { -%>
 		// Soft delete - set deletedAt timestamp
 		const result = await this.db
@@ -290,6 +319,7 @@ export class <%= className %>Repository implements I<%= className %>Repository {
 			.delete(<%= plural %>)
 			.where(eq(<%= plural %>.id, id))
 			.returning();
+<% } -%>
 <% } -%>
 
 		const record = result[0];

package/templates/entity/new/backend/domain/repository-interface.ejs.t

@@ -13,6 +13,9 @@ import type { <%= className %> } from './<%= name %>.entity';
 <% if (hasEntityRefFields) { -%>
 import type { EntityType } from '<%= locations.dbSchemaServer.import %>';
 <% } -%>
+<% if (hasEmits && (createEventType || updateEventType || deleteEventType)) { -%>
+import type { DrizzleTransaction } from '<%= eventsTokenImport %>';
+<% } -%>
 <% if (hasRelationships) { -%>
 
 /**
@@ -44,11 +47,11 @@ export type Create<%= className %>Input = {
 export type Update<%= className %>Input = Partial<Create<%= className %>Input>;
 
 export interface I<%= className %>Repository {
-	create(input: Create<%= className %>Input): Promise<<%= className %>>;
+	create(input: Create<%= className %>Input<%= (hasEmits && createEventType) ? ', tx?: DrizzleTransaction' : '' %>): Promise<<%= className %>>;
 	findById(id: string<%= hasRelationships ? `, include?: ${className}With` : '' %>): Promise<<%= className %> | null>;
 	findAll(<%= hasRelationships ? `include?: ${className}With` : '' %>): Promise<<%= className %>[]>;
-	update(id: string, input: Update<%= className %>Input): Promise<<%= className %> | null>;
-	delete(id: string): Promise<<%= className %> | null>;
+	update(id: string, input: Update<%= className %>Input<%= (hasEmits && updateEventType) ? ', tx?: DrizzleTransaction' : '' %>): Promise<<%= className %> | null>;
+	delete(id: string<%= (hasEmits && deleteEventType) ? ', tx?: DrizzleTransaction' : '' %>): Promise<<%= className %> | null>;
 <% if (hasSoftDelete) { -%>
 	// Soft delete recovery methods
 	restore(id: string): Promise<<%= className %> | null>;

package/templates/entity/new/backend/modules/core/module.ejs.t

@@ -6,6 +6,12 @@ force: true
 /**
  * <%= classNamePlural %> Module
  * Generated by entity codegen - do not edit directly
+<% if (hasEmits) { -%>
+ *
+ * EVT-7: This entity emits typed domain events. Use-cases depend on
+ * TYPED_EVENT_BUS + DRIZZLE. Ensure EventsModule is registered in the
+ * root AppModule (global) so these tokens resolve at runtime.
+<% } -%>
  */
 
 import { Module } from '@nestjs/common';

package/templates/entity/new/backend/presentation/controller.ejs.t

@@ -14,6 +14,7 @@ import {
 	Controller,
 	Delete,
 	Get,
+	Headers,
 	Param,
 	ParseUUIDPipe,
 	Post,
@@ -75,21 +76,31 @@ export class <%= classNamePlural %>Controller {
 
 	@Post()
 	@UsePipes(new ZodValidationPipe(create<%= className %>Schema))
-	async create(@Body() dto: Create<%= className %>Dto): Promise<<%= className %>> {
-		return this.create<%= className %>Command.execute(dto);
+	async create(
+		@Body() dto: Create<%= className %>Dto,
+		@Headers('x-tenant-id') tenantId?: string,
+		@Headers('x-user-id') userId?: string,
+	): Promise<<%= className %>> {
+		return this.create<%= className %>Command.execute(dto, { actor: { tenantId, userId } });
 	}
 
 	@Put(':id')
 	async update(
 		@Param('id', ParseUUIDPipe) id: string,
 		@Body(new ZodValidationPipe(update<%= className %>Schema)) dto: Update<%= className %>Dto,
+		@Headers('x-tenant-id') tenantId?: string,
+		@Headers('x-user-id') userId?: string,
 	): Promise<<%= className %>> {
-		return this.update<%= className %>Command.execute(id, dto);
+		return this.update<%= className %>Command.execute(id, dto, { actor: { tenantId, userId } });
 	}
 
 	@Delete(':id')
-	async delete(@Param('id', ParseUUIDPipe) id: string): Promise<<%= className %>> {
-		return this.delete<%= className %>Command.execute(id);
+	async delete(
+		@Param('id', ParseUUIDPipe) id: string,
+		@Headers('x-tenant-id') tenantId?: string,
+		@Headers('x-user-id') userId?: string,
+	): Promise<<%= className %>> {
+		return this.delete<%= className %>Command.execute(id, { actor: { tenantId, userId } });
 	}
 <% if (hasRelationships) { -%>
 
@@ -120,6 +131,7 @@ import {
 	Get,
 	Body,
 	Delete,
+	Headers,
 	Param,
 	ParseUUIDPipe,
 	Post,
@@ -181,21 +193,31 @@ export class <%= classNamePlural %>Controller {
 
 	@Post()
 	@UsePipes(new ZodValidationPipe(create<%= className %>Schema))
-	async create(@Body() dto: Create<%= className %>Dto): Promise<<%= className %>> {
-		return this.create<%= className %>Command.execute(dto);
+	async create(
+		@Body() dto: Create<%= className %>Dto,
+		@Headers('x-tenant-id') tenantId?: string,
+		@Headers('x-user-id') userId?: string,
+	): Promise<<%= className %>> {
+		return this.create<%= className %>Command.execute(dto, { actor: { tenantId, userId } });
 	}
 
 	@Put(':id')
 	async update(
 		@Param('id', ParseUUIDPipe) id: string,
 		@Body(new ZodValidationPipe(update<%= className %>Schema)) dto: Update<%= className %>Dto,
+		@Headers('x-tenant-id') tenantId?: string,
+		@Headers('x-user-id') userId?: string,
 	): Promise<<%= className %>> {
-		return this.update<%= className %>Command.execute(id, dto);
+		return this.update<%= className %>Command.execute(id, dto, { actor: { tenantId, userId } });
 	}
 
 	@Delete(':id')
-	async delete(@Param('id', ParseUUIDPipe) id: string): Promise<<%= className %>> {
-		return this.delete<%= className %>Command.execute(id);
+	async delete(
+		@Param('id', ParseUUIDPipe) id: string,
+		@Headers('x-tenant-id') tenantId?: string,
+		@Headers('x-user-id') userId?: string,
+	): Promise<<%= className %>> {
+		return this.delete<%= className %>Command.execute(id, { actor: { tenantId, userId } });
 	}
 }
 <% } -%>

package/templates/entity/new/clean-lite-ps/controller.ejs.t

@@ -3,11 +3,24 @@ to: "<%= typeof clpOutputPaths !== 'undefined' ? clpOutputPaths.controller : nul
 skip_if: "<%= typeof clpOutputPaths === 'undefined' %>"
 force: true
 ---
-import { Controller, Get, Param } from '@nestjs/common';
+import { Controller, Get<% if (generateWrites) { %>, Post, Patch, Delete, Body, Headers<% } %>, NotFoundException, Param, ParseUUIDPipe } from '@nestjs/common';
 import { <%= classNames.findByIdUseCase %> } from './use-cases/find-<%= entityName %>-by-id.use-case';
 import { <%= classNames.listUseCase %> } from './use-cases/list-<%= entityNamePlural %>.use-case';
+<% if (eavEnabled) { -%>
+import { <%= classNames.findByIdWithFieldsUseCase %> } from './use-cases/find-<%= entityName %>-by-id-with-fields.use-case';
+import { <%= classNames.listWithFieldsUseCase %> } from './use-cases/list-<%= entityNamePlural %>-with-fields.use-case';
+<% } -%>
+<% if (generateWrites) { -%>
+import { ZodValidationPipe } from '@shared/pipes/zod-validation.pipe';
+import { <%= classNames.createUseCase %> } from './use-cases/create-<%= entityName %>.use-case';
+import { <%= classNames.updateUseCase %> } from './use-cases/update-<%= entityName %>.use-case';
+import { <%= classNames.deleteUseCase %> } from './use-cases/delete-<%= entityName %>.use-case';
+import { <%= classNames.createSchema %> } from './dto/create-<%= entityName %>.dto';
+import type { <%= classNames.createDto %> } from './dto/create-<%= entityName %>.dto';
+import { <%= classNames.updateSchema %> } from './dto/update-<%= entityName %>.dto';
+import type { <%= classNames.updateDto %> } from './dto/update-<%= entityName %>.dto';
+<% } -%>
 import type { <%= classNames.entity %> } from './<%= entityName %>.entity';
-// Write use cases must be hand-written. Import them here when ready.
 
 @Controller('<%= entityNamePlural %>')
 export class <%= classNames.controller %> {
@@ -15,23 +28,71 @@ export class <%= classNames.controller %> {
     // All routes go through use cases (ADR-003 — no controller → service shortcuts)
     private readonly findByIdUseCase: <%= classNames.findByIdUseCase %>,
     private readonly listUseCase: <%= classNames.listUseCase %>,
-    // TODO: inject hand-written write use cases here
+<% if (eavEnabled) { -%>
+    private readonly findByIdWithFieldsUseCase: <%= classNames.findByIdWithFieldsUseCase %>,
+    private readonly listWithFieldsUseCase: <%= classNames.listWithFieldsUseCase %>,
+<% } -%>
+<% if (generateWrites) { -%>
+    private readonly createUseCase: <%= classNames.createUseCase %>,
+    private readonly updateUseCase: <%= classNames.updateUseCase %>,
+    private readonly deleteUseCase: <%= classNames.deleteUseCase %>,
+<% } -%>
   ) {}
 
   @Get()
   async getAll(): Promise<<%= classNames.entity %>[]> {
     return this.listUseCase.execute();
   }
-
+<% if (eavEnabled) { %>
+  @Get('with-fields')
+  async getAllWithFields(): Promise<Array<<%= classNames.entity %> & { fields: Record<string, unknown> }>> {
+    return this.listWithFieldsUseCase.execute();
+  }
+<% } %>
   @Get(':id')
-  async getById(@Param('id') id: string): Promise<<%= classNames.entity %> | null> {
+  async getById(@Param('id', ParseUUIDPipe) id: string): Promise<<%= classNames.entity %>> {
+    // Use case throws NotFoundException on null/undefined (D2)
     return this.findByIdUseCase.execute(id);
   }
+<% if (eavEnabled) { %>
+  @Get(':id/with-fields')
+  async getByIdWithFields(
+    @Param('id', ParseUUIDPipe) id: string,
+  ): Promise<<%= classNames.entity %> & { fields: Record<string, unknown> }> {
+    const entity = await this.findByIdWithFieldsUseCase.execute(id);
+    if (!entity) throw new NotFoundException(`<%= classNames.entity %> ${id} not found`);
+    return entity;
+  }
+<% } %>
+<% if (generateWrites) { %>
+  @Post()
+  async create(
+    @Body(new ZodValidationPipe(<%= classNames.createSchema %>)) dto: <%= classNames.createDto %>,
+    @Headers('x-tenant-id') tenantId?: string,
+    @Headers('x-user-id') userId?: string,
+  ): Promise<<%= classNames.entity %>> {
+    return this.createUseCase.execute(dto, { actor: { tenantId, userId } });
+  }
 
-  // TODO: Add write routes. Each must call a hand-written use case, not the service.
-  // Example:
-  // @Post()
-  // async create(@Body() dto: Create<%= classNames.entity %>Dto): Promise<<%= classNames.entity %>> {
-  //   return this.createUseCase.execute(dto);
-  // }
+  @Patch(':id')
+  async update(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body(new ZodValidationPipe(<%= classNames.updateSchema %>)) dto: <%= classNames.updateDto %>,
+    @Headers('x-tenant-id') tenantId?: string,
+    @Headers('x-user-id') userId?: string,
+  ): Promise<<%= classNames.entity %>> {
+    const entity = await this.updateUseCase.execute(id, dto, { actor: { tenantId, userId } });
+    if (!entity) throw new NotFoundException(`<%= classNames.entity %> ${id} not found`);
+    return entity;
+  }
+
+  @Delete(':id')
+  async remove(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Headers('x-tenant-id') tenantId?: string,
+    @Headers('x-user-id') userId?: string,
+  ): Promise<void> {
+    return this.deleteUseCase.execute(id, { actor: { tenantId, userId } });
+  }
+<% } %>
 }

package/templates/entity/new/clean-lite-ps/entity.ejs.t

@@ -14,7 +14,9 @@ import { relations, type InferSelectModel } from 'drizzle-orm';
 import { type InferSelectModel } from 'drizzle-orm';
 <%_ } _%>
 <%_ clpBelongsTo.forEach(rel => { _%>
+<%_ if (rel.relatedTable !== entityNamePlural) { _%>
 import { <%= rel.relatedTable %> } from '<%= rel.importPath %>';
+<%_ } _%>
 <%_ }) _%>
 
 export const <%= entityNamePlural %> = pgTable(
@@ -22,11 +24,23 @@ export const <%= entityNamePlural %> = pgTable(
   {
     id: uuid('id').primaryKey().defaultRandom(),
 <%_ clpBelongsTo.forEach(rel => { _%>
-    <%= rel.camelField %>: uuid('<%= rel.field %>')<%= rel.nullable ? '' : '.notNull()' %>,
+<%_ if (hasSoftDelete) { _%>
+    // WARNING: on_delete: '<%= rel.onDeleteYaml %>' is a no-op when this entity uses soft_delete.
+    // BaseService.delete() issues UPDATE … SET deleted_at = now(), not DELETE, so Postgres
+    // cascade rules never fire for a soft-deleted parent. This FK constraint only applies on
+    // hard-delete (e.g. admin purge). See ADR-021: docs/adrs/ADR-021-on-delete-semantics.md
+<%_ } _%>
+    <%= rel.camelField %>: uuid('<%= rel.field %>')<%= rel.nullable ? '' : '.notNull()' %>.references(() => <%= rel.relatedTable %>.id, { onDelete: '<%= rel.onDelete %>' }),
 <%_ }) _%>
 <%_ clpProcessedFields.forEach(field => { _%>
     <%= field.camelName %>: <%- field.drizzleChain %>,
 <%_ }) _%>
+<%_ if (hasExternalIdTracking) { _%>
+    // external_id_tracking behavior
+    externalId: varchar('external_id'),
+    provider: varchar('provider'),
+    providerMetadata: jsonb('provider_metadata'),
+<%_ } _%>
 <%_ if (hasTimestamps) { _%>
     createdAt: timestamp('created_at').notNull().defaultNow(),
     updatedAt: timestamp('updated_at').notNull().defaultNow(),
@@ -40,7 +54,7 @@ export const <%= entityNamePlural %> = pgTable(
 
 export const <%= entityNamePlural %>Relations = relations(<%= entityNamePlural %>, ({ one }) => ({
 <%_ clpBelongsTo.forEach(rel => { _%>
-  <%= rel.relatedEntity %>: one(<%= rel.relatedTable %>, {
+  <%= rel.relationKey %>: one(<%= rel.relatedTable %>, {
     fields: [<%= entityNamePlural %>.<%= rel.camelField %>],
     references: [<%= rel.relatedTable %>.id],
   }),

package/templates/entity/new/clean-lite-ps/index.ejs.t

@@ -1,5 +1,5 @@
 ---
-to: "<%= typeof clpOutputPaths !== 'undefined' ? `modules/${entityNamePlural}/index.ts` : null %>"
+to: "<%= typeof clpOutputPaths !== 'undefined' ? clpOutputPaths.index : null %>"
 skip_if: "<%= typeof clpOutputPaths === 'undefined' %>"
 force: true
 ---