@pattern-stack/codegen 0.2.0

package/templates/relationship/new/controller.ejs.t

@@ -0,0 +1,36 @@
+---
+to: "<%= outputPaths.controller %>"
+force: true
+---
+import { Controller, Get, Param } from '@nestjs/common';
+import { <%= classNames.findByIdUseCase %> } from './use-cases/find-<%= name %>-by-id.use-case';
+import { <%= classNames.listUseCase %> } from './use-cases/list-<%= entityNamePlural %>.use-case';
+import type { <%= classNames.entity %> } from './<%= name %>.entity';
+// Write use cases must be hand-written. Import them here when ready.
+
+@Controller('<%= entityNamePlural %>')
+export class <%= classNames.controller %> {
+  constructor(
+    // 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
+  ) {}
+
+  @Get()
+  async getAll(): Promise<<%= classNames.entity %>[]> {
+    return this.listUseCase.execute();
+  }
+
+  @Get(':id')
+  async getById(@Param('id') id: string): Promise<<%= classNames.entity %> | null> {
+    return this.findByIdUseCase.execute(id);
+  }
+
+  // TODO: Add write routes. Each must call a hand-written use case, not the service.
+  // Example:
+  // @Post()
+  // async create(@Body() dto: <%= classNames.createDto %>): Promise<<%= classNames.entity %>> {
+  //   return this.createUseCase.execute(dto);
+  // }
+}

package/templates/relationship/new/dto/create.ejs.t

@@ -0,0 +1,41 @@
+---
+to: "<%= outputPaths.createDto %>"
+force: true
+---
+import { z } from 'zod';
+<%_ if (hasTypes) { _%>
+import { <%= typeEnumName %> } from '../<%= name %>.entity';
+<%_ } _%>
+
+export const <%= classNames.createSchema %> = z.object({
+  // FK endpoints (required)
+  <%= fromColumnCamel %>: z.string().uuid(),
+  <%= toColumnCamel %>: z.string().uuid(),
+<%_ if (hasTypes) { _%>
+
+  // Relationship type (required)
+  type: z.enum(<%= typeEnumName %>.enumValues),
+<%_ } _%>
+<%_ if (temporal) { _%>
+
+  // Temporal fields (optional on create)
+  validFrom: z.coerce.date().nullable().optional(),
+  validTo: z.coerce.date().nullable().optional(),
+  isCurrent: z.boolean().default(true),
+<%_ } _%>
+<%_ if (sourced) { _%>
+
+  // Source tracking (optional on create)
+  source: z.string().nullable().optional(),
+  confidence: z.number().min(0).max(1).nullable().optional(),
+<%_ } _%>
+<%_ if (createDtoFields.length > 0) { _%>
+
+  // Custom fields
+<%_ createDtoFields.forEach(field => { _%>
+  <%= field.camelName %>: <%- field.zodChainCreate %>,
+<%_ }) _%>
+<%_ } _%>
+});
+
+export type <%= classNames.createDto %> = z.infer<typeof <%= classNames.createSchema %>>;

package/templates/relationship/new/dto/output.ejs.t

