@shanyucoder/flowgrid 0.1.0

package/adapters/nestjs/nestgen/runners/lib/plan.mjs

@@ -0,0 +1,124 @@
+import path from 'node:path'
+
+import { analyzeWorkspace, inferWireFromSpec } from './workspace-analysis.mjs'
+import { enrichPlanContext } from './orm-fields.mjs'
+import { toKebab, toPascal } from './read-spec.mjs'
+
+const defaultRepoRoot = path.resolve(process.env.FLOWGRID_PROJECT_ROOT ?? process.cwd())
+
+export function resolveCodegenContext(spec) {
+  const codegen = spec.codegen ?? {}
+  const primaryModule = spec.modules?.[0]
+  const flatEntity = spec.entities?.[0]
+  const primaryEntity = primaryModule?.entities?.[0] ?? flatEntity
+
+  return {
+    module: codegen.module ?? primaryModule?.name ?? 'App',
+    entity: codegen.entity ?? primaryEntity?.name ?? 'Entity',
+    profile: codegen.profile ?? 'crud-standard',
+    orm: codegen.orm ?? 'typeorm',
+    skip: new Set(codegen.skip ?? []),
+    wire: inferWireFromSpec(spec)
+  }
+}
+
+export function buildFilePlan(spec, options = {}) {
+  const repoRoot = options.repoRoot ?? defaultRepoRoot
+  const ctx = resolveCodegenContext(spec)
+  const analysis = analyzeWorkspace(ctx, spec, repoRoot)
+  const moduleKebab = toKebab(ctx.module)
+  const entityKebab = toKebab(ctx.entity)
+  const entityPascal = toPascal(ctx.entity)
+  const modulePascal = toPascal(ctx.module)
+  const files = []
+  const skipped = []
+
+  const add = (id, relativePath, template, layer) => {
+    const abs = path.join(repoRoot, relativePath)
+    if (!options.force && analysis.files[id]) {
+      skipped.push({ id, relativePath, reason: 'exists' })
+      return
+    }
+    files.push({ id, relativePath, template, layer })
+  }
+
+  const base = `server/src/modules/${moduleKebab}/${entityKebab}`
+  const templateCtx = { ...ctx, moduleKebab, entityKebab, entityPascal, modulePascal, spec }
+
+  add('module', `server/src/modules/${moduleKebab}/${moduleKebab}.module.ts`, 'module.module.ts.hbs', 'module')
+  add('controller', `${base}/${entityKebab}.controller.ts`, 'entity.controller.ts.hbs', 'controller')
+  add('resource', `${base}/${entityKebab}.resource.ts`, 'entity.resource.ts.hbs', 'resource')
+
+  if (ctx.wire.search) {
+    add('searchQuery', `${base}/queries/search-${entityKebab}.query.ts`, 'queries/search.query.ts.hbs', 'query')
+    add(
+      'searchHandler',
+      `${base}/queries/search-${entityKebab}.handler.ts`,
+      'queries/search.handler.ts.hbs',
+      'handler'
+    )
+  }
+
+  const commandsBase = `${base}/commands`
+  if (ctx.wire.create) {
+    add('createCommand', `${commandsBase}/create-${entityKebab}.command.ts`, 'commands/create.command.ts.hbs', 'command')
+    add('createHandler', `${commandsBase}/create-${entityKebab}.handler.ts`, 'commands/create.handler.ts.hbs', 'handler')
+  }
+  if (ctx.wire.update) {
+    add('updateCommand', `${commandsBase}/update-${entityKebab}.command.ts`, 'commands/update.command.ts.hbs', 'command')
+    add('updateHandler', `${commandsBase}/update-${entityKebab}.handler.ts`, 'commands/update.handler.ts.hbs', 'handler')
+  }
+  if (ctx.wire.delete) {
+    add('deleteCommand', `${commandsBase}/delete-${entityKebab}.command.ts`, 'commands/delete.command.ts.hbs', 'command')
+    add('deleteHandler', `${commandsBase}/delete-${entityKebab}.handler.ts`, 'commands/delete.handler.ts.hbs', 'handler')
+  }
+
+  if (ctx.orm === 'prisma') {
+    add('entityOrm', `${base}/${entityKebab}.entity.ts`, `orm/${ctx.orm}.entity.ts.hbs`, 'orm')
+    add(
+      'prismaModel',
+      `server/prisma/models/${entityKebab}.prisma`,
+      'orm/prisma.model.prisma.hbs',
+      'orm'
+    )
+  } else if (ctx.orm === 'typeorm') {
+    add('entityOrm', `${base}/${entityKebab}.entity.ts`, 'orm/typeorm.entity.ts.hbs', 'orm')
+  }
+
+  const searchEndpoint =
+    spec.api?.endpoints?.find((e) => e.action === 'search') ??
+    spec.api?.endpoints?.find((e) => e.action === 'list') ??
+    spec.api?.endpoints?.find((e) => /search|list/i.test(e.path ?? ''))
+  const rawPath = searchEndpoint?.path ?? `/${entityKebab}s`
+  const searchPath = rawPath.replace(/^\//, '')
+
+  return {
+    ctx: { ...templateCtx, searchPath },
+    files,
+    skipped,
+    analysis,
+    artisanLines: files.map((f) => `nest-gen:${f.id} ${f.relativePath}`),
+    spec
+  }
+}
+
+export async function buildEnrichedPlan(spec, options = {}) {
+  const plan = buildFilePlan(spec, options)
+  const repoRoot = options.repoRoot ?? defaultRepoRoot
+  plan.ctx = await enrichPlanContext(spec, plan.ctx, repoRoot)
+  return plan
+}
+
+export function enrichSpecCodegen(spec, options = {}) {
+  const plan = buildFilePlan(spec, options)
+  spec.codegen = {
+    ...(spec.codegen ?? {}),
+    module: plan.ctx.module,
+    entity: plan.ctx.entity,
+    profile: plan.ctx.profile,
+    orm: plan.ctx.orm,
+    wire: plan.ctx.wire,
+    commands: plan.artisanLines
+  }
+  return plan
+}

package/adapters/nestjs/nestgen/runners/lib/read-spec.mjs

@@ -0,0 +1,52 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import yaml from 'yaml'
+
+export function parseArgs(argv) {
+  const options = { dryRun: false, writeSpec: false, spec: null, force: false, execute: true, id: null }
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (arg === '--dry-run' || arg === '--dry') options.dryRun = true
+    else if (arg === '--write-spec') options.writeSpec = true
+    else if (arg === '--plan-only') options.execute = false
+    else if (arg === '--force') options.force = true
+    else if (arg === '--openapi') {
+      throw new Error(
+        'OpenAPI YAML is FlowGrid docs (`flowgrid openapi:gen --spec …/01-backend-spec.yaml`), not nest-gen --openapi',
+      )
+    }
+    else if (arg === '--id') options.id = argv[++i]
+    else if (arg === '--spec') options.spec = argv[++i]
+    else if (!arg.startsWith('-') && !options.spec && !options.id) options.spec = arg
+  }
+
+  if (!options.spec && !options.id) {
+    throw new Error('Usage: pnpm nest:gen --spec …/api/<seq>/01-backend-spec.yaml OR --id CMP-XXX')
+  }
+
+  return options
+}
+
+export async function readSpecFile(specPath) {
+  const abs = path.resolve(specPath)
+  const raw = await fs.readFile(abs, 'utf8')
+  const spec = yaml.parse(raw)
+  const featureDir = abs.includes(`${path.sep}backend${path.sep}`)
+    ? path.dirname(path.dirname(abs))
+    : path.dirname(abs)
+  return { spec, specFile: abs, featureDir }
+}
+
+export function toKebab(value) {
+  return String(value)
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/[\s_]+/g, '-')
+    .toLowerCase()
+}
+
+export function toPascal(value) {
+  return String(value)
+    .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+    .replace(/^(.)/, (m) => m.toUpperCase())
+}

