ts-mysql-ddl 1.0.0

package/README.md

@@ -0,0 +1,323 @@
+# ts-mysql-ddl — MySQL Schema DSL
+
+## 概述
+
+`ts-mysql-ddl` 是一个 TypeScript DSL，用于以纯 TS 代码定义 MySQL 数据表结构，直接生成 DDL SQL。它是数据库结构的唯一事实来源（Single Source of Truth），同时为 mock 数据生成提供类型信息。
+
+## 架构设计
+
+| 层 | 文件 | 职责 |
+|---|---|---|
+| 类型系统 | `mysql-type.ts` | MysqlType 枚举 + 类型守卫 |
+| 列定义 | `column-def.ts` | ColumnDef 联合类型（按 type 分支锁参数） |
+| 列引用 | `column-ref.ts` | ColumnRef 类 + `col()` 工厂 |
+| 表定义 | `table-def.ts` | TableSchema / ForeignKey / IndexDef 接口 |
+| 工厂 | `define-table.ts` | `defineTable(name, input)` → TableSchema |
+| DDL 生成 | `generate-ddl.ts` | `generateDdl(tables)` → SQL string |
+| 自动扫描 | `scan-tables.ts` | `scanTables(dir)` 自动发现 `*.table.ts` |
+
+## 核心类型
+
+### MysqlType
+
+枚举定义 MySQL 数据类型家族，每个家族对应一组编译期校验的参数：
+
+```
+INT / TINYINT / SMALLINT / BIGINT   → autoIncrement, default(number), enumRef
+DECIMAL                               → precision, scale, default(string)
+VARCHAR / CHAR                        → length, default(string), enumRef
+TEXT                                   → (无额外参数)
+DATE                                   → (无额外参数)
+DATETIME / TIMESTAMP                   → default('CURRENT_TIMESTAMP' only)
+```
+
+所有类型通用参数：`primaryKey`, `index`, `unique`, `comment`, `deleted`
+
+### ColumnDef 联合类型
+
+```ts
+type ColumnDef = IntColumn | DecimalColumn | StringColumn | TextColumn | DateColumn | DateTimeColumn
+```
+
+每个接口按 type 分支限制参数，编译期拦截非法组合：
+
+- IntColumn: 不能有 `length`, `precision`, `scale`
+- StringColumn: 不能有 `autoIncrement`, `precision`
+- DateTimeColumn: `default` 只能是 `'CURRENT_TIMESTAMP'`
+
+### EnumShape
+
+```ts
+type EnumShape = Record<string, string | number>
+```
+
+表示代码层面的枚举（非 MySQL ENUM），DDL 中存 int/string。由 `enumRef` 字段引用真实 TS 枚举，供 mock 生成使用。
+
+### ColumnRef
+
+```ts
+class ColumnRef {
+  readonly def: ColumnDef;         // 列定义
+  _table: string = '';             // 所属表名（由 defineTable/registerColumns 设置）
+  _column: string = '';            // 列名（由 defineTable/registerColumns 设置）
+  toString(): string               // 返回 _column，未初始化时返回 '?'
+}
+```
+
+`_table` / `_column` 是 identity 字段，由以下时机回填：
+- `defineTable()` 调用时
+- `scanTables()` 的 Phase 1 阶段
+
+**关键约束**：ColumnRef 创建时 identity 为空。两阶段初始化确保在所有 FK 引用解析前，所有列的 identity 已设置完成。
+
+## 使用方式
+
+### 方式一：手动编排（适用于少量表）
+
+```ts
+import { MysqlType, col, defineTable, generateDdl } from '@fastify-api/ts-mysql-ddl';
+
+const merchantCols = {
+  id:   col({ type: MysqlType.VARCHAR, length: 12, primaryKey: true }),
+  name: col({ type: MysqlType.VARCHAR, length: 100 }),
+};
+const merchant = defineTable('merchant', { columns: merchantCols, comment: 'Merchant' });
+
+const orderCols = {
+  id:     col({ type: MysqlType.INT, autoIncrement: true }),
+  mer_id: col({ type: MysqlType.VARCHAR, length: 20 }),
+  status: col({ type: MysqlType.VARCHAR, length: 20, enumRef: OrderStatus }),
+};
+const order = defineTable('order', {
+  columns: orderCols,
+  indexes: [{ columns: [orderCols.status, orderCols.deleted] }],
+  foreignKeys: {
+    fk_order_merchant: { columns: [orderCols.mer_id], ref: merchant.cols.id, onDelete: 'CASCADE' },
+  },
+});
+
+const sql = generateDdl([merchant, order]);
+```
+
+### 方式二：自动扫描（推荐）
+
+按文件命名约定组织 `*.table.ts` 文件：
+
+```
+schema/
+├── merchant.table.ts
+├── order.table.ts
+├── coupon.table.ts
+└── ...
+```
+
+每个文件只需导出数据，不调 `defineTable`：
+
+```ts
+// schema/order.table.ts
+import { col, MysqlType } from '@fastify-api/ts-mysql-ddl';
+import { columns as merchant } from './merchant.table';
+
+export const columns = { ... };          // Record<string, ColumnRef> 必需
+export const indexes = [...];            // IndexDef[] 可选
+export const foreignKeys = { ... };      // Record<string, ForeignKey> 可选
+export const primaryKey = ...;          // ColumnRef | ColumnRef[] 可选
+export const comment = '...';           // string 可选
+```
+
+扫描：
+
+```ts
+const tables = await scanTables('./schema');
+const sql = generateDdl(tables);
+```
+
+表名从文件名推导：`order.table.ts` → `order`。
+
+`scanTables()` 使用两阶段初始化：
+1. **Phase 1**：遍历所有模块，逐列回填 `_table` / `_column`（此时所有 ColumnRef 获得 identity）
+2. **Phase 2**：为每个模块调 `defineTable()` 构建完整 TableSchema
+
+因此 FK 引用（`ref: merchant.id`）无论文件加载顺序如何，都能正确解析。
+
+## 外键引用模式
+
+### 直接引用（不同表）
+
+```ts
+import { columns as merchant } from './merchant.table';
+
+export const foreignKeys = {
+  fk_order_merchant: {
+    columns: [columns.mer_id],
+    ref: merchant.id,           // ColumnRef 直接引用
+    onDelete: 'CASCADE',
+  },
+};
+```
+
+### 懒引用（自引用/循环引用）
+
+```ts
+export const foreignKeys = {
+  fk_category_parent: {
+    columns: [columns.parent_id],
+    ref: () => columns.id,      // 延迟求值，避免循环依赖
+    onDelete: 'CASCADE',
+  },
+};
+```
+
+当 `ref` 是 `() => ColumnRef` 时，DDL 生成阶段再求值。
+
+### 复合外键
+
+```ts
+export const foreignKeys = {
+  fk_order_detail_product: {
+    columns: [columns.sku_id, columns.tenant_id],
+    ref: product.columns,        // 注意：此处需要确认是否支持复合 FK → 见下方约束
+  },
+};
+```
+
+**当前约束**：复合 FK 的 `ref` 语法暂未定型，当前仅支持单列 FK。
+
+## 索引与约束
+
+### 单列索引（在列定义中）
+
+```ts
+col({ type: MysqlType.VARCHAR, length: 20, index: true })
+// → KEY `idx_status` (`status`)
+```
+
+### 单列唯一（在列定义中）
+
+```ts
+col({ type: MysqlType.VARCHAR, length: 50, unique: true })
+// → UNIQUE KEY `uk_name` (`name`)
+```
+
+### 复合索引
+
+```ts
+indexes: [
+  { columns: [columns.status, columns.deleted] },
+  // → KEY `idx_status_deleted` (`status`, `deleted`)
+]
+```
+
+### 复合唯一
+
+```ts
+indexes: [
+  { columns: [columns.user_id, columns.order_no], unique: true },
+  // → UNIQUE KEY `uk_user_id_order_no` (`user_id`, `order_no`)
+]
+```
+
+### 命名规则
+
+| 来源 | 自动命名规则 |
+|---|---|
+| 列级 `index: true` | `idx_{column}` |
+| 列级 `unique: true` | `uk_{column}` |
+| 复合索引（未提供 name） | `idx_{col1}_{col2}_...` |
+| 复合唯一（未提供 name） | `uk_{col1}_{col2}_...` |
+
+如需自定义索引名，设置 `IndexDef.name`：
+
+```ts
+{ columns: [columns.status, columns.deleted], name: 'idx_order_status' }
+```
+
+## 列定义完整参数
+
+### 整数类型（INT / TINYINT / SMALLINT / BIGINT）
+
+| 参数 | 类型 | 说明 |
+|---|---|---|
+| type | IntMysqlType | 必需 |
+| autoIncrement | boolean | 可选 |
+| primaryKey | boolean | 可选（简写，也可在表级声明） |
+| index | boolean | 可选，生成单列索引 |
+| unique | boolean | 可选，生成唯一索引 |
+| default | number | 可选 |
+| comment | string | 可选 |
+| enumRef | EnumShape | 可选，代码级枚举引用 |
+| deleted | boolean | 可选，标识为软删除字段 |
+
+### 小数类型（DECIMAL）
+
+| 参数 | 类型 | 说明 |
+|---|---|---|
+| type | 'DECIMAL' | 必需 |
+| precision | number | 必需 |
+| scale | number | 必需 |
+| default | string | 可选（如 `'0.00'`） |
+| comment | string | 可选 |
+| enumRef | EnumShape | 可选 |
+
+### 字符串类型（VARCHAR / CHAR）
+
+| 参数 | 类型 | 说明 |
+|---|---|---|
+| type | StringMysqlType | 必需 |
+| length | number | VARCHAR 必需，CHAR 必需 |
+| primaryKey | boolean | 可选 |
+| index | boolean | 可选 |
+| unique | boolean | 可选 |
+| default | string | 可选 |
+| comment | string | 可选 |
+| enumRef | EnumShape | 可选 |
+| deleted | boolean | 可选 |
+
+### 文本类型（TEXT）
+
+| 参数 | 类型 | 说明 |
+|---|---|---|
+| type | 'TEXT' | 必需 |
+| comment | string | 可选 |
+
+### 日期时间类型（DATETIME / TIMESTAMP）
+
+| 参数 | 类型 | 说明 |
+|---|---|---|
+| type | DateTimeMysqlType | 必需 |
+| default | 'CURRENT_TIMESTAMP' | 可选 |
+| comment | string | 可选 |
+
+### 日期类型（DATE）
+
+| 参数 | 类型 | 说明 |
+|---|---|---|
+| type | 'DATE' | 必需 |
+| comment | string | 可选 |
+
+## DDL 生成
+
+`generateDdl(tables: TableSchema[])` 输出 SQL：
+
+- 每个表生成 `CREATE TABLE IF NOT EXISTS`
+- 默认 ENGINE=InnoDB, CHARSET=utf8mb4
+- 按表定义顺序输出，以 `-- 表注释` 的 SQL 注释分隔
+- 外键自动推导引用表/列的标识
+
+## 编译期校验
+
+- 列定义：按 type 分支锁定合法参数（如 VARCHAR 不能设 autoIncrement）
+- 列引用：`primaryKey` / `indexes.columns` / `foreignKeys.columns` 只能用 ColumnRef 对象，不能字符串
+- 外键引用：`ref` 必须是 ColumnRef 或 `() => ColumnRef`
+- 可选导出：`scanTables` 对缺少 `columns` 导出的文件输出警告并跳过
+
+## 开发指南
+
+```bash
+# 类型检查
+cd ts-mysql-ddl
+npm run typecheck
+
+# tsx 运行测试
+npx tsx test-scan/verify.ts
+```

