@pylonts/dsl 1.0.2 → 1.0.4

package/src/typebox-driver.ts

@@ -17,24 +17,37 @@ function renderString(s: string): string {
   return `'${s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
 }
 
-function renderBasic(field: Field, pattern: string | undefined, resolver: EnumResolver | undefined): string {
+function renderDefault(v: unknown): string {
+  if (typeof v === 'string') return renderString(v);
+  return JSON.stringify(v);
+}
+
+function renderBasic(
+  field: Field,
+  pattern: string | undefined,
+  defaultValue: unknown,
+  resolver: EnumResolver | undefined,
+): string {
   if (pattern !== undefined && field.type !== 'string') {
     throw new Error(`pattern is only supported on string fields, got ${field.type} (${field.name})`);
   }
+  const def = defaultValue !== undefined ? `default: ${renderDefault(defaultValue)}` : undefined;
   switch (field.type) {
     case 'string': {
       const opts: string[] = [];
       if (field.minLength !== undefined) opts.push(`minLength: ${field.minLength}`);
       if (field.maxLength !== undefined) opts.push(`maxLength: ${field.maxLength}`);
       if (pattern !== undefined) opts.push(`pattern: ${renderString(pattern)}`);
+      if (def !== undefined) opts.push(def);
       return opts.length > 0 ? `Type.String({ ${opts.join(', ')} })` : 'Type.String()';
     }
     case 'text':
-      return 'Type.String()';
+      return def !== undefined ? `Type.String({ ${def} })` : 'Type.String()';
     case 'integer': {
       const opts: string[] = [];
       if (field.min !== undefined) opts.push(`minimum: ${field.min}`);
       if (field.max !== undefined) opts.push(`maximum: ${field.max}`);
+      if (def !== undefined) opts.push(def);
       return opts.length > 0 ? `Type.Integer({ ${opts.join(', ')} })` : 'Type.Integer()';
     }
     case 'bigint':
@@ -44,14 +57,23 @@ function renderBasic(field: Field, pattern: string | undefined, resolver: EnumRe
     case 'datetime':
       // Transmitted as string over HTTP: bigint/decimal keep full precision,
       // date/time serialize to string.
-      return 'Type.String()';
+      return def !== undefined ? `Type.String({ ${def} })` : 'Type.String()';
     case 'boolean':
-      return 'Type.Boolean()';
+      return def !== undefined ? `Type.Boolean({ ${def} })` : 'Type.Boolean()';
     case 'json':
-      return 'Type.Unknown()';
+      return def !== undefined ? `Type.Unknown({ ${def} })` : 'Type.Unknown()';
     case 'enum': {
       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`);
+      if (def !== undefined) {
+        const member = field.enum.values.find((v) => v.value === defaultValue);
+        if (!member) {
+          throw new Error(
+            `enum field ${field.name}: default ${renderDefault(defaultValue)} is not a member of ${field.enum.jsName}`,
+          );
+        }
+        return `Type.Enum(${ref.name}, { default: ${ref.name}.${member.symbol} })`;
+      }
       return `Type.Enum(${ref.name})`;
     }
     default:
@@ -79,7 +101,10 @@ function renderValue(f: DtoField, indent: number, resolver: EnumResolver | undef
     return renderObject(f.properties(), indent + 1, resolver);
   }
   // DtoField only wraps a database Field; array/object defs live in the subclasses.
-  return renderBasic(f.field as Field, f.pattern, resolver);
+  // DTO-level default wins over the DB field default; the DB default (string)
+  // is used as a fallback so from() picks carry it into the API contract.
+  const defaultValue = f.default !== undefined ? f.default : f.field.default;
+  return renderBasic(f.field as Field, f.pattern, defaultValue, resolver);
 }
 
 function collectEnumImports(
@@ -102,14 +127,39 @@ function collectEnumImports(
   }
 }
 
+/** Collect all imports needed to render a DTO: include() bases + enum references. */
+export function collectDtoImports(
+  schema: DtoMessage,
+  resolver: EnumResolver | undefined,
+  out: Map<string, ImportRef>,
+): void {
+  for (const base of schema.bases ?? []) out.set(`${base.from}#${base.name}`, base);
+  for (const f of Object.values(schema.fields)) collectEnumImports(f, resolver, out);
+}
+
+/** Render one DTO export (const + type) — no file header, for file-level generation. */
+export function renderDtoExport(schema: DtoMessage, resolver: EnumResolver | undefined): string {
+  const object = renderObject(schema.fields, 1, resolver);
+  const bases = schema.bases ?? [];
+  const body =
+    bases.length > 0
+      ? `Type.Intersect([${bases.map(renderBase).join(', ')}, ${object}])`
+      : object;
+  return `export const ${schema.name} = ${body};`;
+}
+
+/** Render the Static type export for a DTO. */
+export function renderDtoTypeExport(name: string): string {
+  return `export type ${name} = Static<typeof ${name}>;`;
+}
+
 export function renderDtoMessage(
   schema: DtoMessage,
   options: { resolver?: EnumResolver; source?: string } = {},
 ): string {
   const { resolver, source } = options;
   const imports = new Map<string, ImportRef>();
-  for (const base of schema.bases ?? []) imports.set(`${base.from}#${base.name}`, base);
-  for (const f of Object.values(schema.fields)) collectEnumImports(f, resolver, imports);
+  collectDtoImports(schema, resolver, imports);
 
   const header = [
     '// AUTO-GENERATED by typebox-driver — DO NOT EDIT',
@@ -118,24 +168,17 @@ export function renderDtoMessage(
     ...[...imports.values()].map((r) => `import { ${r.name} } from '${r.from}';`),
   ];
 
-  const object = renderObject(schema.fields, 1, resolver);
-  const bases = schema.bases ?? [];
-  const body =
-    bases.length > 0
-      ? `Type.Intersect([${bases.map(renderBase).join(', ')}, ${object}])`
-      : object;
-
   return [
     ...header,
     '',
-    `export const ${schema.name} = ${body};`,
-    `export type ${schema.name} = Static<typeof ${schema.name}>;`,
+    renderDtoExport(schema, resolver),
+    renderDtoTypeExport(schema.name),
     '',
   ].join('\n');
 }
 
 function renderBase(base: ImportRef): string {
-  return base.args !== undefined && base.args.length > 0
-    ? `${base.name}(${base.args.join(', ')})`
-    : base.name;
+  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(', ')})`;
 }

package/src/utils.ts

@@ -0,0 +1,6 @@
+// ── 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());
+}