@pylonts/dsl 1.0.0

package/README.md

@@ -0,0 +1,94 @@
+# @pylonts/dsl
+
+Schema 定义与产物生成分离的 DSL 系统：先写 DSL 元数据（表 / DTO），再由 driver 翻译成目标产物（SQL、TS 枚举、TypeBox 源码）。
+
+## 结构
+
+```
+dsl/
+├── src/
+│   ├── dsl.ts            # 表 / 字段定义 + builder（stringField / intField / buildTable …）
+│   ├── dto.ts            # 接口层：buildInput / buildOutput / buildQuery / buildPk / from / include / op
+│   ├── mysql-driver.ts   # 表 → CREATE TABLE SQL
+│   ├── enum-driver.ts    # 枚举字段 → TS enum + LABEL 映射源码
+│   └── typebox-driver.ts # DTO → TypeBox 源码（fastify v5 校验）
+└── package.json
+```
+
+## 核心概念：driver 模式
+
+DSL 定义元数据，driver 翻译成目标语言产物。产物与定义解耦，同一份定义可生成不同目标：
+
+| 定义 | Driver | 产物 | 消费方 |
+|---|---|---|---|
+| `TableSchema` | mysql-driver | `CREATE TABLE` | MySQL |
+| `EnumField` | enum-driver | `export enum Xxx { … }` + `XXX_LABEL` | 业务代码 |
+| `DtoMessage` | typebox-driver | `Type.Object({…})` + `Static` 推导 | fastify v5 参数校验 |
+
+## 用法
+
+### 定义表
+
+```ts
+import { bigintField, buildTable, decimalField, stringField } from './src/dsl';
+
+const id = bigintField({ readOnly: true, label: '主键' });
+const merId = bigintField({ label: '商户' });
+
+export const order = buildTable('order', {
+  description: '订单',
+  generator: 'auto_increment',
+  fields: {
+    id,
+    order_no: stringField({ label: '订单号', maxLength: 32, optional: false }),
+    mer_id: merId,
+    amount: decimalField({ precision: 18, scale: 2, label: '金额' }),
+  },
+  primaryKey: id,
+  indexes: [{ fields: merId }],
+});
+```
+
+### 定义 DTO（四种方向）
+
+```ts
+import { buildInput, buildPk, buildQuery, dtoField, from } from './src/dto';
+
+// 输入：新增订单
+buildInput('OrderAddRequest', { ...from(order, [order.fields.mer_id, order.fields.amount]) });
+
+// 输出：订单行
+buildOutput('OrderRow', from(order, [order.fields.id, order.fields.order_no]));
+
+// 查询：分页 + 过滤（query 字段恒为可选，.op() 声明比较操作符）
+buildQuery('OrderPageQuery', {
+  keyword: dtoField(stringField({ maxLength: 32 })).op('like'),
+  ...from(order, [order.fields.mer_id]),
+}).include({ from: '@pylonts/core', name: 'PageRequest' });
+
+// 主键：按 id 取详情
+buildPk('OrderDetailRequest', from(order, [order.fields.id]));
+```
+
+### 生成产物
+
+```ts
+import { buildCreateTableSql } from './src/mysql-driver';
+import { renderEnum } from './src/enum-driver';
+import { renderDtoMessage } from './src/typebox-driver';
+
+buildCreateTableSql(order);                                  // SQL
+renderEnum(statusField);                                    // TS enum 源码
+renderDtoMessage(orderPageQuery, {
+  source: 'dto_schema/order/order.dsl.dto.ts',
+  resolver: (name) => ({ from: '@mall/enums/user', name }), // 枚举引用解析
+});
+```
+
+## 关键语义
+
+- **字段两层名**：`DtoField.name` 是接口字段名（DTO 容器 map key 反写）；`field.name` 是数据库列名（buildTable 反写）。`from()` 提取的字段共享表 Field 实例，`name/schema` 保持指向表，不会被 DTO 覆盖。
+- **可选性优先级**：DTO 层 `optional` 优先于字段层 `optional`；query 方向所有字段强制可选（Rule B）。
+- **枚举外部引用**：枚举由 enum-driver 生成独立文件，typebox-driver 只渲染 `Type.Enum(名称)` + import 引用，不内联。
+- **HTTP 传 string**：bigint / decimal / date / time 在接口层渲染为 `Type.String()`，保证精度与序列化语义。
+- **继承分页**：`.include({ from, name, args })` 渲染 `Type.Intersect([PageRequest, Type.Object({…})])`。