@@ -0,0 +1,44 @@
+---
+to: "<%= outputPaths.outputDto %>"
+force: true
+---
+import { z } from 'zod';
+
+export const <%= classNames.outputSchema %> = z.object({
+  id: z.string().uuid(),
+
+  // FK endpoints
+  <%= fromColumnCamel %>: z.string().uuid(),
+  <%= toColumnCamel %>: z.string().uuid(),
+<%_ if (hasTypes) { _%>
+
+  // Type
+  type: z.string(),
+<%_ } _%>
+<%_ if (temporal) { _%>
+
+  // Temporal
+  validFrom: z.coerce.date().nullable(),
+  validTo: z.coerce.date().nullable(),
+  isCurrent: z.boolean().nullable(),
+<%_ } _%>
+<%_ if (sourced) { _%>
+
+  // Source tracking
+  source: z.string().nullable(),
+  confidence: z.number().nullable(),
+<%_ } _%>
+<%_ if (outputDtoFields.length > 0) { _%>
+
+  // Custom fields
+<%_ outputDtoFields.forEach(field => { _%>
+  <%= field.camelName %>: <%- field.zodChainOutput %>,
+<%_ }) _%>
+<%_ } _%>
+
+  // Timestamps
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+
+export type <%= classNames.outputDto %> = z.infer<typeof <%= classNames.outputSchema %>>;

package/templates/relationship/new/dto/update.ejs.t

@@ -0,0 +1,10 @@
+---
+to: "<%= outputPaths.updateDto %>"
+force: true
+---
+import { z } from 'zod';
+import { <%= classNames.createSchema %> } from './create-<%= name %>.dto';
+
+export const <%= classNames.updateSchema %> = <%= classNames.createSchema %>.partial();
+
+export type <%= classNames.updateDto %> = z.infer<typeof <%= classNames.updateSchema %>>;

package/templates/relationship/new/entity.ejs.t

@@ -0,0 +1,98 @@
+---
+to: "<%= outputPaths.entity %>"
+force: true
+---
+import {
+<%_ drizzleImports.filter(i => i !== 'relations').forEach(i => { _%>
+  <%= i %>,
+<%_ }) _%>
+} from 'drizzle-orm/pg-core';
+import { type InferSelectModel } from 'drizzle-orm';
+import { <%= fromTable %> } from '../../<%= fromTable %>/<%= from %>.entity';
+<%_ if (from !== to) { _%>
+import { <%= toTable %> } from '../../<%= toTable %>/<%= to %>.entity';
+<%_ } _%>
+
+// ============================================================================
+// Enums
+// ============================================================================
+<%_ if (hasTypes) { _%>
+
+export const <%= typeEnumName %> = pgEnum('<%= name %>_type', [
+<%_ typeEnumValues.forEach(t => { _%>
+  '<%= t %>',
+<%_ }) _%>
+]);
+<%_ } _%>
+<%_ if (sourced) { _%>
+
+export const <%= sourceEnumName %> = pgEnum('<%= name %>_source', [
+<%_ sourceEnumValues.forEach(s => { _%>
+  '<%= s %>',
+<%_ }) _%>
+]);
+<%_ } _%>
+<%_ enumFields.forEach(field => { _%>
+
+export const <%= field.enumName %> = pgEnum('<%= name %>_<%= field.name %>', [
+<%_ field.choices.forEach(c => { _%>
+  '<%= c %>',
+<%_ }) _%>
+]);
+<%_ }) _%>
+
+// ============================================================================
+// Table
+// ============================================================================
+
+export const <%= tableVarName %> = pgTable(
+  '<%= tableName %>',
+  {
+    id: uuid('id').primaryKey().defaultRandom(),
+
+    // FK columns (auto-generated from relationship endpoints)
+    <%= fromColumnCamel %>: uuid('<%= fromColumn %>').notNull().references(() => <%= fromTable %>.id, { onDelete: '<%= onDeleteFromSql %>' }),
+    <%= toColumnCamel %>: uuid('<%= toColumn %>').notNull().references(() => <%= toTable %>.id, { onDelete: '<%= onDeleteToSql %>' }),
+<%_ if (hasTypes) { _%>
+
+    // Type taxonomy
+    type: <%= typeEnumName %>('type').notNull(),
+<%_ } _%>
+<%_ if (temporal) { _%>
+
+    // Temporal validity
+    validFrom: date('valid_from'),
+    validTo: date('valid_to'),
+    isCurrent: boolean('is_current').default(true),
+<%_ } _%>
+<%_ if (sourced) { _%>
+
+    // Source tracking
+    source: <%= sourceEnumName %>('source'),
+    confidence: numeric('confidence', { precision: 3, scale: 2 }),
+<%_ } _%>
+<%_ if (processedFields.length > 0) { _%>
+
+    // Custom fields
+<%_ processedFields.forEach(field => { _%>
+<%_ if (field.hasChoices) { _%>
+    <%= field.camelName %>: <%= field.enumName %>('<%= field.name %>'),
+<%_ } else if (field.foreignKey) { _%>
+    <%= field.camelName %>: uuid('<%= field.name %>'),
+<%_ } else { _%>
+    <%= field.camelName %>: <%- field.drizzleChain %>,
+<%_ } _%>
+<%_ }) _%>
+<%_ } _%>
+
+    // Timestamps
+    createdAt: timestamp('created_at').notNull().defaultNow(),
+    updatedAt: timestamp('updated_at').notNull().defaultNow(),
+  },
+  (table) => [
+    uniqueIndex('<%= tableName %>_unique_idx').on(<%- uniqueOnCamel.map(c => `table.${c}`).join(', ') %>),
+  ],
+);
+
+export type <%= classNames.entity %> = InferSelectModel<typeof <%= tableVarName %>>;
+export type <%= classNames.entity %>Insert = typeof <%= tableVarName %>.$inferInsert;

package/templates/relationship/new/index.ejs.t

@@ -0,0 +1,19 @@
+---
+to: "<%= outputPaths.index %>"
+force: true
+---
+/**
+ * <%= classNames.entity %> module barrel export
+ * Generated by relationship codegen - do not edit directly
+ */
+
+// Value exports (module, service, controller)
+export { <%= classNames.module %> } from './<%= entityNamePlural %>.module';
+export { <%= classNames.service %> } from './<%= name %>.service';
+export { <%= classNames.controller %> } from './<%= name %>.controller';
+
+// Type-only exports (entity, DTOs)
+export type { <%= classNames.entity %> } from './<%= name %>.entity';
+export type { <%= classNames.createDto %> } from './dto/create-<%= name %>.dto';
+export type { <%= classNames.updateDto %> } from './dto/update-<%= name %>.dto';
+export type { <%= classNames.outputDto %> } from './dto/<%= name %>-output.dto';

package/templates/relationship/new/module.ejs.t

@@ -0,0 +1,35 @@
+---
+to: "<%= outputPaths.module %>"
+force: true
+---
+import { Module } from '@nestjs/common';
+import { DatabaseModule } from '@shared/database/database.module';
+
+import { <%= classNames.repository %> } from './<%= name %>.repository';
+import { <%= classNames.service %> } from './<%= name %>.service';
+import { <%= classNames.controller %> } from './<%= name %>.controller';
+import { <%= classNames.findByIdUseCase %> } from './use-cases/find-<%= name %>-by-id.use-case';
+import { <%= classNames.listUseCase %> } from './use-cases/list-<%= entityNamePlural %>.use-case';
+<% if (hasDeclarativeQueries) { -%>
+import { declarativeQueryClasses } from './use-cases/declarative-queries';
+<% } -%>
+
+@Module({
+  imports: [
+    DatabaseModule,
+    // TODO: Add subsystem modules as needed (EventsSubsystemModule, etc.)
+  ],
+  controllers: [<%= classNames.controller %>],
+  providers: [
+    <%= classNames.repository %>,
+    <%= classNames.service %>,
+    <%= classNames.findByIdUseCase %>,
+    <%= classNames.listUseCase %>,
+<% if (hasDeclarativeQueries) { -%>
+    ...declarativeQueryClasses,
+<% } -%>
+    // TODO: Register hand-written use cases here
+  ],
+  exports: [<%= classNames.service %>],  // Only service is exported (ADR-002)
+})
+export class <%= classNames.module %> {}