package/bin/ts-mysql-ddl.cjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * CLI wrapper: delegates to the TypeScript entry via tsx.
+ * tsx is required as a peer dependency.
+ */
+const { spawnSync } = require('node:child_process');
+const { resolve } = require('node:path');
+
+const cli = resolve(__dirname, '..', 'src', 'cli.ts');
+
+const result = spawnSync('npx', ['tsx', cli, ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  shell: true,
+});
+
+process.exit(result.status ?? 1);

package/dist/build.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Build schema: scan *.table.ts directory → generate DDL → optionally write to file.
+ *
+ * Usage:
+ *   const sql = await buildSchema({ schemaDir: './schema' });
+ *   await buildSchema({ schemaDir: './schema', outFile: './001_init.sql' });
+ */
+export interface BuildSchemaOptions {
+    /** Directory to scan for *.table.ts files */
+    schemaDir: string;
+    /** Optional output file path — writes generated SQL if provided */
+    outFile?: string;
+}
+/**
+ * Scan schema directory, resolve FK dependency order, generate DDL.
+ * Optionally writes result to `outFile`.
+ * Returns the generated SQL string.
+ */
+export declare function buildSchema(options: BuildSchemaOptions): Promise<string>;

package/dist/build.js

@@ -0,0 +1,53 @@
+/**
+ * Build schema: scan *.table.ts directory → generate DDL → optionally write to file.
+ *
+ * Usage:
+ *   const sql = await buildSchema({ schemaDir: './schema' });
+ *   await buildSchema({ schemaDir: './schema', outFile: './001_init.sql' });
+ */
+import { writeFileSync } from 'node:fs';
+import { scanTables } from './scan-tables.js';
+import { generateDdl } from './generate-ddl.js';
+/** Topological sort by FK dependency — referenced tables come first */
+function sortByDependency(tables) {
+    const byName = new Map(tables.map(t => [t._schema.name, t]));
+    const visited = new Set();
+    const sorted = [];
+    function visit(name) {
+        if (visited.has(name))
+            return;
+        visited.add(name);
+        const table = byName.get(name);
+        if (!table)
+            return;
+        // Visit FK refs first
+        const fks = table._schema.foreignKeys;
+        if (fks) {
+            for (const fk of Object.values(fks)) {
+                const ref = typeof fk.ref === 'function' ? fk.ref() : fk.ref;
+                if (ref._table && ref._table !== name) {
+                    visit(ref._table);
+                }
+            }
+        }
+        sorted.push(table);
+    }
+    for (const t of tables)
+        visit(t._schema.name);
+    return sorted;
+}
+/**
+ * Scan schema directory, resolve FK dependency order, generate DDL.
+ * Optionally writes result to `outFile`.
+ * Returns the generated SQL string.
+ */
+export async function buildSchema(options) {
+    const { schemaDir, outFile } = options;
+    const tables = sortByDependency(await scanTables(schemaDir));
+    const sql = generateDdl(tables);
+    if (outFile) {
+        writeFileSync(outFile, sql + '\n', 'utf-8');
+        console.log(`Generated ${tables.length} tables → ${outFile}`);
+    }
+    return sql;
+}

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env tsx
+/**
+ * CLI for ts-mysql-ddl: scan *.table.ts → generate DDL → write SQL file.
+ *
+ * Usage:
+ *   ts-mysql-ddl --src ./schema --dest ./001_init.sql
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env tsx
+/**
+ * CLI for ts-mysql-ddl: scan *.table.ts → generate DDL → write SQL file.
+ *
+ * Usage:
+ *   ts-mysql-ddl --src ./schema --dest ./001_init.sql
+ */
+import { buildSchema } from './build.js';
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let src = '';
+    let dest = '';
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--src' && i + 1 < args.length) {
+            src = args[++i];
+        }
+        if (arg === '--dest' && i + 1 < args.length) {
+            dest = args[++i];
+        }
+    }
+    if (!src)
+        throw new Error('Missing required flag: --src <schema_dir>');
+    if (!dest)
+        throw new Error('Missing required flag: --dest <output_file>');
+    return { src, dest };
+}
+const { src, dest } = parseArgs();
+await buildSchema({ schemaDir: src, outFile: dest });

