@pylonts/dsl 1.1.5 → 1.1.6

package/src/flow.ts

@@ -1,104 +1,144 @@
-import { SchemaBase } from './dsl.js';
-
-// Flow model: nodes and edges are separate entities. A FlowNode is a plain
-// named step; a FlowEdge references its start/end node objects directly (no
-// ids). Because a node object may appear in many edges, the graph can share
-// nodes, merge branches, and form cycles (e.g. poll-and-retry loops).
-
-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
-   *  via this node's outgoing edges. Sub-flows nest recursively. */
-  flow?: FlowSchema;
-}
-
-export interface FlowEdge extends SchemaBase {
-  /** Trigger condition; undefined = default path (success/normal). */
-  when?: string;
-  start: FlowNode;
-  end: FlowNode;
-}
-
-export interface FlowSchema extends SchemaBase {
-  /** Entry node. */
-  start: FlowNode;
-  /** All nodes, collected from edges (deduplicated by object identity). */
-  nodes: FlowNode[];
-  /** Independent edges; a node may be start of many edges, so cycles are expressible. */
-  edges: FlowEdge[];
-}
-
-export function node(name: string, flow?: FlowSchema, description?: string): FlowNode {
-  return { name, flow, description };
-}
-
-export function edge(start: FlowNode, end: FlowNode, when?: string, description?: string): FlowEdge {
-  // Auto name for uniformity with SchemaBase; `when` stays the branch marker.
-  return { name: `${start.name}->${end.name}`, start, end, when, description };
-}
-
-export function defineFlow(
-  name: string,
-  schema: {
-    start: FlowNode;
-    edges: FlowEdge[];
-    description?: string;
-  },
-): FlowSchema {
-  const seen = new Set<FlowNode>();
-  const nodes: FlowNode[] = [];
-  for (const e of schema.edges) {
-    for (const n of [e.start, e.end]) {
-      if (!seen.has(n)) {
-        seen.add(n);
-        nodes.push(n);
-      }
-    }
-  }
-  if (!seen.has(schema.start)) {
-    seen.add(schema.start);
-    nodes.push(schema.start);
-  }
-  const flow: FlowSchema = { name, description: schema.description, start: schema.start, nodes, edges: schema.edges };
-  validate(flow);
-  return flow;
-}
-
-// Nodes that never appear as an edge start are terminals. Reverse BFS from all
-// terminals marks every node that can reach a terminal; unmarked nodes sit on
-// a path that never ends (e.g. a cycle without an exit) — reject them at
-// definition time.
-function validate(schema: FlowSchema): void {
-  const starts = new Set<FlowNode>();
-  for (const e of schema.edges) starts.add(e.start);
-
-  const reverse = new Map<FlowNode, FlowNode[]>();
-  for (const n of schema.nodes) reverse.set(n, []);
-  for (const e of schema.edges) {
-    reverse.get(e.end)!.push(e.start);
-  }
-
-  const reached = new Set<FlowNode>();
-  const queue: FlowNode[] = [];
-  for (const n of schema.nodes) {
-    if (!starts.has(n)) {
-      reached.add(n);
-      queue.push(n);
-    }
-  }
-  while (queue.length > 0) {
-    const cur = queue.shift()!;
-    for (const prev of reverse.get(cur)!) {
-      if (!reached.has(prev)) {
-        reached.add(prev);
-        queue.push(prev);
-      }
-    }
-  }
-
-  for (const n of schema.nodes) {
-    if (!reached.has(n)) {
-      throw new Error(`flow ${schema.name}: node "${n.name}" cannot reach a terminal`);
-    }
-  }
+import { SchemaBase } from './dsl.js';
+import type { MethodSchema } from './method.js';
+import type { ConvertSchema } from './convert.js';
+import type { DaoMethodSchema } from './dao.js';
+import type { ServiceMethodSchema } from './service.js';
+import type { ThirdServiceMethodSchema } from './third-service.js';
+import type { UtilsMethodSchema } from './utils.js';
+
+// Flow model: nodes and edges are separate entities. A FlowNode is a plain
+// named step; a FlowEdge references its start/end node objects directly (no
+// ids). Because a node object may appear in many edges, the graph can share
+// nodes, merge branches, and form cycles (e.g. poll-and-retry loops).
+
+/** A method a flow node can invoke: contract references, or a pure descriptor
+ *  (MethodSchema) for the period before the contract file exists. */
+export type FlowMethodRef =
+  | MethodSchema
+  | ConvertSchema
+  | DaoMethodSchema
+  | ServiceMethodSchema
+  | ThirdServiceMethodSchema
+  | UtilsMethodSchema;
+
+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
+   *  via this node's outgoing edges. Sub-flows nest recursively. */
+  flow?: FlowSchema;
+  /** Methods this node invokes — contract references or pure descriptors
+   *  (rendered under the node label). */
+  methods?: FlowMethodRef[];
+}
+
+export interface FlowEdge extends SchemaBase {
+  /** Trigger condition; undefined = default path (success/normal). */
+  when?: string;
+  start: FlowNode;
+  end: FlowNode;
+  /** Exception path (rendered dashed); defaults to normal. */
+  exception?: boolean;
+}
+
+export interface FlowSchema extends SchemaBase {
+  /** Entry node. */
+  start: FlowNode;
+  /** All nodes, collected from edges (deduplicated by object identity). */
+  nodes: FlowNode[];
+  /** Independent edges; a node may be start of many edges, so cycles are expressible. */
+  edges: FlowEdge[];
+}
+
+export function node(
+  name: string,
+  options: { flow?: FlowSchema; description?: string; methods?: FlowMethodRef[] } = {},
+): FlowNode {
+  return {
+    name,
+    flow: options.flow,
+    description: options.description,
+    methods: options.methods,
+  };
+}
+
+export function edge(
+  start: FlowNode,
+  end: FlowNode,
+  options: { when?: string; description?: string; exception?: boolean } = {},
+): FlowEdge {
+  // Auto name for uniformity with SchemaBase; `when` stays the branch marker.
+  return {
+    name: `${start.name}->${end.name}`,
+    start,
+    end,
+    when: options.when,
+    description: options.description,
+    exception: options.exception,
+  };
+}
+
+export function defineFlow(
+  name: string,
+  schema: {
+    start: FlowNode;
+    edges: FlowEdge[];
+    description?: string;
+  },
+): FlowSchema {
+  const seen = new Set<FlowNode>();
+  const nodes: FlowNode[] = [];
+  for (const e of schema.edges) {
+    for (const n of [e.start, e.end]) {
+      if (!seen.has(n)) {
+        seen.add(n);
+        nodes.push(n);
+      }
+    }
+  }
+  if (!seen.has(schema.start)) {
+    seen.add(schema.start);
+    nodes.push(schema.start);
+  }
+  const flow: FlowSchema = { name, description: schema.description, start: schema.start, nodes, edges: schema.edges };
+  validate(flow);
+  return flow;
+}
+
+// Nodes that never appear as an edge start are terminals. Reverse BFS from all
+// terminals marks every node that can reach a terminal; unmarked nodes sit on
+// a path that never ends (e.g. a cycle without an exit) — reject them at
+// definition time.
+function validate(schema: FlowSchema): void {
+  const starts = new Set<FlowNode>();
+  for (const e of schema.edges) starts.add(e.start);
+
+  const reverse = new Map<FlowNode, FlowNode[]>();
+  for (const n of schema.nodes) reverse.set(n, []);
+  for (const e of schema.edges) {
+    reverse.get(e.end)!.push(e.start);
+  }
+
+  const reached = new Set<FlowNode>();
+  const queue: FlowNode[] = [];
+  for (const n of schema.nodes) {
+    if (!starts.has(n)) {
+      reached.add(n);
+      queue.push(n);
+    }
+  }
+  while (queue.length > 0) {
+    const cur = queue.shift()!;
+    for (const prev of reverse.get(cur)!) {
+      if (!reached.has(prev)) {
+        reached.add(prev);
+        queue.push(prev);
+      }
+    }
+  }
+
+  for (const n of schema.nodes) {
+    if (!reached.has(n)) {
+      throw new Error(`flow ${schema.name}: node "${n.name}" cannot reach a terminal`);
+    }
+  }
 }

