@metaobjectsdev/codegen-ts 0.6.0-rc.1 → 0.7.0-rc.1

package/src/templates/output-parser.ts

@@ -0,0 +1,143 @@
+// server/typescript/packages/codegen-ts/src/templates/output-parser.ts
+//
+// Per-template renderer for template.output codegen. Walks the @payloadRef's
+// value-object into a Zod schema and emits a dual-API parser (parse + safeParse)
+// alongside the schema. The emitted file is self-contained: it derives a
+// local data type via `z.infer<typeof Schema>` and exports it as
+// `<TemplateName>Data`. Consumers wiring `promptRender()` get a structurally
+// identical payload-VO interface in `prompts.ts`; either type can be used
+// interchangeably with parse results.
+
+import {
+  type MetaData,
+  TYPE_OBJECT,
+  TYPE_FIELD,
+  TYPE_TEMPLATE,
+  TEMPLATE_SUBTYPE_OUTPUT,
+  FIELD_SUBTYPE_OBJECT,
+  FIELD_ATTR_OBJECT_REF,
+  TEMPLATE_ATTR_PAYLOAD_REF,
+} from "@metaobjectsdev/metadata";
+
+const SCALAR_ZOD: Record<string, string> = {
+  string: "z.string()",
+  class: "z.string()",
+  int: "z.number().int()",
+  short: "z.number().int()",
+  byte: "z.number().int()",
+  long: "z.number().int()",
+  double: "z.number()",
+  float: "z.number()",
+  boolean: "z.boolean()",
+};
+
+function findObject(root: MetaData, name: string): MetaData | undefined {
+  return root.ownChildren().find((c) => c.type === TYPE_OBJECT && c.name === name);
+}
+
+function findTemplate(root: MetaData, name: string): MetaData | undefined {
+  return root.ownChildren().find((c) => c.type === TYPE_TEMPLATE && c.name === name);
+}
+
+/** Render the Zod expression for a single field; recurses on @objectRef. */
+function fieldZod(field: MetaData, root: MetaData, seen: ReadonlySet<string>, depth: number): string {
+  // isArray is a native (reserved) property on MetaData, not an attr.
+  const isArray = field.isArray === true;
+  let base: string;
+  if (field.subType === FIELD_SUBTYPE_OBJECT) {
+    const refName = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+    if (typeof refName !== "string") {
+      base = "z.unknown()";
+    } else if (seen.has(refName)) {
+      // Cycle guard — emit unknown for self-references (rare; lazy schemas not in scope for v1).
+      base = "z.unknown()";
+    } else {
+      const inner = findObject(root, refName);
+      base = inner ? renderObjectSchema(inner, root, new Set(seen).add(refName), depth + 1) : "z.unknown()";
+    }
+  } else {
+    base = SCALAR_ZOD[field.subType] ?? "z.unknown()";
+  }
+  return isArray ? `z.array(${base})` : base;
+}
+
+/** Render a `z.object({ ... })` for an object.value node.
+ *  At depth 0 the schema starts at column 0 (consumer's `const Foo = z.object({`),
+ *  so fields sit at 2 spaces and the closing `})` at 0 spaces — matching the
+ *  surrounding `const NameSchema = ...` statement's indent. Nested schemas
+ *  step in two spaces per depth level. */
+function renderObjectSchema(vo: MetaData, root: MetaData, seen: ReadonlySet<string>, depth: number): string {
+  const fields = vo.children().filter((c) => c.type === TYPE_FIELD);
+  const fieldIndent = "  ".repeat(depth + 1);
+  const closeIndent = "  ".repeat(depth);
+  const lines = fields.map((f) => `${fieldIndent}${f.name}: ${fieldZod(f, root, seen, depth)},`);
+  return `z.object({\n${lines.join("\n")}\n${closeIndent}})`;
+}
+
+/**
+ * Render the full output-parser file for one `template.output` node.
+ * Throws if the template isn't found, isn't a template.output, or its
+ * @payloadRef doesn't resolve to an object.value.
+ */
+export function renderOutputParser(root: MetaData, templateName: string): string {
+  const tmpl = findTemplate(root, templateName);
+  if (!tmpl) {
+    throw new Error(`template "${templateName}" not found in metadata root`);
+  }
+  if (tmpl.subType !== TEMPLATE_SUBTYPE_OUTPUT) {
+    throw new Error(`template "${templateName}" is not a template.output (got subtype "${tmpl.subType}")`);
+  }
+  const payloadRef = tmpl.ownAttr(TEMPLATE_ATTR_PAYLOAD_REF);
+  if (typeof payloadRef !== "string") {
+    throw new Error(`template "${templateName}" missing @payloadRef`);
+  }
+  const vo = findObject(root, payloadRef);
+  if (!vo) {
+    throw new Error(`template "${templateName}" @payloadRef "${payloadRef}" not found in metadata root`);
+  }
+
+  const schema = renderObjectSchema(vo, root, new Set([payloadRef]), 0);
+  const schemaName = `${templateName}Schema`;
+  const dataName = `${templateName}Data`;
+  const errorName = `${templateName}ValidationError`;
+  const parseName = `parse${templateName}`;
+  const safeParseName = `safeParse${templateName}`;
+
+  return `import { z } from "zod";
+
+const ${schemaName} = ${schema};
+
+export type ${dataName} = z.infer<typeof ${schemaName}>;
+export type ${errorName} = z.ZodError;
+
+/**
+ * Parse an LLM response into a typed ${dataName}.
+ * @throws ZodError on validation failure.
+ */
+export function ${parseName}(text: string): ${dataName} {
+  return ${schemaName}.parse(JSON.parse(text));
+}
+
+/**
+ * Parse an LLM response with explicit error handling (Result-style).
+ * Does not throw on validation failure.
+ */
+export function ${safeParseName}(
+  text: string,
+): { success: true; data: ${dataName} } | { success: false; error: ${errorName} } {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err) {
+    return {
+      success: false,
+      error: new z.ZodError([{ code: "custom", path: [], message: \`invalid JSON: \${(err as Error).message}\` }]),
+    };
+  }
+  const result = ${schemaName}.safeParse(parsed);
+  return result.success
+    ? { success: true, data: result.data }
+    : { success: false, error: result.error };
+}
+`;
+}

