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

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;
 }
 `;
 }

package/src/templates/value-object-file.ts

@@ -0,0 +1,30 @@
+// Value-object file composer — emits a streamlined "value-only" module for
+// metaobjects with no writable source.rdb child. Output is just the TS
+// interface + the Zod schema (and enum type aliases when applicable); no
+// Drizzle table, no Infer*Model aliases, no filter allowlists, no constants
+// object.
+//
+// Dispatch: entity-file.ts routes here when hasWritableRdbSource(entity) is
+// false. The entity may still have read-only source.* children (those are
+// handled by the projection path before this one is reached).
+
+import { joinCode, type Code } from "ts-poet";
+import type { MetaObject } from "@metaobjectsdev/metadata";
+import { renderValueObjectInterface, renderEnumTypeAliases } from "./inferred-types.js";
+import { renderInsertSchemaOnly } from "./zod-validators.js";
+import { GENERATED_HEADER } from "../constants.js";
+
+export function renderValueObjectFile(obj: MetaObject): string {
+  const enumAliases = renderEnumTypeAliases(obj);
+  const sections: Code[] = [
+    renderValueObjectInterface(obj),
+    ...(enumAliases !== null ? [enumAliases] : []),
+    renderInsertSchemaOnly(obj),
+  ];
+  const body = joinCode(sections, { on: "\n" }).toString();
+  const header =
+    `// ${GENERATED_HEADER} — DO NOT EDIT.\n` +
+    `// Source metadata: ${obj.name} (${obj.fqn()})\n` +
+    `// Customize via ${obj.name}.extra.ts in this directory.\n`;
+  return header + body;
+}

package/src/templates/zod-validators.ts

@@ -2,53 +2,102 @@
 // Auto-generated PKs are EXCLUDED from InsertSchema (caller doesn't provide them).
 // @autoSet fields: INSERT → .optional().transform(() => new Date().toISOString())
 //                 UPDATE → onCreate fields omitted entirely; onUpdate gets same transform
+//
+// field.object isArray:true objectRef:<Ref> — emits z.array(<Ref>InsertSchema)
+// with a cross-module imp() so consumers passing the schema to
+// zod-to-json-schema get a properly element-typed array. Without this, every
+// object-array field collapsed to z.array(z.string()) and the JSON Schema sent
+// downstream (e.g. to LLM tool_use input_schema) lost the nested object shape.
 
-import { code, imp, type Code } from "ts-poet";
+import { code, joinCode, imp, type Code } from "ts-poet";
 import { MetaObject, MetaField } from "@metaobjectsdev/metadata";
 import {
   FIELD_SUBTYPE_STRING, FIELD_SUBTYPE_INT, FIELD_SUBTYPE_LONG, FIELD_SUBTYPE_CURRENCY,
   FIELD_SUBTYPE_BOOLEAN, FIELD_SUBTYPE_DOUBLE, FIELD_SUBTYPE_FLOAT,
   FIELD_SUBTYPE_DATE, FIELD_SUBTYPE_TIME, FIELD_SUBTYPE_TIMESTAMP,
-  FIELD_SUBTYPE_ENUM,
+  FIELD_SUBTYPE_ENUM, FIELD_SUBTYPE_OBJECT,
   VALIDATOR_SUBTYPE_REQUIRED, VALIDATOR_SUBTYPE_LENGTH, VALIDATOR_SUBTYPE_REGEX,
   IDENTITY_ATTR_FIELDS, IDENTITY_ATTR_GENERATION,
   FIELD_ATTR_REQUIRED, FIELD_ATTR_MAX_LENGTH, FIELD_ATTR_DEFAULT,
-  FIELD_ATTR_AUTO_SET, AUTO_SET_ON_CREATE, AUTO_SET_ON_UPDATE,
+  FIELD_ATTR_AUTO_SET, FIELD_ATTR_OBJECT_REF, AUTO_SET_ON_CREATE, AUTO_SET_ON_UPDATE,
   VALIDATOR_ATTR_MAX, VALIDATOR_ATTR_MIN, VALIDATOR_ATTR_PATTERN,
   GENERATION_INCREMENT, GENERATION_UUID,
 } from "@metaobjectsdev/metadata";
 import { enumValues, zodEnumExpr } from "../enum-meta.js";
 import { renderDocsFor } from "./jsdoc.js";
 