package/dist/dsl.d.ts

@@ -0,0 +1,121 @@
+export interface SchemaBase {
+    name: string;
+    description?: string;
+}
+export interface BaseField {
+    name: string;
+    /** 显示名称（中文标签） */
+    label?: string;
+    /** 字段描述 */
+    description?: string;
+    optional?: boolean;
+    readOnly?: boolean;
+    default?: string;
+    /** 所属 schema（db 或 dto） */
+    schema?: SchemaBase;
+}
+interface StringField extends BaseField {
+    type: 'string';
+    jsType: 'string';
+    minLength?: number;
+    maxLength?: number;
+}
+interface TextField extends BaseField {
+    type: 'text';
+    jsType: 'string';
+}
+interface IntField extends BaseField {
+    type: 'integer';
+    jsType: 'number';
+    min?: number;
+    max?: number;
+}
+interface BigintField extends BaseField {
+    type: 'bigint';
+    jsType: 'string';
+}
+interface DecimalField extends BaseField {
+    type: 'decimal';
+    jsType: 'string';
+    precision: number;
+    scale: number;
+}
+interface BooleanField extends BaseField {
+    type: 'boolean';
+    jsType: 'boolean';
+}
+interface DateField extends BaseField {
+    type: 'date';
+    jsType: 'Date';
+}
+interface TimeField extends BaseField {
+    type: 'time';
+    jsType: 'string';
+}
+interface DateTimeField extends BaseField {
+    type: 'datetime';
+    jsType: 'Date';
+}
+export interface EnumValue {
+    value: string | number;
+    symbol: string;
+    label: string;
+}
+export interface EnumField extends BaseField {
+    type: 'enum';
+    jsType: 'string' | 'number';
+    valueType: 'string' | 'integer';
+    /** JS 定义名称，如 MerchantStatus */
+    jsName?: string;
+    values: EnumValue[];
+}
+interface JsonField extends BaseField {
+    type: 'json';
+    jsType: 'object';
+}
+export type Field = StringField | TextField | IntField | BigintField | DecimalField | BooleanField | DateField | TimeField | DateTimeField | EnumField | JsonField;
+export type Index = {
+    name?: string;
+    fields: Field | Field[];
+    unique?: boolean;
+};
+export type ForeignKey = {
+    fields: Field | Field[];
+    references: Field | Field[];
+};
+export interface TableSchema extends SchemaBase {
+    /** 分页 */
+    paginated?: boolean;
+    /** 系统操作者（如小程序为 C 端用户，管理端为运营） */
+    actor?: boolean;
+    /** id 生成器 */
+    generator?: string;
+    primaryKey?: Field | Field[];
+    indexes?: Index[];
+    /** 外键，引用其他表的字段 */
+    foreignKeys?: Record<string, ForeignKey>;
+    fields: Record<string, Field>;
+}
+type FieldExtras<T extends Field> = Omit<T, 'name' | 'type' | 'jsType'>;
+export declare function stringField(extra?: FieldExtras<StringField>): StringField;
+export declare function textField(extra?: FieldExtras<TextField>): TextField;
+export declare function intField(extra?: FieldExtras<IntField>): IntField;
+export declare function bigintField(extra?: FieldExtras<BigintField>): BigintField;
+export declare function decimalField(extra: FieldExtras<DecimalField>): DecimalField;
+export declare function booleanField(extra?: FieldExtras<BooleanField>): BooleanField;
+export declare function dateField(extra?: FieldExtras<DateField>): DateField;
+export declare function timeField(extra?: FieldExtras<TimeField>): TimeField;
+export declare function datetimeField(extra?: FieldExtras<DateTimeField>): DateTimeField;
+export declare function jsonField(extra?: FieldExtras<JsonField>): JsonField;
+export declare function enumField(extra: Omit<EnumField, 'name' | 'type' | 'jsType'>): EnumField;
+export declare function buildTable(name: string, schema: {
+    description?: string;
+    paginated?: boolean;
+    actor?: boolean;
+    generator?: string;
+    primaryKey?: Field | Field[];
+    indexes?: Index[];
+    foreignKeys?: Record<string, ForeignKey>;
+    fields: Record<string, Field>;
+}): TableSchema;
+export {};

