@pylonts/dsl 1.1.18 → 1.1.19

package/dist/dto.d.ts

@@ -103,6 +103,12 @@ export declare function dtoField(field: Field | DtoArrayFieldDef | DtoObjectFiel
 export declare function isDtoMessage(v: unknown): v is DtoMessage;
 /** Structural check — a DtoField wraps a Field in a .field property and has no .type of its own. */
 export declare function isDtoField(v: unknown): v is DtoField;
+/** TS type of a DtoField in generated code — unwraps the wrapped field
+ *  (enum → its JS name, date/datetime → string, containers → jsType). */
+export declare function dtoFieldJsType(df: DtoField): string;
+/** Enum JS names referenced by a DtoField, recursing into inline array/object
+ *  wrappers; DtoMessage item references stop the walk. First-occurrence order. */
+export declare function dtoCollectEnumRefs(df: DtoField, out?: string[]): string[];
 export declare function dtoArrayField(def: {
     items: DtoField | DtoMessage;
 } & Omit<BaseField, 'name'>): DtoArrayField;

package/dist/dto.js

@@ -119,6 +119,34 @@ export function isDtoField(v) {
         return false;
     return 'field' in v && !('type' in v);
 }
+/** TS type of a DtoField in generated code — unwraps the wrapped field
+ *  (enum → its JS name, date/datetime → string, containers → jsType). */
+export function dtoFieldJsType(df) {
+    const f = df.field;
+    if (f.type === 'enum')
+        return f.enum.jsName;
+    if (f.type === 'date' || f.type === 'datetime')
+        return 'string';
+    return f.jsType;
+}
+/** Enum JS names referenced by a DtoField, recursing into inline array/object
+ *  wrappers; DtoMessage item references stop the walk. First-occurrence order. */
+export function dtoCollectEnumRefs(df, out = []) {
+    const f = df.field;
+    if (f.type === 'enum') {
+        out.push(f.enum.jsName);
+    }
+    else if (f.type === 'array') {
+        const items = f.items;
+        if (isDtoField(items))
+            dtoCollectEnumRefs(items, out);
+    }
+    else if (f.type === 'object') {
+        for (const child of Object.values(f.properties))
+            dtoCollectEnumRefs(child, out);
+    }
+    return out;
+}
 export function dtoArrayField(def) {
     // Items stay as-is: an inline DtoField is rendered inline, a DtoMessage is
     // referenced by name (the driver renders Type.Array(<DtoName>)).

package/dist/utils.d.ts

@@ -1,13 +1,16 @@
 import type { CollectionSchemaBase, Field, SchemaBase } from './dsl.js';
+import type { DtoField } from './dto.js';
 import type { FrontAppSchema, ProjectApiSchema } from './project.js';
 /** 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. */
+    /** Input fields — DtoField wrappers (dtoField(...)); may wrap table columns. */
+    args: Record<string, DtoField>;
+    /** Output field — a plain inline Field (boolean for checks, decimal for
+     *  computed amounts, ...). The method output is a fresh value, never a
+     *  shared table column. */
     result: Field;
 }
 /** Method input for defineUtils: type/schema/name are set by the builder. */

package/dist/utils.js

@@ -20,13 +20,23 @@ export function defineUtils(options) {
             args: method.args,
             result: method.result,
         };
+        // Args: write back on the DtoField wrapper only (safe: wrappers are
+        // created per method via dtoField(), never shared). Inline fields get
+        // their underlying Field written back too; fields wrapping table columns
+        // (domain rules) keep the shared column instance untouched — its
+        // name/schema already point to the table.
         for (const argKey of Object.keys(methodSchema.args)) {
-            const field = methodSchema.args[argKey];
-            field.name = argKey;
-            field.schema = methodSchema;
+            const df = methodSchema.args[argKey];
+            df.name = argKey;
+            df.schema = schema;
+            if (df.field.schema === undefined) {
+                df.field.name = argKey;
+                df.field.schema = schema;
+            }
         }
+        // Result: a plain inline Field — write name/schema back directly.
         methodSchema.result.name = key;
-        methodSchema.result.schema = methodSchema;
+        methodSchema.result.schema = schema;
         schema.methods[key] = methodSchema;
     }
     return schema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pylonts/dsl",