package/adapters/nestjs/nestgen/runners/lib/render.mjs

@@ -0,0 +1,52 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import Handlebars from 'handlebars'
+
+const templatesDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../templates')
+
+Handlebars.registerHelper('join', (items, sep) => {
+  if (!Array.isArray(items)) return ''
+  return items.join(typeof sep === 'string' ? sep : ', ')
+})
+Handlebars.registerHelper('eq', (a, b) => a === b)
+
+export async function renderTemplate(templateName, context) {
+  const source = await fs.readFile(path.join(templatesDir, templateName), 'utf8')
+  return Handlebars.compile(source, { noEscape: true })(context)
+}
+
+export function renderHandoffMarkdown(plan, specPath) {
+  const lines = [
+    '# Nest codegen — HANDOFF',
+    '',
+    `Spec: \`${specPath}\``,
+    '',
+    '## Generated',
+    ''
+  ]
+
+  for (const file of plan.files) {
+    lines.push(`- \`${file.relativePath}\` (${file.layer})`)
+  }
+
+  if (plan.skipped.length) {
+    lines.push('', '## Skipped (already exist)', '')
+    for (const s of plan.skipped) {
+      lines.push(`- \`${s.relativePath}\` — ${s.reason}`)
+    }
+  }
+
+  lines.push(
+    '',
+    '## Manual',
+    '',
+    '- Wire repository in Query/Command handlers (TypeORM/Prisma).',
+    '- Register module in `AppModule` if not auto-imported.',
+    '- Relation sync: read `@portal/models` `*.relationships.meta.ts`.',
+    ''
+  )
+
+  return lines.join('\n')
+}

