@pylonts/dsl 1.0.4 → 1.0.6

package/dist/bases.d.ts

@@ -0,0 +1,5 @@
+import type { DtoMessage, ImportRef } from './dto';
+/** Paginated query request base — renders `import { PageRequest } from '@pylonts/core'` + Intersect */
+export declare const PageRequest: ImportRef;
+/** Paginated list response base — renders `import { PageResult } from '@pylonts/core'` + `PageResult(<row>)` */
+export declare const PageResult: (row: DtoMessage) => ImportRef;

package/dist/bases.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageResult = exports.PageRequest = void 0;
+// Named base-schema references for common protocol DTOs.
+//
+// These are ImportRef metadata (not re-exports of the actual TypeBox schemas):
+// the DSL stores { from, name } so the generator can emit the import line and
+// the identifier — the runtime schema object itself is never loaded by the DSL.
+//
+// `import { PageRequest } from '@pylonts/dsl'` therefore gives .include() an
+// already-resolved reference — no static analysis or name lookup needed.
+/** Paginated query request base — renders `import { PageRequest } from '@pylonts/core'` + Intersect */
+exports.PageRequest = { from: '@pylonts/core', name: 'PageRequest' };
+/** Paginated list response base — renders `import { PageResult } from '@pylonts/core'` + `PageResult(<row>)` */
+const PageResult = (row) => ({
+    from: '@pylonts/core',
+    name: 'PageResult',
+    args: [row],
+});
+exports.PageResult = PageResult;

package/dist/check-inheritance.d.ts

@@ -0,0 +1,9 @@
+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[];

