@nage-api/cli 1.0.0-beta.2

package/dist/templates/resource.template.js

@@ -0,0 +1,600 @@
+"use strict";
+/**
+ * `nage g resource product` (PLAN.md §10.3).
+ *
+ * One command produces a live, secured, paginated REST resource: entity,
+ * service, controller, DTOs, migration and tests, wired into the target app.
+ * The point is that it inherits capability rather than copying code — the
+ * service extends `ModelService`, so the list DSL, pagination envelope, soft
+ * delete and audit fields come from the framework, not from generated
+ * boilerplate a developer then has to maintain.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFields = parseFields;
+exports.resourceFiles = resourceFiles;
+exports.compactTimestamp = compactTimestamp;
+const naming_js_1 = require("../naming.js");
+const TYPE_MAP = {
+    string: { ts: 'string', validator: '@IsString()', column: 'DataTypes.STRING' },
+    text: { ts: 'string', validator: '@IsString()', column: 'DataTypes.TEXT' },
+    number: { ts: 'number', validator: '@IsNumber()', column: 'DataTypes.INTEGER' },
+    boolean: { ts: 'boolean', validator: '@IsBoolean()', column: 'DataTypes.BOOLEAN' },
+    date: { ts: 'string', validator: '@IsDateString()', column: 'DataTypes.DATE' },
+    json: { ts: 'Record<string, unknown>', validator: '@IsObject()', column: 'DataTypes.JSON' },
+};
+/** Parse `--fields "name:string,slug:string:unique,note:text:optional"`. */
+function parseFields(raw) {
+    if (raw === undefined || raw.trim() === '') {
+        // A resource with no declared columns still needs something to hold.
+        return [{ name: 'name', type: 'string', unique: false, optional: false }];
+    }
+    return raw
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0)
+        .map((entry) => {
+        const [name, type = 'string', ...modifiers] = entry.split(':').map((part) => part.trim());
+        if (name === undefined || name === '') {
+            throw new Error(`"${entry}" is not a field; use name:type[:modifier]`);
+        }
+        if (!(type in TYPE_MAP)) {
+            throw new Error(`"${type}" is not a supported field type (${Object.keys(TYPE_MAP).join(', ')})`);
+        }
+        return {
+            name,
+            type: type,
+            unique: modifiers.includes('unique'),
+            optional: modifiers.includes('optional'),
+        };
+    });
+}
+function resourceFiles(input) {
+    const names = (0, naming_js_1.deriveNames)(input.name);
+    const base = `apps/${input.appName}/src/modules/${names.kebab}`;
+    const route = input.route ?? names.pluralKebab;
+    const entityDir = input.entityPackage === undefined
+        ? `${base}/entities`
+        : `packages/${input.entityPackage}/src/entities`;
+    const files = [
+        { path: `${entityDir}/${names.kebab}.entity.ts`, contents: entity(names, input.fields) },
+        { path: `${base}/dto/create-${names.kebab}.dto.ts`, contents: createDto(names, input.fields) },
+        { path: `${base}/dto/update-${names.kebab}.dto.ts`, contents: updateDto(names, input.fields) },
+        { path: `${base}/dto/query-${names.kebab}.dto.ts`, contents: queryDto(names, input.fields) },
+        {
+            path: `${base}/${names.kebab}.service.ts`,
+            contents: service(names, input.fields, entityImport(input, names)),
+        },
+        { path: `${base}/${names.kebab}.controller.ts`, contents: controller(names, route) },
+        { path: `${base}/${names.kebab}.module.ts`, contents: module_(names) },
+    ];
+    if (input.withSpec !== false) {
+        files.push({ path: `${base}/${names.kebab}.service.spec.ts`, contents: serviceSpec(names) }, { path: `${base}/${names.kebab}.e2e-spec.ts`, contents: e2eSpec(names, route, input.fields) });
+    }
+    if (input.withMigration !== false) {
+        const stamp = input.timestamp ?? compactTimestamp();
+        files.push({
+            path: `database/migrations/${stamp}-create-${names.pluralKebab}.ts`,
+            contents: migration(names, input.fields, input.engine, stamp),
+        });
+    }
+    return files;
+}
+function entityImport(input, names) {
+    return input.entityPackage === undefined
+        ? `./entities/${names.kebab}.entity.js`
+        : `@app/${input.entityPackage}`;
+}
+function entity(names, fields) {
+    const columns = fields.map((field) => `  ${field.name}${field.optional ? '?' : ''}: ${TYPE_MAP[field.type].ts};`);
+    return [
+        "import type { BaseEntity } from '@nage-api/core';",
+        '',
+        '/**',
+        ` * ${names.title}.`,
+        ' *',
+        ' * `BaseEntity` supplies id, audit columns and soft-delete markers, so they are',
+        ' * consistent across every model and stamped by the framework rather than by',
+        ' * hand (PLAN.md §14.2).',
+        ' */',
+        `export interface ${names.pascal} extends BaseEntity {`,
+        '  readonly id: number;',
+        ...columns,
+        '}',
+        '',
+    ].join('\n');
+}
+function createDto(names, fields) {
+    const validators = new Set(fields.map((field) => TYPE_MAP[field.type].validator.slice(1, -2)));
+    const properties = fields.flatMap((field) => [
+        `  ${TYPE_MAP[field.type].validator}`,
+        ...(field.optional ? ['  @IsOptional()'] : []),
+        `  ${field.name}${field.optional ? '?' : '!'}: ${TYPE_MAP[field.type].ts};`,
+        '',
+    ]);
+    // `IsOptional` is only decorated onto an optional field, so importing it
+    // unconditionally leaves an unused import behind.
+    const imported = fields.some((field) => field.optional)
+        ? [...validators, 'IsOptional']
+        : [...validators];
+    return [
+        `import { ${imported.sort().join(', ')} } from 'class-validator';`,
+        '',
+        '/**',
+        ` * Body accepted when creating a ${names.title.toLowerCase()}.`,
+        ' *',
+        ' * Strict by construction: the global pipe rejects unknown properties, so a',
+        ' * client cannot set audit columns or ids by adding them to the payload.',
+        ' */',
+        `export class Create${names.pascal}Dto {`,
+        ...properties,
+        '}',
+        '',
+    ].join('\n');
+}
+function updateDto(names, fields) {
+    const validators = new Set(fields.map((field) => TYPE_MAP[field.type].validator.slice(1, -2)));
+    const properties = fields.flatMap((field) => [
+        `  ${TYPE_MAP[field.type].validator}`,
+        '  @IsOptional()',
+        `  ${field.name}?: ${TYPE_MAP[field.type].ts};`,
+        '',
+    ]);
+    return [
+        `import { ${[...validators, 'IsOptional'].sort().join(', ')} } from 'class-validator';`,
+        '',
+        '/**',
+        ' * Every field optional, and every validator restated.',
+        ' *',
+        ' * Declared rather than derived: this was originally an empty class merged with',
+        ' * `Partial<Create…Dto>` at the type level, which reads well but leaves the',
+        ' * class with no `class-validator` metadata at all. The global pipe runs with',
+        ' * `whitelist`, so it stripped every property and every PATCH came back 422.',
+        ' * Decorator metadata is a runtime artefact; a type-level `Partial` cannot',
+        ' * produce it.',
+        ' */',
+        `export class Update${names.pascal}Dto {`,
+        ...properties,
+        '}',
+        '',
+    ].join('\n');
+}
+function queryDto(names, fields) {
+    const filterable = fields.map((field) => `'${field.name}'`).join(', ');
+    return [
+        "import { defineQueryPolicy } from '@nage-api/data';",
+        '',
+        `import type { ${names.pascal} } from '../entities/${names.kebab}.entity.js';`,
+        '',
+        '/**',
+        ' * What a client may filter, sort and select.',
+        ' *',
+        ' * Derived from the entity so the resource is not an open query surface: a',
+        ' * field absent from these lists cannot be reached from the URL (§12).',
+        ' */',
+        `export const ${names.camel}QueryPolicy = defineQueryPolicy<${names.pascal}>({`,
+        `  filterable: [${filterable}],`,
+        `  sortable: [${filterable}, 'created_at'],`,
+        `  selectable: ['id', ${filterable}, 'created_at', 'updated_at'],`,
+        `  searchable: [${fields
+            .filter((field) => field.type === 'string' || field.type === 'text')
+            .map((field) => `'${field.name}'`)
+            .join(', ')}],`,
+        '  maxLimit: 100,',
+        '});',
+        '',
+    ].join('\n');
+}
+function service(names, fields, entityPath) {
+    const uniqueFields = fields.filter((field) => field.unique);
+    // `ConflictError` and `Job` appear only in the uniqueness hook. Importing them
+    // unconditionally left an unused import in every resource without a unique
+    // field, which `no-unused-vars` fails — so generated code did not pass the lint
+    // config generated alongside it.
+    const hasUniqueHook = uniqueFields.length > 0;
+    return [
+        "import { Inject, Injectable } from '@nestjs/common';",
+        hasUniqueHook
+            ? "import { ConflictError, repositoryToken } from '@nage-api/core';"
+            : "import { repositoryToken } from '@nage-api/core';",
+        "import { ModelService } from '@nage-api/data';",
+        hasUniqueHook
+            ? "import type { Job, RepositoryPort, UnitOfWork } from '@nage-api/core';"
+            : "import type { RepositoryPort, UnitOfWork } from '@nage-api/core';",
+        "import { NAGE_UNIT_OF_WORK } from '@nage-api/core';",
+        '',
+        `import type { ${names.pascal} } from '${entityPath}';`,
+        '',
+        `export const ${names.pascal.toUpperCase()}_REPOSITORY = repositoryToken<${names.pascal}>('${names.pascal}');`,
+        '',
+        '/**',
+        ` * ${names.title} service.`,
+        ' *',
+        ' * Extends `ModelService`, so the query DSL, pagination, soft delete and audit',
+        ' * stamping are inherited. Override the lifecycle hooks below to add rules;',
+        ' * they run inside the transaction.',
+        ' */',
+        '@Injectable()',
+        `export class ${names.pascal}Service extends ModelService<${names.pascal}> {`,
+        '  constructor(',
+        `    @Inject(${names.pascal.toUpperCase()}_REPOSITORY) repository: RepositoryPort<${names.pascal}>,`,
+        '    @Inject(NAGE_UNIT_OF_WORK) unitOfWork: UnitOfWork,',
+        '  ) {',
+        '    super(repository, { unitOfWork });',
+        '  }',
+        '',
+        ...(uniqueFields.length > 0
+            ? [
+                '  /** Uniqueness is enforced before the write, not by a database error. */',
+                `  protected override async doBeforeWrite(job: Job<${names.pascal}>): Promise<void> {`,
+                ...uniqueFields.flatMap((field) => [
+                    `    if (job.body.${field.name} !== undefined) {`,
+                    `      const clash = await this.repository.findOne({ where: { ${field.name}: job.body.${field.name} } });`,
+                    // `findOne` resolves to `TEntity | null`, never `undefined`, so a
+                    // `!== undefined` guard here is dead — and the generated lint config
+                    // fails on it under `no-unnecessary-condition`.
+                    '      if (clash !== null && clash.id !== job.id) {',
+                    '        throw new ConflictError({',
+                    `          message: '${indefiniteArticle(names.title)} ${names.title.toLowerCase()} with that ${field.name} already exists',`,
+                    `          meta: { field: '${field.name}' },`,
+                    '        });',
+                    '      }',
+                    '    }',
+                ]),
+                '  }',
+                '',
+            ]
+            : []),
+        `  // Import Job from '@nage-api/core' to use the read hook:`,
+        '  // protected override doBeforeRead(job: Job<' + names.pascal + '>): void {',
+        "  //   this.scopeToOwner(job, 'user_id'); // restrict to the caller's records",
+        '  // }',
+        '}',
+        '',
+    ].join('\n');
+}
+/** "An invoice", not "A invoice" — the message reaches a client. */
+function indefiniteArticle(noun) {
+    return /^[aeiou]/i.test(noun) ? 'An' : 'A';
+}
+function controller(names, route) {
+    return [
+        'import {',
+        '  Body,',
+        '  Controller,',
+        '  Delete,',
+        '  Get,',
+        '  HttpCode,',
+        '  Param,',
+        '  ParseIntPipe,',
+        '  Patch,',
+        '  Post,',
+        '  Query,',
+        "} from '@nestjs/common';",
+        "import { parseQuery } from '@nage-api/data';",
+        "import type { Paginated } from '@nage-api/core';",
+        '',
+        `import { ${names.pascal}Service } from './${names.kebab}.service.js';`,
+        `import { Create${names.pascal}Dto } from './dto/create-${names.kebab}.dto.js';`,
+        `import { Update${names.pascal}Dto } from './dto/update-${names.kebab}.dto.js';`,
+        `import { ${names.camel}QueryPolicy } from './dto/query-${names.kebab}.dto.js';`,
+        `import type { ${names.pascal} } from './entities/${names.kebab}.entity.js';`,
+        '',
+        '/**',
+        ` * ${names.title} REST resource.`,
+        ' *',
+        ' * Handlers return data; the global interceptor wraps it in the envelope and',
+        ' * the global filter turns any error into one (§16.1). Nothing here touches',
+        ' * `res`.',
+        ' */',
+        `@Controller('${route}')`,
+        `export class ${names.pascal}Controller {`,
+        `  constructor(private readonly ${names.camel}s: ${names.pascal}Service) {}`,
+        '',
+        '  @Post()',
+        `  create(@Body() body: Create${names.pascal}Dto): Promise<${names.pascal}> {`,
+        `    return this.${names.camel}s.create(body);`,
+        '  }',
+        '',
+        '  @Get()',
+        `  findAll(@Query() query: Record<string, unknown>): Promise<Paginated<${names.pascal}>> {`,
+        '    // Untrusted input is validated against the policy before it reaches the driver.',
+        `    return this.${names.camel}s.findAll(parseQuery(query, ${names.camel}QueryPolicy));`,
+        '  }',
+        '',
+        "  @Get(':id')",
+        `  findOne(@Param('id', ParseIntPipe) id: number): Promise<${names.pascal}> {`,
+        `    return this.${names.camel}s.findByIdOrFail(id);`,
+        '  }',
+        '',
+        "  @Patch(':id')",
+        '  update(',
+        "    @Param('id', ParseIntPipe) id: number,",
+        `    @Body() body: Update${names.pascal}Dto,`,
+        `  ): Promise<${names.pascal}> {`,
+        `    return this.${names.camel}s.update(id, body);`,
+        '  }',
+        '',
+        "  @Delete(':id')",
+        '  @HttpCode(204)',
+        "  remove(@Param('id', ParseIntPipe) id: number): Promise<void> {",
+        `    return this.${names.camel}s.delete(id);`,
+        '  }',
+        '}',
+        '',
+    ].join('\n');
+}
+function module_(names) {
+    return [
+        "import { Module } from '@nestjs/common';",
+        '',
+        `import { ${names.pascal}Controller } from './${names.kebab}.controller.js';`,
+        `import { ${names.pascal}Service } from './${names.kebab}.service.js';`,
+        '',
+        '@Module({',
+        `  controllers: [${names.pascal}Controller],`,
+        `  providers: [${names.pascal}Service],`,
+        `  exports: [${names.pascal}Service],`,
+        '})',
+        `export class ${names.pascal}Module {}`,
+        '',
+    ].join('\n');
+}
+function serviceSpec(names) {
+    return [
+        "import { describe, expect, it } from 'vitest';",
+        "import { MemoryRepository, MemoryUnitOfWork } from '@nage-api/data';",
+        "import { RequestContextService } from '@nage-api/core';",
+        '',
+        `import { ${names.pascal}Service } from './${names.kebab}.service.js';`,
+        `import type { ${names.pascal} } from './entities/${names.kebab}.entity.js';`,
+        '',
+        '/** The in-memory driver stands in for the database: no container needed. */',
+        `describe('${names.pascal}Service', () => {`,
+        '  const context = new RequestContextService();',
+        '',
+        '  const build = () => {',
+        '    const unitOfWork = new MemoryUnitOfWork();',
+        `    const repository = new MemoryRepository<${names.pascal}>('${names.pascal}', { unitOfWork });`,
+        `    return new ${names.pascal}Service(repository, unitOfWork);`,
+        '  };',
+        '',
+        "  it('should create and read back a record', async () => {",
+        '    const service = build();',
+        '',
+        "    const created = await context.run({ requestId: 'req-test-000001', startedAt: 0 }, () =>",
+        `      service.create({ name: 'First' } as never),`,
+        '    );',
+        '',
+        '    expect(created.id).toBeDefined();',
+        '  });',
+        '});',
+        '',
+    ].join('\n');
+}
+/**
+ * A literal body the generated DTO will accept.
+ *
+ * Built from the field list rather than hardcoded: the DTO validates exactly
+ * these fields and the global pipe rejects unknown properties, so a fixed
+ * `{ name: 'First' }` payload made the generated spec fail with a 422 for every
+ * resource whose fields were not called `name`.
+ */
+function sampleBody(fields, variant) {
+    const required = fields.filter((field) => !field.optional);
+    const chosen = required.length > 0 ? required : fields;
+    const suffix = variant === 'first' ? '' : ' Renamed';
+    const members = chosen.map((field) => {
+        switch (field.type) {
+            case 'number':
+                return `${field.name}: ${variant === 'first' ? '1' : '2'}`;
+            case 'boolean':
+                return `${field.name}: ${variant === 'first' ? 'true' : 'false'}`;
+            case 'date':
+                return `${field.name}: '2026-01-0${variant === 'first' ? '1' : '2'}T00:00:00.000Z'`;
+            case 'json':
+                return `${field.name}: { note: 'First${suffix}' }`;
+            default:
+                return `${field.name}: 'First${suffix}'`;
+        }
+    });
+    return `{ ${members.join(', ')} }`;
+}
+function e2eSpec(names, route, fields) {
+    return [
+        "import 'reflect-metadata';",
+        '',
+        "import { afterAll, beforeAll, describe, expect, it } from 'vitest';",
+        "import { Test } from '@nestjs/testing';",
+        "import type { INestApplication } from '@nestjs/common';",
+        "import { MemoryRepository, MemoryUnitOfWork, NageDataModule, registerModel } from '@nage-api/data';",
+        "import { NageCoreModule, enableQueryDsl } from '@nage-api/core';",
+        "import request from 'supertest';",
+        '',
+        `import { ${names.pascal}Module } from './${names.kebab}.module.js';`,
+        '',
+        '/** The generated CRUD contract: list DSL, pagination, soft delete, envelope. */',
+        `describe('${names.title} resource', () => {`,
+        '  let app: INestApplication;',
+        '',
+        '  beforeAll(async () => {',
+        '    const unitOfWork = new MemoryUnitOfWork();',
+        `    const repository = new MemoryRepository('${names.pascal}', { unitOfWork });`,
+        '',
+        '    const moduleRef = await Test.createTestingModule({',
+        '      imports: [',
+        '        NageCoreModule.forRoot({',
+        `          app: { name: 'test', environment: 'test' },`,
+        "          logging: { level: 'fatal' },",
+        '        }),',
+        '        // The same wiring a running app uses, with the in-memory driver',
+        '        // standing in for the real one. `NageDataModule` is @Global(), which',
+        '        // is what puts the repository token in reach of the service inside',
+        `        // ${names.pascal}Module — a provider declared on this testing module`,
+        '        // would not be, and `overrideProvider` cannot help because the',
+        '        // module declares no such provider to override.',
+        '        NageDataModule.forRoot({ unitOfWork }),',
+        `        NageDataModule.forFeature([registerModel('${names.pascal}', repository)]),`,
+        `        ${names.pascal}Module,`,
+        '      ],',
+        '    }).compile();',
+        '',
+        '    app = moduleRef.createNestApplication();',
+        '    // `createNestApplication` does not go through `bootstrap`, so the query',
+        '    // parser has to be enabled here too. Without it Express 5 leaves',
+        '    // `?where[x]=1` as a flat key and the list DSL silently does nothing.',
+        '    enableQueryDsl(app);',
+        '    await app.init();',
+        '  });',
+        '',
+        '  afterAll(async () => {',
+        '    await app.close();',
+        '  });',
+        '',
+        "  it('should create, list, read, update and delete', async () => {",
+        '    const created = await request(app.getHttpServer())',
+        `      .post('/${route}')`,
+        `      .send(${sampleBody(fields, 'first')})`,
+        '      .expect(201);',
+        '',
+        '    const id = created.body.data.id;',
+        '',
+        `    const list = await request(app.getHttpServer()).get('/${route}').expect(200);`,
+        '    expect(list.body.data).toHaveLength(1);',
+        '    expect(list.body.meta.pagination.count).toBe(1);',
+        '',
+        `    await request(app.getHttpServer()).get(\`/${route}/\${id}\`).expect(200);`,
+        '',
+        '    await request(app.getHttpServer())',
+        `      .patch(\`/${route}/\${id}\`)`,
+        `      .send(${sampleBody(fields, 'second')})`,
+        '      .expect(200);',
+        '',
+        `    await request(app.getHttpServer()).delete(\`/${route}/\${id}\`).expect(204);`,
+        '',
+        '    // Soft-deleted records leave the collection.',
+        `    const after = await request(app.getHttpServer()).get('/${route}').expect(200);`,
+        '    expect(after.body.data).toHaveLength(0);',
+        '  });',
+        '',
+        "  it('should reject a query field that is not allow-listed', async () => {",
+        '    await request(app.getHttpServer())',
+        `      .get('/${route}?where[secret]=1')`,
+        '      .expect(400);',
+        '  });',
+        '',
+        ...(fields.length > 0
+            ? [
+                "  it('should filter by an allow-listed field', async () => {",
+                '    // The positive half: a resource that refused every query would satisfy',
+                '    // the case above, and the DSL only earns its place if the allowed path',
+                '    // works. Filters on its own record rather than on whatever an earlier',
+                '    // test left behind, so the two cases cannot affect each other.',
+                `    const created = await request(app.getHttpServer())`,
+                `      .post('/${route}')`,
+                `      .send(${sampleBody(fields, 'second')})`,
+                '      .expect(201);',
+                '',
+                '    const filtered = await request(app.getHttpServer())',
+                `      .get('/${route}?where[${fields[0]?.name ?? 'id'}]=${filterValueFor(fields[0], 'second')}')`,
+                '      .expect(200);',
+                '',
+                '    expect(filtered.body.data).toHaveLength(1);',
+                '    expect(filtered.body.data[0].id).toBe(created.body.data.id);',
+                '  });',
+            ]
+            : []),
+        '});',
+        '',
+    ].join('\n');
+}
+/** The URL-encoded value that matches `sampleBody(fields, variant)` for a field. */
+function filterValueFor(field, variant) {
+    const second = variant === 'second';
+    if (field === undefined)
+        return second ? '2' : '1';
+    switch (field.type) {
+        case 'number':
+            return second ? '2' : '1';
+        case 'boolean':
+            return second ? 'false' : 'true';
+        case 'date':
+            return `2026-01-0${second ? '2' : '1'}T00%3A00%3A00.000Z`;
+        default:
+            // The sample body's second variant is "First Renamed"; a raw space in a
+            // query string is not a value the server will see intact.
+            return second ? 'First%20Renamed' : 'First';
+    }
+}
+function migration(names, fields, engine, stamp) {
+    if (engine === 'mongodb') {
+        return [
+            "import type { Migration } from '@nage-api/data';",
+            '',
+            '/** Collections are schemaless; this creates the indexes the resource needs. */',
+            'const migration: Migration = {',
+            `  id: '${stamp}',`,
+            `  name: 'create-${names.pluralKebab}',`,
+            '  up: async (context) => {',
+            `    // await context.createCollection('${names.pluralSnake}');`,
+            ...fields
+                .filter((field) => field.unique)
+                .map((field) => `    // await context.createIndex('${names.pluralSnake}', { ${field.name}: 1 }, { unique: true });`),
+            '  },',
+            '  down: async (context) => {',
+            `    // await context.dropCollection('${names.pluralSnake}');`,
+            '  },',
+            '};',
+            '',
+            'export default migration;',
+            '',
+        ].join('\n');
+    }
+    const columns = fields.map((field) => {
+        const parts = [`type: ${TYPE_MAP[field.type].column}`, `allowNull: ${String(field.optional)}`];
+        if (field.unique)
+            parts.push('unique: true');
+        return `      ${field.name}: { ${parts.join(', ')} },`;
+    });
+    return [
+        "import { DataTypes } from 'sequelize';",
+        "import type { Migration } from '@nage-api/data';",
+        "import type { Sequelize } from 'sequelize';",
+        '',
+        '/**',
+        ` * Creates the ${names.pluralSnake} table.`,
+        ' *',
+        ' * Reviewed and applied with `nage db migrate` — never `synchronize` (§14.2).',
+        ' */',
+        'const migration: Migration<Sequelize> = {',
+        `  id: '${stamp}',`,
+        `  name: 'create-${names.pluralKebab}',`,
+        '  up: async (sequelize) => {',
+        `    await sequelize.getQueryInterface().createTable('${names.pluralSnake}', {`,
+        '      id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },',
+        ...columns,
+        '      created_at: { type: DataTypes.STRING, allowNull: false },',
+        '      updated_at: { type: DataTypes.STRING, allowNull: false },',
+        '      created_by: { type: DataTypes.INTEGER, allowNull: true },',
+        '      updated_by: { type: DataTypes.INTEGER, allowNull: true },',
+        '      deleted_at: { type: DataTypes.STRING, allowNull: true },',
+        '      deleted_by: { type: DataTypes.INTEGER, allowNull: true },',
+        '    });',
+        '  },',
+        '  down: async (sequelize) => {',
+        `    await sequelize.getQueryInterface().dropTable('${names.pluralSnake}');`,
+        '  },',
+        '};',
+        '',
+        'export default migration;',
+        '',
+    ].join('\n');
+}
+/** `20260814T134512` — sorts chronologically and reads as a date. */
+function compactTimestamp(now = new Date()) {
+    return now
+        .toISOString()
+        .replace(/[-:]/g, '')
+        .replace(/\.\d+Z$/, '')
+        .replace('T', 'T');
+}
+//# sourceMappingURL=resource.template.js.map