package/dist/dsl.js

@@ -0,0 +1,67 @@
+"use strict";
+// DSL field type definitions.
+// Shape: { type: <type name>, <extension fields> }
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringField = stringField;
+exports.textField = textField;
+exports.intField = intField;
+exports.bigintField = bigintField;
+exports.decimalField = decimalField;
+exports.booleanField = booleanField;
+exports.dateField = dateField;
+exports.timeField = timeField;
+exports.datetimeField = datetimeField;
+exports.jsonField = jsonField;
+exports.enumField = enumField;
+exports.buildTable = buildTable;
+function stringField(extra = {}) {
+    return { name: '', type: 'string', jsType: 'string', ...extra };
+}
+function textField(extra = {}) {
+    return { name: '', type: 'text', jsType: 'string', ...extra };
+}
+function intField(extra = {}) {
+    return { name: '', type: 'integer', jsType: 'number', ...extra };
+}
+function bigintField(extra = {}) {
+    return { name: '', type: 'bigint', jsType: 'string', ...extra };
+}
+function decimalField(extra) {
+    return { name: '', type: 'decimal', jsType: 'string', ...extra };
+}
+function booleanField(extra = {}) {
+    return { name: '', type: 'boolean', jsType: 'boolean', ...extra };
+}
+function dateField(extra = {}) {
+    return { name: '', type: 'date', jsType: 'Date', ...extra };
+}
+function timeField(extra = {}) {
+    return { name: '', type: 'time', jsType: 'string', ...extra };
+}
+function datetimeField(extra = {}) {
+    return { name: '', type: 'datetime', jsType: 'Date', ...extra };
+}
+function jsonField(extra = {}) {
+    return { name: '', type: 'json', jsType: 'object', ...extra };
+}
+function enumField(extra) {
+    const jsType = extra.valueType === 'integer' ? 'number' : 'string';
+    return { name: '', type: 'enum', jsType, ...extra };
+}
+function buildTable(name, schema) {
+    const table = { name, ...schema };
+    for (const key of Object.keys(table.fields)) {
+        table.fields[key].name = key;
+        table.fields[key].schema = table;
+    }
+    for (const [fkName, fk] of Object.entries(table.foreignKeys ?? {})) {
+        const refs = Array.isArray(fk.references) ? fk.references : [fk.references];
+        for (const ref of refs) {
+            if (!ref.schema)
+                throw new Error(`foreign key ${fkName}: references field has no schema`);
+            if (ref.schema === table)
+                throw new Error(`foreign key ${fkName}: cannot reference own table ${table.name}`);
+        }
+    }
+    return table;
+}

package/dist/dto.d.ts

