@pylonts/dsl 1.1.4 → 1.1.6

package/dist/controller.d.ts

@@ -0,0 +1,27 @@
+import { SchemaBase } from './dsl.js';
+import { FrontAppSchema } from './project.js';
+import type { EndpointSchema } from './endpoint.js';
+/** A backend RPC controller. Strong constraints:
+ *  - a backend module maps 1:1 to a frontend app (they are peers);
+ *  - a controller serves exactly one frontend app — no cross-module calls. */
+export interface ControllerSchema extends SchemaBase {
+    type: 'controller';
+    /** The frontend app this controller serves (shared instance from project.config). */
+    app: FrontAppSchema;
+    /** RPC methods exposed by this controller. */
+    methods: ControllerMethodSchema[];
+}
+export declare function defineController(options: {
+    name: string;
+    app: FrontAppSchema;
+    /** Method declarations: type/schema are injected by this builder. */
+    methods: Array<Omit<ControllerMethodSchema, 'type' | 'schema'>>;
+    description?: string;
+}): ControllerSchema;
+/** An RPC method exposed by a controller. */
+export interface ControllerMethodSchema extends SchemaBase {
+    type: 'method';
+    schema: ControllerSchema;
+    /** Shared API signature — same instance the page-side provider references. */
+    signature: EndpointSchema;
+}

package/dist/controller.js

@@ -0,0 +1,11 @@
+export function defineController(options) {
+    const schema = {
+        type: 'controller',
+        name: options.name,
+        description: options.description,
+        app: options.app,
+        methods: [],
+    };
+    schema.methods = options.methods.map((method) => ({ type: 'method', schema, ...method }));
+    return schema;
+}

package/dist/convert.d.ts

@@ -1,12 +1,24 @@
 import type { SchemaBase } from './dsl.js';
+import type { DtoMessage } from './dto.js';
+import type { TableSchema } from './db.js';
+import type { ThirdMethodSchema } from './third-service.js';
 import type { FrontAppSchema } from './project.js';
-/** Declares post-call result → page data field mapping.
- *  Driver generates per-item transform (e.g. .map()) before setData. */
+/** A source/target collection of a convert — dto, entity or third-party message. */
+export type ConvertSourceSchema = DtoMessage | TableSchema | ThirdMethodSchema;
+/** Declares a multi-source → single-target schema integration. */
 export interface ConvertSchema extends SchemaBase {
     type: 'convert';
-    /** The frontend app this convert belongs to (shared instance from project.config). */
+    /** The app (module) this convert belongs to — its artifact lands in modules/{app}/convert/. */
     app: FrontAppSchema;
-    /** { targetField: sourceField } — renames or copies fields from call result. */
-    fields: Record<string, string>;
+    /** Source schemas — one or more, mixed dimensions. */
+    sources: ConvertSourceSchema[];
+    /** Target schema — the single integrated collection. */
+    target: ConvertSourceSchema;
 }
-export declare function defineConvert(name: string, app: FrontAppSchema, fields: Record<string, string>): ConvertSchema;
+export declare function defineConvert(options: {
+    name: string;
+    app: FrontAppSchema;
+    sources: ConvertSourceSchema[];
+    target: ConvertSourceSchema;
+    description?: string;
+}): ConvertSchema;

package/dist/convert.js