package/dist/column-def.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Column definition — discriminated union by MysqlType.
+ *
+ * Each type family only allows the parameters that make sense for that type.
+ * Compile-time errors if you try to use `length` on INT or `autoIncrement` on VARCHAR.
+ */
+interface BaseColumn {
+    nullable?: boolean;
+    comment?: string;
+}
+/** Any TypeScript enum value — string or numeric */
+export type EnumShape = Record<string, string | number>;
+export interface IntColumn extends BaseColumn {
+    type: typeof import('./mysql-type').MysqlType.TINYINT | typeof import('./mysql-type').MysqlType.SMALLINT | typeof import('./mysql-type').MysqlType.INT | typeof import('./mysql-type').MysqlType.BIGINT;
+    autoIncrement?: true;
+    primaryKey?: true;
+    default?: number;
+    enumRef?: EnumShape;
+    index?: boolean;
+    unique?: boolean;
+}
+export interface DecimalColumn extends BaseColumn {
+    type: typeof import('./mysql-type').MysqlType.DECIMAL;
+    precision: number;
+    scale: number;
+    default?: string;
+}
+export interface StringColumn extends BaseColumn {
+    type: typeof import('./mysql-type').MysqlType.CHAR | typeof import('./mysql-type').MysqlType.VARCHAR;
+    length: number;
+    enumRef?: EnumShape;
+    primaryKey?: true;
+    default?: string;
+    index?: boolean;
+    unique?: boolean;
+}
+export interface TextColumn extends BaseColumn {
+    type: typeof import('./mysql-type').MysqlType.TEXT;
+}
+export interface DateColumn extends BaseColumn {
+    type: typeof import('./mysql-type').MysqlType.DATE;
+    default?: 'CURRENT_TIMESTAMP';
+}
+export interface DateTimeColumn extends BaseColumn {
+    type: typeof import('./mysql-type').MysqlType.DATETIME | typeof import('./mysql-type').MysqlType.TIMESTAMP;
+    default?: 'CURRENT_TIMESTAMP';
+}
+export type ColumnDef = IntColumn | DecimalColumn | StringColumn | TextColumn | DateColumn | DateTimeColumn;
+/** Get the SQL type name with parameters, e.g. "VARCHAR(100)" or "DECIMAL(10,2)" */
+export declare function columnSqlType(def: ColumnDef): string;
+export {};