@@ -0,0 +1,81 @@
+import { BaseField, Field, SchemaBase, TableSchema } from './dsl';
+export type Operator = 'eq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ne';
+/**
+ * Reference to an existing TypeBox base schema by its import location.
+ * Serializable metadata: the driver renders `import { name } from 'from'`
+ * and `Type.Intersect([name, ...])` — the runtime schema is never loaded by the DSL.
+ */
+export interface ImportRef {
+    /** Module specifier, e.g. '@pylonts/core' */
+    from: string;
+    /** Named export, e.g. 'PageRequest' */
+    name: string;
+    /** Generic type arguments for the base schema (same-file DTO export names), e.g. PageResult(AdvertRow) */
+    args?: string[];
+}
+export type DtoExtras = {
+    pattern?: string;
+    /** 联合判断是否可选，定义后优先级高于 field.optional */
+    optional?: boolean;
+    /** 查询比较操作符（query 方向字段） */
+    operator?: Operator;
+};
+export type DtoArrayFieldDef = BaseField & {
+    type: 'array';
+    jsType: 'array';
+    items: DtoField;
+};
+export type DtoObjectFieldDef = BaseField & {
+    type: 'object';
+    jsType: 'object';
+    properties: Record<string, DtoField>;
+};
+export declare class DtoField {
+    /** DTO 语义字段名（接口字段名），与 field.name（数据库列名）含义不同。
+     *  构造时未知，由 buildMessage 从 map key 反写。 */
+    name: string;
+    /** 所属 DTO 容器（buildMessage 反写） */
+    schema?: DtoMessage;
+    field: Field | DtoArrayFieldDef | DtoObjectFieldDef;
+    pattern?: string;
+    optional?: boolean;
+    operator?: Operator;
+    constructor(field: Field | DtoArrayFieldDef | DtoObjectFieldDef, extra?: DtoExtras);
+    setPattern(value: string): this;
+    setOptional(value: boolean): this;
+    /** 查询比较操作符（query 方向字段）。Rule B: 查询字段恒为可选 */
+    op(value: Operator): this;
+    /** optional 优先于 field.optional */
+    isOptional(): boolean;
+}
+export declare class DtoArrayField extends DtoField {
+    field: DtoArrayFieldDef;
+    items(): DtoField;
+}
+export declare class DtoObjectField extends DtoField {
+    field: DtoObjectFieldDef;
+    properties(): Record<string, DtoField>;
+}
+export type DtoDirection = 'input' | 'output' | 'query' | 'pk';
+export interface DtoMessage extends SchemaBase {
+    /** 方向：输入或输出 */
+    direction: DtoDirection;
+    fields: Record<string, DtoField>;
+    /** TypeBox base schemas to intersect with at generation time (e.g. PageRequest) */
+    bases?: ImportRef[];
+    /** 引用已存在的 TypeBox base schema，例如 include({ from: '@pylonts/core', name: 'PageRequest' }) */
+    include(...refs: ImportRef[]): DtoMessage;
+}
+export declare function dtoField(field: Field, extra?: DtoExtras): DtoField;
+export declare function dtoArrayField(def: {
+    items: DtoField;
+} & Omit<BaseField, 'name'>, extra?: DtoExtras): DtoArrayField;
+export declare function dtoObjectField(def: {
+    properties: Record<string, DtoField>;
+} & Omit<BaseField, 'name'>, extra?: DtoExtras): DtoObjectField;
+export declare function buildInput(name: string, fields: Record<string, DtoField>, description?: string): DtoMessage;
+export declare function buildOutput(name: string, fields: Record<string, DtoField>, description?: string): DtoMessage;
+export declare function buildQuery(name: string, fields: Record<string, DtoField>, description?: string): DtoMessage;
+export declare function buildPk(name: string, fields: Record<string, DtoField>, description?: string): DtoMessage;
+/** Pick columns from a built table and wrap them as DTO fields (aligned with dto.from). */
+export declare function from(table: TableSchema, fields: Field[]): Record<string, DtoField>;