@@ -1,3 +1,13 @@
-export function defineConvert(name, app, fields) {
-    return { name, type: 'convert', app, fields };
+export function defineConvert(options) {
+    if (options.sources.length === 0) {
+        throw new Error(`convert '${options.name}': sources must not be empty`);
+    }
+    return {
+        type: 'convert',
+        name: options.name,
+        description: options.description,
+        app: options.app,
+        sources: options.sources,
+        target: options.target,
+    };
 }

package/dist/curd.d.ts

@@ -7,8 +7,6 @@ export type ActionPageMode = 'modal' | 'route';
 /** One CRUD action page (add / update / detail). */
 export interface ActionPage {
     mode: ActionPageMode;
-    /** For add/update: when true, render as modal on list page; when false/undefined, render as standalone route page. */
-    modal?: boolean;
     /** Fields rendered on this page. Required, non-empty — every field the
      *  frontend shows must be listed explicitly. */
     columns: Field[];

package/dist/curd.js

@@ -1,3 +1,4 @@
+import { toKebabCase } from '@pylonts/core';
 function assertColumns(curd, pageName, columns) {
     if (columns.length === 0) {
         throw new Error(`curd ${curd.name}: ${pageName}.columns must be non-empty`);
@@ -17,6 +18,12 @@ export function defineCurd(name, schema) {
     if (curd.app.type !== 'admin') {
         throw new Error(`curd ${name}: app ${curd.app.name} must be type 'admin' (got '${curd.app.type}')`);
     }
+    // The name is the admin route path — it must be the kebab-case table name
+    // so paths cannot drift from the table they serve.
+    const expectedName = toKebabCase(curd.table.name);
+    if (name !== expectedName) {
+        throw new Error(`curd name must be '${expectedName}' (kebab-case of table '${curd.table.name}'); got '${name}'`);
+    }
     if (!curd.section) {
         throw new Error(`curd ${name}: section is required (sidebar menu group, e.g. '商户管理')`);
     }

package/dist/dao.d.ts

@@ -1,9 +1,118 @@
-import { SchemaBase } from './dsl.js';
+import { SchemaBase, Field, Operator } from './dsl.js';
 import { FrontAppSchema } from './project.js';
+import { TableSchema } from './db.js';
 /** A data-access layer bound to exactly one frontend app. */
 export interface DaoSchema extends SchemaBase {
     type: 'dao';
     /** The frontend app this DAO belongs to (shared instance from project.config). */
     app: FrontAppSchema;
+    /** The table this DAO operates on (single-table atomicity). */
+    table: TableSchema;
+    /** Methods keyed by name — the map key is written back as the method name. */
+    methods: Record<string, DaoMethodSchema>;
+}
+/** Method input for defineDao: name is written back from the methods map key. */
+export type DaoMethodDef = Omit<FindSchema, 'schema' | 'name'> | Omit<GetSchema, 'schema' | 'name'> | Omit<InsertSchema, 'schema' | 'name'> | Omit<UpdateSchema, 'schema' | 'name'> | Omit<DeleteSchema, 'schema' | 'name'> | Omit<AggregateSchema, 'schema' | 'name'>;
+export declare function defineDao(options: {
+    name: string;
+    app: FrontAppSchema;
+    table: TableSchema;
+    methods: Record<string, DaoMethodDef>;
+    description?: string;
+}): DaoSchema;
+/** One AND-combined criterion: a column plus its comparison operator. */
+export interface QueryField {
+    /** Column to compare. */
+    field: Field;
+    /** Comparison operator; defaults to 'eq'. */
+    op?: Operator;
+}
+/** Query criteria for find methods. */
+export interface QuerySchema extends SchemaBase {
+    type: 'query';
+    /** Criteria; all fields are AND-combined. */
+    fields: QueryField[];
+}
+/** Sort specification for find results. */
+export interface OrderBySchema {
+    /** Column to sort by. */
+    column: Field;
+    /** Sort direction. */
+    sort: 'asc' | 'desc';
+}
+/** Query rows by criteria; returns a list of row objects. */
+export interface FindSchema extends SchemaBase {
+    type: 'find';
+    schema: DaoSchema;
+    /** Query criteria; omit = all rows. */
+    args?: QuerySchema;
+    /** Pagination marker: 'page' (page/pageSize) or 'limit' (position/limit).
+     *  Only presence matters — parameter shapes are a generator convention. */
+    mode?: 'page' | 'limit';
+    /** Result sort; omit = no explicit order. */
+    orderBy?: OrderBySchema | OrderBySchema[];
+    /** Row type of the result list. */
+    results: EntitySchema;
+}
+/** Fetch a single row by primary key. Composite PK is not supported. */
+export interface GetSchema extends SchemaBase {
+    type: 'get';
+    schema: DaoSchema;
+    /** Single PK scalar value. */
+    args: Field;
+    /** Row type. Get may miss the row: the generated signature returns Entity | null. */
+    results: EntitySchema;
+}
+/** Insert one row; returns number (insert id). */
+export interface InsertSchema extends SchemaBase {
+    type: 'insert';
+    schema: DaoSchema;
+    /** Row object. */
+    args: EntitySchema;
+}
+/** Update one row; returns number (affected rows). The where key is derived
+ *  from the PK columns inside args. */
+export interface UpdateSchema extends SchemaBase {
+    type: 'update';
+    schema: DaoSchema;
+    /** Row object containing the PK columns plus the columns to set. */
+    args: EntitySchema;
+    /** Additional criteria beyond the derived PK (AND-combined). */
+    where?: QuerySchema;
+}
+/** Delete one row by primary key; returns number (affected rows).
+ *  Composite PK is not supported. */
+export interface DeleteSchema extends SchemaBase {
+    type: 'delete';
+    schema: DaoSchema;
+    /** Single PK scalar value. */
+    args: Field;
+}
+export type DaoMethodSchema = FindSchema | GetSchema | InsertSchema | UpdateSchema | DeleteSchema | AggregateSchema;
+/** Aggregate expression result for aggregate queries. */
+export interface ComputeExpr {
+    fn: 'sum' | 'avg' | 'count';
+    /** Column the function applies to; absent for count(*). */
+    field?: Field;
+}
+/** Aggregate expressions: Compute.sum(col) / Compute.avg(col) / Compute.count(). */
+export declare const Compute: {
+    sum(field: Field): ComputeExpr;
+    avg(field: Field): ComputeExpr;
+    count(): ComputeExpr;
+};
+/** Aggregate query (count/sum/avg): returns computed scalar values. */
+export interface AggregateSchema extends SchemaBase {
+    type: 'aggregate';
+    schema: DaoSchema;
+    /** Criteria, same shape as find. */
+    args?: QuerySchema;
+    /** Computed results: key = result field name. */
+    results: Record<string, ComputeExpr>;
+}
+/** A database entity backed by a table. */
+export interface EntitySchema extends SchemaBase {
+    type: 'entity';
+    /** The table columns of this entity. */
+    columns: Field[];
 }
-export declare function defineDao(name: string, app: FrontAppSchema, description?: string): DaoSchema;

package/dist/dao.js

@@ -1,3 +1,29 @@
-export function defineDao(name, app, description) {
-    return { name, type: 'dao', app, description };
+export function defineDao(options) {
+    const schema = {
+        type: 'dao',
+        name: options.name,
+        description: options.description,
+        app: options.app,
+        table: options.table,
+        methods: {},
+    };
+    for (const key of Object.keys(options.methods)) {
+        const method = options.methods[key];
+        // Spread of a union loses discriminant correlation; the cast is safe
+        // (the builder only adds name and the back-reference field).
+        schema.methods[key] = { ...method, name: key, schema };
+    }
+    return schema;
 }
+/** Aggregate expressions: Compute.sum(col) / Compute.avg(col) / Compute.count(). */
+export const Compute = {
+    sum(field) {
+        return { fn: 'sum', field };
+    },
+    avg(field) {
+        return { fn: 'avg', field };
+    },
+    count() {
+        return { fn: 'count' };
+    },
+};

package/dist/db.js

@@ -66,6 +66,9 @@ export function defineTable(name, schema) {
         if (field.schema && field.schema !== table) {
             throw new Error(`field ${key}: belongs to table ${field.schema.name}, cannot reuse in table ${table.name}`);
         }
+        if (field.type === 'array' || field.type === 'object') {
+            throw new Error(`table '${name}': column '${key}' cannot be a nested ${field.type} field — wire-format nesting is not a table column`);
+        }
     }
     for (const key of Object.keys(table.columns)) {
         table.columns[key].name = key;

package/dist/dsl.d.ts

@@ -54,6 +54,13 @@ interface DecimalField extends BaseField {
     precision: number;
     scale: number;
 }
+type RateUnit = 'pct' | 'pm' | 'bp';
+export declare function rateScale(unit: RateUnit): number;
+interface RateField extends BaseField {
+    type: 'rate';
+    jsType: 'string';
+    unit: RateUnit;
+}
 interface BooleanField extends BaseField {
     type: 'boolean';
     jsType: 'boolean';
@@ -93,17 +100,33 @@ interface JsonField extends BaseField {
     type: 'json';
     jsType: 'object';
 }
-export type Field = StringField | TextField | IntField | BigintField | DecimalField | BooleanField | DateField | TimeField | DateTimeField | EnumField | JsonField;
+/** Recursive array field — wire-format nesting (third-party messages), not a table column. */
+interface ArrayField extends BaseField {
+    type: 'array';
+    jsType: 'array';
+    /** Element type: any Field, including nested array/object. */
+    items: Field;
+}
+/** Recursive object field — wire-format nesting (third-party messages), not a table column. */
+interface ObjectField extends BaseField {
+    type: 'object';
+    jsType: 'object';
+    properties: Record<string, Field>;
+}
+export type Field = StringField | TextField | IntField | BigintField | DecimalField | RateField | BooleanField | DateField | TimeField | DateTimeField | EnumField | JsonField | ArrayField | ObjectField;
 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 rateField(unit: RateUnit, extra?: Omit<FieldExtras<RateField>, 'unit'>): RateField;
 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 arrayField(extra: FieldExtras<ArrayField>): ArrayField;
+export declare function objectField(extra: FieldExtras<ObjectField>): ObjectField;
 export declare function enumField(extra: Omit<EnumField, 'name' | 'type' | 'jsType'>): EnumField;
 export {};

package/dist/dsl.js

@@ -1,5 +1,12 @@
 // DSL field type definitions.
 // Shape: { type: <type name>, <extension fields> }
+export function rateScale(unit) {
+    switch (unit) {
+        case 'pct': return 2;
+        case 'pm': return 3;
+        case 'bp': return 4;
+    }
+}
 export function defineEnum(jsName, valueType, values) {
     return { jsName, valueType, values };
 }
@@ -18,6 +25,9 @@ export function bigintField(extra = {}) {
 export function decimalField(extra) {
     return { name: '', type: 'decimal', jsType: 'string', ...extra };
 }
+export function rateField(unit, extra = {}) {
+    return { name: '', type: 'rate', jsType: 'string', unit, ...extra };
+}
 export function booleanField(extra = {}) {
     return { name: '', type: 'boolean', jsType: 'boolean', ...extra };
 }
@@ -33,6 +43,12 @@ export function datetimeField(extra = {}) {
 export function jsonField(extra = {}) {
     return { name: '', type: 'json', jsType: 'object', ...extra };
 }
+export function arrayField(extra) {
+    return { name: '', type: 'array', jsType: 'array', ...extra };
+}
+export function objectField(extra) {
+    return { name: '', type: 'object', jsType: 'object', ...extra };
+}
 export function enumField(extra) {
     const jsType = extra.enum.valueType === 'integer' ? 'number' : 'string';
     return { name: '', type: 'enum', jsType, ...extra };

package/dist/dto.d.ts

@@ -1,6 +1,7 @@
 import { BaseField, CollectionSchemaBase, Field, Operator, SchemaBase } from './dsl.js';
 import { TableSchema } from './db.js';
 import type { ImportBase } from './import-base.js';
+import type { ThirdMethodSchema } from './third-service.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). */
@@ -99,5 +100,8 @@ export declare function buildInput(name: string, fields: Record<string, DtoField
 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>;
+/** Field-collection source a DTO can project from: a DB table or a third-party method message. */
+export type DtoFieldSource = TableSchema | ThirdMethodSchema;
+/** Project fields from a field-collection source (table or third-party method
+ *  message) and wrap them as DTO fields (aligned with dto.from). */
+export declare function from(source: DtoFieldSource, fields: Field[]): Record<string, DtoField>;

package/dist/dto.js

@@ -1,4 +1,4 @@
-import { toCamelCase } from './utils.js';
+import { toCamelCase } from '@pylonts/core';
 export class DtoField {
     /** DTO 语义字段名（接口字段名），与 field.name（数据库列名）含义不同。
      *  构造时未知，由 buildMessage 从 map key 反写。 */
@@ -159,21 +159,32 @@ export function buildPk(name, fields, description) {
         if (field.optional !== undefined)
             continue;
         const f = field.field;
-        const table = f.schema;
+        const table = f.schema?.type === 'table' ? f.schema : undefined;
         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). */
-export function from(table, fields) {
+// Type guard instead of a plain discriminant check: TableSchema.type is declared
+// as a class property, so TS widens it to string and cannot narrow the union.
+function isThirdMethod(source) {
+    return source.type === 'thirdMethod';
+}
+function ownsField(source, field) {
+    if (isThirdMethod(source))
+        return Object.values(source.fields).includes(field);
+    return Object.values(source.columns).includes(field);
+}
+/** Project fields from a field-collection source (table or third-party method
+ *  message) and wrap them as DTO fields (aligned with dto.from). */
+export function from(source, 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`);
+        if (!ownsField(source, field)) {
+            throw new Error(`dto.from(${source.name}): field ${field.name} does not belong to this ${source.type}`);
         }
-        // DTO field name is camelCase (mer_id → merId); the underlying field.name
-        // stays snake_case (DB column).
-        out[toCamelCase(field.name)] = dtoField(field);
+        // DB columns map to camelCase interface names (mer_id → merId); wire-format
+        // names are protocol names themselves and stay untouched.
+        out[isThirdMethod(source) ? field.name : toCamelCase(field.name)] = dtoField(field);
     }
     return out;
 }

package/dist/endpoint.d.ts

@@ -0,0 +1,15 @@
+import { SchemaBase } from './dsl.js';
+import type { DtoMessage } from './dto.js';
+/** Shared API call signature: one request DTO in, one response shape out.
+ *  Referenced by both backend controller methods and frontend page providers —
+ *  both sides must use the exact same instance, so drift is impossible. */
+export interface EndpointSchema extends SchemaBase {
+    type: 'endpoint';
+    args: DtoMessage;
+    results: DtoMessage | number | boolean | string;
+}
+export declare function defineEndpoint(name: string, options: {
+    args: DtoMessage;
+    results: DtoMessage | number | boolean | string;
+    description?: string;
+}): EndpointSchema;

package/dist/endpoint.js

@@ -0,0 +1,3 @@
+export function defineEndpoint(name, options) {
+    return { type: 'endpoint', name, args: options.args, results: options.results, description: options.description };
+}

package/dist/exception.d.ts

@@ -0,0 +1,14 @@
+import type { SchemaBase } from './dsl.js';
+import type { ImportBase } from './import-base.js';
+/** Describes an exception a method can throw. */
+export interface ExceptionSchema extends SchemaBase, Omit<ImportBase, 'type'> {
+    type: 'exception';
+    /** Whether the caller may safely retry after catching this exception. */
+    retryable: boolean;
+}
+export declare function defineException(options: {
+    name: string;
+    from: string;
+    retryable: boolean;
+    description?: string;
+}): ExceptionSchema;

package/dist/exception.js

@@ -0,0 +1,9 @@
+export function defineException(options) {
+    return {
+        type: 'exception',
+        name: options.name,
+        from: options.from,
+        retryable: options.retryable,
+        description: options.description,
+    };
+}

package/dist/field-rule.d.ts

@@ -0,0 +1,20 @@
+import type { SchemaBase } from './dsl.js';
+/** One end of a field rule (e.g. 'fen' / 'yuan', 'plain' / 'cipher', 'raw' / 'masked'). */
+export interface FieldRuleEnd {
+    /** End name — written back by defineFieldRule from the ends map key. */
+    name: string;
+    description?: string;
+}
+/** A semantic transformation rule between two field representations. */
+export interface FieldRuleSchema extends SchemaBase {
+    type: 'fieldRule';
+    /** Rule name — the semantic uniqueness key. */
+    name: string;
+    /** The two ends of the rule, keyed by end name. */
+    ends: Record<string, FieldRuleEnd>;
+}
+export declare function defineFieldRule(options: {
+    name: string;
+    ends: Record<string, Omit<FieldRuleEnd, 'name'>>;
+    description?: string;
+}): FieldRuleSchema;

package/dist/field-rule.js

@@ -0,0 +1,19 @@
+/** One rule per semantic name. Defining the same name twice throws. */
+const ruleRegistry = new Map();
+export function defineFieldRule(options) {
+    if (ruleRegistry.has(options.name)) {
+        throw new Error(`fieldRule '${options.name}' is already defined — one rule per semantic`);
+    }
+    const ends = {};
+    for (const key of Object.keys(options.ends)) {
+        ends[key] = { name: key, description: options.ends[key].description };
+    }
+    const rule = {
+        type: 'fieldRule',
+        name: options.name,
+        description: options.description,
+        ends,
+    };
+    ruleRegistry.set(options.name, rule);
+    return rule;
+}

package/dist/flow.d.ts

@@ -1,15 +1,29 @@
 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';
+/** 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. */
@@ -19,8 +33,16 @@ export interface FlowSchema extends SchemaBase {
     /** Independent edges; a node may be start of many edges, so cycles are expressible. */
     edges: FlowEdge[];
 }
-export declare function node(name: string, flow?: FlowSchema, description?: string): FlowNode;
-export declare function edge(start: FlowNode, end: FlowNode, when?: string, description?: string): FlowEdge;
+export declare function node(name: string, options?: {
+    flow?: FlowSchema;
+    description?: string;
+    methods?: FlowMethodRef[];
+}): FlowNode;
+export declare function edge(start: FlowNode, end: FlowNode, options?: {
+    when?: string;
+    description?: string;
+    exception?: boolean;
+}): FlowEdge;
 export declare function defineFlow(name: string, schema: {
     start: FlowNode;
     edges: FlowEdge[];

package/dist/flow.js

@@ -1,9 +1,21 @@
-export function node(name, flow, description) {
-    return { name, flow, description };
+export function node(name, options = {}) {
+    return {
+        name,
+        flow: options.flow,
+        description: options.description,
+        methods: options.methods,
+    };
 }
-export function edge(start, end, when, description) {
+export function edge(start, end, options = {}) {
     // Auto name for uniformity with SchemaBase; `when` stays the branch marker.
-    return { name: `${start.name}->${end.name}`, start, end, when, description };
+    return {
+        name: `${start.name}->${end.name}`,
+        start,
+        end,
+        when: options.when,
+        description: options.description,
+        exception: options.exception,
+    };
 }
 export function defineFlow(name, schema) {
     const seen = new Set();

package/dist/index.d.ts

@@ -22,7 +22,12 @@ 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';
@@ -31,3 +36,5 @@ export * from './page-def.js';
 export * from './mermaid-driver.js';
 export * from './navigation.js';
 export * from './popup.js';
+export * from './method.js';
+export { toCamelCase, toPascalCase, toKebabCase } from '@pylonts/core';

package/dist/index.js

@@ -22,7 +22,12 @@ 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';
@@ -31,3 +36,7 @@ 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';