package/dist/templates/workspace.template.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Workspace-level files emitted by `nage create` (PLAN.md §9.1).
+ *
+ * The generated workspace is monorepo-first: one lockfile, one CI pipeline, one
+ * set of tooling, seeded with a single app so the simple case stays simple.
+ * Everything here is production-shaped from the first commit — strict TypeScript,
+ * a CI workflow, Docker, and a `.env.example` documenting every variable — because
+ * retrofitting those onto a project that started loose rarely happens.
+ */
+import type { DatabaseDriver } from '@nage-api/contracts';
+import type { PlannedFile } from '../fs/file-tree.js';
+import { type WorkspaceManifest } from '../workspace/manifest.js';
+export interface WorkspaceTemplateInput {
+    readonly manifest: WorkspaceManifest;
+    readonly packageManager: 'pnpm' | 'npm' | 'yarn';
+}
+/** The driver package that matches the workspace engine (§14.1: one, never both). */
+export declare function driverPackageFor(engine: DatabaseDriver): string;
+export declare function workspaceFiles(input: WorkspaceTemplateInput): PlannedFile[];
+/** Deterministic JSON with a trailing newline, so regeneration is diff-free. */
+export declare function json(value: unknown): string;
+//# sourceMappingURL=workspace.template.d.ts.map