@pylonts/dsl 1.0.6 → 1.1.1

package/dist/dsl.js

@@ -1,130 +1,39 @@
-"use strict";
 // 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;
-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.defineTable = defineTable;
-function defineEnum(jsName, valueType, values) {
+export 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 = {}) {
+export function stringField(extra = {}) {
     return { name: '', type: 'string', jsType: 'string', ...extra };
 }
-function textField(extra = {}) {
+export function textField(extra = {}) {
     return { name: '', type: 'text', jsType: 'string', ...extra };
 }
-function intField(extra = {}) {
+export function intField(extra = {}) {
     return { name: '', type: 'integer', jsType: 'number', ...extra };
 }
-function bigintField(extra = {}) {
+export function bigintField(extra = {}) {
     return { name: '', type: 'bigint', jsType: 'string', ...extra };
 }
-function decimalField(extra) {
+export function decimalField(extra) {
     return { name: '', type: 'decimal', jsType: 'string', ...extra };
 }
-function booleanField(extra = {}) {
+export function booleanField(extra = {}) {
     return { name: '', type: 'boolean', jsType: 'boolean', ...extra };
 }
-function dateField(extra = {}) {
+export function dateField(extra = {}) {
     return { name: '', type: 'date', jsType: 'Date', ...extra };
 }
-function timeField(extra = {}) {
+export function timeField(extra = {}) {
     return { name: '', type: 'time', jsType: 'string', ...extra };
 }
-function datetimeField(extra = {}) {
+export function datetimeField(extra = {}) {
     return { name: '', type: 'datetime', jsType: 'Date', ...extra };
 }
-function jsonField(extra = {}) {
+export function jsonField(extra = {}) {
     return { name: '', type: 'json', jsType: 'object', ...extra };
 }
-function enumField(extra) {
+export function enumField(extra) {
     const jsType = extra.enum.valueType === 'integer' ? 'number' : 'string';
     return { name: '', type: 'enum', jsType, ...extra };
 }
-function defineTable(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) {
-            throw new Error(`field ${key}: belongs to table ${field.schema.name}, cannot reuse in table ${table.name}`);
-        }
-    }
-    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];
-        const fields = Array.isArray(fk.fields) ? fk.fields : [fk.fields];
-        for (let i = 0; i < refs.length; i++) {
-            const ref = refs[i];
-            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}`);
-            const phrase = ref.schema.phrase;
-            if (!phrase)
-                throw new Error(`foreign key ${fkName}: referenced table ${ref.schema.name} has no phrase, cannot check field naming`);
-            const expected = `${phrase.name}_${ref.name}`;
-            const fkField = fields[i];
-            if (fkField.name !== expected) {
-                throw new Error(`foreign key ${fkName}: field must be named ${expected} (phrase ${phrase.name} + ${ref.name}), got ${fkField.name}`);
-            }
-        }
-    }
-    return table;
-}

package/dist/dto.d.ts

@@ -1,15 +1,18 @@
-import { BaseField, CollectionSchemaBase, Field, SchemaBase, TableSchema } from './dsl';
-export type Operator = 'eq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ne';
+import { BaseField, CollectionSchemaBase, Field, Operator, SchemaBase } from './dsl.js';
+import { TableSchema } from './db.js';
+import type { ImportBase } from './import-base.js';
+/** Re-export — Operator lives on the DSL level (see dsl.ts). */
+export type { Operator } from './dsl.js';
+/** Re-export — ImportBase lives on its own module (see import-base.ts). */
+export type { ImportBase } from './import-base.js';
+/** Re-export — MockDescriptor lives on its own module (see mock.ts). */
+export type { MockDescriptor } from './mock.js';
 /**
  * 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;
+export interface ImportRef extends ImportBase {
     /**
      * Generic type arguments for the base schema (e.g. PageResult(OrderRow)).
      * Two forms, both local DTOs:

package/dist/dto.js

@@ -1,16 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DtoMessage = exports.DtoDirection = 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;
-const utils_1 = require("./utils");
-class DtoField {
+import { toCamelCase } from './utils.js';
+export class DtoField {
     /** DTO 语义字段名（接口字段名），与 field.name（数据库列名）含义不同。
      *  构造时未知，由 buildMessage 从 map key 反写。 */
     name;
@@ -64,28 +53,25 @@ class DtoField {
         return this.field.optional ?? false;
     }
 }
-exports.DtoField = DtoField;
-class DtoArrayField extends DtoField {
+export class DtoArrayField extends DtoField {
     /** Element type: inline DtoField or a referenced DtoMessage (rendered by name). */
     items() {
         return this.field.items;
     }
 }
-exports.DtoArrayField = DtoArrayField;
-class DtoObjectField extends DtoField {
+export class DtoObjectField extends DtoField {
     properties() {
         return this.field.properties;
     }
 }
-exports.DtoObjectField = DtoObjectField;
-var DtoDirection;
+export var DtoDirection;
 (function (DtoDirection) {
     DtoDirection["Input"] = "input";
     DtoDirection["Output"] = "output";
     DtoDirection["Query"] = "query";
     DtoDirection["Pk"] = "pk";
-})(DtoDirection || (exports.DtoDirection = DtoDirection = {}));
-class DtoMessage {
+})(DtoDirection || (DtoDirection = {}));
+export class DtoMessage {
     type = 'dto';
     name;
     description;
@@ -106,16 +92,15 @@ class DtoMessage {
         return this;
     }
 }
-exports.DtoMessage = DtoMessage;
-function dtoField(field) {
+export function dtoField(field) {
     return new DtoField(field);
 }
-function dtoArrayField(def) {
+export function dtoArrayField(def) {
     // Items stay as-is: an inline DtoField is rendered inline, a DtoMessage is
     // referenced by name (the driver renders Type.Array(<DtoName>)).
     return new DtoArrayField({ name: '', type: 'array', jsType: 'array', ...def });
 }
-function dtoObjectField(def) {
+export function dtoObjectField(def) {
     return new DtoObjectField({ name: '', type: 'object', jsType: 'object', ...def });
 }
 function buildMessage(name, direction, fields, description) {
@@ -124,6 +109,11 @@ function buildMessage(name, direction, fields, description) {
     // are created per DTO, never shared).
     for (const key of Object.keys(message.fields)) {
         const df = message.fields[key];
+        if (!(df instanceof DtoField)) {
+            const got = df === null || df === undefined ? String(df) : `${df.constructor.name ?? typeof df}`;
+            throw new Error(`[dto] DTO "${name}" field "${key}" must be a DtoField (created with dtoField()/dtoArrayField()/dtoObjectField()), got ${got}. ` +
+                `Did you pass enumField(...) directly? Use dtoField(enumField({...})) instead.`);
+        }
         df.name = key;
         df.schema = message;
         // Custom (inline) fields are owned by this DTO: write back name + schema.
@@ -136,10 +126,11 @@ function buildMessage(name, direction, fields, description) {
     }
     return message;
 }
-function buildInput(name, fields, description) {
+export function buildInput(name, 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.
+    // already set): nullable / default → optional, else required.
+    // PK columns are always required.
     for (const field of Object.values(message.fields)) {
         if (field.optional !== undefined)
             continue;
@@ -147,21 +138,21 @@ function buildInput(name, fields, description) {
         if (f.schema?.type !== 'table')
             continue;
         const table = f.schema;
-        field.optional = f.optional !== false || f.default !== undefined || table.autoIncrement === f;
+        field.optional = table.isPk(f) ? false : f.optional !== false || f.default !== undefined;
     }
     return message;
 }
-function buildOutput(name, fields, description) {
+export function buildOutput(name, fields, description) {
     return buildMessage(name, DtoDirection.Output, fields, description);
 }
-function buildQuery(name, fields, description) {
+export function buildQuery(name, 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) {
+export function buildPk(name, 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)) {
@@ -174,7 +165,7 @@ function buildPk(name, fields, description) {
     return message;
 }
 /** Pick columns from a built table and wrap them as DTO fields (aligned with dto.from). */
-function from(table, fields) {
+export function from(table, fields) {
     const out = {};
     for (const field of fields) {
         if (field.schema !== table) {
@@ -182,7 +173,7 @@ function from(table, fields) {
         }
         // 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);
+        out[toCamelCase(field.name)] = dtoField(field);
     }
     return out;
 }

package/dist/enum-driver.d.ts

@@ -1,2 +1,2 @@
-import { EnumDef } from './dsl';
+import { EnumDef } from './dsl.js';
 export declare function renderEnum(def: EnumDef): string;

package/dist/enum-driver.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderEnum = renderEnum;
 // Enum driver: renders an EnumDef into a standalone TypeScript enum file.
 // Shape matches the generated-enum product consumed by the TypeBox driver (Type.Enum):
 //
@@ -23,7 +20,7 @@ function renderValue(value) {
 function labelName(jsName) {
     return `${jsName.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase()}_LABEL`;
 }
-function renderEnum(def) {
+export function renderEnum(def) {
     const name = def.jsName;
     const members = def.values.map((v) => `  ${v.symbol} = ${renderValue(v.value)},`);
     const labels = def.values.map((v) => `  [${name}.${v.symbol}]: ${renderString(v.label)},`);

package/dist/flow.d.ts

@@ -1,4 +1,4 @@
-import { SchemaBase } from './dsl';
+import { SchemaBase } from './dsl.js';
 export interface FlowNode extends SchemaBase {
     /** Optional sub-flow. When present, entering this node runs the sub-flow;
      *  after the sub-flow reaches any terminal node, the outer flow continues

package/dist/flow.js

@@ -1,16 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.node = node;
-exports.edge = edge;
-exports.defineFlow = defineFlow;
-function node(name, flow, description) {
+export function node(name, flow, description) {
     return { name, flow, description };
 }
-function edge(start, end, when, description) {
+export function edge(start, end, when, description) {
     // Auto name for uniformity with SchemaBase; `when` stays the branch marker.
     return { name: `${start.name}->${end.name}`, start, end, when, description };
 }
-function defineFlow(name, schema) {
+export function defineFlow(name, schema) {
     const seen = new Set();
     const nodes = [];
     for (const e of schema.edges) {

package/dist/import-base.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Reference to a named export from another module, by its import location.
+ * Serializable metadata: the driver renders `import { name } from 'from'`.
+ * Used for enum types and plain imports that need no generic arguments.
+ */
+export interface ImportBase {
+    /** Module specifier, e.g. '@pylonts/core' */
+    from: string;
+    /** Named export, e.g. 'PageRequest' */
+    name: string;
+    /** Type-only import (`import type`); defaults to a value import. */
+    type?: boolean;
+    /** Default import (`import X from '...'`) instead of named (`import { X }`). */
+    default?: boolean;
+}

package/dist/import-base.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -1,17 +1,21 @@
-export * from './dsl';
-export * from './dto';
-export * from './bases';
-export * from './utils';
-export * from './project';
-export * from './prototype';
-export * from './dictionary';
-export * from './mysql-driver';
-export * from './enum-driver';
-export * from './typebox-driver';
-export * from './check-inheritance';
-export * from './pattern';
-export * from './patterns/retry';
-export * from './flow';
-export * from './page';
-export * from './page-flow';
-export * from './mermaid-driver';
+export * from './dsl.js';
+export * from './db.js';
+export * from './mock.js';
+export * from './asset.js';
+export * from './dto.js';
+export * from './db-config.js';
+export * from './bases.js';
+export * from './utils.js';
+export * from './project.js';
+export * from './prototype.js';
+export * from './dictionary.js';
+export * from './mysql-driver.js';
+export * from './enum-driver.js';
+export * from './typebox-driver.js';
+export * from './pattern.js';
+export * from './patterns/retry.js';
+export * from './flow.js';
+export * from './page.js';
+export * from './curd.js';
+export * from './page-flow.js';
+export * from './mermaid-driver.js';

package/dist/index.js

@@ -1,33 +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("./bases"), exports);
-__exportStar(require("./utils"), exports);
-__exportStar(require("./project"), exports);
-__exportStar(require("./prototype"), exports);
-__exportStar(require("./dictionary"), exports);
-__exportStar(require("./mysql-driver"), exports);
-__exportStar(require("./enum-driver"), exports);
-__exportStar(require("./typebox-driver"), exports);
-__exportStar(require("./check-inheritance"), exports);
-__exportStar(require("./pattern"), exports);
-__exportStar(require("./patterns/retry"), exports);
-__exportStar(require("./flow"), exports);
-__exportStar(require("./page"), exports);
-__exportStar(require("./page-flow"), exports);
-__exportStar(require("./mermaid-driver"), exports);
+export * from './dsl.js';
+export * from './db.js';
+export * from './mock.js';
+export * from './asset.js';
+export * from './dto.js';
+export * from './db-config.js';
+export * from './bases.js';
+export * from './utils.js';
+export * from './project.js';
+export * from './prototype.js';
+export * from './dictionary.js';
+export * from './mysql-driver.js';
+export * from './enum-driver.js';
+export * from './typebox-driver.js';
+export * from './pattern.js';
+export * from './patterns/retry.js';
+export * from './flow.js';
+export * from './page.js';
+export * from './curd.js';
+export * from './page-flow.js';
+export * from './mermaid-driver.js';

package/dist/mermaid-driver.d.ts

@@ -1,4 +1,4 @@
-import { FlowSchema } from './flow';
-import { PageFlow } from './page-flow';
+import { FlowSchema } from './flow.js';
+import { PageFlow } from './page-flow.js';
 export declare function renderFlowMermaid(schema: FlowSchema): string;
 export declare function renderPageFlowMermaid(schema: PageFlow): string;

package/dist/mermaid-driver.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderFlowMermaid = renderFlowMermaid;
-exports.renderPageFlowMermaid = renderPageFlowMermaid;
 // Mermaid driver: converts a FlowSchema into a Mermaid flowchart (TD).
 // Node ids are hierarchical (n0, n0_0, n0_0_0, ...) so nested sub-flows stay
 // globally unique. A node with a sub-flow renders as a subgraph block whose
@@ -10,7 +6,7 @@ exports.renderPageFlowMermaid = renderPageFlowMermaid;
 function escapeLabel(s) {
     return s.replace(/"/g, '\\"').replace(/\n/g, '<br/>');
 }
-function renderFlowMermaid(schema) {
+export function renderFlowMermaid(schema) {
     const lines = ['flowchart TD'];
     const ids = new Map();
     renderFlow(schema, 'n', lines, ids);
@@ -42,7 +38,7 @@ function renderEdge(e, ids) {
 }
 // Page-driven flow renderer: groups pages by their app into swimlane
 // subgraphs, then renders edges across the whole flow.
-function renderPageFlowMermaid(schema) {
+export function renderPageFlowMermaid(schema) {
     const lines = ['flowchart TD'];
     const ids = new Map();
     const byApp = new Map();

package/dist/mock.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pure-data mock descriptor. Stored on DTO fields, consumed by gen-cli mock
+ * or runtime resolveMock. No function references — serializable and gen-readable.
+ *
+ * @example { fn: 'abc', count: 20 }
+ * @example { fn: 'amt', min: 10, max: 500 }
+ * @example { fn: 'phone' }
+ */
+export interface MockDescriptor {
+    fn: string;
+    [param: string]: unknown;
+}
+/**
+ * Result of a descriptor factory call: pure-data descriptor + lazy generator.
+ * generate is non-enumerable — JSON.stringify / spread won't pick it up.
+ */
+export interface MockSchema {
+    descriptor: MockDescriptor;
+    generate: () => unknown;
+}
+type Params = Record<string, unknown>;
+/**
+ * Define a mock descriptor factory.
+ *
+ * @param fn      mock function name (for descriptor & dispatch)
+ * @param resolve converts descriptor params to a no-arg generator
+ * @returns       (params?) => { descriptor, generate }
+ */
+export declare function defineMock(fn: string, resolve: (d: Params) => () => unknown): (params?: Params) => MockSchema;
+export {};

package/dist/mock.js

@@ -0,0 +1,18 @@
+/**
+ * Define a mock descriptor factory.
+ *
+ * @param fn      mock function name (for descriptor & dispatch)
+ * @param resolve converts descriptor params to a no-arg generator
+ * @returns       (params?) => { descriptor, generate }
+ */
+export function defineMock(fn, resolve) {
+    return (params) => {
+        const d = { fn, ...params };
+        const result = { descriptor: d };
+        Object.defineProperty(result, 'generate', {
+            value: resolve(d),
+            enumerable: false,
+        });
+        return result;
+    };
+}

package/dist/mysql-driver.d.ts

@@ -1,4 +1,4 @@
-import { TableSchema } from './dsl';
+import { TableSchema } from './db.js';
 export interface BuildCreateTableSqlOptions {
     /** 是否生成外键约束，默认 false（不生成） */
     generateForeignKeys?: boolean;

package/dist/mysql-driver.js

@@ -1,6 +1,3 @@
-"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) {
@@ -31,14 +28,27 @@ function columnType(field) {
             return 'JSON';
     }
 }
+function renderDefault(field) {
+    if (field.default === undefined)
+        return '';
+    // CURRENT_TIMESTAMP is a MySQL function keyword, not a string literal.
+    if (field.default === 'CURRENT_TIMESTAMP')
+        return ' DEFAULT CURRENT_TIMESTAMP';
+    // Numeric columns take a bare literal, not a quoted one.
+    if (field.type === 'integer' || field.type === 'bigint' || field.type === 'decimal' || field.type === 'boolean') {
+        return ` DEFAULT ${field.default}`;
+    }
+    return ` DEFAULT '${field.default}'`;
+}
 function columnDef(field, autoIncrement) {
     const parts = [field.name, columnType(field)];
     if (field.optional === false)
         parts.push('NOT NULL');
-    if (field.default !== undefined)
-        parts.push(`DEFAULT '${field.default}'`);
+    parts.push(renderDefault(field));
     if (field === autoIncrement)
         parts.push('AUTO_INCREMENT');
+    if (field.description)
+        parts.push(`COMMENT '${field.description.replace(/'/g, "\\'")}'`);
     return parts.join(' ');
 }
 function primaryKeyClause(schema) {
@@ -48,13 +58,13 @@ function primaryKeyClause(schema) {
     return `PRIMARY KEY (${fields.map((f) => f.name).join(', ')})`;
 }
 function indexClause(index) {
-    const fields = Array.isArray(index.fields) ? index.fields : [index.fields];
+    const fields = Array.isArray(index.columns) ? index.columns : [index.columns];
     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 foreignKeyClause(name, fk) {
-    const fields = Array.isArray(fk.fields) ? fk.fields : [fk.fields];
+    const fields = Array.isArray(fk.columns) ? fk.columns : [fk.columns];
     const refs = Array.isArray(fk.references) ? fk.references : [fk.references];
     const refTable = refs[0].schema?.name;
     if (!refTable)
@@ -63,8 +73,8 @@ function foreignKeyClause(name, fk) {
     const refCols = refs.map((r) => r.name).join(', ');
     return `CONSTRAINT \`${name}\` FOREIGN KEY (${fkCols}) REFERENCES \`${refTable}\` (${refCols})`;
 }
-function buildCreateTableSql(schema, options = {}) {
-    const lines = Object.values(schema.fields).map((field) => columnDef(field, schema.autoIncrement));
+export function buildCreateTableSql(schema, options = {}) {
+    const lines = Object.values(schema.columns).map((field) => columnDef(field, schema.autoIncrement));
     const pk = primaryKeyClause(schema);
     if (pk)
         lines.push(pk);
@@ -75,5 +85,5 @@ function buildCreateTableSql(schema, options = {}) {
             lines.push(foreignKeyClause(name, fk));
         }
     }
-    return `CREATE TABLE \`${schema.name}\` (\n  ${lines.join(',\n  ')}\n);`;
+    return `CREATE TABLE IF NOT EXISTS \`${schema.name}\` (\n  ${lines.join(',\n  ')}\n);`;
 }

package/dist/page-flow.d.ts

@@ -1,5 +1,5 @@
-import { SchemaBase } from './dsl';
-import { ActionSchema, Page } from './page';
+import { SchemaBase } from './dsl.js';
+import { ActionSchema, Page } from './page.js';
 export interface PageEdge extends SchemaBase {
     /** Trigger action; undefined = default path (success/normal). */
     when?: ActionSchema;