@pylonts/dsl 1.1.16 → 1.1.17

package/src/typebox-driver.ts

@@ -1,5 +1,7 @@
 import { DtoArrayField, DtoField, DtoMessage, DtoObjectField, ImportBase, ImportRef, isDtoField, isDtoMessage } from './dto.js';
 import { collectEnumRefs, EnumField, Field } from './dsl.js';
+import type { TableSchema } from './db.js';
+import type { TokenSchema } from './token.js';
 
 // TypeBox driver: renders a DtoMessage into TypeBox TypeScript source.
 // Shape matches the codegen product consumed by fastify v5 TypeBoxTypeProvider:
@@ -32,6 +34,21 @@ function dtoFieldDescription(f: DtoField): string | undefined {
   return f.description ?? fieldDescription(f.field);
 }
 
+/** Resolve a ref chain to its terminal field (the one without .ref).
+ *  Cycles are a DSL definition error — fail loudly at render time. */
+function resolveRefChain(f: DtoField): DtoField {
+  const seen = new Set<DtoField>();
+  let cur: DtoField = f;
+  while (cur.ref !== undefined) {
+    if (seen.has(cur.ref)) {
+      throw new Error(`dto field ${cur.name}: circular ref chain (field references itself)`);
+    }
+    seen.add(cur.ref);
+    cur = cur.ref;
+  }
+  return cur;
+}
+
 function renderBasic(
   field: Field,
   pattern: string | undefined,
@@ -171,11 +188,36 @@ function renderObject(
 }
 
 function renderField(f: DtoField, indent: number, resolver: EnumResolver | undefined): string {
+  // Ref branch renders its own optional (referencing overrides + chain fallback).
+  if (f.ref !== undefined) return renderValue(f, indent, resolver);
   const base = renderValue(f, indent, resolver);
   return f.isOptional() ? `Type.Optional(${base})` : base;
 }
 
+/** Render a ref-carrying field's bare type (no optional wrapper): resolve the
+ *  chain, inherit the terminal field's type/constraints, keep the referencing
+ *  field's own overrides (pattern / default / description). */
+function renderRefBase(f: DtoField, indent: number, resolver: EnumResolver | undefined): string {
+  const target = resolveRefChain(f);
+  const targetField = target.field as Field;
+  const pattern = f.pattern ?? target.pattern;
+  const defaultValue = f.default ?? target.default;
+  const desc = f.description ?? dtoFieldDescription(target);
+  return renderBasic(targetField, pattern, defaultValue, resolver, indent, desc);
+}
+
+/** Render a ref-carrying field with its optional wrapper: referencing
+ *  override first, then the chain's DtoField-level optional, then the bare
+ *  column optionality. */
+function renderRefField(f: DtoField, indent: number, resolver: EnumResolver | undefined): string {
+  const target = resolveRefChain(f);
+  const optional = f.optional ?? target.optional ?? (target.field as Field).optional ?? false;
+  const base = renderRefBase(f, indent, resolver);
+  return optional ? `Type.Optional(${base})` : base;
+}
+
 function renderValue(f: DtoField, indent: number, resolver: EnumResolver | undefined): string {
+  if (f.ref !== undefined) return renderRefField(f, indent, resolver);
   if (f.field.type === 'array') {
     const items = f.field.items;
     const desc = dtoFieldDescription(f);
@@ -210,6 +252,10 @@ function collectEnumImports(
   resolver: EnumResolver | undefined,
   out: Map<string, ImportBase>,
 ): void {
+  if (f.ref !== undefined) {
+    collectEnumImports(resolveRefChain(f), resolver, out);
+    return;
+  }
   if (f.field.type === 'array') {
     const items = f.field.items;
     if (isDtoMessage(items)) return;
@@ -257,14 +303,41 @@ export function collectDtoImports(
   for (const f of Object.values(schema.fields)) collectEnumImports(f, resolver, out);
 }
 
+/** Render the server-injection base: token-injected fields as Optional
+ *  properties of a TypeBox object, plus a non-enumerable __inject adapter
+ *  (same mechanism as hand-written bases, see pylon __inject docs) that fills
+ *  each field from the token at runtime. */
+function renderInjectBase(fields: Record<string, DtoField>, resolver: EnumResolver | undefined): string {
+  const entries = Object.entries(fields).map(([name, f]) => {
+    const base = f.ref !== undefined ? renderRefBase(f, 1, resolver) : renderValue(f, 1, resolver);
+    return `  ${name}: Type.Optional(${base})`;
+  });
+  const inner = `Type.Object({\n${entries.join(',\n')}\n})`;
+  const assigns = Object.keys(fields)
+    .map((k) => `body.${k} = token.${k};`)
+    .join(' ');
+  return [
+    `Object.defineProperty(`,
+    `  ${inner},`,
+    `  '__inject',`,
+    `  { value: (body: Record<string, unknown>, token: Record<string, unknown>): void => { ${assigns} }, enumerable: false },`,
+    `)`,
+  ].join('\n');
+}
+
 /** 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, schema.description);
-  const bases = schema.bases ?? [];
-  const body =
-    bases.length > 0
-      ? `Type.Intersect([${bases.map(renderBase).join(', ')}, ${object}])`
-      : object;
+  const injectFields: Record<string, DtoField> = {};
+  const normalFields: Record<string, DtoField> = {};
+  for (const [key, f] of Object.entries(schema.fields)) {
+    if (f.injectFrom !== undefined) injectFields[key] = f;
+    else normalFields[key] = f;
+  }
+  const parts: string[] = [];
+  if (Object.keys(injectFields).length > 0) parts.push(renderInjectBase(injectFields, resolver));
+  parts.push(renderObject(normalFields, 1, resolver, schema.description));
+  for (const base of schema.bases ?? []) parts.push(renderBase(base));
+  const body = parts.length > 1 ? `Type.Intersect([${parts.join(', ')}])` : parts[0];
   return `export const ${schema.name} = ${body};`;
 }
 
@@ -273,6 +346,55 @@ export function renderDtoTypeExport(name: string): string {
   return `export type ${name} = Static<typeof ${name}>;`;
 }
 
+/** Render one token export: a flat TypeBox object. Security fields keep
+ *  their declared optionality (secret required, cipher optional); identity
+ *  fields are Optional except the primary-key anchor — they only exist after
+ *  login (two-state object, flat runtime shape), while the PK is guaranteed
+ *  to be projected (token validation enforces it) and serves as the identity
+ *  anchor (e.g. the tenant key for tenant-scoped controllers). */
+export function renderTokenExport(token: TokenSchema, resolver: EnumResolver | undefined): string {
+  const constName = `${token.name}Token`;
+  const entries = [
+    ...Object.entries(token.security).map(([name, f]) => `  ${name}: ${renderField(f, 1, resolver)}`),
+    ...Object.entries(token.identity).map(([name, f]) =>
+      isPrimaryKeyProjection(f) ? `  ${name}: ${renderValue(f, 1, resolver)}` : `  ${name}: Type.Optional(${renderValue(f, 1, resolver)})`,
+    ),
+  ];
+  const desc = token.description !== undefined ? `, { description: ${renderString(token.description)} }` : '';
+  return `export const ${constName} = Type.Object({\n${entries.join(',\n')}\n}${desc});`;
+}
+
+/** True when the DTO field projects a primary-key column of its source table. */
+function isPrimaryKeyProjection(f: DtoField): boolean {
+  const tbl = f.field.schema;
+  if (tbl?.type !== 'table') return false;
+  // A table-backed field is always a plain Field (only Field carries a table
+  // schema); array/object DTO fields reference messages, not tables.
+  const field = f.field as Field;
+  const table = tbl as TableSchema;
+  const pk = table.primaryKey;
+  if (!pk) return false;
+  const pks = Array.isArray(pk) ? pk : [pk];
+  return pks.includes(field);
+}
+
+/** Render the Static type export for a token. */
+export function renderTokenTypeExport(name: string): string {
+  return `export type ${name}Token = Static<typeof ${name}Token>;`;
+}
+
+/** Collect all imports needed to render a token: enum references across
+ *  security + identity fields. */
+export function collectTokenImports(
+  token: TokenSchema,
+  resolver: EnumResolver | undefined,
+  out: Map<string, ImportBase>,
+): void {
+  for (const f of [...Object.values(token.security), ...Object.values(token.identity)]) {
+    collectEnumImports(f, resolver, out);
+  }
+}
+
 export function renderDtoMessage(
   schema: DtoMessage,
   options: { resolver?: EnumResolver; source?: string } = {},