package/dist/dto.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtoObjectField = exports.DtoArrayField = exports.DtoField = void 0;
+exports.dtoField = dtoField;
+exports.dtoArrayField = dtoArrayField;
+exports.dtoObjectField = dtoObjectField;
+exports.buildInput = buildInput;
+exports.buildOutput = buildOutput;
+exports.buildQuery = buildQuery;
+exports.buildPk = buildPk;
+exports.from = from;
+class DtoField {
+    /** DTO 语义字段名（接口字段名），与 field.name（数据库列名）含义不同。
+     *  构造时未知，由 buildMessage 从 map key 反写。 */
+    name;
+    /** 所属 DTO 容器（buildMessage 反写） */
+    schema;
+    field;
+    pattern;
+    optional;
+    operator;
+    constructor(field, extra = {}) {
+        this.name = '';
+        this.field = field;
+        this.pattern = extra.pattern;
+        this.optional = extra.optional;
+        this.operator = extra.operator;
+    }
+    setPattern(value) {
+        this.pattern = value;
+        return this;
+    }
+    setOptional(value) {
+        this.optional = value;
+        return this;
+    }
+    /** 查询比较操作符（query 方向字段）。Rule B: 查询字段恒为可选 */
+    op(value) {
+        this.operator = value;
+        this.optional = true;
+        return this;
+    }
+    /** optional 优先于 field.optional */
+    isOptional() {
+        if (this.optional !== undefined)
+            return this.optional;
+        return this.field.optional ?? false;
+    }
+}
+exports.DtoField = DtoField;
+class DtoArrayField extends DtoField {
+    items() {
+        return this.field.items;
+    }
+}
+exports.DtoArrayField = DtoArrayField;
+class DtoObjectField extends DtoField {
+    properties() {
+        return this.field.properties;
+    }
+}
+exports.DtoObjectField = DtoObjectField;
+function dtoField(field, extra = {}) {
+    return new DtoField(field, extra);
+}
+function dtoArrayField(def, extra = {}) {
+    return new DtoArrayField({ name: '', type: 'array', jsType: 'array', ...def }, extra);
+}
+function dtoObjectField(def, extra = {}) {
+    return new DtoObjectField({ name: '', type: 'object', jsType: 'object', ...def }, extra);
+}
+function buildMessage(name, direction, fields, description) {
+    const message = {
+        name,
+        direction,
+        description,
+        fields,
+        bases: [],
+        include(...refs) {
+            this.bases.push(...refs);
+            return this;
+        },
+    };
+    if (direction === 'query') {
+        // Rule B: query/search fields are always optional.
+        for (const field of Object.values(message.fields))
+            field.optional = true;
+    }
+    // Write back the DTO field name from the map key (safe: DtoField instances
+    // are created per DTO, never shared).
+    for (const key of Object.keys(message.fields)) {
+        const df = message.fields[key];
+        df.name = key;
+        df.schema = message;
+        // Custom (inline) fields are owned by this DTO: write back name + schema.
+        // Fields picked via from() share the database Field instance whose
+        // name/schema already point to the table — leave them untouched.
+        if (df.field.schema === undefined) {
+            df.field.name = key;
+            df.field.schema = message;
+        }
+    }
+    return message;
+}
+function buildInput(name, fields, description) {
+    return buildMessage(name, 'input', fields, description);
+}
+function buildOutput(name, fields, description) {
+    return buildMessage(name, 'output', fields, description);
+}
+function buildQuery(name, fields, description) {
+    return buildMessage(name, 'query', fields, description);
+}
+function buildPk(name, fields, description) {
+    return buildMessage(name, 'pk', fields, description);
+}
+/** Pick columns from a built table and wrap them as DTO fields (aligned with dto.from). */
+function from(table, fields) {
+    const out = {};
+    for (const field of fields) {
+        if (field.schema !== table) {
+            throw new Error(`dto.from(${table.name}): field ${field.name} does not belong to this table`);
+        }
+        out[field.name] = dtoField(field);
+    }
+    return out;
+}

package/dist/enum-driver.d.ts

@@ -0,0 +1,2 @@
+import { EnumField } from './dsl';
+export declare function renderEnum(field: EnumField): string;