package/src/index.ts

@@ -1,33 +1,43 @@
-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 './action.js';
-export * from './event.js';
-export * from './component.js';
-export * from './convert.js';
-export * from './ref.js';
-export * from './route.js';
-export * from './service.js';
-export * from './dao.js';
-export * from './page.js';
-export * from './curd.js';
-export * from './page-flow.js';
-export * from './provider.js';
-export * from './page-def.js';
-export * from './mermaid-driver.js';
-export * from './navigation.js';
-export * from './popup.js';
+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 './action.js';
+export * from './event.js';
+export * from './component.js';
+export * from './convert.js';
+export * from './ref.js';
+export * from './route.js';
+export * from './service.js';
+export * from './controller.js';
+export * from './endpoint.js';
+export * from './dao.js';
+export * from './third-service.js';
+export * from './field-rule.js';
+export * from './exception.js';
+export * from './page.js';
+export * from './curd.js';
+export * from './page-flow.js';
+export * from './provider.js';
+export * from './page-def.js';
+export * from './mermaid-driver.js';
+export * from './navigation.js';
+export * from './popup.js';
+export * from './method.js';
+
+// Naming conversions moved to @pylonts/core; re-exported for compatibility
+// with packages that import them from @pylonts/dsl.
+export { toCamelCase, toPascalCase, toKebabCase } from '@pylonts/core';

