@pylonts/dsl 1.0.5 → 1.1.1

package/src/mysql-driver.ts

@@ -1,4 +1,5 @@
-import { Field, ForeignKey, Index, TableSchema } from './dsl';
+import { Field } from './dsl.js';
+import { ForeignKey, Index, TableSchema } from './db.js';
 
 // MySQL driver: converts a TableSchema into a CREATE TABLE statement.
 
@@ -31,11 +32,23 @@ function columnType(field: Field): string {
   }
 }
 
+function renderDefault(field: Field): string {
+  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: Field, autoIncrement?: Field): string {
   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(' ');
 }
 
@@ -46,14 +59,14 @@ function primaryKeyClause(schema: TableSchema): string | null {
 }
 
 function indexClause(index: Index): string {
-  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: string, fk: ForeignKey): string {
-  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) throw new Error(`foreign key ${name}: references field has no schema`);
@@ -68,7 +81,7 @@ export interface BuildCreateTableSqlOptions {
 }
 
 export function buildCreateTableSql(schema: TableSchema, options: BuildCreateTableSqlOptions = {}): string {
-  const lines = Object.values(schema.fields).map((field) => columnDef(field, schema.autoIncrement));
+  const lines = Object.values(schema.columns).map((field) => columnDef(field, schema.autoIncrement));
   const pk = primaryKeyClause(schema);
   if (pk) lines.push(pk);
   for (const index of schema.indexes ?? []) lines.push(indexClause(index));
@@ -77,5 +90,5 @@ export function buildCreateTableSql(schema: TableSchema, options: BuildCreateTab
       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/src/page-flow.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';
 
 // Page-driven flow: every node is a page, and a page belongs to an app.
 // Leaf nodes are pages too — a journey starts at a page and ends at a page.
@@ -49,4 +49,4 @@ export function definePageFlow(
     pages.push(schema.start);
   }
   return { name, description: schema.description, start: schema.start, pages, edges: schema.edges };
-}
+}

package/src/page.ts

@@ -1,5 +1,5 @@
-import { SchemaBase } from './dsl';
-import { FrontApp } from './project';
+import { SchemaBase } from './dsl.js';
+import { FrontAppSchema } from './project.js';
 
 // Page definitions: standalone page schemas and the page node type used by
 // page-driven flows. Kept separate from page-flow.ts (the flow graph itself).
@@ -8,7 +8,7 @@ import { FrontApp } from './project';
  *  the actions a user can perform, and belongs to exactly one frontend app. */
 export interface PageSchema extends SchemaBase {
   /** The frontend app this page belongs to (shared instance from project.config). */
-  app: FrontApp;
+  app: FrontAppSchema;
   /** Actions a user can perform on this page (e.g. submit, approve, reject). */
   actions: ActionSchema[];
 }