package/dist/column-def.js

@@ -0,0 +1,29 @@
+/**
+ * Column definition — discriminated union by MysqlType.
+ *
+ * Each type family only allows the parameters that make sense for that type.
+ * Compile-time errors if you try to use `length` on INT or `autoIncrement` on VARCHAR.
+ */
+// ── Helpers ──
+function isIntType(t) {
+    return t === 'TINYINT' || t === 'SMALLINT' || t === 'INT' || t === 'BIGINT';
+}
+function isStringType(t) {
+    return t === 'CHAR' || t === 'VARCHAR';
+}
+/** Get the SQL type name with parameters, e.g. "VARCHAR(100)" or "DECIMAL(10,2)" */
+export function columnSqlType(def) {
+    const t = def.type;
+    if (isIntType(t))
+        return t;
+    if (t === 'DECIMAL') {
+        const d = def;
+        return `${t}(${d.precision},${d.scale})`;
+    }
+    if (isStringType(t)) {
+        const d = def;
+        return `${t}(${d.length})`;
+    }
+    // TEXT, DATE, DATETIME, TIMESTAMP — no params
+    return t;
+}

package/dist/column-ref.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ColumnRef — a column definition that also carries its table/column identity.
+ *
+ * Created via `col()` factory, identity is set by `defineTable()`.
+ * `toString()` enables use in template literals:
+ *   name: `idx_${columns.status}`
+ */
+import type { ColumnDef } from './column-def';
+export declare class ColumnRef {
+    /** Underlying column definition (immutable) */
+    readonly def: ColumnDef;
+    /** Table name — set by defineTable() */
+    _table: string;
+    /** Column name — set by defineTable() */
+    _column: string;
+    constructor(def: ColumnDef);
+    /** For template literals: `idx_${col}` → "idx_status" */
+    toString(): string;
+}
+/**
+ * Factory to create a ColumnRef from a ColumnDef.
+ *
+ * Usage:
+ *   const columns = {
+ *     id:     col({ type: MysqlType.INT, autoIncrement: true }),
+ *     name:   col({ type: MysqlType.VARCHAR, length: 50 }),
+ *     status: col({ type: MysqlType.VARCHAR, length: 20 }),
+ *   };
+ */
+export declare function col(def: ColumnDef): ColumnRef;