-export function renderZodValidators(obj: MetaObject): Code {
-  const z = imp("z@zod");
+/** Auto-generated PK field names that should be omitted from InsertSchema. */
+function autoGenPkFieldNames(obj: MetaObject): Set<string> {
+  const out = new Set<string>();
   const primary = obj.primaryIdentity();
-  const autoGenPkFields = new Set<string>();
   if (primary) {
     const generation = primary.ownAttr(IDENTITY_ATTR_GENERATION);
     if (generation === GENERATION_INCREMENT || generation === GENERATION_UUID) {
       const fields = primary.ownAttr(IDENTITY_ATTR_FIELDS);
       const fieldsList = Array.isArray(fields) ? fields : (typeof fields === "string" ? [fields] : []);
-      for (const f of fieldsList) autoGenPkFields.add(String(f));
+      for (const f of fieldsList) out.add(String(f));
     }
   }
+  return out;
+}
 
-  const insertFieldLines: string[] = [];
-  const updateFieldLines: string[] = [];
+/**
+ * Emit ONLY the `<Name>InsertSchema`. Used by the value-object file emitter
+ * for metaobjects with no writable source.rdb — those have no PATCH/update
+ * semantics, so emitting an UpdateSchema would be misleading.
+ *
+ * The schema name is kept as `<Name>InsertSchema` even for pure value objects
+ * so consumer imports don't churn. A future polish PR could add a `<Name>Schema`
+ * alias for clarity.
+ */
+export function renderInsertSchemaOnly(obj: MetaObject): Code {
+  const z = imp("z@zod");
+  const autoGenPkFields = autoGenPkFieldNames(obj);
+
+  const insertFieldLines: Code[] = [];
+  for (const child of obj.fields()) {
+    if (autoGenPkFields.has(child.name)) continue;
+
+    const autoSet = child.ownAttr(FIELD_ATTR_AUTO_SET);
+
+    if (autoSet === AUTO_SET_ON_CREATE || autoSet === AUTO_SET_ON_UPDATE) {
+      insertFieldLines.push(
+        code`  ${child.name}: z.string().optional().transform(() => new Date().toISOString())`,
+      );
+    } else {
+      insertFieldLines.push(code`  ${child.name}: ${zodFieldExpr(child)}`);
+    }
+  }
+
+  const insertSchemaName = `${obj.name}InsertSchema`;
+  const docs = renderDocsFor(obj);
+  const docsPrefix = docs ? `${docs}\n` : "";
+
+  return code`
+${docsPrefix}export const ${insertSchemaName} = ${z}.object({
+${joinCode(insertFieldLines, { on: ",\n" })}
+});
+`;
+}
+
+export function renderZodValidators(obj: MetaObject): Code {
+  const z = imp("z@zod");
+  const autoGenPkFields = autoGenPkFieldNames(obj);
+
+  const insertFieldLines: Code[] = [];
+  const updateFieldLines: Code[] = [];
   for (const child of obj.fields()) {
     if (autoGenPkFields.has(child.name)) continue;
 
     const autoSet = child.ownAttr(FIELD_ATTR_AUTO_SET);
 
     // Insert schema: @autoSet fields use transform (always override client input).
-    // NOTE: use "z" as a literal string here — these lines are embedded in the
-    // `code` template tag below which resolves the imp("z@zod") import.
     if (autoSet === AUTO_SET_ON_CREATE || autoSet === AUTO_SET_ON_UPDATE) {
       insertFieldLines.push(
-        `  ${child.name}: z.string().optional().transform(() => new Date().toISOString())`,
+        code`  ${child.name}: z.string().optional().transform(() => new Date().toISOString())`,
       );
     } else {
-      insertFieldLines.push(`  ${child.name}: ${zodFieldExpr(child)}`);
+      insertFieldLines.push(code`  ${child.name}: ${zodFieldExpr(child)}`);
     }
 
     // Update schema: @autoSet onCreate → omit entirely; onUpdate → transform
@@ -56,13 +105,16 @@ export function renderZodValidators(obj: MetaObject): Code {
       // Omit: creation timestamps cannot be changed after creation
     } else if (autoSet === AUTO_SET_ON_UPDATE) {
       updateFieldLines.push(
-        `  ${child.name}: z.string().optional().transform(() => new Date().toISOString())`,
+        code`  ${child.name}: z.string().optional().transform(() => new Date().toISOString())`,
       );
     } else {
-      // All non-autoSet fields are optional in the update schema (PATCH semantics)
-      const expr = zodFieldExpr(child);
-      const optionalExpr = expr.endsWith(".optional()") ? expr : `${expr}.optional()`;
-      updateFieldLines.push(`  ${child.name}: ${optionalExpr}`);
+      // All non-autoSet fields are optional in the update schema (PATCH semantics).
+      // zodFieldExpr already appends .optional() when the field is non-required
+      // OR has a default; only append once more when it didn't.
+      const baseExpr = zodFieldExpr(child);
+      updateFieldLines.push(
+        fieldWillBeOptional(child) ? code`  ${child.name}: ${baseExpr}` : code`  ${child.name}: ${baseExpr}.optional()`,
+      );
     }
   }
 
@@ -74,48 +126,82 @@ export function renderZodValidators(obj: MetaObject): Code {
 
   return code`
 ${docsPrefix}export const ${insertSchemaName} = ${z}.object({
-${insertFieldLines.join(",\n")}
+${joinCode(insertFieldLines, { on: ",\n" })}
 });
 
 ${docsPrefix}export const ${updateSchemaName} = ${z}.object({
-${updateFieldLines.join(",\n")}
+${joinCode(updateFieldLines, { on: ",\n" })}
 });
 `;
 }
 
-function zodFieldExpr(field: MetaField): string {
-  let base: string;
+function zodFieldExpr(field: MetaField): Code {
+  // FIELD_SUBTYPE_OBJECT: emit z.array(<Ref>InsertSchema) / <Ref>InsertSchema
+  // via an imp() so ts-poet hoists the cross-module import. Without this the
+  // field used to collapse to z.string() / z.array(z.string()) and downstream
+  // JSON Schema (e.g. LLM tool_use input_schema) lost the nested object shape.
+  if (field.subType === FIELD_SUBTYPE_OBJECT) {
+    const ref = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+    if (typeof ref === "string" && ref.length > 0) {
+      const refImp = imp(`${ref}InsertSchema@./${ref}.js`);
+      let base: Code = code`${refImp}`;
+      if (field.isArray) base = code`z.array(${base})`;
+      return appendValidatorChain(base, field);
+    }
+    // No resolvable @objectRef — fall through to z.unknown(); downstream code
+    // can still pass a value through but loses validation.
+    let base: Code = code`z.unknown()`;
+    if (field.isArray) base = code`z.array(${base})`;
+    return appendValidatorChain(base, field);
+  }
+
+  let baseStr: string;
   switch (field.subType) {
     case FIELD_SUBTYPE_INT:
     case FIELD_SUBTYPE_CURRENCY:
     case FIELD_SUBTYPE_LONG:
-      base = "z.number().int()";
+      baseStr = "z.number().int()";
       break;
     case FIELD_SUBTYPE_DOUBLE:
     case FIELD_SUBTYPE_FLOAT:
-      base = "z.number()";
+      baseStr = "z.number()";
       break;
     case FIELD_SUBTYPE_BOOLEAN:
-      base = "z.boolean()";
+      baseStr = "z.boolean()";
       break;
     case FIELD_SUBTYPE_DATE:
     case FIELD_SUBTYPE_TIME:
     case FIELD_SUBTYPE_TIMESTAMP:
-      base = "z.string()";
+      baseStr = "z.string()";
       break;
     case FIELD_SUBTYPE_ENUM: {
       const values = enumValues(field);
-      base = values !== undefined ? zodEnumExpr(values) : "z.string()";
+      baseStr = values !== undefined ? zodEnumExpr(values) : "z.string()";
       break;
     }
     case FIELD_SUBTYPE_STRING:
     default:
-      base = "z.string()";
+      baseStr = "z.string()";
       break;
   }
 
-  if (field.isArray) base = `z.array(${base})`;
+  if (field.isArray) baseStr = `z.array(${baseStr})`;
+  return appendValidatorChain(code`${baseStr}`, field);
+}
+
+/** Mirrors the optional-or-not decision inside appendValidatorChain so the update-schema
+ *  caller can avoid stacking a second `.optional()` onto an already-optional expression. */
+function fieldWillBeOptional(field: MetaField): boolean {
+  let isRequired = field.ownAttr(FIELD_ATTR_REQUIRED) === true;
+  for (const child of field.validators()) {
+    if (child.subType === VALIDATOR_SUBTYPE_REQUIRED) isRequired = true;
+  }
+  const hasDefault = field.ownAttr(FIELD_ATTR_DEFAULT) !== undefined;
+  return !isRequired || hasDefault;
+}
 
+/** Append .min/.max/.regex/.optional() based on field-level validators + required state. */
+function appendValidatorChain(base: Code, field: MetaField): Code {
   let isRequired = field.ownAttr(FIELD_ATTR_REQUIRED) === true;
   let maxLen: number | undefined = field.ownAttr(FIELD_ATTR_MAX_LENGTH) as number | undefined;
   let minLen: number | undefined;
@@ -134,18 +220,18 @@ function zodFieldExpr(field: MetaField): string {
     }
   }
 
-  let chain = base;
+  let chain: Code = base;
   if (field.subType === FIELD_SUBTYPE_STRING && !field.isArray) {
-    if (minLen !== undefined) chain += `.min(${minLen})`;
-    else if (isRequired) chain += `.min(1)`;
-    if (maxLen !== undefined) chain += `.max(${maxLen})`;
-    if (pattern !== undefined) chain += `.regex(new RegExp(${JSON.stringify(pattern)}))`;
+    if (minLen !== undefined) chain = code`${chain}.min(${minLen})`;
+    else if (isRequired) chain = code`${chain}.min(1)`;
+    if (maxLen !== undefined) chain = code`${chain}.max(${maxLen})`;
+    if (pattern !== undefined) chain = code`${chain}.regex(new RegExp(${JSON.stringify(pattern)}))`;
   }
 
   // Fields with DB-level defaults are optional in the InsertSchema: the caller
   // can omit them and the DB will fill in. Otherwise required-with-default
   // would force callers to repeat the default at every call site.
   const hasDefault = field.ownAttr(FIELD_ATTR_DEFAULT) !== undefined;
-  if (!isRequired || hasDefault) chain += `.optional()`;
+  if (!isRequired || hasDefault) chain = code`${chain}.optional()`;
   return chain;
 }