@pylonts/dsl 1.1.5 → 1.1.6

package/src/provider.ts

@@ -1,73 +1,68 @@
-import type { ImportBase } from './import-base.js';
-import type { ImportableSchemaBase } from './dsl.js';
-import type { DtoField, DtoMessage, DtoArrayField, DtoObjectField } from './dto.js';
-import type { ActionSchema } from './action.js';
-import type { RefSchema } from './ref.js';
-import type { ConvertSchema } from './convert.js';
-
-// ProviderSchema: an API function signature (args DTO + results DTO).
-
-/** Parameter data source for a call argument. */
-export type DataRef =
-  | { type: 'route'; key: string }
-  | { type: 'data';  key: string }
-  | { type: 'value'; value: unknown };
-
-/** Create a route-parameter reference. */
-export function route(key: string): DataRef {
-  return { type: 'route', key };
-}
-
-/** Create a page-data reference. */
-export function data(key: string): DataRef {
-  return { type: 'data', key };
-}
-
-export interface CallAction extends ActionSchema {
-  type: 'call';
-  func: ProviderSchema;
-  args?: Record<string, DtoField | DtoMessage | DtoArrayField | DtoObjectField | RefSchema | string>;
-}
-
-
-export function call(func: ProviderSchema, args?: Record<string, DtoField | DtoMessage | DtoArrayField | DtoObjectField | RefSchema | string>): CallAction {
-  return { name: func.name, type: 'call', func, args };
-}
-
-/** Provider function signature. The generated API client exposes one function
- *  per endpoint; ProviderSchema gives that function a name and types. */
-export interface ProviderSchema extends ImportableSchemaBase {
-  isAsync: boolean;
-  /** Input DTO (buildInput / buildQuery / buildPk result). */
-  args: DtoMessage;
-  /** Output DTO (buildOutput result) or primitive. */
-  results: DtoMessage | number | boolean | string;
-}
-
-/** Define a provider function. */
-export function defineProvider(
-  name: string,
-  schema: {
-    isAsync: boolean;
-    args: DtoMessage;
-    results: DtoMessage | number | boolean | string;
-    description?: string;
-    importRef?: ImportBase;
-  },
-): ProviderSchema {
-  return { name, ...schema };
-}
-
-/** Assign a call's result to a page data field.
- *  React: setState({ [field]: await ... }). Mini-program: this.setData({ [field]: ... }). */
-export interface SetDataAction extends ActionSchema {
-  type: 'setData';
-  call: CallAction;
-  field: DtoField;
-  /** Optional field-level transform before assignment. */
-  convert?: ConvertSchema;
-}
-
-export function setData(call: CallAction, field: DtoField, convert?: ConvertSchema): SetDataAction {
-  return { name: 'setData', type: 'setData', call, field, convert };
+import type { ImportBase } from './import-base.js';
+import type { ImportableSchemaBase } from './dsl.js';
+import type { DtoField, DtoMessage, DtoArrayField, DtoObjectField } from './dto.js';
+import type { ActionSchema } from './action.js';
+import type { RefSchema } from './ref.js';
+import type { EndpointSchema } from './endpoint.js';
+
+// ProviderSchema: an API function signature (args DTO + results DTO).
+
+/** Parameter data source for a call argument. */
+export type DataRef =
+  | { type: 'route'; key: string }
+  | { type: 'data';  key: string }
+  | { type: 'value'; value: unknown };
+
+/** Create a route-parameter reference. */
+export function route(key: string): DataRef {
+  return { type: 'route', key };
+}
+
+/** Create a page-data reference. */
+export function data(key: string): DataRef {
+  return { type: 'data', key };
+}
+
+export interface CallAction extends ActionSchema {
+  type: 'call';
+  func: ProviderSchema;
+  args?: Record<string, DtoField | DtoMessage | DtoArrayField | DtoObjectField | RefSchema | string>;
+}
+
+
+export function call(func: ProviderSchema, args?: Record<string, DtoField | DtoMessage | DtoArrayField | DtoObjectField | RefSchema | string>): CallAction {
+  return { name: func.name, type: 'call', func, args };
+}
+
+/** Provider function signature. The generated API client exposes one function
+ *  per endpoint; ProviderSchema gives that function a name and a shared signature. */
+export interface ProviderSchema extends ImportableSchemaBase {
+  isAsync: boolean;
+  /** Shared API signature — same instance the backend controller method references. */
+  signature: EndpointSchema;
+}
+
+/** Define a provider function. */
+export function defineProvider(
+  name: string,
+  schema: {
+    isAsync: boolean;
+    signature: EndpointSchema;
+    description?: string;
+    importRef?: ImportBase;
+  },
+): ProviderSchema {
+  return { name, ...schema };
+}
+
+/** Assign a call's result to a page data field.
+ *  React: setState({ [field]: await ... }). Mini-program: this.setData({ [field]: ... }). */
+export interface SetDataAction extends ActionSchema {
+  type: 'setData';
+  call: CallAction;
+  field: DtoField;
+}
+
+export function setData(call: CallAction, field: DtoField): SetDataAction {
+  return { name: 'setData', type: 'setData', call, field };
 }

package/src/service.ts

@@ -1,21 +1,43 @@
-import { SchemaBase } from './dsl.js';
-import { FrontAppSchema } from './project.js';
-import type { DtoArrayField, DtoField, DtoMessage, DtoObjectField } from './dto.js';
-
-/** A frontend service bound to exactly one frontend app. */
-export interface ServiceSchema extends SchemaBase {
-  type: 'service';
-  /** The frontend app this service belongs to (shared instance from project.config). */
-  app: FrontAppSchema;
-}
-
-export function defineService(name: string, app: FrontAppSchema, description?: string): ServiceSchema {
-  return { name, type: 'service', app, description };
-}
-
-/** A method exposed by a service. */
-export interface ServiceMethodSchema extends SchemaBase {
-  type: 'method';
-  name: string;
-  fields: Record<string, DtoField | DtoMessage | DtoArrayField | DtoObjectField>;
+import { SchemaBase } from './dsl.js';
+import { FrontAppSchema } from './project.js';
+import type { DtoArrayField, DtoField, DtoMessage, DtoObjectField } from './dto.js';
+
+/** A backend service serving exactly one frontend app (1:1 module). */
+export interface ServiceSchema extends SchemaBase {
+  type: 'service';
+  /** The frontend app this service serves (shared instance from project.config). */
+  app: FrontAppSchema;
+  /** Methods keyed by name — the map key is written back as the method name. */
+  methods: Record<string, ServiceMethodSchema>;
+}
+
+/** Method input for defineService: type/schema/name are set by the builder. */
+export type ServiceMethodDef = Omit<ServiceMethodSchema, 'type' | 'schema' | 'name'>;
+
+export function defineService(options: {
+  name: string;
+  app: FrontAppSchema;
+  methods: Record<string, ServiceMethodDef>;
+  description?: string;
+}): ServiceSchema {
+  const schema: ServiceSchema = {
+    type: 'service',
+    name: options.name,
+    description: options.description,
+    app: options.app,
+    methods: {},
+  };
+  for (const key of Object.keys(options.methods)) {
+    const method = options.methods[key] as ServiceMethodDef;
+    schema.methods[key] = { type: 'method', schema, ...method, name: key };
+  }
+  return schema;
+}
+
+/** A method exposed by a service. */
+export interface ServiceMethodSchema extends SchemaBase {
+  type: 'method';
+  schema : ServiceSchema;
+  args: DtoMessage,
+  results : DtoMessage
 }

package/src/third-service.ts

@@ -0,0 +1,186 @@
+import { CollectionSchemaBase, Field, SchemaBase } from './dsl.js';
+import type { FieldRuleEnd, FieldRuleSchema } from './field-rule.js';
+import type { ThirdApiSchema } from './project.js';
+
+// Third-party integration services.
+// A ThirdMethodSchema is the Field-collection counterpart of a DtoMessage —
+// like TableSchema.columns but for wire-format fields instead of DB columns.
+// DTOs project from it via from(thirdMethod), and its fields may either share
+// a local entity column instance (same fact, same type) or declare their own
+// wire type plus a refs link (same fact, different type/format).
+
+/** A third-party integration service (e.g. tenpay wechat pay).
+ *  Distinct from ServiceSchema (backend service bound to an app) and
+ *  ThirdApiSchema (project topology: the dir the integration lives in).
+ *  Describes the adapter class contract: constructor config + methods. */
+export interface ThirdServiceSchema extends SchemaBase {
+  type: 'thirdService';
+  /** The third-party system this service integrates (topology reference). */
+  schema: ThirdApiSchema;
+  /** Methods keyed by name — the map key is written back as the method name. */
+  methods: Record<string, ThirdServiceMethodSchema>;
+}
+
+/** A method exposed by a third-party service. */
+export interface ThirdServiceMethodSchema extends SchemaBase {
+  type: 'method';
+  schema: ThirdServiceSchema;
+  /** Input message — the Field-collection counterpart of a DtoMessage. */
+  args: ThirdMethodSchema;
+  /** Output message. */
+  results: ThirdMethodSchema;
+}
+
+/** Field binding to a rule: which end the local wire field stands on.
+ *  The ref always stands on the other end — from/to carry no extra information. */
+export interface ConvertFieldSchema {
+  /** The rule binding field and ref (rule = name + two ends). */
+  rule: FieldRuleSchema;
+  /** The end instance the local wire field stands on. */
+  end: FieldRuleEnd;
+}
+
+/** Same-fact variant link: a wire field carrying the same fact as a local
+ *  entity column under a different type/format (e.g. total_fee in fen vs amount in yuan). */
+export interface ThirdFieldRef {
+  /** Wire field defined in this message (local definition). */
+  field: Field;
+  /** Field in another schema (table column or another message). */
+  ref: Field;
+  /** Optional rule binding — omitted when the fact is merely linked, not converted. */
+  convert?: ConvertFieldSchema;
+}
+
+/** A directional message of a third-party method: a Field collection mirroring
+ *  TableSchema.columns, but fields hold wire-format names/types. A field may be
+ *  a shared instance of a local entity column (same fact, same type) — its
+ *  name/schema keep pointing at the table and the DTO projection inherits
+ *  type/semantics from the entity, exactly like from(table). */
+export interface ThirdMethodSchema extends CollectionSchemaBase {
+  type: 'thirdMethod';
+  /** The method this message belongs to (direction implied by args/results slot). */
+  schema: ThirdServiceMethodSchema;
+  /** Wire-format fields. */
+  fields: Record<string, Field>;
+  /** Same-fact variant links: wire field -> local entity column. */
+  refs?: ThirdFieldRef[];
+}
+
+/** Message input for defineThirdMethod: type/schema are set by the builder. */
+export type ThirdMethodDef = Omit<ThirdMethodSchema, 'type' | 'schema'>;
+
+/** Build a third-party method message. Writes back name/schema on own fields
+ *  (top-level and nested); shared entity columns keep their table identity and
+ *  must be keyed by their column name. */
+export function defineThirdMethod(def: ThirdMethodDef): ThirdMethodSchema {
+  const message: ThirdMethodSchema = {
+    type: 'thirdMethod',
+    name: def.name,
+    description: def.description,
+    // Filled by defineThirdService.
+    schema: undefined as unknown as ThirdServiceMethodSchema,
+    fields: def.fields,
+    refs: def.refs,
+  };
+  for (const key of Object.keys(message.fields)) {
+    const field = message.fields[key] as Field;
+    if (field.schema === undefined) {
+      field.name = key;
+      field.schema = message;
+    } else if (field.schema.type === 'table') {
+      // Shared entity column: from() names the projection after field.name, so
+      // a mismatched key would silently rename the wire field. Same-fact fields
+      // with different names go through refs instead.
+      if (field.name !== key) {
+        throw new Error(
+          `thirdMethod '${message.name}': shared column key '${key}' must match the column name '${field.name}' — ` +
+          `same-fact fields with different names go through refs instead`,
+        );
+      }
+    } else if (field.schema !== message) {
+      throw new Error(
+        `thirdMethod '${message.name}': field '${key}' already belongs to ${field.schema.type} '${field.schema.name}', cannot reuse`,
+      );
+    }
+    writeBackNested(message, field);
+  }
+  if (message.refs !== undefined) {
+    const ownFields = Object.values(message.fields);
+    for (const link of message.refs) {
+      if (!ownFields.includes(link.field)) {
+        throw new Error(`thirdMethod '${message.name}': ref field must be one of its fields`);
+      }
+      if (link.ref.schema === undefined || link.ref.schema === message) {
+        throw new Error(`thirdMethod '${message.name}': ref target '${link.ref.name}' must be defined in another schema`);
+      }
+      if (link.convert !== undefined) {
+        const ends = Object.values(link.convert.rule.ends);
+        if (!ends.includes(link.convert.end)) {
+          throw new Error(
+            `thirdMethod '${message.name}': convert end '${link.convert.end.name}' must be one of rule '${link.convert.rule.name}' ends`,
+          );
+        }
+      }
+    }
+  }
+  return message;
+}
+
+/** Write back name/schema on nested wire fields (array items, object properties);
+ *  shared entity columns keep their table identity. */
+function writeBackNested(message: ThirdMethodSchema, field: Field): void {
+  if (field.type === 'array') {
+    writeBackNested(message, field.items);
+    return;
+  }
+  if (field.type !== 'object') return;
+  for (const key of Object.keys(field.properties)) {
+    const child = field.properties[key] as Field;
+    if (child.schema === undefined) {
+      child.name = key;
+      child.schema = message;
+    }
+    writeBackNested(message, child);
+  }
+}
+
+/** Method input for defineThirdService: name is written back from the methods map key. */
+export interface ThirdServiceMethodDef {
+  /** Input message. */
+  args: ThirdMethodDef;
+  /** Output message. */
+  results: ThirdMethodDef;
+  description?: string;
+}
+
+export function defineThirdService(options: {
+  schema: ThirdApiSchema;
+  name: string;
+  methods: Record<string, ThirdServiceMethodDef>;
+  description?: string;
+}): ThirdServiceSchema {
+  const schema: ThirdServiceSchema = {
+    type: 'thirdService',
+    name: options.name,
+    description: options.description,
+    schema: options.schema,
+    methods: {},
+  };
+  for (const key of Object.keys(options.methods)) {
+    const method = options.methods[key] as ThirdServiceMethodDef;
+    const methodSchema: ThirdServiceMethodSchema = {
+      type: 'method',
+      name: key,
+      description: method.description,
+      schema,
+      args: undefined as unknown as ThirdMethodSchema,
+      results: undefined as unknown as ThirdMethodSchema,
+    };
+    methodSchema.args = defineThirdMethod(method.args);
+    methodSchema.results = defineThirdMethod(method.results);
+    methodSchema.args.schema = methodSchema;
+    methodSchema.results.schema = methodSchema;
+    schema.methods[key] = methodSchema;
+  }
+  return schema;
+}

package/src/typebox-driver.ts

@@ -1,5 +1,6 @@
 import { DtoArrayField, DtoField, DtoMessage, DtoObjectField, ImportBase, ImportRef } from './dto.js';
-import { Field } from './dsl.js';
+import { EnumField, Field } from './dsl.js';
+import type { ThirdMethodSchema } from './third-service.js';
 
 // TypeBox driver: renders a DtoMessage into TypeBox TypeScript source.
 // Shape matches the codegen product consumed by fastify v5 TypeBoxTypeProvider:
@@ -27,6 +28,7 @@ function renderBasic(
   pattern: string | undefined,
   defaultValue: unknown,
   resolver: EnumResolver | undefined,
+  indent = 0,
 ): string {
   if (pattern !== undefined && field.type !== 'string') {
     throw new Error(`pattern is only supported on string fields, got ${field.type} (${field.name})`);
@@ -77,15 +79,35 @@ function renderBasic(
       }
       return `Type.Enum(${ref.name})`;
     }
+    case 'array':
+      return `Type.Array(${renderFieldValue(field.items, indent, resolver)})`;
+    case 'object':
+      return renderFieldObject(field.properties, indent + 1, resolver);
     default:
       // Field union is exhaustive; this branch is unreachable at runtime.
       throw new Error(`unsupported field type: ${String((field as Field).type)}`);
   }
 }
 
-function renderObject(fields: Record<string, DtoField>, indent: number, resolver: EnumResolver | undefined): string {
+/** Render a plain Field value (wire-format nested fields), wrapping optional. */
+function renderFieldValue(field: Field, indent: number, resolver: EnumResolver | undefined): string {
+  const base = renderBasic(field, undefined, undefined, resolver, indent);
+  return field.optional ? `Type.Optional(${base})` : base;
+}
+
+/** Render a plain Field object (wire-format nested object). */
+function renderFieldObject(properties: Record<string, Field>, indent: number, resolver: EnumResolver | undefined): string {
+  const pad = '  '.repeat(indent);
+  const entries = Object.entries(properties).map(([name, f]) => `${pad}${name}: ${renderFieldValue(f, indent, resolver)}`);
+  return `Type.Object({\n${entries.join(',\n')}\n${'  '.repeat(indent - 1)}})`;
+}
+
+function renderObject(fields: Record<string, DtoField | Field>, indent: number, resolver: EnumResolver | undefined): string {
   const pad = '  '.repeat(indent);
-  const entries = Object.entries(fields).map(([name, f]) => `${pad}${name}: ${renderField(f, indent, resolver)}`);
+  const entries = Object.entries(fields).map(([name, f]) => {
+    const rendered = isDtoField(f) ? renderField(f, indent, resolver) : renderFieldValue(f, indent, resolver);
+    return `${pad}${name}: ${rendered}`;
+  });
   return `Type.Object({\n${entries.join(',\n')}\n${'  '.repeat(indent - 1)}})`;
 }
 
@@ -99,7 +121,8 @@ function renderValue(f: DtoField, indent: number, resolver: EnumResolver | undef
     const items = f.field.items;
     // Referenced DTO element — render by name (same-file export), not expanded.
     if (isDtoMessage(items)) return `Type.Array(${items.name})`;
-    return `Type.Array(${renderField(items, indent + 1, resolver)})`;
+    if (isDtoField(items)) return `Type.Array(${renderField(items, indent + 1, resolver)})`;
+    return `Type.Array(${renderFieldValue(items, indent, resolver)})`;
   }
   if (f.field.type === 'object') {
     return renderObject(f.field.properties, indent + 1, resolver);
@@ -107,7 +130,7 @@ function renderValue(f: DtoField, indent: number, resolver: EnumResolver | undef
   // DtoField only wraps a database Field; array/object defs live in the subclasses.
   // Only DTO-level defaults (setDefault) are emitted as TypeBox default
   // annotations; DB field defaults are not carried into the API contract.
-  return renderBasic(f.field as Field, f.pattern, f.default, resolver);
+  return renderBasic(f.field as Field, f.pattern, f.default, resolver, indent);
 }
 
 /** Structural check — DtoMessage instances may come from a different module copy, so instanceof is unreliable. */
@@ -116,6 +139,12 @@ function isDtoMessage(v: unknown): v is DtoMessage {
   return (v as Record<string, unknown>).type === 'dto';
 }
 
+/** Structural check — a DtoField wraps a Field in a .field property and has no .type of its own. */
+function isDtoField(v: unknown): v is DtoField {
+  if (typeof v !== 'object' || v === null) return false;
+  return 'field' in v && !('type' in v);
+}
+
 function collectEnumImports(
   f: DtoField,
   resolver: EnumResolver | undefined,
@@ -123,18 +152,45 @@ function collectEnumImports(
 ): void {
   if (f.field.type === 'array') {
     const items = f.field.items;
-    if (!isDtoMessage(items)) collectEnumImports(items, resolver, out);
+    if (isDtoMessage(items)) return;
+    if (isDtoField(items)) {
+      collectEnumImports(items, resolver, out);
+      return;
+    }
+    collectFieldEnumImports(items, resolver, out);
     return;
   }
   if (f.field.type === 'object') {
-    for (const child of Object.values(f.field.properties)) collectEnumImports(child, resolver, out);
+    for (const child of Object.values(f.field.properties)) {
+      if (isDtoField(child)) collectEnumImports(child, resolver, out);
+      else collectFieldEnumImports(child, resolver, out);
+    }
     return;
   }
-  if (f.field.type === 'enum') {
-    const ref = resolver?.(f.field.enum.jsName);
-    if (!ref) throw new Error(`enum field ${f.field.name}: no import ref for ${f.field.enum.jsName} — pass an EnumResolver`);
-    out.set(`${ref.from}#${ref.name}`, ref);
+  if (f.field.type === 'enum') collectEnumRef(f.field, resolver, out);
+}
+
+/** Enum import collection over a plain Field (wire-format nested fields). */
+function collectFieldEnumImports(
+  field: Field,
+  resolver: EnumResolver | undefined,
+  out: Map<string, ImportBase>,
+): void {
+  if (field.type === 'array') {
+    collectFieldEnumImports(field.items, resolver, out);
+    return;
   }
+  if (field.type === 'object') {
+    for (const child of Object.values(field.properties)) collectFieldEnumImports(child, resolver, out);
+    return;
+  }
+  if (field.type === 'enum') collectEnumRef(field, resolver, out);
+}
+
+function collectEnumRef(field: EnumField, resolver: EnumResolver | undefined, out: Map<string, ImportBase>): void {
+  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`);
+  out.set(`${ref.from}#${ref.name}`, ref);
 }
 
 /** Collect all imports needed to render a DTO: include() bases + enum references. */
@@ -191,4 +247,19 @@ function renderBase(base: ImportRef): string {
   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(', ')})`;
+}
+
+/** Render one third-party method message export (const only — pair with
+ *  renderDtoTypeExport for the Static type). */
+export function renderThirdMethodExport(schema: ThirdMethodSchema, resolver: EnumResolver | undefined): string {
+  return `export const ${schema.name} = ${renderFieldObject(schema.fields, 1, resolver)};`;
+}
+
+/** Collect all imports needed to render a third-party method message: enum references. */
+export function collectThirdMethodImports(
+  schema: ThirdMethodSchema,
+  resolver: EnumResolver | undefined,
+  out: Map<string, ImportBase>,
+): void {
+  for (const f of Object.values(schema.fields)) collectFieldEnumImports(f, resolver, out);
 }

package/src/utils.ts

@@ -1,27 +1,64 @@
-// ── naming conversions ──
-
-/** snake_case → camelCase: mer_id → merId; names without underscores are unchanged */
-export function toCamelCase(name: string): string {
-  return name.replace(/_([a-z])/g, (_, c: string) => c.toUpperCase());
-}
-
-/** snake_case → PascalCase: mer_id → MerId */
-export function toPascalCase(snake: string): string {
-  return snake.replace(/(^|_)([a-z])/g, (_m, _p, c: string) => c.toUpperCase());
-}
-
-// ── schema ──
-
-import { SchemaBase } from './dsl.js';
-import { FrontAppSchema } from './project.js';
-
-/** A utility module bound to exactly one frontend app. */
-export interface UtilsSchema extends SchemaBase {
-  type: 'utils';
-  /** The frontend app this utility module belongs to (shared instance from project.config). */
-  app: FrontAppSchema;
-}
-
-export function defineUtils(name: string, app: FrontAppSchema, description?: string): UtilsSchema {
-  return { name, type: 'utils', app, description };
+import type { Field, SchemaBase } from './dsl.js';
+import type { FrontAppSchema } from './project.js';
+
+// Base utility modules — business-agnostic helpers with full method
+// signatures (e.g. DateTimeUtils.format). Called at the service layer;
+// their args/results are own wire types, independent of business schemas.
+
+/** A utility method with a full signature. */
+export interface UtilsMethodSchema extends SchemaBase {
+  type: 'utilsMethod';
+  /** The utility module this method belongs to. */
+  schema: UtilsSchema;
+  /** Input fields. */
+  args: Record<string, Field>;
+  /** Output field. */
+  result: Field;
+}
+
+/** Method input for defineUtils: type/schema/name are set by the builder. */
+export type UtilsMethodDef = Omit<UtilsMethodSchema, 'type' | 'schema' | 'name'>;
+
+/** A base utility module (e.g. DateTimeUtils). */
+export interface UtilsSchema extends SchemaBase {
+  type: 'utils';
+  /** Optional binding — empty means a shared public module. */
+  app?: FrontAppSchema;
+  /** Methods keyed by name — the map key is written back as the method name. */
+  methods: Record<string, UtilsMethodSchema>;
+}
+
+export function defineUtils(options: {
+  name: string;
+  app?: FrontAppSchema;
+  methods: Record<string, UtilsMethodDef>;
+  description?: string;
+}): UtilsSchema {
+  const schema: UtilsSchema = {
+    type: 'utils',
+    name: options.name,
+    description: options.description,
+    app: options.app,
+    methods: {},
+  };
+  for (const key of Object.keys(options.methods)) {
+    const method = options.methods[key] as UtilsMethodDef;
+    const methodSchema: UtilsMethodSchema = {
+      type: 'utilsMethod',
+      name: key,
+      description: method.description,
+      schema,
+      args: method.args,
+      result: method.result,
+    };
+    for (const argKey of Object.keys(methodSchema.args)) {
+      const field = methodSchema.args[argKey] as Field;
+      field.name = argKey;
+      field.schema = methodSchema;
+    }
+    methodSchema.result.name = key;
+    methodSchema.result.schema = methodSchema;
+    schema.methods[key] = methodSchema;
+  }
+  return schema;
 }

package/dist/check-inheritance.d.ts

@@ -1,9 +0,0 @@
-export interface InheritanceIssue {
-    file: string;
-    container: string;
-    field: string;
-    /** e.g. ["t_order.order_no"] or ["t_order.id", "t_merchant.id"] when several inferred tables share the name */
-    candidates: string[];
-}
-/** Check one loaded DSL module (its exports) for inheritance gaps. */
-export declare function checkInheritance(mod: Record<string, unknown>, file: string): InheritanceIssue[];