package/dist/enum-driver.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderEnum = renderEnum;
+// Enum driver: renders an EnumField into a standalone TypeScript enum file.
+// Shape matches the generated-enum product consumed by the TypeBox driver (Type.Enum):
+//
+//   export enum UserStatus {
+//     ACTIVE = 'ACTIVE',
+//     DISABLED = 'DISABLED',
+//   }
+//
+//   export const USER_STATUS_LABEL: Record<UserStatus, string> = {
+//     [UserStatus.ACTIVE]: '启用',
+//     [UserStatus.DISABLED]: '禁用',
+//   };
+function renderString(s) {
+    return `'${s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+function renderValue(value) {
+    return typeof value === 'number' ? String(value) : renderString(value);
+}
+/** 'UserStatus' → 'USER_STATUS_LABEL' (matches the label map naming convention) */
+function labelName(jsName) {
+    return `${jsName.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase()}_LABEL`;
+}
+function renderEnum(field) {
+    if (!field.jsName)
+        throw new Error(`enum field ${field.name} requires jsName to render`);
+    const name = field.jsName;
+    const members = field.values.map((v) => `  ${v.symbol} = ${renderValue(v.value)},`);
+    const labels = field.values.map((v) => `  [${name}.${v.symbol}]: ${renderString(v.label)},`);
+    return [
+        `export enum ${name} {`,
+        ...members,
+        '}',
+        '',
+        `export const ${labelName(name)}: Record<${name}, string> = {`,
+        ...labels,
+        '};',
+        '',
+    ].join('\n');
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './dsl';
+export * from './dto';
+export * from './mysql-driver';
+export * from './enum-driver';
+export * from './typebox-driver';

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dsl"), exports);
+__exportStar(require("./dto"), exports);
+__exportStar(require("./mysql-driver"), exports);
+__exportStar(require("./enum-driver"), exports);
+__exportStar(require("./typebox-driver"), exports);

package/dist/mysql-driver.d.ts

@@ -0,0 +1,2 @@
+import { TableSchema } from './dsl';
+export declare function buildCreateTableSql(schema: TableSchema): string;

package/dist/mysql-driver.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCreateTableSql = buildCreateTableSql;
+// MySQL driver: converts a TableSchema into a CREATE TABLE statement.
+function columnType(field) {
+    switch (field.type) {
+        case 'string':
+            if (!field.maxLength)
+                throw new Error(`field ${field.name} (string) requires maxLength`);
+            return `VARCHAR(${field.maxLength})`;
+        case 'text':
+            return 'TEXT';
+        case 'integer':
+            return 'INT';
+        case 'bigint':
+            return 'BIGINT';
+        case 'decimal':
+            return `DECIMAL(${field.precision}, ${field.scale})`;
+        case 'boolean':
+            return 'TINYINT(1)';
+        case 'date':
+            return 'DATE';
+        case 'time':
+            return 'TIME';
+        case 'datetime':
+            return 'DATETIME';
+        case 'enum':
+            // Enum is stored as a plain column: string -> VARCHAR(20), integer -> TINYINT.
+            return field.valueType === 'integer' ? 'TINYINT' : 'VARCHAR(20)';
+        case 'json':
+            return 'JSON';
+    }
+}
+function columnDef(field) {
+    const parts = [field.name, columnType(field)];
+    if (field.optional === false)
+        parts.push('NOT NULL');
+    if (field.default !== undefined)
+        parts.push(`DEFAULT '${field.default}'`);
+    return parts.join(' ');
+}
+function primaryKeyClause(schema) {
+    if (!schema.primaryKey)
+        return null;
+    const fields = Array.isArray(schema.primaryKey) ? schema.primaryKey : [schema.primaryKey];
+    return `PRIMARY KEY (${fields.map((f) => f.name).join(', ')})`;
+}
+function indexClause(index) {
+    const fields = Array.isArray(index.fields) ? index.fields : [index.fields];
+    const kind = index.unique ? 'UNIQUE KEY' : 'KEY';
+    const name = index.name ?? fields.map((f) => f.name).join('_');
+    return `${kind} ${name} (${fields.map((f) => f.name).join(', ')})`;
+}
+function buildCreateTableSql(schema) {
+    const lines = Object.values(schema.fields).map(columnDef);
+    const pk = primaryKeyClause(schema);
+    if (pk)
+        lines.push(pk);
+    for (const index of schema.indexes ?? [])
+        lines.push(indexClause(index));
+    return `CREATE TABLE \`${schema.name}\` (\n  ${lines.join(',\n  ')}\n);`;
+}

package/dist/typebox-driver.d.ts

@@ -0,0 +1,6 @@
+import { DtoMessage, ImportRef } from './dto';
+export type EnumResolver = (enumName: string) => ImportRef | undefined;
+export declare function renderDtoMessage(schema: DtoMessage, options?: {
+    resolver?: EnumResolver;
+    source?: string;
+}): string;