@pylonts/dsl 1.0.0

package/src/typebox-driver.ts

@@ -0,0 +1,143 @@
+import { DtoArrayField, DtoField, DtoMessage, DtoObjectField, ImportRef } from './dto';
+import { Field } from './dsl';
+
+// TypeBox driver: renders a DtoMessage into TypeBox TypeScript source.
+// Shape matches the codegen product consumed by fastify v5 TypeBoxTypeProvider:
+//
+//   export const RegisterUserInput = Type.Object({...});
+//   export type RegisterUserInput = Static<typeof RegisterUserInput>;
+//
+// ENUM fields reference a generated enum (see enum-driver) by its import
+// location — the resolver maps a jsName to its product import.
+// DTO bases (.include()) render as Type.Intersect([...bases, Type.Object({...})]).
+
+export type EnumResolver = (enumName: string) => ImportRef | undefined;
+
+function renderString(s: string): string {
+  return `'${s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+
+function renderBasic(field: Field, pattern: string | undefined, 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})`);
+  }
+  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)}`);
+      return opts.length > 0 ? `Type.String({ ${opts.join(', ')} })` : 'Type.String()';
+    }
+    case 'text':
+      return '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}`);
+      return opts.length > 0 ? `Type.Integer({ ${opts.join(', ')} })` : 'Type.Integer()';
+    }
+    case 'bigint':
+    case 'decimal':
+    case 'time':
+    case 'date':
+    case 'datetime':
+      // Transmitted as string over HTTP: bigint/decimal keep full precision,
+      // date/time serialize to string.
+      return 'Type.String()';
+    case 'boolean':
+      return 'Type.Boolean()';
+    case 'json':
+      return 'Type.Unknown()';
+    case 'enum': {
+      if (!field.jsName) throw new Error(`enum field ${field.name} requires jsName to render`);
+      const ref = resolver?.(field.jsName);
+      if (!ref) throw new Error(`enum field ${field.name}: no import ref for ${field.jsName} — pass an EnumResolver`);
+      return `Type.Enum(${ref.name})`;
+    }
+    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 {
+  const pad = '  '.repeat(indent);
+  const entries = Object.entries(fields).map(([name, f]) => `${pad}${name}: ${renderField(f, indent, resolver)}`);
+  return `Type.Object({\n${entries.join(',\n')}\n${'  '.repeat(indent - 1)}})`;
+}
+
+function renderField(f: DtoField, indent: number, resolver: EnumResolver | undefined): string {
+  const base = renderValue(f, indent, resolver);
+  return f.isOptional() ? `Type.Optional(${base})` : base;
+}
+
+function renderValue(f: DtoField, indent: number, resolver: EnumResolver | undefined): string {
+  if (f instanceof DtoArrayField) {
+    return `Type.Array(${renderField(f.items(), indent + 1, resolver)})`;
+  }
+  if (f instanceof DtoObjectField) {
+    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);
+}
+
+function collectEnumImports(
+  f: DtoField,
+  resolver: EnumResolver | undefined,
+  out: Map<string, ImportRef>,
+): void {
+  if (f instanceof DtoArrayField) {
+    collectEnumImports(f.items(), resolver, out);
+    return;
+  }
+  if (f instanceof DtoObjectField) {
+    for (const child of Object.values(f.properties())) collectEnumImports(child, resolver, out);
+    return;
+  }
+  if (f.field.type === 'enum') {
+    if (!f.field.jsName) throw new Error(`enum field ${f.field.name} requires jsName to render`);
+    const ref = resolver?.(f.field.jsName);
+    if (!ref) throw new Error(`enum field ${f.field.name}: no import ref for ${f.field.jsName} — pass an EnumResolver`);
+    out.set(`${ref.from}#${ref.name}`, ref);
+  }
+}
+
+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);
+
+  const header = [
+    '// AUTO-GENERATED by typebox-driver — DO NOT EDIT',
+    ...(source !== undefined ? [`// Source: ${source}`] : []),
+    "import { Type, Static } from '@sinclair/typebox';",
+    ...[...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}>;`,
+    '',
+  ].join('\n');
+}
+
+function renderBase(base: ImportRef): string {
+  return base.args !== undefined && base.args.length > 0
+    ? `${base.name}(${base.args.join(', ')})`
+    : base.name;
+}