package/src/mermaid-driver.ts

@@ -1,85 +1,113 @@
-import { FlowEdge, FlowNode, FlowSchema } from './flow.js';
-import { Page } from './page.js';
-import { PageEdge, PageFlow } from './page-flow.js';
-
-// 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
-// internals are rendered recursively. ok edges render as -->, conditional
-// edges render as -->|"WHEN"|.
-
-function escapeLabel(s: string): string {
-  return s.replace(/"/g, '\\"').replace(/\n/g, '<br/>');
-}
-
-export function renderFlowMermaid(schema: FlowSchema): string {
-  const lines: string[] = ['flowchart TD'];
-  const ids = new Map<FlowNode, string>();
-  renderFlow(schema, 'n', lines, ids);
-  lines.push('');
-  lines.push('    classDef start fill:#e6f4ea,stroke:#333,stroke-width:1px;');
-  lines.push(`    class ${ids.get(schema.start)} start;`);
-  return lines.join('\n');
-}
-
-function renderFlow(schema: FlowSchema, prefix: string, lines: string[], ids: Map<FlowNode, string>): void {
-  schema.nodes.forEach((n, i) => ids.set(n, `${prefix}${i}`));
-  for (const n of schema.nodes) {
-    const id = ids.get(n)!;
-    if (n.flow) {
-      lines.push(`    subgraph ${id}["${escapeLabel(n.name)}"]`);
-      renderFlow(n.flow, `${id}_`, lines, ids);
-      lines.push('    end');
-    } else {
-      lines.push(`    ${id}["${escapeLabel(n.name)}"]`);
-    }
-  }
-  for (const e of schema.edges) {
-    lines.push(renderEdge(e, ids));
-  }
-}
-
-function renderEdge(e: FlowEdge, ids: Map<FlowNode, string>): string {
-  const label = e.when ? `|"${escapeLabel(e.when)}"|` : '';
-  return `    ${ids.get(e.start)} -->${label} ${ids.get(e.end)}`;
-}
-
-// Page-driven flow renderer: groups pages by their app into swimlane
-// subgraphs, then renders edges across the whole flow.
-
-export function renderPageFlowMermaid(schema: PageFlow): string {
-  const lines: string[] = ['flowchart TD'];
-  const ids = new Map<Page, string>();
-
-  const byApp = new Map<string, Page[]>();
-  for (const p of schema.pages) {
-    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) {
-    lines.push(`    subgraph app${appIdx}["${escapeLabel(appName)}"]`);
-    pages.forEach((p, i) => ids.set(p, `app${appIdx}_p${i}`));
-    for (const p of pages) {
-      const display = p.label ?? p.name;
-      lines.push(`    ${ids.get(p)}["${escapeLabel(display)}"]`);
-    }
-    appIdx++;
-    lines.push('    end');
-  }
-
-  for (const e of schema.edges) {
-    const label = e.when ? `|"${escapeLabel(e.when.name)}"|` : '';
-    lines.push(`    ${ids.get(e.start)} -->${label} ${ids.get(e.end)}`);
-  }
-
-  lines.push('');
-  lines.push('    classDef start fill:#e6f4ea,stroke:#333,stroke-width:1px;');
-  lines.push(`    class ${ids.get(schema.start)} start;`);
-  return lines.join('\n');
+import { FlowEdge, FlowNode, FlowSchema } from './flow.js';
+import type { FlowMethodRef } from './flow.js';
+import { Page } from './page.js';
+import { PageEdge, PageFlow } from './page-flow.js';
+
+// 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
+// internals are rendered recursively. ok edges render as -->, conditional
+// edges render as -->|"WHEN"|.
+
+function escapeLabel(s: string): string {
+  return s.replace(/"/g, '\\"').replace(/\n/g, '<br/>');
+}
+
+export function renderFlowMermaid(schema: FlowSchema): string {
+  const lines: string[] = ['flowchart TD'];
+  const ids = new Map<FlowNode, string>();
+  renderFlow(schema, 'n', lines, ids);
+  lines.push('');
+  lines.push('    classDef start fill:#e6f4ea,stroke:#333,stroke-width:1px;');
+  lines.push(`    class ${ids.get(schema.start)} start;`);
+  return lines.join('\n');
+}
+
+function renderFlow(schema: FlowSchema, prefix: string, lines: string[], ids: Map<FlowNode, string>): void {
+  schema.nodes.forEach((n, i) => ids.set(n, `${prefix}${i}`));
+  const outgoing = new Map<FlowNode, FlowEdge[]>();
+  for (const n of schema.nodes) outgoing.set(n, []);
+  for (const e of schema.edges) outgoing.get(e.start)!.push(e);
+
+  for (const n of schema.nodes) {
+    const id = ids.get(n)!;
+    if (n.flow) {
+      lines.push(`    subgraph ${id}["${escapeLabel(renderNodeLabel(n))}"]`);
+      renderFlow(n.flow, `${id}_`, lines, ids);
+      lines.push('    end');
+    } else {
+      const shape = renderShape(n, schema, outgoing.get(n)!);
+      lines.push(`    ${id}${shape.open}${escapeLabel(renderNodeLabel(n))}${shape.close}`);
+    }
+  }
+  for (const e of schema.edges) {
+    lines.push(renderEdge(e, ids));
+  }
+}
+
+/** Node label: name on the first line, method references on the second. */
+function renderNodeLabel(n: FlowNode): string {
+  if (n.methods === undefined || n.methods.length === 0) return n.name;
+  return `${n.name}\n${n.methods.map((m: FlowMethodRef) => renderMethodRef(m)).join(' | ')}`;
+}
+
+/** Display form: owner.name for descriptors and container methods, bare name for converts. */
+function renderMethodRef(m: FlowMethodRef): string {
+  if ('owner' in m) return `${m.owner}.${m.name}`;
+  if ('schema' in m) return `${m.schema.name}.${m.name}`;
+  return m.name;
+}
+
+/** Shape derived from topology: start and terminals rounded, branching nodes diamond, else rect.
+ *  Exception edges do not count as branches. */
+function renderShape(n: FlowNode, schema: FlowSchema, outgoing: FlowEdge[]): { open: string; close: string } {
+  if (n === schema.start || outgoing.length === 0) return { open: '(["', close: '"])' };
+  const normal = outgoing.filter((e) => e.exception !== true).length;
+  return normal >= 2 ? { open: '{"', close: '"}' } : { open: '["', close: '"]' };
+}
+
+function renderEdge(e: FlowEdge, ids: Map<FlowNode, string>): string {
+  const arrow = e.exception === true ? '-.->' : '-->';
+  const label = e.when ? `|"${escapeLabel(e.when)}"|` : '';
+  return `    ${ids.get(e.start)} ${arrow}${label} ${ids.get(e.end)}`;
+}
+
+// Page-driven flow renderer: groups pages by their app into swimlane
+// subgraphs, then renders edges across the whole flow.
+
+export function renderPageFlowMermaid(schema: PageFlow): string {
+  const lines: string[] = ['flowchart TD'];
+  const ids = new Map<Page, string>();
+
+  const byApp = new Map<string, Page[]>();
+  for (const p of schema.pages) {
+    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) {
+    lines.push(`    subgraph app${appIdx}["${escapeLabel(appName)}"]`);
+    pages.forEach((p, i) => ids.set(p, `app${appIdx}_p${i}`));
+    for (const p of pages) {
+      const display = p.label ?? p.name;
+      lines.push(`    ${ids.get(p)}["${escapeLabel(display)}"]`);
+    }
+    appIdx++;
+    lines.push('    end');
+  }
+
+  for (const e of schema.edges) {
+    const label = e.when ? `|"${escapeLabel(e.when.name)}"|` : '';
+    lines.push(`    ${ids.get(e.start)} -->${label} ${ids.get(e.end)}`);
+  }
+
+  lines.push('');
+  lines.push('    classDef start fill:#e6f4ea,stroke:#333,stroke-width:1px;');
+  lines.push(`    class ${ids.get(schema.start)} start;`);
+  return lines.join('\n');
 }

package/src/method.ts

@@ -0,0 +1,20 @@
+import type { SchemaBase } from './dsl.js';
+
+// A pure descriptor of one method invocation (e.g. payDao.insert).
+// No args/results — the invocation stays natural language for now.
+// SequenceSchema is the ordered list of such invocations.
+
+export interface MethodSchema extends SchemaBase {
+  /** Owning schema name, e.g. 'payDao'. */
+  owner: string;
+}
+
+export type SequenceSchema = MethodSchema[];
+
+export function defineMethod(options: {
+  name: string;
+  owner: string;
+  description?: string;
+}): MethodSchema {
+  return { name: options.name, owner: options.owner, description: options.description };
+}

package/src/mysql-driver.ts

@@ -36,6 +36,10 @@ function columnType(field: Field): string {
       return field.enum.valueType === 'integer' ? 'TINYINT' : 'VARCHAR(20)';
     case 'json':
       return 'JSON';
+    case 'array':
+    case 'object':
+      // Nested fields are wire-format only (third-party messages); table columns cannot nest.
+      throw new Error(`field ${field.name} (${field.type}): nested fields are not supported on table columns`);
   }
 }