-  "version": "1.1.18",
+  "version": "1.1.19",
   "description": "Schema definition DSL with drivers: MySQL DDL, TS enum, TypeBox schema codegen.",
   "type": "module",
   "main": "dist/index.js",

package/src/dto.ts

@@ -185,6 +185,30 @@ export function isDtoField(v: unknown): v is DtoField {
   return 'field' in v && !('type' in v);
 }
 
+/** TS type of a DtoField in generated code — unwraps the wrapped field
+ *  (enum → its JS name, date/datetime → string, containers → jsType). */
+export function dtoFieldJsType(df: DtoField): string {
+  const f = df.field;
+  if (f.type === 'enum') return f.enum.jsName;
+  if (f.type === 'date' || f.type === 'datetime') return 'string';
+  return f.jsType;
+}
+
+/** Enum JS names referenced by a DtoField, recursing into inline array/object
+ *  wrappers; DtoMessage item references stop the walk. First-occurrence order. */
+export function dtoCollectEnumRefs(df: DtoField, out: string[] = []): string[] {
+  const f = df.field;
+  if (f.type === 'enum') {
+    out.push(f.enum.jsName);
+  } else if (f.type === 'array') {
+    const items = f.items;
+    if (isDtoField(items)) dtoCollectEnumRefs(items, out);
+  } else if (f.type === 'object') {
+    for (const child of Object.values(f.properties)) dtoCollectEnumRefs(child, out);
+  }
+  return out;
+}
+
 export function dtoArrayField(def: { items: DtoField | DtoMessage } & Omit<BaseField, 'name'>): DtoArrayField {
   // Items stay as-is: an inline DtoField is rendered inline, a DtoMessage is
   // referenced by name (the driver renders Type.Array(<DtoName>)).

package/src/utils.ts

@@ -1,18 +1,26 @@
 import type { CollectionSchemaBase, Field, SchemaBase } from './dsl.js';
+import type { DtoField } from './dto.js';
 import type { FrontAppSchema, ProjectApiSchema } 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 utils whose name matches a table name is a domain rule module: its
+// methods may wrap table columns via dtoField(table.columns.x) — the DtoField
+// wrapper owns the write-back, so the shared column instance is never
+// mutated (same rule as buildMessage: only inline fields get their
+// underlying Field written back).
 
 /** 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. */
+  /** Input fields — DtoField wrappers (dtoField(...)); may wrap table columns. */
+  args: Record<string, DtoField>;
+  /** Output field — a plain inline Field (boolean for checks, decimal for
+   *  computed amounts, ...). The method output is a fresh value, never a
+   *  shared table column. */
   result: Field;
 }
 
@@ -62,13 +70,23 @@ export function defineUtils(options: {
       args: method.args,
       result: method.result,
     };
+    // Args: write back on the DtoField wrapper only (safe: wrappers are
+    // created per method via dtoField(), never shared). Inline fields get
+    // their underlying Field written back too; fields wrapping table columns
+    // (domain rules) keep the shared column instance untouched — its
+    // name/schema already point to the table.
     for (const argKey of Object.keys(methodSchema.args)) {
-      const field = methodSchema.args[argKey] as Field;
-      field.name = argKey;
-      field.schema = methodSchema;
+      const df = methodSchema.args[argKey] as DtoField;
+      df.name = argKey;
+      df.schema = schema;
+      if (df.field.schema === undefined) {
+        df.field.name = argKey;
+        df.field.schema = schema;
+      }
     }
+    // Result: a plain inline Field — write name/schema back directly.
     methodSchema.result.name = key;
-    methodSchema.result.schema = methodSchema;
+    methodSchema.result.schema = schema;
     schema.methods[key] = methodSchema;
   }
   return schema;