scaffold-engine 0.1.0

package/tools/generate-module.cjs

@@ -0,0 +1,1218 @@
+#!/usr/bin/env node
+const path = require('path');
+const {
+  buildContext,
+  loadRuntimeConfig,
+  resolveScaffoldPath,
+  validateModelFile,
+  writeGeneratedFile,
+  snakeCase,
+} = require('./lib/model-toolkit.cjs');
+const {
+  getAdminHeaderIcon,
+  getPatternCreateLabel,
+  getPatternDetailSubtitle,
+  getPatternFieldPriority,
+  getPatternFormSubtitle,
+  getPatternId,
+  getPatternListSubtitle,
+  getPatternListTitle,
+  getPatternSearchPlaceholder,
+} = require('./lib/pattern-renderers.cjs');
+const { renderAdminListPage: renderAdminListPageModule } = require('./lib/renderers/list-page-renderer.cjs');
+const { renderAdminFormPage: renderAdminFormPageModule } = require('./lib/renderers/form-page-renderer.cjs');
+const { renderAdminDetailPage: renderAdminDetailPageModule } = require('./lib/renderers/detail-page-renderer.cjs');
+
+const args = process.argv.slice(2);
+const force = args.includes('--force');
+const dryRun = args.includes('--dry-run');
+const configPath = readArgValue(args, '--config');
+const specArg = args.find((item) => !item.startsWith('--'));
+const specPath = specArg
+  ? resolveInputPath(specArg)
+  : resolveScaffoldPath('specs', 'projects', 'crm-pilot', 'customer.yaml');
+
+try {
+  const runtimeConfig = loadRuntimeConfig({ configPath });
+  const validation = validateModelFile(specPath, runtimeConfig);
+  if (!validation.valid) {
+    console.error('\n❌ 模型未通过校验，无法生成模块。请先执行 model:validate 修复问题。');
+    process.exit(1);
+  }
+
+  const context = buildContext(validation.model);
+  const targets = buildTargets(context, runtimeConfig);
+  const results = [];
+
+  for (const target of targets) {
+    results.push(writeGeneratedFile(target.filePath, target.content, { force, dryRun }));
+  }
+
+  const written = results.filter((item) => item.status === 'written' || item.status === 'planned');
+  const skipped = results.filter((item) => item.status === 'skipped');
+
+  console.log(`\n🧩 已处理模型: ${validation.absolutePath}`);
+  console.log(`📁 目标模块: ${context.domainKebab}/${context.objectKebab}`);
+  console.log(`📝 新生成文件: ${written.length}`);
+  console.log(`⏭️  跳过文件: ${skipped.length}`);
+
+  for (const item of written) {
+    console.log(`- [${item.status}] ${path.relative(resolveScaffoldPath(), item.filePath)}`);
+  }
+
+  for (const item of skipped) {
+    console.log(`- [skipped] ${path.relative(resolveScaffoldPath(), item.filePath)}`);
+  }
+
+  console.log('\n✅ 模块骨架生成完成');
+} catch (error) {
+  console.error(`\n❌ 模块生成失败: ${error.message}`);
+  process.exit(1);
+}
+
+function buildTargets(context, runtimeConfig) {
+  const scaffoldRoot = runtimeConfig.scaffoldRoot;
+  const apiBase = runtimeConfig.targets.apiSrcDir;
+  const adminBase = runtimeConfig.targets.adminSrcDir;
+  const generatedHeader = `/**\n * AUTO-GENERATED FILE.\n * Source spec: ${context.meta.domain}/${context.meta.object}\n * Edit the business model first, then regenerate.\n */\n`;
+
+  return [
+    {
+      filePath: path.join(apiBase, 'entity', 'generated', context.domainKebab, `${context.objectKebab}.entity.ts`),
+      content: generatedHeader + renderRootEntity(context),
+    },
+    ...context.childTables.map((child) => ({
+      filePath: path.join(apiBase, 'entity', 'generated', context.domainKebab, `${child.fileName}.entity.ts`),
+      content: generatedHeader + renderChildEntity(context, child),
+    })),
+    {
+      filePath: path.join(apiBase, 'dto', 'generated', context.domainKebab, `${context.objectKebab}.dto.ts`),
+      content: generatedHeader + renderDto(context),
+    },
+    {
+      filePath: path.join(apiBase, 'mapper', 'generated', context.domainKebab, `${context.objectKebab}.mapper.ts`),
+      content: generatedHeader + renderMapper(context),
+    },
+    ...context.childTables.map((child) => ({
+      filePath: path.join(apiBase, 'mapper', 'generated', context.domainKebab, `${child.fileName}.mapper.ts`),
+      content: generatedHeader + renderChildMapper(context, child),
+    })),
+    {
+      filePath: path.join(apiBase, 'service', 'generated', context.domainKebab, `${context.objectKebab}.service.ts`),
+      content: generatedHeader + renderService(context),
+    },
+    {
+      filePath: path.join(apiBase, 'controller', 'generated', context.domainKebab, `${context.objectKebab}.controller.ts`),
+      content: generatedHeader + renderController(context),
+    },
+    {
+      filePath: path.join(apiBase, 'scripts', 'generated', context.domainKebab, `${context.objectKebab}.init.ts`),
+      content: generatedHeader + renderInitScript(context),
+    },
+    {
+      filePath: path.join(adminBase, 'pages', 'generated', context.domainKebab, context.objectKebab, 'ListPage.tsx'),
+      content: generatedHeader + renderAdminListPage(context),
+    },
+    {
+      filePath: path.join(adminBase, 'pages', 'generated', context.domainKebab, context.objectKebab, `${context.objectKebab}-ui.ts`),
+      content: generatedHeader + renderAdminUiHelper(context),
+    },
+    {
+      filePath: path.join(adminBase, 'pages', 'generated', context.domainKebab, context.objectKebab, 'FormPage.tsx'),
+      content: generatedHeader + renderAdminFormPage(context),
+    },
+    {
+      filePath: path.join(adminBase, 'pages', 'generated', context.domainKebab, context.objectKebab, 'DetailPage.tsx'),
+      content: generatedHeader + renderAdminDetailPage(context),
+    },
+    {
+      filePath: path.join(adminBase, 'routes', 'modules', `${context.moduleSlug}.ts`),
+      content: generatedHeader + renderAdminRouteModule(context),
+    },
+  ];
+}
+
+function readArgValue(argv, flag) {
+  const index = argv.indexOf(flag);
+  if (index === -1) {
+    return '';
+  }
+  return argv[index + 1] || '';
+}
+
+function renderRootEntity(context) {
+  const fieldLines = context.fields.map((field) => renderEntityField(field)).join('\n\n');
+  return `import { Entity, TableField, TableId } from '@ai-partner-x/aiko-boot-starter-orm';
+
+@Entity({ tableName: '${context.data.table}' })
+export class ${context.objectPascal} {
+  @TableId({ type: 'AUTO' })
+  id!: number;
+
+${indent(fieldLines, 2)}
+
+  @TableField({ column: 'created_at' })
+  createdAt?: Date;
+
+  @TableField({ column: 'updated_at' })
+  updatedAt?: Date;
+}
+`;
+}
+
+function renderChildEntity(context, child) {
+  const fieldLines = child.fields.map((field) => renderEntityField(field)).join('\n\n');
+  return `import { Entity, TableField, TableId } from '@ai-partner-x/aiko-boot-starter-orm';
+
+@Entity({ tableName: '${child.table}' })
+export class ${child.className} {
+  @TableId({ type: 'AUTO' })
+  id!: number;
+
+  @TableField({ column: '${snakeCase(child.foreignKey)}' })
+  ${child.foreignKey}!: number;
+
+${indent(fieldLines, 2)}
+
+  @TableField({ column: 'created_at' })
+  createdAt?: Date;
+
+  @TableField({ column: 'updated_at' })
+  updatedAt?: Date;
+}
+`;
+}
+
+function renderDto(context) {
+  const createFields = context.fields.map((field) => renderDtoField(field, field.required)).join('\n');
+  const updateFields = context.fields.map((field) => renderDtoField(field, false)).join('\n');
+  const pageFields = ((context.ui.list && context.ui.list.filters) || []).map((fieldName) => {
+    const field = context.fields.find((item) => item.name === fieldName);
+    const tsType = field ? normalizeDtoType(field.tsType) : 'string';
+    return `  ${fieldName}?: ${tsType};`;
+  }).join('\n');
+  const childClasses = context.childTables.map((child) => {
+    const lines = child.fields.map((field) => renderDtoField(field, false)).join('\n');
+    return `export class ${child.className}Input {\n${lines}\n}\n`;
+  }).join('\n');
+  const childCreateProps = context.childTables.map((child) => `  ${child.variableName}?: ${child.className}Input[];`).join('\n');
+
+  return `${childClasses}export class Create${context.objectPascal}Dto {
+${createFields}
+${childCreateProps ? `${childCreateProps}\n` : ''}}
+
+export class Update${context.objectPascal}Dto {
+${updateFields}
+${childCreateProps ? `${childCreateProps}\n` : ''}}
+
+export class ${context.objectPascal}PageDto {
+  pageNo: number = 1;
+  pageSize: number = 10;
+${pageFields ? `${pageFields}\n` : ''}}
+
+export interface ${context.objectPascal}Vo {
+  id: number;
+${context.fields.map((field) => `  ${field.name}${field.required ? '' : '?'}: ${normalizeDtoType(field.tsType)};`).join('\n')}
+${context.childTables.map((child) => `  ${child.variableName}?: ${child.className}Input[];`).join('\n')}
+  createdAt?: Date | string;
+  updatedAt?: Date | string;
+}
+`;
+}
+
+function renderMapper(context) {
+  return `import 'reflect-metadata';
+import { BaseMapper, Mapper } from '@ai-partner-x/aiko-boot-starter-orm';
+import { ${context.objectPascal} } from '../../../entity/generated/${context.domainKebab}/${context.objectKebab}.entity.js';
+
+@Mapper(${context.objectPascal})
+export class ${context.objectPascal}Mapper extends BaseMapper<${context.objectPascal}> {}
+`;
+}
+
+function renderChildMapper(context, child) {
+  return `import 'reflect-metadata';
+import { BaseMapper, Mapper } from '@ai-partner-x/aiko-boot-starter-orm';
+import { ${child.className} } from '../../../entity/generated/${context.domainKebab}/${child.fileName}.entity.js';
+
+@Mapper(${child.className})
+export class ${child.className}Mapper extends BaseMapper<${child.className}> {}
+`;
+}
+
+function renderService(context) {
+  const childDtoImports = context.childTables.map((child) => `${child.className}Input`).join(',\n  ');
+  const actionMethods = [];
+
+  if (context.hasAction('activate')) {
+    actionMethods.push(`  async activate${context.objectPascal}(id: number) {
+    const entity = await this.${context.objectCamel}Mapper.selectById(id);
+    if (!entity) {
+      throw new Error('${context.label}不存在');
+    }
+
+    const nextEntity = { ...entity, status: 'active', updatedAt: new Date().toISOString() } as any;
+    await this.${context.objectCamel}Mapper.updateById(nextEntity);
+    return this.get${context.objectPascal}ById(id);
+  }\n`);
+  }
+
+  if (context.hasAction('deactivate')) {
+    actionMethods.push(`  async deactivate${context.objectPascal}(id: number) {
+    const entity = await this.${context.objectCamel}Mapper.selectById(id);
+    if (!entity) {
+      throw new Error('${context.label}不存在');
+    }
+
+    const nextEntity = { ...entity, status: 'inactive', updatedAt: new Date().toISOString() } as any;
+    await this.${context.objectCamel}Mapper.updateById(nextEntity);
+    return this.get${context.objectPascal}ById(id);
+  }\n`);
+  }
+
+  return `import 'reflect-metadata';
+import { Autowired, Injectable } from '@ai-partner-x/aiko-boot/di/server';
+import type {
+  Create${context.objectPascal}Dto,
+  Update${context.objectPascal}Dto,
+  ${context.objectPascal}PageDto,
+  ${context.objectPascal}Vo,
+${childDtoImports ? `  ${childDtoImports}` : ''}
+} from '../../../dto/generated/${context.domainKebab}/${context.objectKebab}.dto.js';
+import { ${context.objectPascal}Mapper } from '../../../mapper/generated/${context.domainKebab}/${context.objectKebab}.mapper.js';
+${context.childTables.map((child) => `import { ${child.className}Mapper } from '../../../mapper/generated/${context.domainKebab}/${child.fileName}.mapper.js';`).join('\n')}
+
+@Injectable()
+export class ${context.objectPascal}Service {
+  @Autowired()
+  private ${context.objectCamel}Mapper!: ${context.objectPascal}Mapper;
+
+${context.childTables.map((child) => `  @Autowired()\n  private ${child.variableName}Mapper!: ${child.className}Mapper;\n`).join('\n')}
+
+  async page${context.objectPascal}s(params: ${context.objectPascal}PageDto) {
+    const records = await this.${context.objectCamel}Mapper.selectList({}, [{ field: 'id', direction: 'desc' }]);
+    let filtered = records.map((item) => this.normalizeRootEntity(item));
+${context.fields.map((field) => {
+  const filterEnabled = (context.ui.list && context.ui.list.filters || []).includes(field.name);
+  if (!filterEnabled) return '';
+  if (field.tsType === 'number') {
+    return `    if (params.${field.name} !== undefined && params.${field.name} !== null && params.${field.name} !== '' as any) {
+      filtered = filtered.filter((item) => Number(item.${field.name}) === Number(params.${field.name}));
+    }`;
+  }
+  return `    if (params.${field.name}) {
+      filtered = filtered.filter((item) => String(item.${field.name} || '').toLowerCase().includes(String(params.${field.name}).toLowerCase()));
+    }`;
+}).filter(Boolean).join('\n')}
+
+    const pageNo = params.pageNo || 1;
+    const pageSize = params.pageSize || 10;
+    const total = filtered.length;
+    const start = (pageNo - 1) * pageSize;
+    const pageRecords = filtered.slice(start, start + pageSize);
+    const pageItems = [];
+
+    for (const record of pageRecords) {
+      pageItems.push(await this.toVo(record));
+    }
+
+    return {
+      records: pageItems,
+      total,
+      pageNo,
+      pageSize,
+      totalPages: Math.ceil(total / pageSize),
+    };
+  }
+
+  async get${context.objectPascal}ById(id: number): Promise<${context.objectPascal}Vo> {
+    const entity = await this.${context.objectCamel}Mapper.selectById(id);
+    if (!entity) {
+      throw new Error('${context.label}不存在');
+    }
+
+    return this.toVo(this.normalizeRootEntity(entity));
+  }
+
+  async create${context.objectPascal}(dto: Create${context.objectPascal}Dto) {
+    await this.assertUniqueConstraints(dto);
+
+    const now = new Date().toISOString();
+    await this.${context.objectCamel}Mapper.insert({
+${context.fields.map((field) => `      ${field.name}: dto.${field.name},`).join('\n')}
+      createdAt: now,
+      updatedAt: now,
+    } as any);
+
+    const created = await this.findCreatedEntity(dto);
+    if (!created) {
+      throw new Error('创建${context.label}失败');
+    }
+
+${context.childTables.map((child) => `    if (dto.${child.variableName}) {
+      await this.replace${child.className}(created.id, dto.${child.variableName});
+    }`).join('\n')}
+
+    return this.get${context.objectPascal}ById(Number(created.id));
+  }
+
+  async update${context.objectPascal}(id: number, dto: Update${context.objectPascal}Dto) {
+    const current = await this.${context.objectCamel}Mapper.selectById(id);
+    if (!current) {
+      throw new Error('${context.label}不存在');
+    }
+
+    await this.assertUniqueConstraints(dto, id);
+    const nextEntity = {
+      ...this.normalizeRootEntity(current),
+${context.fields.map((field) => `      ${field.name}: dto.${field.name} !== undefined ? dto.${field.name} : current.${field.name},`).join('\n')}
+      updatedAt: new Date().toISOString(),
+    };
+
+    await this.${context.objectCamel}Mapper.updateById(nextEntity as any);
+
+${context.childTables.map((child) => `    if (dto.${child.variableName}) {
+      await this.replace${child.className}(id, dto.${child.variableName});
+    }`).join('\n')}
+
+    return this.get${context.objectPascal}ById(id);
+  }
+
+${actionMethods.join('\n')}
+  private normalizeRootEntity(entity: any) {
+    return {
+      ...entity,
+      createdAt: entity.createdAt instanceof Date ? entity.createdAt.toISOString() : entity.createdAt,
+      updatedAt: entity.updatedAt instanceof Date ? entity.updatedAt.toISOString() : entity.updatedAt,
+    };
+  }
+
+  private async assertUniqueConstraints(dto: Partial<Create${context.objectPascal}Dto>, excludeId?: number) {
+${context.fields.filter((field) => field.unique).map((field) => `    if (dto.${field.name} !== undefined) {
+      const existing = await this.${context.objectCamel}Mapper.selectOne({ ${field.name}: dto.${field.name} } as any);
+      if (existing && Number(existing.id) !== Number(excludeId || 0)) {
+        throw new Error('${field.label || field.name}已存在');
+      }
+    }`).join('\n')}
+  }
+
+  private async findCreatedEntity(dto: Create${context.objectPascal}Dto) {
+${renderFindCreatedEntity(context)}
+  }
+
+${context.childTables.map((child) => `  private async replace${child.className}(rootId: number, rows: ${child.className}Input[]) {
+    await this.${child.variableName}Mapper.delete({ ${child.foreignKey}: rootId } as any);
+    for (const row of rows) {
+      await this.${child.variableName}Mapper.insert({
+        ${child.foreignKey}: rootId,
+${child.fields.map((field) => `        ${field.name}: ${renderPersistExpression(field, `row.${field.name}`)},`).join('\n')}
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      } as any);
+    }
+  }
+
+  private async load${child.className}(rootId: number): Promise<${child.className}Input[]> {
+    const rows = await this.${child.variableName}Mapper.selectList({ ${child.foreignKey}: rootId } as any, [{ field: 'id', direction: 'asc' }]);
+    return rows.map((item: any) => ({
+${child.fields.map((field) => `      ${field.name}: ${renderReadExpression(field, `item.${field.name}`)},`).join('\n')}
+    }));
+  }
+`).join('\n')}
+  private async toVo(entity: any): Promise<${context.objectPascal}Vo> {
+    return {
+      id: Number(entity.id),
+${context.fields.map((field) => `      ${field.name}: entity.${field.name},`).join('\n')}
+${context.childTables.map((child) => `      ${child.variableName}: await this.load${child.className}(Number(entity.id)),`).join('\n')}
+      createdAt: entity.createdAt,
+      updatedAt: entity.updatedAt,
+    };
+  }
+}
+`;
+}
+
+function renderController(context) {
+  const filterParams = ((context.ui.list && context.ui.list.filters) || []).map((fieldName) => {
+    return `    @RequestParam('${fieldName}') ${fieldName}: string,`;
+  }).join('\n');
+
+  const pageAssignments = ((context.ui.list && context.ui.list.filters) || []).map((fieldName) => {
+    const field = context.fields.find((item) => item.name === fieldName);
+    const valueExpr = field && ['number'].includes(normalizeDtoType(field.tsType))
+      ? `${fieldName} ? Number(${fieldName}) : undefined`
+      : `${fieldName} || undefined`;
+    return `      ${fieldName}: ${valueExpr},`;
+  }).join('\n');
+
+  const actionMethods = [];
+
+  if (context.hasAction('activate')) {
+    actionMethods.push(`  @PutMapping('/:id/activate')
+  async activate(@PathVariable('id') id: string) {
+    return this.${context.objectCamel}Service.activate${context.objectPascal}(Number(id));
+  }\n`);
+  }
+
+  if (context.hasAction('deactivate')) {
+    actionMethods.push(`  @PutMapping('/:id/deactivate')
+  async deactivate(@PathVariable('id') id: string) {
+    return this.${context.objectCamel}Service.deactivate${context.objectPascal}(Number(id));
+  }\n`);
+  }
+
+  return `import 'reflect-metadata';
+import {
+  GetMapping,
+  PathVariable,
+  PostMapping,
+  PutMapping,
+  RequestBody,
+  RequestParam,
+  RestController,
+} from '@ai-partner-x/aiko-boot-starter-web';
+import { Autowired } from '@ai-partner-x/aiko-boot/di/server';
+import { ${context.objectPascal}Service } from '../../../service/generated/${context.domainKebab}/${context.objectKebab}.service.js';
+import type {
+  Create${context.objectPascal}Dto,
+  Update${context.objectPascal}Dto,
+  ${context.objectPascal}PageDto,
+} from '../../../dto/generated/${context.domainKebab}/${context.objectKebab}.dto.js';
+
+@RestController({ path: '${context.apiBasePath}' })
+export class ${context.objectPascal}Controller {
+  @Autowired()
+  private ${context.objectCamel}Service!: ${context.objectPascal}Service;
+
+  @GetMapping('/page')
+  async page(
+    @RequestParam('pageNo') pageNo: string,
+    @RequestParam('pageSize') pageSize: string,
+${filterParams ? `${filterParams}\n` : ''}  ) {
+    const params: ${context.objectPascal}PageDto = {
+      pageNo: pageNo ? Number(pageNo) : 1,
+      pageSize: pageSize ? Number(pageSize) : 10,
+${pageAssignments ? `${pageAssignments}\n` : ''}    };
+    return this.${context.objectCamel}Service.page${context.objectPascal}s(params);
+  }
+
+  @GetMapping('/:id')
+  async getById(@PathVariable('id') id: string) {
+    return this.${context.objectCamel}Service.get${context.objectPascal}ById(Number(id));
+  }
+
+  @PostMapping()
+  async create(@RequestBody() dto: Create${context.objectPascal}Dto) {
+    return this.${context.objectCamel}Service.create${context.objectPascal}(dto);
+  }
+
+  @PutMapping('/:id')
+  async update(@PathVariable('id') id: string, @RequestBody() dto: Update${context.objectPascal}Dto) {
+    return this.${context.objectCamel}Service.update${context.objectPascal}(Number(id), dto);
+  }
+
+${actionMethods.join('\n')}
+}
+`;
+}
+
+function renderInitScript(context) {
+  const rootColumns = context.fields.map((field) => renderColumn(field, 4)).join('\n');
+  const childTables = context.childTables.map((child) => {
+    const childColumns = child.fields.map((field) => renderColumn(field, 4)).join('\n');
+    return `  await db.schema.createTable('${child.table}').ifNotExists()
+    .addColumn('id', 'integer', (col: any) => col.primaryKey().autoIncrement())
+    .addColumn('${snakeCase(child.foreignKey)}', 'integer', (col: any) => col.notNull())
+${childColumns}
+    .addColumn('created_at', 'datetime')
+    .addColumn('updated_at', 'datetime')
+    .execute();
+`;
+  }).join('\n');
+
+  return `export async function registerModuleTables(db: any) {
+  await db.schema.createTable('${context.data.table}').ifNotExists()
+    .addColumn('id', 'integer', (col: any) => col.primaryKey().autoIncrement())
+${rootColumns}
+    .addColumn('created_at', 'datetime')
+    .addColumn('updated_at', 'datetime')
+    .execute();
+
+${childTables}}
+`;
+}
+
+function renderAdminRouteModule(context) {
+  const listImport = `${context.domainKebab}/${context.objectKebab}/ListPage`;
+  const formImport = `${context.domainKebab}/${context.objectKebab}/FormPage`;
+  const detailImport = `${context.domainKebab}/${context.objectKebab}/DetailPage`;
+  const headerIcon = getAdminHeaderIcon(context);
+
+  return `import { createElement, lazy } from "react";
+import { ${headerIcon} } from "lucide-react";
+import type { RouteConfig } from "../index";
+import { withSuspense } from "../withSuspense";
+
+const ${context.objectPascal}ListPage = lazy(() => import("@/pages/generated/${listImport}"));
+const ${context.objectPascal}FormPage = lazy(() => import("@/pages/generated/${formImport}"));
+const ${context.objectPascal}DetailPage = lazy(() => import("@/pages/generated/${detailImport}"));
+
+export const routes: RouteConfig[] = [
+  {
+    path: "${context.routePath}",
+    label: "${context.label}",
+    icon: createElement(${headerIcon}, { className: "size-[18px]" }),
+    group: "business",
+    groupName: "${context.domainUpper}",
+    groupOrder: 5,
+    useGuard: false,
+    children: [
+      { index: true, element: withSuspense(${context.objectPascal}ListPage) },
+      { path: "create", element: withSuspense(${context.objectPascal}FormPage) },
+      { path: ":id", element: withSuspense(${context.objectPascal}DetailPage) },
+      { path: ":id/edit", element: withSuspense(${context.objectPascal}FormPage) }
+    ],
+  },
+];
+`;
+}
+
+function renderAdminListPage(context) {
+  return renderAdminListPageModule(context, {
+    findFieldByPriority,
+    getAdminHeaderIcon,
+    getFieldLabel,
+    getPatternCreateLabel,
+    getPatternFieldPriority,
+    getPatternId,
+    getPatternListSubtitle,
+    getPatternListTitle,
+    getPatternSearchPlaceholder,
+    getPrimarySearchField,
+    getPrimaryTitleField,
+    indent,
+    renderDisplayValue,
+  });
+}
+
+function renderAdminFormPage(context) {
+  return renderAdminFormPageModule(context, {
+    getAdminHeaderIcon,
+    getChildEnumOptionConst,
+    getFormFields,
+    getPatternFormSubtitle,
+    getPrimaryTitleField,
+    indent,
+    renderFieldInput,
+    renderFormHeaderFields,
+  });
+}
+
+function renderAdminDetailPage(context) {
+  return renderAdminDetailPageModule(context, {
+    getAdminHeaderIcon,
+    getChildEnumOptionConst,
+    getPatternDetailSubtitle,
+    getPrimaryTitleField,
+    indent,
+    renderDetailFields,
+    renderDetailHeaderFields,
+  });
+}
+
+function getPrimaryTitleField(context) {
+  const patternCandidates = getPatternFieldPriority(context, 'title');
+  return findFieldByPriority(context, patternCandidates)?.name
+    || findFieldByPriority(context, ['leadName', 'opportunityName', 'quoteName', 'contractName', 'customerName', 'materialName'])?.name
+    || context.fields.find((field) => field.name.toLowerCase().endsWith('name'))?.name
+    || context.fields[0]?.name;
+}
+
+function getPrimarySearchField(context) {
+  return findFieldByPriority(context, getPatternFieldPriority(context, 'search'))?.name
+    || getPrimaryTitleField(context);
+}
+
+function getFormFields(context) {
+  const groups = (context.ui.form && context.ui.form.groups) || [];
+  const ordered = [];
+  const seen = new Set();
+
+  for (const group of groups) {
+    for (const fieldName of group.fields || []) {
+      const field = context.fields.find((item) => item.name === fieldName);
+      if (field && !seen.has(field.name)) {
+        ordered.push(field);
+        seen.add(field.name);
+      }
+    }
+  }
+
+  for (const field of context.fields) {
+    if (!seen.has(field.name)) {
+      ordered.push(field);
+      seen.add(field.name);
+    }
+  }
+
+  return ordered;
+}
+
+function getFieldLabel(context, fieldName) {
+  return context.fields.find((field) => field.name === fieldName)?.label || fieldName;
+}
+
+function renderFieldInput(context, field, formRef) {
+  if (field.type === 'enum') {
+    return `<div className="space-y-2">
+  <Label>${field.label || field.name}${field.required ? ' <span className="text-destructive">*</span>' : ''}</Label>
+  <Select value={${formRef}.${field.name}} onValueChange={(value) => updateField("${field.name}", value)}>
+    <SelectTrigger className="w-full">
+      <SelectValue placeholder="请选择${field.label || field.name}" />
+    </SelectTrigger>
+    <SelectContent>
+      {${field.name.toUpperCase()}_OPTIONS.map((item) => (
+        <SelectItem key={item.value} value={item.value}>
+          {item.label}
+        </SelectItem>
+      ))}
+    </SelectContent>
+  </Select>
+</div>`;
+  }
+  return `<div className="space-y-2">
+  <Label>${field.label || field.name}${field.required ? ' <span className="text-destructive">*</span>' : ''}</Label>
+  <Input
+    value={${formRef}.${field.name}}
+    onChange={(event) => updateField("${field.name}", event.target.value)}
+    placeholder="请输入${field.label || field.name}"
+  />
+</div>`;
+}
+
+function renderFormHeaderFields(context) {
+  const picks = getHeaderFieldCandidates(context).slice(0, 4);
+  return picks.map((field) => {
+    const renderer = field.type === 'enum'
+      ? `getOptionLabel(${field.name.toUpperCase()}_OPTIONS, form.${field.name})`
+      : renderDisplayValue(field, `form.${field.name}`, `"${field.name === 'ownerName' ? '未分配' : '-'}"`);
+    return `{ icon: <${getAdminHeaderIcon(context)} className="h-4 w-4" />, label: "${field.label || field.name}", value: ${renderer} },`;
+  }).join('\n');
+}
+
+function renderDetailHeaderFields(context) {
+  const picks = getHeaderFieldCandidates(context).slice(0, 3);
+  const lines = picks.map((field) => {
+    const renderer = field.type === 'enum'
+      ? `getOptionLabel(${field.name.toUpperCase()}_OPTIONS, ${context.objectCamel}.${field.name})`
+      : renderDisplayValue(field, `${context.objectCamel}.${field.name}`, `"${field.name === 'ownerName' ? '未分配' : '-'}"`);
+    return `{ icon: <${getAdminHeaderIcon(context)} className="h-4 w-4" />, label: "${field.label || field.name}", value: ${renderer} },`;
+  });
+  lines.push(`{ icon: <${getAdminHeaderIcon(context)} className="h-4 w-4" />, label: "创建时间", value: formatDateTime(${context.objectCamel}.createdAt) },`);
+  return lines.join('\n');
+}
+
+function renderDetailFields(context) {
+  return getFormFields(context).map((field) => {
+    const value = field.name === 'status'
+      ? `statusMeta.label`
+      : field.type === 'enum'
+        ? `getOptionLabel(${field.name.toUpperCase()}_OPTIONS, ${context.objectCamel}.${field.name})`
+        : renderDisplayValue(field, `${context.objectCamel}.${field.name}`);
+    return `<div>
+  <p className="mb-1 text-xs text-muted-foreground">${field.label || field.name}</p>
+  <p className="text-sm${field.name === getPrimaryTitleField(context) ? ' font-medium' : ''}">{${value}}</p>
+</div>`;
+  }).join('\n');
+}
+
+function getHeaderFieldCandidates(context) {
+  const preferred = [
+    ...getPatternFieldPriority(context, 'header'),
+    'leadCode', 'customerCode', 'opportunityCode', 'quoteCode', 'materialCode',
+    'ownerName', 'phone', 'source', 'stage', 'materialType', 'status',
+  ];
+  const ordered = [];
+  for (const name of preferred) {
+    const field = context.fields.find((item) => item.name === name);
+    if (field) {
+      ordered.push(field);
+    }
+  }
+  for (const field of context.fields) {
+    if (!ordered.some((item) => item.name === field.name)) {
+      ordered.push(field);
+    }
+  }
+  return ordered;
+}
+
+function renderAdminDefaultValue(field) {
+  if (field.tsType === 'boolean') {
+    return field.default === undefined ? 'false' : String(Boolean(field.default));
+  }
+  if (field.tsType === 'number') {
+    return field.default === undefined ? '""' : JSON.stringify(String(field.default));
+  }
+  if (field.default !== undefined) {
+    return JSON.stringify(String(field.default));
+  }
+  return '""';
+}
+
+function renderFormStateType(field) {
+  if (field.tsType === 'boolean') {
+    return 'boolean';
+  }
+  return 'string';
+}
+
+function renderPayloadExpression(field, required) {
+  if (field.tsType === 'boolean') {
+    return required ? `Boolean(form.${field.name})` : `form.${field.name}`;
+  }
+  if (field.tsType === 'number') {
+    return required
+      ? `Number(form.${field.name})`
+      : `(form.${field.name} === "" ? undefined : Number(form.${field.name}))`;
+  }
+  if (required) {
+    return `form.${field.name}.trim()`;
+  }
+  return `form.${field.name}.trim() || undefined`;
+}
+
+function renderEnumOptions(field) {
+  return (field.options || []).map((value) => `{
+  value: ${JSON.stringify(String(value))},
+  label: ${JSON.stringify(String(value))},
+}`).join(',\n');
+}
+
+function renderStatusMeta(context) {
+  const statusField = context.fields.find((field) => field.name === 'status');
+  const options = statusField && statusField.options ? statusField.options : ['draft', 'active', 'inactive'];
+  return options.map((value) => {
+    const meta = getStatusPreset(String(value));
+    return `${JSON.stringify(String(value))}: {
+  label: ${JSON.stringify(meta.label)},
+  badgeClassName: ${JSON.stringify(meta.badgeClassName)},
+  dotClassName: ${JSON.stringify(meta.dotClassName)},
+  objectPageColor: ${JSON.stringify(meta.objectPageColor)},
+},`;
+  }).join('\n');
+}
+
+function getStatusPreset(value) {
+  const key = String(value).toLowerCase();
+  if (['active', 'converted'].includes(key)) {
+    return { label: value, badgeClassName: 'bg-emerald-500/10 text-emerald-700', dotClassName: 'bg-emerald-500', objectPageColor: 'green' };
+  }
+  if (['inactive', 'closed', 'lost'].includes(key)) {
+    return { label: value, badgeClassName: 'bg-red-500/10 text-red-600', dotClassName: 'bg-red-500', objectPageColor: 'red' };
+  }
+  if (['following', 'proposal', 'qualifying'].includes(key)) {
+    return { label: value, badgeClassName: 'bg-blue-500/10 text-blue-700', dotClassName: 'bg-blue-500', objectPageColor: 'blue' };
+  }
+  return { label: value, badgeClassName: 'bg-muted text-muted-foreground', dotClassName: 'bg-muted-foreground', objectPageColor: 'gray' };
+}
+
+function getChildEnumOptionConst(child, field) {
+  return `${child.className.toUpperCase()}_${field.name.toUpperCase()}_OPTIONS`;
+}
+
+function renderChildRowDefaultValue(field) {
+  if (field.tsType === 'boolean') {
+    return field.default === undefined ? 'false' : String(Boolean(field.default));
+  }
+  if (field.tsType === 'number') {
+    return field.default === undefined ? '""' : JSON.stringify(String(field.default));
+  }
+  if (field.default !== undefined) {
+    return JSON.stringify(String(field.default));
+  }
+  return '""';
+}
+
+function renderChildFormAssignment(field, sourceExpr) {
+  if (field.tsType === 'boolean') {
+    return `Boolean(${sourceExpr})`;
+  }
+  if (field.tsType === 'number') {
+    return `${sourceExpr} === undefined || ${sourceExpr} === null ? ${renderChildRowDefaultValue(field)} : String(${sourceExpr})`;
+  }
+  if (field.tsType === 'Date') {
+    return `toFormDateValue(${sourceExpr})`;
+  }
+  return `${sourceExpr} ?? ${renderChildRowDefaultValue(field)}`;
+}
+
+function renderNormalizeChildRowFields(child) {
+  const hasPrimaryField = child.fields.some((field) => field.name === 'isPrimary');
+  const lines = child.fields.map((field) => {
+    if (field.tsType === 'boolean') {
+      if (field.name === 'isPrimary') {
+        return `      ${field.name}: list.some((item) => item.isPrimary) ? Boolean(row.${field.name}) : index === 0,`;
+      }
+      return `      ${field.name}: Boolean(row.${field.name}),`;
+    }
+    if (field.tsType === 'number') {
+      return `      ${field.name}: row.${field.name} === "" ? undefined : Number(row.${field.name}),`;
+    }
+    return `      ${field.name}: row.${field.name}?.trim() || undefined,`;
+  });
+
+  return `      return {\n${lines.join('\n')}\n      };`;
+}
+
+function renderChildFilterCondition(child) {
+  const conditions = child.fields.map((field) => {
+    if (field.tsType === 'boolean') {
+      return `Boolean(row.${field.name})`;
+    }
+    if (field.tsType === 'number') {
+      return `row.${field.name} !== undefined && row.${field.name} !== null`;
+    }
+    return `Boolean(row.${field.name})`;
+  });
+  return conditions.join(' || ') || 'true';
+}
+
+function renderChildValidation(child) {
+  const requiredFields = child.fields.filter((field) => field.required);
+  if (requiredFields.length === 0) {
+    return '';
+  }
+
+  const hasAnyValue = child.fields.map((field) => {
+    if (field.tsType === 'boolean') {
+      return `Boolean(row.${field.name})`;
+    }
+    if (field.tsType === 'number') {
+      return `row.${field.name} !== "" && row.${field.name} !== undefined && row.${field.name} !== null`;
+    }
+    return `Boolean(row.${field.name}?.trim())`;
+  }).join(' || ');
+
+  const missingRequired = requiredFields.map((field) => {
+    if (field.tsType === 'boolean') {
+      return `row.${field.name} === undefined || row.${field.name} === null`;
+    }
+    if (field.tsType === 'number') {
+      return `row.${field.name} === "" || row.${field.name} === undefined || row.${field.name} === null`;
+    }
+    return `!row.${field.name}?.trim()`;
+  }).join(' || ');
+
+  return `  const invalid${child.className} = form.${child.variableName}.find((row) => {
+    const hasAnyValue = ${hasAnyValue};
+    return hasAnyValue && (${missingRequired});
+  });
+
+  if (invalid${child.className}) {
+    return "${child.label || child.name}${requiredFields[0].label || requiredFields[0].name}不能为空";
+  }`;
+}
+
+function findFieldByPriority(context, names) {
+  for (const name of names) {
+    const field = context.fields.find((item) => item.name === name);
+    if (field) {
+      return field;
+    }
+  }
+  return null;
+}
+
+
+function renderAdminUiHelper(context) {
+  const enumFields = context.fields.filter((field) => field.type === 'enum');
+  const childEnumFields = context.childTables.flatMap((child) =>
+    child.fields
+      .filter((field) => field.type === 'enum')
+      .map((field) => ({ child, field }))
+  );
+  const childFormRowTypes = context.childTables.map((child) => `export interface ${child.className}FormRow {\n  rowId: string;\n${child.fields.map((field) => `  ${field.name}: ${renderFormStateType(field)};`).join('\n')}\n}`).join('\n\n');
+  const defaultFieldLines = context.fields.map((field) => `    ${field.name}: ${renderAdminDefaultValue(field)},`).join('\n');
+  const childDefaultLines = context.childTables.map((child) => `    ${child.variableName}: [],`).join('\n');
+  const formStateLines = [
+    ...context.fields.map((field) => `  ${field.name}: ${renderFormStateType(field)};`),
+    ...context.childTables.map((child) => `  ${child.variableName}: ${child.className}FormRow[];`),
+  ].join('\n');
+  const formStateAssignments = context.fields.map((field) => `    ${field.name}: ${renderRootFormAssignment(field, `${context.objectCamel}.${field.name}`, `form.${field.name}`)},`).join('\n');
+  const childAssignments = context.childTables.map((child) => `    ${child.variableName}: (${context.objectCamel}.${child.variableName} ?? []).map((row) =>
+      createEmpty${child.className}Row({
+${indent(child.fields.map((field) => `        ${field.name}: ${renderChildFormAssignment(field, `row.${field.name}`)},`).join('\n'), 0)}
+      })
+    ),`).join('\n');
+  const createPayloadLines = context.fields.map((field) => `    ${field.name}: ${renderPayloadExpression(field, true)},`).join('\n');
+  const childCreateLines = context.childTables.map((child) => `    ${child.variableName}: normalize${child.className}Rows(form.${child.variableName}),`).join('\n');
+  const updatePayloadLines = context.fields.map((field) => `    ${field.name}: ${renderPayloadExpression(field, false)},`).join('\n');
+  const childUpdateLines = context.childTables.map((child) => `    ${child.variableName}: normalize${child.className}Rows(form.${child.variableName}),`).join('\n');
+  const validations = context.fields.filter((field) => field.required).map((field) => `  if (!form.${field.name}.trim()) {\n    return "${field.label || field.name}不能为空";\n  }`).join('\n');
+  const childValidations = context.childTables.map((child) => renderChildValidation(child)).filter(Boolean).join('\n\n');
+  const statusMeta = context.fields.some((field) => field.name === 'status')
+    ? `\nexport interface ${context.objectPascal}StatusMeta {\n  label: string;\n  badgeClassName: string;\n  dotClassName: string;\n  objectPageColor: "blue" | "green" | "yellow" | "red" | "gray";\n}\n\nconst ${context.objectPascal.toUpperCase()}_STATUS_META: Record<string, ${context.objectPascal}StatusMeta> = {\n${indent(renderStatusMeta(context), 2)}\n};\n`
+    : '';
+  const statusGetter = context.fields.some((field) => field.name === 'status')
+    ? `\nexport function get${context.objectPascal}StatusMeta(status?: string): ${context.objectPascal}StatusMeta {\n  if (!status) {\n    return {\n      label: "未设置",\n      badgeClassName: "bg-muted text-muted-foreground",\n      dotClassName: "bg-muted-foreground",\n      objectPageColor: "gray",\n    };\n  }\n\n  return ${context.objectPascal.toUpperCase()}_STATUS_META[status] ?? {\n    label: status,\n    badgeClassName: "bg-primary/10 text-primary",\n    dotClassName: "bg-primary",\n    objectPageColor: "blue",\n  };\n}\n`
+    : '';
+
+  const childTypeImports = context.childTables.map((child) => `${child.className}Input`).join(', ');
+  const dtoTypeImports = [`Create${context.objectPascal}Dto`, `${context.objectPascal}Vo`, `Update${context.objectPascal}Dto`];
+  if (childTypeImports) {
+    dtoTypeImports.splice(1, 0, childTypeImports);
+  }
+
+  return `import { ${context.objectPascal}Api, type ${dtoTypeImports.join(', type ')} } from "@scaffold/api/client";
+
+export interface ${context.objectPascal}PageResult {
+  records: ${context.objectPascal}Vo[];
+  total: number;
+  pageNo: number;
+  pageSize: number;
+  totalPages: number;
+}
+
+export interface ${context.objectPascal}Filters {
+${context.fields.filter((field) => ((context.ui.list && context.ui.list.filters) || []).includes(field.name)).map((field) => `  ${field.name}: string;`).join('\n')}
+}
+
+${childFormRowTypes ? `${childFormRowTypes}\n\n` : ''}export interface ${context.objectPascal}FormState {
+${formStateLines}
+}
+
+export interface OptionItem {
+  value: string;
+  label: string;
+}
+${statusMeta}
+${enumFields.map((field) => `export const ${field.name.toUpperCase()}_OPTIONS: OptionItem[] = [\n${indent(renderEnumOptions(field), 2)}\n];`).join('\n\n')}${childEnumFields.length ? '\n\n' : ''}${childEnumFields.map(({ child, field }) => `export const ${getChildEnumOptionConst(child, field)}: OptionItem[] = [\n${indent(renderEnumOptions(field), 2)}\n];`).join('\n\n')}
+
+const DEFAULT_API_BASE_URL = "http://localhost:3001";
+const apiBaseUrl = (import.meta.env.VITE_API_URL || DEFAULT_API_BASE_URL).replace(/\\/$/, "");
+
+export function create${context.objectPascal}Api() {
+  return new ${context.objectPascal}Api(apiBaseUrl);
+}
+${statusGetter}
+
+export function getOptionLabel(options: OptionItem[], value?: string) {
+  if (!value) {
+    return "-";
+  }
+
+  return options.find((item) => item.value === value)?.label ?? value;
+}
+
+export function createEmpty${context.objectPascal}Form(): ${context.objectPascal}FormState {
+  return {
+${defaultFieldLines}
+${childDefaultLines ? `${childDefaultLines}\n` : ''}  };
+}
+
+${context.childTables.map((child) => `export function createEmpty${child.className}Row(overrides?: Partial<${child.className}FormRow>): ${child.className}FormRow {
+  return {
+    rowId: crypto.randomUUID(),
+${child.fields.map((field) => `    ${field.name}: ${renderChildRowDefaultValue(field)},`).join('\n')}
+    ...overrides,
+  };
+}`).join('\n\n')}
+
+export function to${context.objectPascal}FormState(${context.objectCamel}?: Partial<${context.objectPascal}Vo> | null): ${context.objectPascal}FormState {
+  const form = createEmpty${context.objectPascal}Form();
+  if (!${context.objectCamel}) {
+    return form;
+  }
+
+  return {
+${formStateAssignments}
+${childAssignments ? `${childAssignments}\n` : ''}  };
+}
+
+export function toCreate${context.objectPascal}Payload(form: ${context.objectPascal}FormState): Create${context.objectPascal}Dto {
+  return {
+${createPayloadLines}
+${childCreateLines ? `${childCreateLines}\n` : ''}  };
+}
+
+export function toUpdate${context.objectPascal}Payload(form: ${context.objectPascal}FormState): Update${context.objectPascal}Dto {
+  return {
+${updatePayloadLines}
+${childUpdateLines ? `${childUpdateLines}\n` : ''}  };
+}
+
+export function validate${context.objectPascal}Form(form: ${context.objectPascal}FormState): string | null {
+${validations || '  return null;'}
+${childValidations ? `\n${childValidations}` : ''}
+
+  return null;
+}
+
+${context.childTables.map((child) => `export function normalize${child.className}Rows(rows: ${child.className}FormRow[]): ${child.className}Input[] {
+  const normalized = rows
+    .map((row${child.fields.some((field) => field.name === 'isPrimary') ? ', index, list' : ''}) => {
+${indent(renderNormalizeChildRowFields(child), 6)}
+    })
+    .filter((row) => ${renderChildFilterCondition(child)});
+${child.fields.some((field) => field.name === 'isPrimary') ? `
+
+  if (normalized.length > 0 && !normalized.some((row) => row.isPrimary)) {
+    normalized[0] = {
+      ...normalized[0],
+      isPrimary: true,
+    };
+  }` : ''}
+
+  return normalized;
+}`).join('\n\n')}
+
+export function formatDateTime(value?: string | Date) {
+  if (!value) {
+    return "-";
+  }
+
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return String(value);
+  }
+
+  return date.toLocaleString("zh-CN", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+}
+
+export function toFormDateValue(value?: string | Date | null) {
+  if (!value) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return value.toISOString().slice(0, 10);
+  }
+  return String(value);
+}
+`;
+}
+
+function renderRootFormAssignment(field, sourceExpr, fallbackExpr) {
+  if (field.tsType === 'boolean') {
+    return `Boolean(${sourceExpr})`;
+  }
+  if (field.tsType === 'number') {
+    return `${sourceExpr} === undefined || ${sourceExpr} === null ? ${fallbackExpr} : String(${sourceExpr})`;
+  }
+  if (field.tsType === 'Date') {
+    return `toFormDateValue(${sourceExpr}) || ${fallbackExpr}`;
+  }
+  return `${sourceExpr} ?? ${fallbackExpr}`;
+}
+
+function renderDisplayValue(field, sourceExpr, fallbackText = '"-"') {
+  if (field.tsType === 'Date' || field.name === 'createdAt' || field.name === 'updatedAt') {
+    return `formatDateTime(${sourceExpr})`;
+  }
+  if (field.tsType === 'number') {
+    return `${sourceExpr} === undefined || ${sourceExpr} === null ? ${fallbackText} : String(${sourceExpr})`;
+  }
+  return `${sourceExpr} || ${fallbackText}`;
+}
+
+function resolveInputPath(filePath) {
+  if (path.isAbsolute(filePath)) {
+    return filePath;
+  }
+  const normalized = String(filePath).replace(/\\/g, '/');
+  if (normalized.startsWith('scaffold/')) {
+    return path.resolve(process.cwd(), normalized.slice('scaffold/'.length));
+  }
+  if (normalized.startsWith('specs/')) {
+    return resolveScaffoldPath(...normalized.split('/'));
+  }
+  return path.resolve(filePath);
+}
+
+function renderEntityField(field) {
+  const optionalFlag = field.required ? '!' : '?';
+  return `@TableField({ column: '${field.column}' })
+  ${field.name}${optionalFlag}: ${normalizeEntityType(field.tsType)};`;
+}
+
+function renderDtoField(field, required) {
+  if (required) {
+    return `  ${field.name}!: ${normalizeDtoType(field.tsType)};`;
+  }
+  return `  ${field.name}?: ${normalizeDtoType(field.tsType)};`;
+}
+
+function normalizeEntityType(type) {
+  if (type === 'Date') {
+    return 'Date';
+  }
+  return type;
+}
+
+function normalizeDtoType(type) {
+  if (type === 'Date') {
+    return 'string | Date';
+  }
+  return type;
+}
+
+function renderColumn(field, indentSize) {
+  const modifiers = [];
+  if (field.required) {
+    modifiers.push('notNull()');
+  }
+  if (field.unique) {
+    modifiers.push('unique()');
+  }
+  if (field.default !== undefined) {
+    modifiers.push(`defaultTo(${JSON.stringify(field.default)})`);
+  }
+  const modifierText = modifiers.length > 0
+    ? `, (col: any) => col.${modifiers.join('.')}`
+    : '';
+  return `${' '.repeat(indentSize)}.addColumn('${field.column}', '${field.sqlType}'${modifierText})`;
+}
+
+function renderFindCreatedEntity(context) {
+  const uniqueField = context.fields.find((field) => field.unique);
+  if (uniqueField) {
+    return `    const entity = await this.${context.objectCamel}Mapper.selectOne({ ${uniqueField.name}: dto.${uniqueField.name} } as any);
+    return entity ? this.normalizeRootEntity(entity) : null;`;
+  }
+
+  return `    const list = await this.${context.objectCamel}Mapper.selectList({}, [{ field: 'id', direction: 'desc' }]);
+    if (list.length === 0) {
+      return null;
+    }
+    return this.normalizeRootEntity(list[0]);`;
+}
+
+function renderPersistExpression(field, sourceExpr) {
+  if (field.tsType === 'boolean') {
+    return `${sourceExpr} ? 1 : 0`;
+  }
+  return sourceExpr;
+}
+
+function renderReadExpression(field, sourceExpr) {
+  if (field.tsType === 'boolean') {
+    return `Boolean(${sourceExpr})`;
+  }
+  return sourceExpr;
+}
+
+function indent(text, size) {
+  return String(text)
+    .split('\n')
+    .map((line) => (line ? `${' '.repeat(size)}${line}` : line))
+    .join('\n');
+}