package/dist/column-ref.js

@@ -0,0 +1,35 @@
+/**
+ * ColumnRef — a column definition that also carries its table/column identity.
+ *
+ * Created via `col()` factory, identity is set by `defineTable()`.
+ * `toString()` enables use in template literals:
+ *   name: `idx_${columns.status}`
+ */
+export class ColumnRef {
+    /** Underlying column definition (immutable) */
+    def;
+    /** Table name — set by defineTable() */
+    _table = '';
+    /** Column name — set by defineTable() */
+    _column = '';
+    constructor(def) {
+        this.def = def;
+    }
+    /** For template literals: `idx_${col}` → "idx_status" */
+    toString() {
+        return this._column || '?';
+    }
+}
+/**
+ * Factory to create a ColumnRef from a ColumnDef.
+ *
+ * Usage:
+ *   const columns = {
+ *     id:     col({ type: MysqlType.INT, autoIncrement: true }),
+ *     name:   col({ type: MysqlType.VARCHAR, length: 50 }),
+ *     status: col({ type: MysqlType.VARCHAR, length: 20 }),
+ *   };
+ */
+export function col(def) {
+    return new ColumnRef(def);
+}

package/dist/define-table.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Factory that creates a TableSchema from column refs and metadata.
+ *
+ * Input columns are ColumnRef objects (created via `col()`).
+ * defineTable sets their _table and _column identity.
+ *
+ * Usage:
+ *   const columns = {
+ *     id:   col({ type: MysqlType.VARCHAR, length: 12, primaryKey: true }),
+ *     name: col({ type: MysqlType.VARCHAR, length: 100 }),
+ *   };
+ *
+ *   export const merchant = defineTable('merchant', { columns });
+ *
+ *   export const coupon = defineTable('coupon', {
+ *     columns: {
+ *       mer_id: col({ type: MysqlType.VARCHAR, length: 20 }),
+ *     },
+ *     foreignKeys: {
+ *       fk_coupon_merchant: {
+ *         columns: [columns.mer_id],
+ *         ref: merchant.columns.id,
+ *       },
+ *     },
+ *   });
+ */
+import { ColumnRef } from './column-ref';
+import type { TableSchema, ForeignKey, IndexDef } from './table-def';
+export interface DefineTableInput {
+    columns: Record<string, ColumnRef>;
+    primaryKey?: ColumnRef | ColumnRef[];
+    foreignKeys?: Record<string, ForeignKey>;
+    indexes?: IndexDef[];
+    comment?: string;
+}
+export declare function defineTable(name: string, input: DefineTableInput): TableSchema;

