@pylonts/dsl 1.0.3 → 1.0.4

package/dist/dsl.d.ts

@@ -3,17 +3,23 @@ export interface SchemaBase {
     name: string;
     description?: string;
 }
+/** Field collection schemas (DB table vs DTO message); `type` is the discriminator */
+export interface CollectionSchemaBase extends SchemaBase {
+    type: string;
+}
 export interface BaseField {
     name: string;
     /** 显示名称（中文标签） */
     label?: string;
     /** 字段描述 */
     description?: string;
+    /** 业务语义码（如 'merchant_name'），驱动 mock 生成等下游消费 */
+    semantic?: string;
     optional?: boolean;
     readOnly?: boolean;
     default?: string;
     /** 所属 schema（db 或 dto） */
-    schema?: SchemaBase;
+    schema?: CollectionSchemaBase;
 }
 interface StringField extends BaseField {
     type: 'string';
@@ -90,7 +96,23 @@ export type ForeignKey = {
     fields: Field | Field[];
     references: Field | Field[];
 };
-export interface TableSchema extends SchemaBase {
+export interface TableSchemaOptions {
+    description?: string;
+    paginated?: boolean;
+    actor?: boolean;
+    generator?: string;
+    autoIncrement?: Field;
+    primaryKey?: Field | Field[];
+    indexes?: Index[];
+    foreignKeys?: Record<string, ForeignKey>;
+    /** 引用的实体短语（词典条目）：本表归属的实体；关联表等多实体场景不需要 */
+    phrase?: DictionaryEntry;
+    fields: Record<string, Field>;
+}
+export declare class TableSchema implements CollectionSchemaBase {
+    type: string;
+    name: string;
+    description?: string;
     /** 分页 */
     paginated?: boolean;
     /** 系统操作者（如小程序为 C 端用户，管理端为运营） */
@@ -106,6 +128,9 @@ export interface TableSchema extends SchemaBase {
     /** 引用的实体短语（词典条目）：本表归属的实体；关联表等多实体场景不需要 */
     phrase?: DictionaryEntry;
     fields: Record<string, Field>;
+    constructor(name: string, options: TableSchemaOptions);
+    /** True when the field is part of this table's primary key */
+    isPk(fieldRef: Field): boolean;
 }
 type FieldExtras<T extends Field> = Omit<T, 'name' | 'type' | 'jsType'>;
 export declare function stringField(extra?: FieldExtras<StringField>): StringField;
@@ -119,17 +144,5 @@ 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 defineTable(name: string, schema: {
-    description?: string;
-    paginated?: boolean;
-    actor?: boolean;
-    generator?: string;
-    autoIncrement?: Field;
-    primaryKey?: Field | Field[];
-    indexes?: Index[];
-    foreignKeys?: Record<string, ForeignKey>;
-    /** 引用的实体短语（词典条目） */
-    phrase?: DictionaryEntry;
-    fields: Record<string, Field>;
-}): TableSchema;
+export declare function defineTable(name: string, schema: TableSchemaOptions): TableSchema;
 export {};

package/dist/dsl.js

@@ -2,6 +2,7 @@
 // DSL field type definitions.
 // Shape: { type: <type name>, <extension fields> }
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableSchema = void 0;
 exports.defineEnum = defineEnum;
 exports.stringField = stringField;
 exports.textField = textField;
@@ -18,6 +19,48 @@ exports.defineTable = defineTable;
 function defineEnum(jsName, valueType, values) {
     return { jsName, valueType, values };
 }
+class TableSchema {
+    type = 'table';
+    name;
+    description;
+    /** 分页 */
+    paginated;
+    /** 系统操作者（如小程序为 C 端用户，管理端为运营） */
+    actor;
+    /** id 生成器 */
+    generator;
+    /** 自增主键字段 */
+    autoIncrement;
+    primaryKey;
+    indexes;
+    /** 外键，引用其他表的字段 */
+    foreignKeys;
+    /** 引用的实体短语（词典条目）：本表归属的实体；关联表等多实体场景不需要 */
+    phrase;
+    fields;
+    constructor(name, options) {
+        this.name = name;
+        this.description = options.description;
+        this.paginated = options.paginated;
+        this.actor = options.actor;
+        this.generator = options.generator;
+        this.autoIncrement = options.autoIncrement;
+        this.primaryKey = options.primaryKey;
+        this.indexes = options.indexes;
+        this.foreignKeys = options.foreignKeys;
+        this.phrase = options.phrase;
+        this.fields = options.fields;
+    }
+    /** True when the field is part of this table's primary key */
+    isPk(fieldRef) {
+        if (this.primaryKey === undefined)
+            return false;
+        return Array.isArray(this.primaryKey)
+            ? this.primaryKey.includes(fieldRef)
+            : this.primaryKey === fieldRef;
+    }
+}
+exports.TableSchema = TableSchema;
 function stringField(extra = {}) {
     return { name: '', type: 'string', jsType: 'string', ...extra };
 }
@@ -53,7 +96,7 @@ function enumField(extra) {
     return { name: '', type: 'enum', jsType, ...extra };
 }
 function defineTable(name, schema) {
-    const table = { name, ...schema };
+    const table = new TableSchema(name, schema);
     for (const key of Object.keys(table.fields)) {
         const field = table.fields[key];
         if (field.schema && field.schema !== table) {

package/dist/dto.d.ts

@@ -1,4 +1,4 @@
-import { BaseField, Field, SchemaBase, TableSchema } from './dsl';
+import { BaseField, CollectionSchemaBase, 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.
@@ -10,16 +10,14 @@ export interface ImportRef {
     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[];
+    /**
+     * Generic type arguments for the base schema (e.g. PageResult(OrderRow)).
+     * Two forms, both local DTOs:
+     *   string     — the DTO export name
+     *   DtoMessage — the DTO instance itself; the driver resolves it to its name
+     */
+    args?: (string | DtoMessage)[];
 }
-export type DtoExtras = {
-    pattern?: string;
-    /** 联合判断是否可选，定义后优先级高于 field.optional */
-    optional?: boolean;
-    /** 查询比较操作符（query 方向字段） */
-    operator?: Operator;
-};
 export type DtoArrayFieldDef = BaseField & {
     type: 'array';
     jsType: 'array';
@@ -30,21 +28,29 @@ export type DtoObjectFieldDef = BaseField & {
     jsType: 'object';
     properties: Record<string, DtoField>;
 };
-export declare class DtoField {
+export declare class DtoField implements SchemaBase {
     /** DTO 语义字段名（接口字段名），与 field.name（数据库列名）含义不同。
      *  构造时未知，由 buildMessage 从 map key 反写。 */
     name: string;
+    /** 字段描述 */
+    description?: string;
     /** 所属 DTO 容器（buildMessage 反写） */
     schema?: DtoMessage;
     field: Field | DtoArrayFieldDef | DtoObjectFieldDef;
     pattern?: string;
     optional?: boolean;
     operator?: Operator;
-    constructor(field: Field | DtoArrayFieldDef | DtoObjectFieldDef, extra?: DtoExtras);
+    /** TypeBox default annotation (API contract level); falls back to field.default (DB default) */
+    default?: unknown;
+    constructor(field: Field | DtoArrayFieldDef | DtoObjectFieldDef);
     setPattern(value: string): this;
+    setDescription(value: string): this;
+    getDescription(): string | undefined;
     setOptional(value: boolean): this;
+    /** Set a default value — emitted as a TypeBox schema default annotation */
+    setDefault(value: unknown): this;
     /** 查询比较操作符（query 方向字段）。Rule B: 查询字段恒为可选 */
-    op(value: Operator): this;
+    setOperator(value: Operator): this;
     /** optional 优先于 field.optional */
     isOptional(): boolean;
 }
@@ -56,23 +62,32 @@ export declare class DtoObjectField extends DtoField {
     field: DtoObjectFieldDef;
     properties(): Record<string, DtoField>;
 }
-export type DtoDirection = 'input' | 'output' | 'query' | 'pk';
-export interface DtoMessage extends SchemaBase {
+export declare enum DtoDirection {
+    Input = "input",
+    Output = "output",
+    Query = "query",
+    Pk = "pk"
+}
+export declare class DtoMessage implements CollectionSchemaBase {
+    type: string;
+    name: string;
+    description?: string;
     /** 方向：输入或输出 */
     direction: DtoDirection;
     fields: Record<string, DtoField>;
     /** TypeBox base schemas to intersect with at generation time (e.g. PageRequest) */
-    bases?: ImportRef[];
+    bases: ImportRef[];
+    constructor(name: string, direction: DtoDirection, fields: Record<string, DtoField>, description?: string);
     /** 引用已存在的 TypeBox base schema，例如 include({ from: '@pylonts/core', name: 'PageRequest' }) */
-    include(...refs: ImportRef[]): DtoMessage;
+    include(...refs: ImportRef[]): this;
 }
-export declare function dtoField(field: Field, extra?: DtoExtras): DtoField;
+export declare function dtoField(field: Field): DtoField;
 export declare function dtoArrayField(def: {
-    items: DtoField;
-} & Omit<BaseField, 'name'>, extra?: DtoExtras): DtoArrayField;
+    items: DtoField | DtoMessage;
+} & Omit<BaseField, 'name'>): DtoArrayField;
 export declare function dtoObjectField(def: {
     properties: Record<string, DtoField>;
-} & Omit<BaseField, 'name'>, extra?: DtoExtras): DtoObjectField;
+} & Omit<BaseField, 'name'>): 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;

package/dist/dto.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DtoObjectField = exports.DtoArrayField = exports.DtoField = void 0;
+exports.DtoMessage = exports.DtoDirection = exports.DtoObjectField = exports.DtoArrayField = exports.DtoField = void 0;
 exports.dtoField = dtoField;
 exports.dtoArrayField = dtoArrayField;
 exports.dtoObjectField = dtoObjectField;
@@ -9,35 +9,48 @@ exports.buildOutput = buildOutput;
 exports.buildQuery = buildQuery;
 exports.buildPk = buildPk;
 exports.from = from;
+const utils_1 = require("./utils");
 class DtoField {
     /** DTO 语义字段名（接口字段名），与 field.name（数据库列名）含义不同。
      *  构造时未知，由 buildMessage 从 map key 反写。 */
     name;
+    /** 字段描述 */
+    description;
     /** 所属 DTO 容器（buildMessage 反写） */
     schema;
     field;
     pattern;
     optional;
     operator;
-    constructor(field, extra = {}) {
+    /** TypeBox default annotation (API contract level); falls back to field.default (DB default) */
+    default;
+    constructor(field) {
         this.name = '';
         this.field = field;
-        this.pattern = extra.pattern;
-        this.optional = extra.optional;
-        this.operator = extra.operator;
     }
     setPattern(value) {
         this.pattern = value;
         return this;
     }
+    setDescription(value) {
+        this.description = value;
+        return this;
+    }
+    getDescription() {
+        return this.description;
+    }
     setOptional(value) {
         this.optional = value;
         return this;
     }
+    /** Set a default value — emitted as a TypeBox schema default annotation */
+    setDefault(value) {
+        this.default = value;
+        return this;
+    }
     /** 查询比较操作符（query 方向字段）。Rule B: 查询字段恒为可选 */
-    op(value) {
+    setOperator(value) {
         this.operator = value;
-        this.optional = true;
         return this;
     }
     /** optional 优先于 field.optional */
@@ -60,32 +73,50 @@ class DtoObjectField extends DtoField {
     }
 }
 exports.DtoObjectField = DtoObjectField;
-function dtoField(field, extra = {}) {
-    return new DtoField(field, extra);
+var DtoDirection;
+(function (DtoDirection) {
+    DtoDirection["Input"] = "input";
+    DtoDirection["Output"] = "output";
+    DtoDirection["Query"] = "query";
+    DtoDirection["Pk"] = "pk";
+})(DtoDirection || (exports.DtoDirection = DtoDirection = {}));
+class DtoMessage {
+    type = 'dto';
+    name;
+    description;
+    /** 方向：输入或输出 */
+    direction;
+    fields;
+    /** TypeBox base schemas to intersect with at generation time (e.g. PageRequest) */
+    bases = [];
+    constructor(name, direction, fields, description) {
+        this.name = name;
+        this.direction = direction;
+        this.fields = fields;
+        this.description = description;
+    }
+    /** 引用已存在的 TypeBox base schema，例如 include({ from: '@pylonts/core', name: 'PageRequest' }) */
+    include(...refs) {
+        this.bases.push(...refs);
+        return this;
+    }
+}
+exports.DtoMessage = DtoMessage;
+function dtoField(field) {
+    return new DtoField(field);
 }
-function dtoArrayField(def, extra = {}) {
-    return new DtoArrayField({ name: '', type: 'array', jsType: 'array', ...def }, extra);
+function dtoArrayField(def) {
+    // Reuse an existing DTO as the array element: expand its fields into an object.
+    const items = def.items instanceof DtoMessage
+        ? new DtoObjectField({ name: '', type: 'object', jsType: 'object', properties: def.items.fields })
+        : def.items;
+    return new DtoArrayField({ name: '', type: 'array', jsType: 'array', ...def, items });
 }
-function dtoObjectField(def, extra = {}) {
-    return new DtoObjectField({ name: '', type: 'object', jsType: 'object', ...def }, extra);
+function dtoObjectField(def) {
+    return new DtoObjectField({ name: '', type: 'object', jsType: 'object', ...def });
 }
 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;
-    }
+    const message = new DtoMessage(name, direction, fields, description);
     // 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)) {
@@ -103,16 +134,41 @@ function buildMessage(name, direction, fields, description) {
     return message;
 }
 function buildInput(name, fields, description) {
-    return buildMessage(name, 'input', fields, description);
+    const message = buildMessage(name, DtoDirection.Input, fields, description);
+    // Rule A — set optionality from the DB column rule (skips fields the author
+    // already set): nullable / default / auto-increment → optional, else required.
+    for (const field of Object.values(message.fields)) {
+        if (field.optional !== undefined)
+            continue;
+        const f = field.field;
+        if (f.schema?.type !== 'table')
+            continue;
+        const table = f.schema;
+        field.optional = f.optional !== false || f.default !== undefined || table.autoIncrement === f;
+    }
+    return message;
 }
 function buildOutput(name, fields, description) {
-    return buildMessage(name, 'output', fields, description);
+    return buildMessage(name, DtoDirection.Output, fields, description);
 }
 function buildQuery(name, fields, description) {
-    return buildMessage(name, 'query', fields, description);
+    const message = buildMessage(name, DtoDirection.Query, fields, description);
+    // Rule B: query/search fields are always optional.
+    for (const field of Object.values(message.fields))
+        field.optional = true;
+    return message;
 }
 function buildPk(name, fields, description) {
-    return buildMessage(name, 'pk', fields, description);
+    const message = buildMessage(name, DtoDirection.Pk, fields, description);
+    // Rule P: PK locator fields are required, other fields are optional.
+    for (const field of Object.values(message.fields)) {
+        if (field.optional !== undefined)
+            continue;
+        const f = field.field;
+        const table = f.schema;
+        field.optional = table !== undefined && table.isPk(f) ? false : true;
+    }
+    return message;
 }
 /** Pick columns from a built table and wrap them as DTO fields (aligned with dto.from). */
 function from(table, fields) {
@@ -121,7 +177,9 @@ function from(table, 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);
+        // DTO field name is camelCase (mer_id → merId); the underlying field.name
+        // stays snake_case (DB column).
+        out[(0, utils_1.toCamelCase)(field.name)] = dtoField(field);
     }
     return out;
 }

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './dsl';
 export * from './dto';
+export * from './utils';
 export * from './project';
 export * from './prototype';
 export * from './dictionary';

package/dist/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./dsl"), exports);
 __exportStar(require("./dto"), exports);
+__exportStar(require("./utils"), exports);
 __exportStar(require("./project"), exports);
 __exportStar(require("./prototype"), exports);
 __exportStar(require("./dictionary"), exports);

package/dist/mermaid-driver.js

@@ -47,9 +47,13 @@ function renderPageFlowMermaid(schema) {
     const ids = new Map();
     const byApp = new Map();
     for (const p of schema.pages) {
-        const list = byApp.get(p.app.name) ?? [];
-        list.push(p);
-        byApp.set(p.app.name, list);
+        const list = byApp.get(p.app.name);
+        if (!list) {
+            byApp.set(p.app.name, [p]);
+        }
+        else {
+            list.push(p);
+        }
     }
     let appIdx = 0;
     for (const [appName, pages] of byApp) {

package/dist/typebox-driver.d.ts

@@ -1,5 +1,11 @@
 import { DtoMessage, ImportRef } from './dto';
 export type EnumResolver = (enumName: string) => ImportRef | undefined;
+/** Collect all imports needed to render a DTO: include() bases + enum references. */
+export declare function collectDtoImports(schema: DtoMessage, resolver: EnumResolver | undefined, out: Map<string, ImportRef>): void;
+/** Render one DTO export (const + type) — no file header, for file-level generation. */
+export declare function renderDtoExport(schema: DtoMessage, resolver: EnumResolver | undefined): string;
+/** Render the Static type export for a DTO. */
+export declare function renderDtoTypeExport(name: string): string;
 export declare function renderDtoMessage(schema: DtoMessage, options?: {
     resolver?: EnumResolver;
     source?: string;

package/dist/typebox-driver.js

@@ -1,14 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectDtoImports = collectDtoImports;
+exports.renderDtoExport = renderDtoExport;
+exports.renderDtoTypeExport = renderDtoTypeExport;
 exports.renderDtoMessage = renderDtoMessage;
 const dto_1 = require("./dto");
 function renderString(s) {
     return `'${s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
 }
-function renderBasic(field, pattern, resolver) {
+function renderDefault(v) {
+    if (typeof v === 'string')
+        return renderString(v);
+    return JSON.stringify(v);
+}
+function renderBasic(field, pattern, defaultValue, resolver) {
     if (pattern !== undefined && field.type !== 'string') {
         throw new Error(`pattern is only supported on string fields, got ${field.type} (${field.name})`);
     }
+    const def = defaultValue !== undefined ? `default: ${renderDefault(defaultValue)}` : undefined;
     switch (field.type) {
         case 'string': {
             const opts = [];
@@ -18,16 +27,20 @@ function renderBasic(field, pattern, resolver) {
                 opts.push(`maxLength: ${field.maxLength}`);
             if (pattern !== undefined)
                 opts.push(`pattern: ${renderString(pattern)}`);
+            if (def !== undefined)
+                opts.push(def);
             return opts.length > 0 ? `Type.String({ ${opts.join(', ')} })` : 'Type.String()';
         }
         case 'text':
-            return 'Type.String()';
+            return def !== undefined ? `Type.String({ ${def} })` : 'Type.String()';
         case 'integer': {
             const opts = [];
             if (field.min !== undefined)
                 opts.push(`minimum: ${field.min}`);
             if (field.max !== undefined)
                 opts.push(`maximum: ${field.max}`);
+            if (def !== undefined)
+                opts.push(def);
             return opts.length > 0 ? `Type.Integer({ ${opts.join(', ')} })` : 'Type.Integer()';
         }
         case 'bigint':
@@ -37,15 +50,22 @@ function renderBasic(field, pattern, resolver) {
         case 'datetime':
             // Transmitted as string over HTTP: bigint/decimal keep full precision,
             // date/time serialize to string.
-            return 'Type.String()';
+            return def !== undefined ? `Type.String({ ${def} })` : 'Type.String()';
         case 'boolean':
-            return 'Type.Boolean()';
+            return def !== undefined ? `Type.Boolean({ ${def} })` : 'Type.Boolean()';
         case 'json':
-            return 'Type.Unknown()';
+            return def !== undefined ? `Type.Unknown({ ${def} })` : 'Type.Unknown()';
         case 'enum': {
             const ref = resolver?.(field.enum.jsName);
             if (!ref)
                 throw new Error(`enum field ${field.name}: no import ref for ${field.enum.jsName} — pass an EnumResolver`);
+            if (def !== undefined) {
+                const member = field.enum.values.find((v) => v.value === defaultValue);
+                if (!member) {
+                    throw new Error(`enum field ${field.name}: default ${renderDefault(defaultValue)} is not a member of ${field.enum.jsName}`);
+                }
+                return `Type.Enum(${ref.name}, { default: ${ref.name}.${member.symbol} })`;
+            }
             return `Type.Enum(${ref.name})`;
         }
         default:
@@ -70,7 +90,10 @@ function renderValue(f, indent, resolver) {
         return renderObject(f.properties(), indent + 1, resolver);
     }
     // DtoField only wraps a database Field; array/object defs live in the subclasses.
-    return renderBasic(f.field, f.pattern, resolver);
+    // DTO-level default wins over the DB field default; the DB default (string)
+    // is used as a fallback so from() picks carry it into the API contract.
+    const defaultValue = f.default !== undefined ? f.default : f.field.default;
+    return renderBasic(f.field, f.pattern, defaultValue, resolver);
 }
 function collectEnumImports(f, resolver, out) {
     if (f instanceof dto_1.DtoArrayField) {
@@ -89,34 +112,47 @@ function collectEnumImports(f, resolver, out) {
         out.set(`${ref.from}#${ref.name}`, ref);
     }
 }
+/** Collect all imports needed to render a DTO: include() bases + enum references. */
+function collectDtoImports(schema, resolver, out) {
+    for (const base of schema.bases ?? [])
+        out.set(`${base.from}#${base.name}`, base);
+    for (const f of Object.values(schema.fields))
+        collectEnumImports(f, resolver, out);
+}
+/** Render one DTO export (const + type) — no file header, for file-level generation. */
+function renderDtoExport(schema, resolver) {
+    const object = renderObject(schema.fields, 1, resolver);
+    const bases = schema.bases ?? [];
+    const body = bases.length > 0
+        ? `Type.Intersect([${bases.map(renderBase).join(', ')}, ${object}])`
+        : object;
+    return `export const ${schema.name} = ${body};`;
+}
+/** Render the Static type export for a DTO. */
+function renderDtoTypeExport(name) {
+    return `export type ${name} = Static<typeof ${name}>;`;
+}
 function renderDtoMessage(schema, options = {}) {
     const { resolver, source } = options;
     const imports = new Map();
-    for (const base of schema.bases ?? [])
-        imports.set(`${base.from}#${base.name}`, base);
-    for (const f of Object.values(schema.fields))
-        collectEnumImports(f, resolver, imports);
+    collectDtoImports(schema, resolver, imports);
     const header = [
         '// AUTO-GENERATED by typebox-driver — DO NOT EDIT',
         ...(source !== undefined ? [`// Source: ${source}`] : []),
         "import { Type, Static } from '@sinclair/typebox';",
         ...[...imports.values()].map((r) => `import { ${r.name} } from '${r.from}';`),
     ];
-    const object = renderObject(schema.fields, 1, resolver);
-    const bases = schema.bases ?? [];
-    const body = bases.length > 0
-        ? `Type.Intersect([${bases.map(renderBase).join(', ')}, ${object}])`
-        : object;
     return [
         ...header,
         '',
-        `export const ${schema.name} = ${body};`,
-        `export type ${schema.name} = Static<typeof ${schema.name}>;`,
+        renderDtoExport(schema, resolver),
+        renderDtoTypeExport(schema.name),
         '',
     ].join('\n');
 }
 function renderBase(base) {
-    return base.args !== undefined && base.args.length > 0
-        ? `${base.name}(${base.args.join(', ')})`
-        : base.name;
+    if (base.args === undefined || base.args.length === 0)
+        return base.name;
+    const args = base.args.map((a) => (typeof a === 'string' ? a : a.name));
+    return `${base.name}(${args.join(', ')})`;
 }

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+/** snake_case → camelCase: mer_id → merId; names without underscores are unchanged */
+export declare function toCamelCase(name: string): string;

package/dist/utils.js

@@ -0,0 +1,8 @@
+"use strict";
+// ── naming conversions ──
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCamelCase = toCamelCase;
+/** snake_case → camelCase: mer_id → merId; names without underscores are unchanged */
+function toCamelCase(name) {
+    return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}