package/dist/check-inheritance.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkInheritance = checkInheritance;
+/** snake_case → camelCase: order_no → orderNo; names without underscores are unchanged */
+function toCamelCase(name) {
+    return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function isDtoMessage(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const o = v;
+    return o.type === 'dto' && typeof o.name === 'string' && typeof o.fields === 'object' && o.fields !== null;
+}
+function collectFields(mod) {
+    const out = [];
+    for (const [name, v] of Object.entries(mod)) {
+        if (isDtoMessage(v)) {
+            const container = v;
+            for (const [fname, f] of Object.entries(container.fields)) {
+                out.push({ name: fname, field: f.field, container: name });
+            }
+        }
+    }
+    return out;
+}
+/** Check one loaded DSL module (its exports) for inheritance gaps. */
+function checkInheritance(mod, file) {
+    const fields = collectFields(mod);
+    if (fields.length === 0)
+        return [];
+    // Infer the tables this file is about from the referenced fields' schema identity.
+    const tables = new Map(); // table -> camelCol -> origCol
+    for (const f of fields) {
+        const schema = f.field.schema;
+        if (schema?.type !== 'table')
+            continue;
+        const table = schema;
+        if (!tables.has(table.name))
+            tables.set(table.name, new Map());
+        tables.get(table.name).set(toCamelCase(f.name), f.name);
+    }
+    if (tables.size === 0)
+        return [];
+    const issues = [];
+    for (const f of fields) {
+        if (f.field.schema?.type === 'table')
+            continue;
+        if (f.field.semantic !== undefined || f.field.type === 'enum')
+            continue;
+        const candidates = [];
+        for (const [t, cols] of tables) {
+            const orig = cols.get(f.name);
+            if (orig !== undefined)
+                candidates.push(`${t}.${orig}`);
+        }
+        if (candidates.length > 0) {
+            issues.push({ file, container: f.container, field: f.name, candidates });
+        }
+    }
+    return issues;
+}

package/dist/dto.d.ts

@@ -21,7 +21,8 @@ export interface ImportRef {
 export type DtoArrayFieldDef = BaseField & {
     type: 'array';
     jsType: 'array';
-    items: DtoField;
+    /** Element type: inline DtoField, or a reference to an existing DTO (rendered by name) */
+    items: DtoField | DtoMessage;
 };
 export type DtoObjectFieldDef = BaseField & {
     type: 'object';
@@ -46,6 +47,8 @@ export declare class DtoField implements SchemaBase {
     setPattern(value: string): this;
     setDescription(value: string): this;
     getDescription(): string | undefined;
+    /** True when this field wraps a DB column (picked via from()); false for inline fields. */
+    isColumn(): boolean;
     setOptional(value: boolean): this;
     /** Set a default value — emitted as a TypeBox schema default annotation */
     setDefault(value: unknown): this;
@@ -56,7 +59,8 @@ export declare class DtoField implements SchemaBase {
 }
 export declare class DtoArrayField extends DtoField {
     field: DtoArrayFieldDef;
-    items(): DtoField;
+    /** Element type: inline DtoField or a referenced DtoMessage (rendered by name). */
+    items(): DtoField | DtoMessage;
 }
 export declare class DtoObjectField extends DtoField {
     field: DtoObjectFieldDef;

package/dist/dto.js

@@ -39,6 +39,10 @@ class DtoField {
     getDescription() {
         return this.description;
     }
+    /** True when this field wraps a DB column (picked via from()); false for inline fields. */
+    isColumn() {
+        return this.field.schema?.type === 'table';
+    }
     setOptional(value) {
         this.optional = value;
         return this;
@@ -62,6 +66,7 @@ class DtoField {
 }
 exports.DtoField = DtoField;
 class DtoArrayField extends DtoField {
+    /** Element type: inline DtoField or a referenced DtoMessage (rendered by name). */
     items() {
         return this.field.items;
     }
@@ -106,11 +111,9 @@ function dtoField(field) {
     return new DtoField(field);
 }
 function dtoArrayField(def) {
-    // Reuse an existing DTO as the array element: expand its fields into an object.
-    const items = def.items instanceof DtoMessage
-        ? new DtoObjectField({ name: '', type: 'object', jsType: 'object', properties: def.items.fields })
-        : def.items;
-    return new DtoArrayField({ name: '', type: 'array', jsType: 'array', ...def, items });
+    // 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) {
     return new DtoObjectField({ name: '', type: 'object', jsType: 'object', ...def });

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './dsl';
 export * from './dto';
+export * from './bases';
 export * from './utils';
 export * from './project';
 export * from './prototype';
@@ -7,6 +8,7 @@ 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';

package/dist/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 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);
@@ -23,6 +24,7 @@ __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);

package/dist/typebox-driver.js

@@ -84,7 +84,11 @@ function renderField(f, indent, resolver) {
 }
 function renderValue(f, indent, resolver) {
     if (f instanceof dto_1.DtoArrayField) {
-        return `Type.Array(${renderField(f.items(), indent + 1, resolver)})`;
+        const items = f.items();
+        // Referenced DTO element — render by name (same-file export), not expanded.
+        if (items instanceof dto_1.DtoMessage)
+            return `Type.Array(${items.name})`;
+        return `Type.Array(${renderField(items, indent + 1, resolver)})`;
     }
     if (f instanceof dto_1.DtoObjectField) {
         return renderObject(f.properties(), indent + 1, resolver);
@@ -97,7 +101,9 @@ function renderValue(f, indent, resolver) {
 }
 function collectEnumImports(f, resolver, out) {
     if (f instanceof dto_1.DtoArrayField) {
-        collectEnumImports(f.items(), resolver, out);
+        const items = f.items();
+        if (!(items instanceof dto_1.DtoMessage))
+            collectEnumImports(items, resolver, out);
         return;
     }
     if (f instanceof dto_1.DtoObjectField) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pylonts/dsl",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Schema definition DSL with drivers: MySQL DDL, TS enum, TypeBox schema codegen.",
   "type": "commonjs",
   "main": "src/index.ts",

package/src/bases.ts

@@ -0,0 +1,20 @@
+import type { DtoMessage, ImportRef } from './dto';
+
+// Named base-schema references for common protocol DTOs.
+//
+// These are ImportRef metadata (not re-exports of the actual TypeBox schemas):
+// the DSL stores { from, name } so the generator can emit the import line and
+// the identifier — the runtime schema object itself is never loaded by the DSL.
+//
+// `import { PageRequest } from '@pylonts/dsl'` therefore gives .include() an
+// already-resolved reference — no static analysis or name lookup needed.
+
+/** Paginated query request base — renders `import { PageRequest } from '@pylonts/core'` + Intersect */
+export const PageRequest: ImportRef = { from: '@pylonts/core', name: 'PageRequest' };
+
+/** Paginated list response base — renders `import { PageResult } from '@pylonts/core'` + `PageResult(<row>)` */
+export const PageResult = (row: DtoMessage): ImportRef => ({
+  from: '@pylonts/core',
+  name: 'PageResult',
+  args: [row],
+});

package/src/check-inheritance.ts

@@ -0,0 +1,86 @@
+import type { DtoMessage } from './dto';
+import type { TableSchema } from './dsl';
+
+// Inheritance check — find DTO fields that should inherit from a DB column
+// (via from()) but were written by hand, so they miss the column's
+// type / semantic / optionality backfill.
+//
+// Inference: the tables a DSL file is about are inferred from the referenced
+// fields in the same file (each Field carries schema identity via .schema).
+// A field without a table ref whose name matches a column of an inferred table
+// is a candidate for inheritance. Fields with an explicit semantic or enum type
+// are treated as author-intent and skipped.
+//
+// False-positive boundary: when a DSL file has zero referenced fields, no table
+// can be inferred and nothing is reported (never guess which table a hand-written
+// field belongs to).
+
+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[];
+}
+
+/** snake_case → camelCase: order_no → orderNo; names without underscores are unchanged */
+function toCamelCase(name: string): string {
+  return name.replace(/_([a-z])/g, (_, c: string) => c.toUpperCase());
+}
+
+function isDtoMessage(v: unknown): v is DtoMessage {
+  if (typeof v !== 'object' || v === null) return false;
+  const o = v as Record<string, unknown>;
+  return o.type === 'dto' && typeof o.name === 'string' && typeof o.fields === 'object' && o.fields !== null;
+}
+
+interface FieldEntry {
+  name: string;
+  field: { schema?: { type?: string }; semantic?: string; type?: string };
+  container: string;
+}
+
+function collectFields(mod: Record<string, unknown>): FieldEntry[] {
+  const out: FieldEntry[] = [];
+  for (const [name, v] of Object.entries(mod)) {
+    if (isDtoMessage(v)) {
+      const container = v as { fields: Record<string, { field: FieldEntry['field'] }> };
+      for (const [fname, f] of Object.entries(container.fields)) {
+        out.push({ name: fname, field: f.field, container: name });
+      }
+    }
+  }
+  return out;
+}
+
+/** Check one loaded DSL module (its exports) for inheritance gaps. */
+export function checkInheritance(mod: Record<string, unknown>, file: string): InheritanceIssue[] {
+  const fields = collectFields(mod);
+  if (fields.length === 0) return [];
+
+  // Infer the tables this file is about from the referenced fields' schema identity.
+  const tables = new Map<string, Map<string, string>>(); // table -> camelCol -> origCol
+  for (const f of fields) {
+    const schema = f.field.schema;
+    if (schema?.type !== 'table') continue;
+    const table = schema as TableSchema;
+    if (!tables.has(table.name)) tables.set(table.name, new Map());
+    tables.get(table.name)!.set(toCamelCase(f.name), f.name);
+  }
+  if (tables.size === 0) return [];
+
+  const issues: InheritanceIssue[] = [];
+  for (const f of fields) {
+    if (f.field.schema?.type === 'table') continue;
+    if (f.field.semantic !== undefined || f.field.type === 'enum') continue;
+    const candidates: string[] = [];
+    for (const [t, cols] of tables) {
+      const orig = cols.get(f.name);
+      if (orig !== undefined) candidates.push(`${t}.${orig}`);
+    }
+    if (candidates.length > 0) {
+      issues.push({ file, container: f.container, field: f.name, candidates });
+    }
+  }
+  return issues;
+}

package/src/dto.ts

@@ -29,7 +29,8 @@ export interface ImportRef {
 export type DtoArrayFieldDef = BaseField & {
   type: 'array';
   jsType: 'array';
-  items: DtoField;
+  /** Element type: inline DtoField, or a reference to an existing DTO (rendered by name) */
+  items: DtoField | DtoMessage;
 };
 
 export type DtoObjectFieldDef = BaseField & {
@@ -72,6 +73,11 @@ export class DtoField implements SchemaBase {
     return this.description;
   }
 
+  /** True when this field wraps a DB column (picked via from()); false for inline fields. */
+  isColumn(): boolean {
+    return this.field.schema?.type === 'table';
+  }
+
   setOptional(value: boolean): this {
     this.optional = value;
     return this;
@@ -99,7 +105,8 @@ export class DtoField implements SchemaBase {
 export class DtoArrayField extends DtoField {
   declare field: DtoArrayFieldDef;
 
-  items(): DtoField {
+  /** Element type: inline DtoField or a referenced DtoMessage (rendered by name). */
+  items(): DtoField | DtoMessage {
     return this.field.items;
   }
 }
@@ -148,11 +155,9 @@ export function dtoField(field: Field): DtoField {
 }
 
 export function dtoArrayField(def: { items: DtoField | DtoMessage } & Omit<BaseField, 'name'>): DtoArrayField {
-  // Reuse an existing DTO as the array element: expand its fields into an object.
-  const items = def.items instanceof DtoMessage
-    ? new DtoObjectField({ name: '', type: 'object', jsType: 'object', properties: def.items.fields })
-    : def.items;
-  return new DtoArrayField({ name: '', type: 'array', jsType: 'array', ...def, items });
+  // 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 });
 }
 
 export function dtoObjectField(def: { properties: Record<string, DtoField> } & Omit<BaseField, 'name'>): DtoObjectField {

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './dsl';
 export * from './dto';
+export * from './bases';
 export * from './utils';
 export * from './project';
 export * from './prototype';
@@ -7,6 +8,7 @@ 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';

package/src/typebox-driver.ts

@@ -95,7 +95,10 @@ function renderField(f: DtoField, indent: number, resolver: EnumResolver | undef
 
 function renderValue(f: DtoField, indent: number, resolver: EnumResolver | undefined): string {
   if (f instanceof DtoArrayField) {
-    return `Type.Array(${renderField(f.items(), indent + 1, resolver)})`;
+    const items = f.items();
+    // Referenced DTO element — render by name (same-file export), not expanded.
+    if (items instanceof DtoMessage) return `Type.Array(${items.name})`;
+    return `Type.Array(${renderField(items, indent + 1, resolver)})`;
   }
   if (f instanceof DtoObjectField) {
     return renderObject(f.properties(), indent + 1, resolver);
@@ -113,7 +116,8 @@ function collectEnumImports(
   out: Map<string, ImportRef>,
 ): void {
   if (f instanceof DtoArrayField) {
-    collectEnumImports(f.items(), resolver, out);
+    const items = f.items();
+    if (!(items instanceof DtoMessage)) collectEnumImports(items, resolver, out);
     return;
   }
   if (f instanceof DtoObjectField) {