package/src/templates/projection-decl.ts

@@ -56,7 +56,7 @@ function pathFromProjectionName(name: string): string {
  *
  * @param projection  The projection entity (has a source[dbView] child).
  * @param root        The loader's root (all top-level objects as direct children,
- *                    from `MetaDataLoader.load()` / `FileMetaDataLoader.loadFiles()` as `result.root`).
+ *                    from `MetaDataLoader.load()` or `MetaDataLoader.fromDirectory()` as `result.root`).
  * @param opts        Column naming strategy + dialect.
  */
 export function renderProjectionDecl(

package/src/templates/queries-file.ts

@@ -4,7 +4,7 @@
 import { code, joinCode, type Code } from "ts-poet";
 import { MetaObject } from "@metaobjectsdev/metadata";
 import { type RenderContext } from "../render-context.js";
-import { entityModuleSpecifier, relativeModuleSpecifier } from "../import-path.js";
+import { entityModuleSpecifier } from "../import-path.js";
 import {
   renderFindByIdFn,
   renderListFn,
@@ -26,13 +26,27 @@ export function renderQueriesFile(obj: MetaObject, ctx: RenderContext): string {
     entityName,
     ctx.extStyle,
   );
-  const dbImportSpec = relativeModuleSpecifier(ctx.outputLayout, obj.package, ctx.dbImport);
   const varName = variableNameFromEntity(entityName);
 
-  // Literal imports (db + entity types) live in a code block so they sort
+  // The persistence-context `db` is parameter-passed into every generated CRUD
+  // helper (ADR-0008). Emit the dialect-correct Drizzle type alias so the
+  // signatures `findXxx(db: Db, ...)` typecheck without the consumer importing
+  // anything to construct one. Consumers pass any compatible Drizzle instance.
+  const dbTypeImport =
+    ctx.dialect === "postgres"
+      ? `import type { NodePgDatabase } from "drizzle-orm/node-postgres";`
+      : `import type { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";`;
+  const dbTypeAlias =
+    ctx.dialect === "postgres"
+      ? `type Db = NodePgDatabase<Record<string, never>>;`
+      : `type Db = BaseSQLiteDatabase<"async", Record<string, never>>;`;
+
+  // Literal imports (Db type + entity types) live in a code block so they sort
   // alongside ts-poet's hoisted imp() imports at the top of the body.
   const literalImports = code`
-import { db } from ${JSON.stringify(dbImportSpec)};
+${dbTypeImport}
+${dbTypeAlias}
+
 import { ${varName}, type ${entityName}, ${entityName}InsertSchema } from ${JSON.stringify(entityFileName)};
 `;
 

package/src/templates/queries.ts

@@ -5,12 +5,7 @@ import { code, imp, type Code } from "ts-poet";
 import type { MetaObject } from "@metaobjectsdev/metadata";
 import { IDENTITY_ATTR_FIELDS } from "@metaobjectsdev/metadata";
 import type { RenderContext } from "../render-context.js";
-import { variableNameFromEntity, toSnakeCase, pluralize } from "../naming.js";
-
-/** Derive a stable prepared statement name. Deterministic from entity + field names. */
-function prepareName(prefix: string, entitySnakeName: string, fieldDbName: string): string {
-  return `${prefix}_${entitySnakeName}_by_${fieldDbName}`;
-}
+import { variableNameFromEntity, pluralize } from "../naming.js";
 
 /** Get the PK field name and its TS type for a given entity. */
 function getPkInfo(entity: MetaObject, ctx: RenderContext): { fieldName: string; tsType: string } {
@@ -34,31 +29,13 @@ export function renderFindByIdFn(entity: MetaObject, ctx: RenderContext): Code {
   const varName = variableNameFromEntity(entity.name);
   const entityName = entity.name;
   const singularVar = entityName.charAt(0).toLowerCase() + entityName.slice(1);
-  const entitySnakeName = toSnakeCase(entityName);
   const { fieldName: pkField, tsType: pkType } = getPkInfo(entity, ctx);
-  const pkSnakeName = toSnakeCase(pkField);
-  const prepName = prepareName("find", entitySnakeName, pkSnakeName);
   const fnName = `find${entityName}ById`;
-  const prepVarName = `${fnName}Prepared`;
   const eqSym = imp("eq@drizzle-orm");
-  const sqlSym = imp("sql@drizzle-orm");
-
-  const baseVarName = `${fnName}Base`;
-
-  // Drizzle's `.prepare()` signature differs by dialect:
-  //   - Postgres: prepare(name) — the name is used by the pg driver to cache the plan
-  //   - SQLite:   prepare()     — no name; the name arg was removed in drizzle-orm 0.41+
-  const prepArg = ctx.dialect === "postgres" ? `"${prepName}"` : "";
 
   return code`
-const ${baseVarName} = db
-  .select()
-  .from(${varName})
-  .where(${eqSym}(${varName}.${pkField}, ${sqlSym}.placeholder(${JSON.stringify(pkField)})));
-const ${prepVarName} = ${baseVarName}.prepare(${prepArg});
-
-export async function ${fnName}(${pkField}: ${pkType}): Promise<${entityName} | null> {
-  const [${singularVar}] = await ${prepVarName}.execute({ ${pkField} });
+export async function ${fnName}(db: Db, ${pkField}: ${pkType}): Promise<${entityName} | null> {
+  const [${singularVar}] = await db.select().from(${varName}).where(${eqSym}(${varName}.${pkField}, ${pkField})).limit(1);
   return ${singularVar} ?? null;
 }
 `;
@@ -72,7 +49,7 @@ export function renderListFn(entity: MetaObject, _ctx: RenderContext): Code {
   const fnName = `list${pluralize(entityName)}`;
 
   return code`
-export async function ${fnName}(opts?: { limit?: number; offset?: number }): Promise<${entityName}[]> {
+export async function ${fnName}(db: Db, opts?: { limit?: number; offset?: number }): Promise<${entityName}[]> {
   let q = db.select().from(${varName}).$dynamic();
   if (opts?.limit !== undefined) q = q.limit(opts.limit);
   if (opts?.offset !== undefined) q = q.offset(opts.offset);
@@ -89,7 +66,7 @@ export function renderCreateFn(entity: MetaObject, _ctx: RenderContext): Code {
   const schemaName = `${entityName}InsertSchema`;
 
   return code`
-export async function ${fnName}(data: unknown): Promise<${entityName}> {
+export async function ${fnName}(db: Db, data: unknown): Promise<${entityName}> {
   const validated = ${schemaName}.parse(data);
   const [${singularVar}] = await db.insert(${varName}).values(validated).returning();
   return ${singularVar}!;
@@ -107,7 +84,7 @@ export function renderUpdateFn(entity: MetaObject, ctx: RenderContext): Code {
   const eqSym = imp("eq@drizzle-orm");
 
   return code`
-export async function ${fnName}(${pkField}: ${pkType}, data: unknown): Promise<${entityName} | null> {
+export async function ${fnName}(db: Db, ${pkField}: ${pkType}, data: unknown): Promise<${entityName} | null> {
   const validated = ${schemaName}.partial().parse(data);
   const [${singularVar}] = await db.update(${varName}).set(validated).where(${eqSym}(${varName}.${pkField}, ${pkField})).returning();
   return ${singularVar} ?? null;
@@ -123,10 +100,11 @@ export function renderDeleteByIdFn(entity: MetaObject, ctx: RenderContext): Code
   const eqSym = imp("eq@drizzle-orm");
 
   return code`
-export async function ${fnName}(${pkField}: ${pkType}): Promise<boolean> {
-  const result = await db.delete(${varName}).where(${eqSym}(${varName}.${pkField}, ${pkField}));
-  // SQLite (libsql/Turso) returns { rowsAffected }; postgres returns array from .returning()
-  return ('rowsAffected' in result ? result.rowsAffected : (result as unknown as unknown[]).length) > 0;
+export async function ${fnName}(db: Db, ${pkField}: ${pkType}): Promise<boolean> {
+  // Use .returning() unconditionally — supported on SQLite ≥3.35 (covers D1, libsql/Turso)
+  // and Postgres. Result is an array of deleted rows; presence implies success.
+  const deleted = await db.delete(${varName}).where(${eqSym}(${varName}.${pkField}, ${pkField})).returning();
+  return deleted.length > 0;
 }
 `;
 }