package/adapters/nestjs/nestgen/runners/lib/workspace-analysis.mjs

@@ -0,0 +1,80 @@
+import { accessSync } from 'node:fs'
+import path from 'node:path'
+
+import { toKebab } from './read-spec.mjs'
+
+export function inferWireFromSpec(spec) {
+  const wire = {
+    search: false,
+    detail: false,
+    create: false,
+    update: false,
+    delete: false,
+    'bulk-delete': false,
+    selectItems: false,
+    ...(spec.codegen?.wire ?? {})
+  }
+
+  for (const endpoint of spec.api?.endpoints ?? []) {
+    // Skip backend codegen for endpoints marked with #reuse-api
+    if (endpoint.tags && endpoint.tags.includes('#reuse-api')) {
+      continue
+    }
+
+    const action = endpoint.action
+    if (action && Object.prototype.hasOwnProperty.call(wire, action)) {
+      wire[action] = true
+    }
+    if (action === 'list') {
+      wire.search = true
+    }
+    if (action === 'custom' && /select/i.test(endpoint.path ?? '')) {
+      wire.selectItems = true
+    }
+  }
+
+  return wire
+}
+
+export function resolveWorkspacePaths(ctx, repoRoot) {
+  const moduleKebab = toKebab(ctx.module)
+  const entityKebab = toKebab(ctx.entity)
+  const moduleRoot = path.join(repoRoot, 'server/src/modules', moduleKebab)
+  const entityRoot = path.join(moduleRoot, entityKebab)
+
+  return {
+    moduleFile: path.join(moduleRoot, `${moduleKebab}.module.ts`),
+    controller: path.join(entityRoot, `${entityKebab}.controller.ts`),
+    resource: path.join(entityRoot, `${entityKebab}.resource.ts`),
+    searchQuery: path.join(entityRoot, 'queries', `search-${entityKebab}.query.ts`),
+    searchHandler: path.join(entityRoot, 'queries', `search-${entityKebab}.handler.ts`),
+    entityOrm: path.join(entityRoot, `${entityKebab}.entity.ts`)
+  }
+}
+
+function exists(filePath) {
+  try {
+    accessSync(filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function analyzeWorkspace(ctx, spec, repoRoot) {
+  const paths = resolveWorkspacePaths(ctx, repoRoot)
+  const wire = inferWireFromSpec(spec)
+
+  return {
+    paths,
+    wire,
+    files: {
+      module: exists(paths.moduleFile),
+      controller: exists(paths.controller),
+      resource: exists(paths.resource),
+      searchQuery: exists(paths.searchQuery),
+      searchHandler: exists(paths.searchHandler),
+      entityOrm: exists(paths.entityOrm)
+    }
+  }
+}

package/adapters/nestjs/nestgen/runners/lib/write-files.mjs

@@ -0,0 +1,49 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import { renderHandoffMarkdown, renderTemplate } from './render.mjs'
+
+export async function writeOutputs(repoRoot, plan, options) {
+  const written = []
+  const skipped = [...plan.skipped]
+
+  for (const file of plan.files) {
+    const absPath = path.join(repoRoot, file.relativePath)
+    const content = await renderTemplate(file.template, plan.ctx)
+
+    if (options.dryRun) {
+      written.push(file.relativePath)
+      continue
+    }
+
+    await fs.mkdir(path.dirname(absPath), { recursive: true })
+    await fs.writeFile(absPath, content, 'utf8')
+    written.push(file.relativePath)
+  }
+
+  return { written, skipped }
+}
+
+export async function writeManifest(featureDir, plan, specPath, options, written) {
+  const manifest = {
+    spec: specPath,
+    module: plan.ctx.module,
+    entity: plan.ctx.entity,
+    orm: plan.ctx.orm,
+    files: plan.files.map((f) => ({ layer: f.layer, path: f.relativePath, template: f.template })),
+    written,
+    skipped: plan.skipped,
+    generatedAt: new Date().toISOString()
+  }
+
+  const manifestPath = path.join(featureDir, 'generated', 'codegen.manifest.json')
+  const handoffPath = path.join(featureDir, 'generated', 'HANDOFF.md')
+
+  if (!options.dryRun) {
+    await fs.mkdir(path.dirname(manifestPath), { recursive: true })
+    await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8')
+    await fs.writeFile(handoffPath, renderHandoffMarkdown(plan, specPath), 'utf8')
+  }
+
+  return { manifestPath, handoffPath, manifest }
+}

package/adapters/nestjs/nestgen/runners/validate-registry.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const adapterRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..')
+const productRoot = path.resolve(process.env.FLOWGRID_PROJECT_ROOT ?? process.cwd())
+
+async function resolveRegistry() {
+  const name = 'registries/nest-codegen.registry.json'
+  for (const root of [productRoot, adapterRoot]) {
+    const candidate = path.join(root, name)
+    try {
+      await fs.access(candidate)
+      return candidate
+    } catch {
+      // try next
+    }
+  }
+  throw new Error(`Missing ${name}`)
+}
+
+async function main() {
+  const registryPath = await resolveRegistry()
+  const raw = await fs.readFile(registryPath, 'utf8')
+  const registry = JSON.parse(raw)
+  if (!registry.version) throw new Error('Invalid nest-codegen.registry.json')
+  console.log(`nest-codegen.registry.json OK (v${registry.version})`)
+  console.log(`  path: ${registryPath}`)
+  console.log('  validate: OK')
+}
+
+main().catch((error) => {
+  console.error(error.message ?? error)
+  process.exit(1)
+})

package/adapters/nestjs/nestgen/templates/commands/create.command.ts.hbs

@@ -0,0 +1,3 @@
+export class Create{{entityPascal}}Command {
+  constructor(readonly dto: Record<string, unknown>) {}
+}

package/adapters/nestjs/nestgen/templates/commands/create.handler.ts.hbs

@@ -0,0 +1,34 @@
+import { CommandHandler, ICommandHandler } from '@nestjs/cqrs'
+import { InjectRepository } from '@nestjs/typeorm'
+import { Repository } from 'typeorm'
+
+import { BaseWriteHandler } from '../../../../common/crud/base-write.handler'
+import { createTypeormWriteRepository } from '../../../../common/persistence/typeorm-write.repository'
+import { {{entityPascal}}Entity } from '../{{entityKebab}}.entity'
+import { {{entityPascal}}Resource } from '../{{entityKebab}}.resource'
+import { Create{{entityPascal}}Command } from './create-{{entityKebab}}.command'
+
+@CommandHandler(Create{{entityPascal}}Command)
+export class Create{{entityPascal}}Handler
+  extends BaseWriteHandler<{{entityPascal}}Entity>
+  implements ICommandHandler<Create{{entityPascal}}Command>
+{
+  protected repository: ReturnType<typeof createTypeormWriteRepository<{{entityPascal}}Entity>>
+
+  constructor(
+    @InjectRepository({{entityPascal}}Entity)
+    typeormRepo: Repository<{{entityPascal}}Entity>
+  ) {
+    super()
+    this.repository = createTypeormWriteRepository(typeormRepo)
+  }
+
+  protected async refresh(entity: {{entityPascal}}Entity) {
+    return entity
+  }
+
+  async execute(command: Create{{entityPascal}}Command) {
+    const entity = await this.create(command.dto, [])
+    return {{entityPascal}}Resource.toDto(entity)
+  }
+}

package/adapters/nestjs/nestgen/templates/commands/delete.command.ts.hbs

@@ -0,0 +1,3 @@
+export class Delete{{entityPascal}}Command {
+  constructor(readonly id: number | string) {}
+}

package/adapters/nestjs/nestgen/templates/commands/delete.handler.ts.hbs

@@ -0,0 +1,33 @@
+import { CommandHandler, ICommandHandler } from '@nestjs/cqrs'
+import { InjectRepository } from '@nestjs/typeorm'
+import { Repository } from 'typeorm'
+
+import { BaseWriteHandler } from '../../../../common/crud/base-write.handler'
+import { createTypeormWriteRepository } from '../../../../common/persistence/typeorm-write.repository'
+import { {{entityPascal}}Entity } from '../{{entityKebab}}.entity'
+import { Delete{{entityPascal}}Command } from './delete-{{entityKebab}}.command'
+
+@CommandHandler(Delete{{entityPascal}}Command)
+export class Delete{{entityPascal}}Handler
+  extends BaseWriteHandler<{{entityPascal}}Entity>
+  implements ICommandHandler<Delete{{entityPascal}}Command>
+{
+  protected repository: ReturnType<typeof createTypeormWriteRepository<{{entityPascal}}Entity>>
+
+  constructor(
+    @InjectRepository({{entityPascal}}Entity)
+    typeormRepo: Repository<{{entityPascal}}Entity>
+  ) {
+    super()
+    this.repository = createTypeormWriteRepository(typeormRepo)
+  }
+
+  protected async refresh(entity: {{entityPascal}}Entity) {
+    return entity
+  }
+
+  async execute(command: Delete{{entityPascal}}Command) {
+    await this.delete(command.id)
+    return { success: true }
+  }
+}

package/adapters/nestjs/nestgen/templates/commands/update.command.ts.hbs

@@ -0,0 +1,6 @@
+export class Update{{entityPascal}}Command {
+  constructor(
+    readonly id: number | string,
+    readonly dto: Record<string, unknown>
+  ) {}
+}

package/adapters/nestjs/nestgen/templates/commands/update.handler.ts.hbs

@@ -0,0 +1,34 @@
+import { CommandHandler, ICommandHandler } from '@nestjs/cqrs'
+import { InjectRepository } from '@nestjs/typeorm'
+import { Repository } from 'typeorm'
+
+import { BaseWriteHandler } from '../../../../common/crud/base-write.handler'
+import { createTypeormWriteRepository } from '../../../../common/persistence/typeorm-write.repository'
+import { {{entityPascal}}Entity } from '../{{entityKebab}}.entity'
+import { {{entityPascal}}Resource } from '../{{entityKebab}}.resource'
+import { Update{{entityPascal}}Command } from './update-{{entityKebab}}.command'
+
+@CommandHandler(Update{{entityPascal}}Command)
+export class Update{{entityPascal}}Handler
+  extends BaseWriteHandler<{{entityPascal}}Entity>
+  implements ICommandHandler<Update{{entityPascal}}Command>
+{
+  protected repository: ReturnType<typeof createTypeormWriteRepository<{{entityPascal}}Entity>>
+
+  constructor(
+    @InjectRepository({{entityPascal}}Entity)
+    typeormRepo: Repository<{{entityPascal}}Entity>
+  ) {
+    super()
+    this.repository = createTypeormWriteRepository(typeormRepo)
+  }
+
+  protected async refresh(entity: {{entityPascal}}Entity) {
+    return entity
+  }
+
+  async execute(command: Update{{entityPascal}}Command) {
+    const entity = await this.update(command.id, command.dto, [])
+    return {{entityPascal}}Resource.toDto(entity)
+  }
+}

package/adapters/nestjs/nestgen/templates/entity.controller.ts.hbs

@@ -0,0 +1,51 @@
+import { Body, Controller, Delete, Get, Param, Patch, Post, Query } from '@nestjs/common'
+import { CommandBus, QueryBus } from '@nestjs/cqrs'
+
+{{#if wire.search}}
+import { Search{{entityPascal}}Query } from './queries/search-{{entityKebab}}.query'
+{{/if}}
+{{#if wire.create}}
+import { Create{{entityPascal}}Command } from './commands/create-{{entityKebab}}.command'
+{{/if}}
+{{#if wire.update}}
+import { Update{{entityPascal}}Command } from './commands/update-{{entityKebab}}.command'
+{{/if}}
+{{#if wire.delete}}
+import { Delete{{entityPascal}}Command } from './commands/delete-{{entityKebab}}.command'
+{{/if}}
+
+@Controller('{{searchPath}}')
+export class {{entityPascal}}Controller {
+  constructor(
+    private readonly queryBus: QueryBus,
+    private readonly commandBus: CommandBus
+  ) {}
+
+{{#if wire.search}}
+  @Get()
+  search(@Query() query: Record<string, unknown>) {
+    return this.queryBus.execute(new Search{{entityPascal}}Query(query))
+  }
+{{/if}}
+
+{{#if wire.create}}
+  @Post()
+  create(@Body() body: Record<string, unknown>) {
+    return this.commandBus.execute(new Create{{entityPascal}}Command(body))
+  }
+{{/if}}
+
+{{#if wire.update}}
+  @Patch(':id')
+  update(@Param('id') id: string, @Body() body: Record<string, unknown>) {
+    return this.commandBus.execute(new Update{{entityPascal}}Command(id, body))
+  }
+{{/if}}
+
+{{#if wire.delete}}
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.commandBus.execute(new Delete{{entityPascal}}Command(id))
+  }
+{{/if}}
+}

package/adapters/nestjs/nestgen/templates/entity.resource.ts.hbs

@@ -0,0 +1,45 @@
+import { BaseResource } from '../../../common/crud/base-resource'
+
+type {{entityPascal}}Row = {
+  id: number
+{{#each resourceScalars}}
+  {{key}}?: {{tsType}}
+{{/each}}
+{{#each resourceRelations}}
+  {{key}}?: Array<{
+{{#each embed}}
+    {{key}}?: {{tsType}}
+{{/each}}
+  }>
+{{/each}}
+  created_at?: string | Date | null
+  updated_at?: string | Date | null
+}
+
+export class {{entityPascal}}Resource extends BaseResource<{{entityPascal}}Row> {
+  fields(entity: {{entityPascal}}Row) {
+    return {
+{{#each resourceScalars}}
+      {{key}}: entity.{{key}} ?? null{{#unless @last}},{{/unless}}
+{{/each}}
+    }
+  }
+
+  relations(entity: {{entityPascal}}Row) {
+    const out: Record<string, unknown> = {}
+{{#each resourceRelations}}
+    if (entity.{{key}}) {
+      out.{{key}} = entity.{{key}}.map((row) => ({
+{{#each embed}}
+        {{key}}: row.{{key}} ?? null{{#unless @last}},{{/unless}}
+{{/each}}
+      }))
+    }
+{{/each}}
+    return out
+  }
+
+  static toDto(entity: {{entityPascal}}Row) {
+    return new {{entityPascal}}Resource().toDto(entity)
+  }
+}

package/adapters/nestjs/nestgen/templates/module.module.ts.hbs

@@ -0,0 +1,38 @@
+import { Module } from '@nestjs/common'
+import { CqrsModule } from '@nestjs/cqrs'
+import { TypeOrmModule } from '@nestjs/typeorm'
+
+import { {{entityPascal}}Controller } from './{{entityKebab}}/{{entityKebab}}.controller'
+import { {{entityPascal}}Entity } from './{{entityKebab}}/{{entityKebab}}.entity'
+{{#if wire.search}}
+import { Search{{entityPascal}}Handler } from './{{entityKebab}}/queries/search-{{entityKebab}}.handler'
+{{/if}}
+{{#if wire.create}}
+import { Create{{entityPascal}}Handler } from './{{entityKebab}}/commands/create-{{entityKebab}}.handler'
+{{/if}}
+{{#if wire.update}}
+import { Update{{entityPascal}}Handler } from './{{entityKebab}}/commands/update-{{entityKebab}}.handler'
+{{/if}}
+{{#if wire.delete}}
+import { Delete{{entityPascal}}Handler } from './{{entityKebab}}/commands/delete-{{entityKebab}}.handler'
+{{/if}}
+
+@Module({
+  imports: [CqrsModule, TypeOrmModule.forFeature([{{entityPascal}}Entity])],
+  controllers: [{{entityPascal}}Controller],
+  providers: [
+{{#if wire.search}}
+    Search{{entityPascal}}Handler,
+{{/if}}
+{{#if wire.create}}
+    Create{{entityPascal}}Handler,
+{{/if}}
+{{#if wire.update}}
+    Update{{entityPascal}}Handler,
+{{/if}}
+{{#if wire.delete}}
+    Delete{{entityPascal}}Handler
+{{/if}}
+  ]
+})
+export class {{modulePascal}}Module {}

package/adapters/nestjs/nestgen/templates/orm/prisma.entity.ts.hbs

@@ -0,0 +1,10 @@
+/**
+ * Prisma model pointer — define model in schema.prisma; this stub documents mapping.
+ * Replace with PrismaService queries in handlers.
+ */
+export type {{entityPascal}}Record = {
+  id: number
+  name: string | null
+  created_at: Date | null
+  updated_at: Date | null
+}

package/adapters/nestjs/nestgen/templates/orm/prisma.model.prisma.hbs

@@ -0,0 +1,9 @@
+// Generated by nest:gen — merge into server/prisma/schema.prisma
+model {{entityPascal}} {
+{{#each prismaFields}}
+  {{name}} {{prismaType}}{{optional}}
+{{/each}}
+{{#each prismaRelations}}
+  {{field}} {{target}}{{relationSuffix}}
+{{/each}}
+}