package/dist/define-table.js

@@ -0,0 +1,50 @@
+/**
+ * Factory that creates a TableSchema from column refs and metadata.
+ *
+ * Input columns are ColumnRef objects (created via `col()`).
+ * defineTable sets their _table and _column identity.
+ *
+ * Usage:
+ *   const columns = {
+ *     id:   col({ type: MysqlType.VARCHAR, length: 12, primaryKey: true }),
+ *     name: col({ type: MysqlType.VARCHAR, length: 100 }),
+ *   };
+ *
+ *   export const merchant = defineTable('merchant', { columns });
+ *
+ *   export const coupon = defineTable('coupon', {
+ *     columns: {
+ *       mer_id: col({ type: MysqlType.VARCHAR, length: 20 }),
+ *     },
+ *     foreignKeys: {
+ *       fk_coupon_merchant: {
+ *         columns: [columns.mer_id],
+ *         ref: merchant.columns.id,
+ *       },
+ *     },
+ *   });
+ */
+export function defineTable(name, input) {
+    const colDefs = {};
+    const refs = {};
+    for (const [colName, colRef] of Object.entries(input.columns)) {
+        // Set column identity on the ref
+        colRef._table = name;
+        colRef._column = colName;
+        colDefs[colName] = colRef.def;
+        refs[colName] = colRef;
+    }
+    const internal = {
+        name,
+        columns: colDefs,
+    };
+    if (input.primaryKey)
+        internal.primaryKey = input.primaryKey;
+    if (input.foreignKeys)
+        internal.foreignKeys = input.foreignKeys;
+    if (input.indexes)
+        internal.indexes = input.indexes;
+    if (input.comment)
+        internal.comment = input.comment;
+    return { _schema: internal, columns: refs };
+}