@@ -23,7 +23,7 @@ export function defineAction(name: string, description?: string): ActionSchema {
 export function definePage(schema: {
   name: string;
   description?: string;
-  app: FrontApp;
+  app: FrontAppSchema;
   actions: ActionSchema[];
 }): PageSchema {
   return { ...schema };
@@ -32,9 +32,9 @@ export function definePage(schema: {
 /** A page node in a page-driven flow: every node is a page, and a page belongs to an app. */
 export interface Page extends SchemaBase {
   /** The frontend app this page belongs to (shared instance from project.config). */
-  app: FrontApp;
+  app: FrontAppSchema;
 }
 
-export function page(app: FrontApp, name: string, description?: string): Page {
+export function page(app: FrontAppSchema, name: string, description?: string): Page {
   return { name, app, description };
-}
+}

package/src/patterns/retry.ts

@@ -1,4 +1,4 @@
-import { PatternDef } from '../pattern';
+import { PatternDef } from '../pattern.js';
 
 // Retry pattern: blind mechanical retry for read-only operations.
 // Valid because a read-only action is idempotent by nature: clicking a query

package/src/project.ts

@@ -1,55 +1,91 @@
-import { SchemaBase } from './dsl';
-
-// Project topology definitions: describe the applications (frontends) and
-// backend APIs of a repository, and which frontends each API serves.
-
-/** Frontend form factor. Closed enum, extend when new form factors appear. */
-export type FrontType = 'admin' | 'wxmini';
-
-/** A frontend application (e.g. admin console, wechat mini program). */
-export interface FrontApp extends SchemaBase {
-  type: FrontType;
-  /** Source directory relative to project root, e.g. 'web-admin/'. */
-  dir: string;
-}
-
-/** A backend API service. apps references shared FrontApp instances. */
-export interface ProjectApi extends SchemaBase {
-  /** Source directory relative to project root, e.g. 'api/'. */
-  dir: string;
-  /** Frontends this API serves. Direct instance references (see defineProject). */
-  apps: FrontApp[];
-  /** API base URL prefix shared by all apps it serves, e.g. '/mall'. '' = no prefix. */
-  contextPath?: string;
-}
-
-/** A third-party system (e.g. wechat pay, unionpay). Owns its own
- *  implementation dir and contract (controller_types), just like an API,
- *  but is not part of this repo's served surface. */
-export interface ThirdApi extends SchemaBase {
-  /** Source directory relative to project root, e.g. 'wechat/'. */
-  dir: string;
-}
-
-export interface ProjectSchema extends SchemaBase {
-  apps: FrontApp[];
-  apis: ProjectApi[];
-  thirdApis: ThirdApi[];
-}
-
-/**
- * Defines the project topology. FrontApp instances are shared value objects:
- * api.apps references the same instances from project.apps, so an app served
- * by multiple APIs is defined once and referenced many times.
- */
-export function defineProject(
-  name: string,
-  schema: {
-    description?: string;
-    apps: FrontApp[];
-    apis: ProjectApi[];
-    thirdApis?: ThirdApi[];
-  },
-): ProjectSchema {
-  return { name, ...schema, thirdApis: schema.thirdApis ?? [] };
+import { SchemaBase } from './dsl.js';
+
+// Project topology definitions: describe the applications (frontends) and
+// backend APIs of a repository, and which frontends each API serves.
+
+/** Frontend form factor. Closed enum, extend when new form factors appear. */
+export type FrontType = 'admin' | 'wxmini';
+
+/** A frontend application (e.g. admin console, wechat mini program). */
+export interface FrontAppSchema extends SchemaBase {
+  type: FrontType;
+  /** Source directory relative to project root, e.g. 'web-admin/'. */
+  dir: string;
+}
+
+/** A backend API service. apps references shared FrontAppSchema instances. */
+export interface ProjectApiSchema extends SchemaBase {
+  /** Source directory relative to project root, e.g. 'api/'. */
+  dir: string;
+  /** Frontends this API serves. Direct instance references (see defineProject). */
+  apps: FrontAppSchema[];
+  /** API base URL prefix shared by all apps it serves, e.g. '/mall'. '' = no prefix. */
+  contextPath?: string;
+  /** API service base URL for node clients, e.g. 'http://127.0.0.1:3000'. */
+  baseUrl?: string;
+}
+
+/** A third-party system (e.g. wechat pay, unionpay). Owns its own
+ *  implementation dir and contract (controller_types), just like an API,
+ *  but is not part of this repo's served surface. */
+export interface ThirdApiSchema extends SchemaBase {
+  /** Source directory relative to project root, e.g. 'wechat/'. */
+  dir: string;
+}
+
+export interface ProjectSchema extends SchemaBase {
+  apps: FrontAppSchema[];
+  apis: ProjectApiSchema[];
+  thirdApis: ThirdApiSchema[];
+}
+
+/**
+ * Defines the project topology. FrontAppSchema instances are shared value objects:
+ * api.apps references the same instances from project.apps, so an app served
+ * by multiple APIs is defined once and referenced many times.
+ *
+ * Runtime-validates app type whitelist, unique names and api.apps reference
+ * integrity (same style as defineTable/defineCurd).
+ */
+export function defineProject(
+  name: string,
+  schema: {
+    description?: string;
+    apps: FrontAppSchema[];
+    apis: ProjectApiSchema[];
+    thirdApis?: ThirdApiSchema[];
+  },
+): ProjectSchema {
+  const project: ProjectSchema = { name, ...schema, thirdApis: schema.thirdApis ?? [] };
+
+  const appNames = new Set<string>();
+  for (const app of project.apps) {
+    if (!app.name) throw new Error(`project ${name}: app name is required`);
+    if (appNames.has(app.name)) throw new Error(`project ${name}: duplicate app name '${app.name}'`);
+    appNames.add(app.name);
+    if (app.type !== 'admin' && app.type !== 'wxmini') {
+      throw new Error(`project ${name}: app '${app.name}' must be type 'admin' or 'wxmini' (got '${app.type}')`);
+    }
+    if (!app.dir) throw new Error(`project ${name}: app '${app.name}' dir is required`);
+  }
+
+  const apiNames = new Set<string>();
+  for (const api of project.apis) {
+    if (!api.name) throw new Error(`project ${name}: api name is required`);
+    if (apiNames.has(api.name)) throw new Error(`project ${name}: duplicate api name '${api.name}'`);
+    apiNames.add(api.name);
+    if (!api.dir) throw new Error(`project ${name}: api '${api.name}' dir is required`);
+    for (const ref of api.apps) {
+      if (!project.apps.includes(ref)) {
+        throw new Error(`project ${name}: api '${api.name}' references app '${ref.name}' that is not a shared instance in project.apps (define once and reference it)`);
+      }
+    }
+  }
+
+  for (const third of project.thirdApis) {
+    if (!third.name) throw new Error(`project ${name}: thirdApi name is required`);
+    if (!third.dir) throw new Error(`project ${name}: thirdApi '${third.name}' dir is required`);
+  }
+
+  return project;
 }

package/src/prototype.ts

@@ -1,4 +1,4 @@
-import { SchemaBase } from './dsl';
+import { SchemaBase } from './dsl.js';
 
 // Prototype definitions: high-level design of a page. A prototype lists only
 // the fields a page needs — no types, no bindings to apps/APIs/tables. Field