@supatype/cli 0.3.2 → 0.3.3

package/src/seed.ts

@@ -1,3 +1,22 @@
+/**
+ * What a project's seed file imports.
+ *
+ * Two contracts live here. `sql()` is the old one: the author opens a connection, writes
+ * statements and closes it. It is unchanged and still supported, because every existing
+ * project uses it.
+ *
+ * The rest is the new one. A seed exports a function, the runner hands it a `db` typed from
+ * the project's schema, and the calls it makes are **collected, not executed**: they become
+ * a seed IR document that the engine validates, orders, batches and runs in one
+ * transaction.
+ *
+ * **Nothing here connects to a database, and nothing here builds SQL.** That is the point of
+ * the split: the hard parts, ordering a foreign-key graph, batching, mapping a Postgres
+ * error back to the schema, are written once in the engine rather than once per language.
+ * This file is the part that has to exist per language, and it is deliberately small enough
+ * to be worth writing seven times.
+ */
+
 import pg from "pg"
 
 export interface SeedSql {
@@ -41,3 +60,392 @@ export function sql(connectionString: string): SeedSql {
     },
   })
 }
+
+// --- The expression language ---
+
+/**
+ * A value the database computes, rather than one the seed hardcodes.
+ *
+ * The same operand set the schema's access rules use, serialised the same way. Not a second
+ * vocabulary: forking one for seeds would need a second validator and a second SQL
+ * renderer, and would re-litigate decisions the engine has already made and documented.
+ */
+export type Operand<C extends string = string> =
+  | { kind: "literal"; value: LiteralValue }
+  | { kind: "column"; name: C }
+  | { kind: "now" }
+  | { kind: "startOf"; unit: TruncUnit }
+  | { kind: "ago"; amount: number; unit: TimeUnit }
+  | { kind: "fromNow"; amount: number; unit: TimeUnit }
+  | { kind: "after"; base: Operand<C>; interval: IntervalSpec }
+  | { kind: "before"; base: Operand<C>; interval: IntervalSpec }
+
+export type LiteralValue = string | number | boolean
+
+export type TruncUnit = "day" | "week" | "month" | "year"
+
+export type TimeUnit = "seconds" | "minutes" | "hours" | "days" | "weeks" | "months" | "years"
+
+/**
+ * A span of time, in any combination of units.
+ *
+ * Multi-unit because a fixture calendar wants "thirty days from now at 09:00", which a
+ * single `{ amount, unit }` cannot say. Components are non-negative: the direction lives in
+ * the operand's name, so that `ago` reads as itself rather than as a double negative.
+ */
+export interface IntervalSpec {
+  years?: number
+  months?: number
+  weeks?: number
+  days?: number
+  hours?: number
+  minutes?: number
+  seconds?: number
+}
+
+/**
+ * A time the database evaluates.
+ *
+ * Its own type so a generated builder can accept it on date-like columns and nowhere else:
+ * `expr.now()` assigned to a title does not compile.
+ */
+export type TimeExpr = Extract<
+  Operand,
+  { kind: "now" | "startOf" | "ago" | "fromNow" | "after" | "before" }
+>
+
+/**
+ * The column's own default.
+ *
+ * Distinct from leaving the field out. Omission means "do not write this column", which on
+ * the update half of an upsert keeps the existing value; this means "put it back to the
+ * default". Both are wanted and only one can be spelled by absence.
+ */
+export interface DefaultExpr {
+  readonly $default: true
+}
+
+const DEFAULT_EXPR: DefaultExpr = { $default: true }
+
+const INTERVAL_UNITS = [
+  "years",
+  "months",
+  "weeks",
+  "days",
+  "hours",
+  "minutes",
+  "seconds",
+] as const
+
+/**
+ * Drop the units nobody asked for, so two equal intervals serialise the same way.
+ *
+ * A negative or fractional component is refused rather than carried. The engine's interval
+ * components are whole and unsigned, so one that is not fails to read as an operand, falls
+ * through to being a plain value, and reaches the database as JSON text in a date column.
+ * That surfaced as `invalid input syntax for type timestamp with time zone`, naming neither
+ * the field nor the real mistake. Here it names both, at the call that made it.
+ */
+function interval(spec: IntervalSpec): IntervalSpec {
+  const out: IntervalSpec = {}
+  for (const unit of INTERVAL_UNITS) {
+    const value = spec[unit]
+    if (value === undefined || value === 0) continue
+    if (!Number.isInteger(value) || value < 0) {
+      throw new TypeError(
+        `An interval's \`${unit}\` must be a whole number and not negative, and this is ${value}. ` +
+          "The direction is in the name: use `ago` or `before` to go backwards.",
+      )
+    }
+    out[unit] = value
+  }
+  return out
+}
+
+function shifted(base: Operand, spec: IntervalSpec | undefined, ahead: boolean): TimeExpr {
+  if (spec === undefined) return base as TimeExpr
+  const amount = interval(spec)
+  if (Object.keys(amount).length === 0) return base as TimeExpr
+  return ahead
+    ? { kind: "after", base, interval: amount }
+    : { kind: "before", base, interval: amount }
+}
+
+/**
+ * Values the database computes.
+ *
+ * Deliberately database-side rather than computed here. A client-computed `daysFromNow(30)`
+ * produces a different instant on every run, so a builder emitting it could never reproduce
+ * a checked-in fixture; and one IR applied to several environments at different times would
+ * give every one of them the same hardcoded instant, which for a fixture calendar is never
+ * what people mean.
+ */
+export const expr = {
+  /** `now()`, optionally shifted forward. */
+  now(after?: IntervalSpec): TimeExpr {
+    return shifted({ kind: "now" }, after, true)
+  },
+  /** `now()` shifted back. */
+  ago(before: IntervalSpec): TimeExpr {
+    return shifted({ kind: "now" }, before, false)
+  },
+  /** The start of the current day, week, month or year, optionally shifted forward. */
+  startOf(unit: TruncUnit, after?: IntervalSpec): TimeExpr {
+    return shifted({ kind: "startOf", unit }, after, true)
+  },
+  /** The start of a period, shifted back. */
+  startOfBefore(unit: TruncUnit, amount: IntervalSpec): TimeExpr {
+    return shifted({ kind: "startOf", unit }, amount, false)
+  },
+  /** The column's own default. */
+  default(): DefaultExpr {
+    return DEFAULT_EXPR
+  },
+} as const
+
+// --- Predicates ---
+
+export type CompareOp = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "like"
+
+/**
+ * A condition on rows, in the schema's own rule language.
+ *
+ * The engine already parses, validates and compiles this tree for every RLS policy it
+ * writes, so a seed condition is that tree scoped to a model rather than anything new. A
+ * person who has written `Eq<"status", Literal<"published">>` in their schema already knows
+ * this language.
+ */
+export type Predicate<C extends string = string> =
+  | { type: "compare"; left: Operand<C>; op: CompareOp; right: Operand<C> }
+  | { type: "any"; rules: Predicate<C>[] }
+  | { type: "all"; rules: Predicate<C>[] }
+  | { type: "not"; rule: Predicate<C> }
+  | { type: "nullCheck"; operand: Operand<C>; isNull: boolean }
+  | { type: "in"; column: C; source: { kind: "literal"; values: LiteralValue[] } }
+
+function compare<C extends string>(column: C, op: CompareOp, value: LiteralValue): Predicate<C> {
+  return {
+    type: "compare",
+    left: { kind: "column", name: column },
+    op,
+    right: { kind: "literal", value },
+  }
+}
+
+export const eq = <C extends string>(column: C, value: LiteralValue): Predicate<C> =>
+  compare(column, "eq", value)
+export const neq = <C extends string>(column: C, value: LiteralValue): Predicate<C> =>
+  compare(column, "neq", value)
+export const gt = <C extends string>(column: C, value: LiteralValue): Predicate<C> =>
+  compare(column, "gt", value)
+export const gte = <C extends string>(column: C, value: LiteralValue): Predicate<C> =>
+  compare(column, "gte", value)
+export const lt = <C extends string>(column: C, value: LiteralValue): Predicate<C> =>
+  compare(column, "lt", value)
+export const lte = <C extends string>(column: C, value: LiteralValue): Predicate<C> =>
+  compare(column, "lte", value)
+export const like = <C extends string>(column: C, pattern: string): Predicate<C> =>
+  compare(column, "like", pattern)
+
+export const isNull = <C extends string>(column: C): Predicate<C> => ({
+  type: "nullCheck",
+  operand: { kind: "column", name: column },
+  isNull: true,
+})
+export const notNull = <C extends string>(column: C): Predicate<C> => ({
+  type: "nullCheck",
+  operand: { kind: "column", name: column },
+  isNull: false,
+})
+
+/** Every rule must hold. */
+export const and = <C extends string>(...rules: Predicate<C>[]): Predicate<C> => ({
+  type: "all",
+  rules,
+})
+
+/** Any one rule holding is enough. */
+export const or = <C extends string>(...rules: Predicate<C>[]): Predicate<C> => ({
+  type: "any",
+  rules,
+})
+
+export const not = <C extends string>(rule: Predicate<C>): Predicate<C> => ({ type: "not", rule })
+
+/**
+ * The column's value is one of these.
+ *
+ * `oneOf` rather than `in`, which is a reserved word and cannot be an identifier.
+ */
+export const oneOf = <C extends string>(
+  column: C,
+  values: readonly LiteralValue[],
+): Predicate<C> => ({
+  type: "in",
+  column,
+  source: { kind: "literal", values: [...values] },
+})
+
+// --- The document a builder produces ---
+
+/** A value produced by an earlier operation in the same document. */
+export interface RefValue {
+  readonly $ref: string
+}
+
+/** An exact decimal, kept as text because JSON has no decimal type. */
+export interface NumericValue {
+  readonly $numeric: string
+}
+
+export type SeedValue =
+  | string
+  | number
+  | boolean
+  | null
+  | readonly SeedValue[]
+  | RefValue
+  | NumericValue
+  | DefaultExpr
+  | Operand
+  | { readonly [key: string]: SeedValue | undefined }
+
+export type SeedData = Record<string, SeedValue>
+
+export type SeedOperation =
+  | { op: "create"; model: string; id?: string; data: SeedData }
+  | { op: "createMany"; model: string; rows: SeedData[] }
+  | { op: "upsert"; model: string; id?: string; where: SeedData; data: SeedData }
+  | { op: "sql"; text: string; params?: SeedValue[] }
+  | { op: "group"; if?: SeedCondition; operations: SeedOperation[] }
+
+export type SeedCondition =
+  | { kind: "exists"; model: string; where?: Predicate }
+  | { kind: "notExists"; model: string; where?: Predicate }
+  | { kind: "environment"; name: string }
+
+/** One seed document, as the engine reads it. */
+export interface SeedIr {
+  irVersion: 1
+  schemaFingerprint: string
+  operations: SeedOperation[]
+}
+
+// --- What a generated builder plugs into ---
+
+/**
+ * What the runtime needs to know about a model and cannot tell from a value.
+ *
+ * Written by the generator, read by the collector. Three facts, each of which changes how a
+ * value is encoded and none of which is visible at runtime: which columns are exact
+ * decimals, which hold a time, and which fields are relations to what.
+ */
+export interface ModelManifest {
+  model: string
+  table: string
+  /** Columns where a number would lose precision, so the value travels as an exact decimal. */
+  numeric: readonly string[]
+  /** Columns that hold an instant, so a `Date` is rendered as one. */
+  temporal: readonly string[]
+  relations: Readonly<Record<string, { kind: RelationKind; target: string }>>
+}
+
+export type RelationKind = "belongsTo" | "hasOne" | "hasMany" | "manyToMany"
+
+/** What a model exposes on `db`. */
+export interface ModelApi<TCreate, TWhere, TRef> {
+  /** Insert one row, and hand back something later operations can point at. */
+  create(data: TCreate, options?: { id?: string }): TRef
+  /**
+   * Insert many rows of one model in one statement.
+   *
+   * Not sugar for repeated `create`: a per-row API is how a seed of a few thousand rows
+   * becomes a few thousand round trips.
+   */
+  createMany(rows: readonly TCreate[]): void
+  /**
+   * Insert, or update the row the `where` columns already identify.
+   *
+   * The primary operation for a seed, because seeds get re-run and idempotency is the thing
+   * every hand-written one gets wrong.
+   */
+  upsert(args: { where: TWhere; data: TCreate; id?: string }): TRef
+}
+
+/**
+ * Filled in by the generated builder, through declaration merging.
+ *
+ * Empty here so the runtime compiles on its own, and so a project that has not run
+ * `supatype generate` yet gets a loosely typed `db` rather than a module that does not
+ * resolve.
+ */
+export interface SupatypeSeedRegistry {
+  /** Never set. Present so the interface is not empty, which some lint rules refuse. */
+  readonly __generated?: never
+}
+
+type FallbackModel = ModelApi<SeedData, SeedData, Record<string, RefValue>>
+
+type RegisteredModels = SupatypeSeedRegistry extends { models: infer M }
+  ? M
+  : Record<string, FallbackModel>
+
+type RegisteredCondition = SupatypeSeedRegistry extends { condition: infer C }
+  ? C
+  : SeedConditionInput
+
+/** The condition surface, before a generated builder narrows it to this schema's models. */
+export type SeedConditionInput =
+  | { exists: { model: string; where?: Predicate } }
+  | { notExists: { model: string; where?: Predicate } }
+  | { environment: string }
+
+export type SeedDb = RegisteredModels & {
+  /**
+   * Run a block only when the database says so.
+   *
+   * Plain `if` already works for anything decided from the program's own inputs, and should
+   * be preferred. This is for the one thing plain `if` cannot do: branch on database state,
+   * which the builder cannot read because it never connects. The condition travels in the
+   * IR and the engine evaluates it at this position, inside the transaction.
+   */
+  $if(condition: RegisteredCondition, body: () => void): void
+  /**
+   * A raw statement, in the same transaction and the same order as everything else.
+   *
+   * Inside the IR rather than offered as a side channel, so a seed that mixes typed
+   * operations and raw SQL still runs as one thing instead of the author opening a second
+   * connection the engine knows nothing about.
+   */
+  $sql(text: string, params?: readonly SeedValue[]): void
+}
+
+/** What the runner hands a seed's default export. */
+export interface SeedContext {
+  db: SeedDb
+  expr: typeof expr
+  /** Print a line, through the runner's own output rather than straight to stdout. */
+  log: (message: string) => void
+  /** The environment this run targets, when the runner was told one. */
+  environment?: string | undefined
+}
+
+/** What a seed file may ask of the runner. */
+export interface SeedConfig {
+  /** Run this document in a transaction. Default true, and rarely worth changing. */
+  transaction?: boolean
+  /**
+   * Apply this document at most once per environment.
+   *
+   * For a genuine one-time backfill rather than a fixture. Off by default, because seeds
+   * are idempotent upserts by design and skipping one because it ran before would turn
+   * every seed file into a one-shot migration.
+   */
+  runOnce?: boolean
+}
+
+/** The shape a seed module exports. */
+export interface SeedModule {
+  default?: (context: SeedContext) => void | Promise<void>
+  config?: SeedConfig
+}

package/src/self-host-compose.ts

@@ -14,11 +14,11 @@ import {
   usesExternalDatabase,
   type SupatypeProjectConfig,
 } from "./project-config.js"
-import { hasEngineOverride, hasStudioOverride, pinnedVersion, fetchLatestVersion, VERSION_PIN_LOCAL } from "./binary-cache.js"
+import { hasStudioOverride, pinnedVersion, fetchLatestVersion, VERSION_PIN_LOCAL } from "./binary-cache.js"
 import { buildKongDeclarative } from "./kong-config.js"
 import { keyspaceInPostgres } from "./cache-provider.js"
 import { STUDIO_DEV_PORT } from "./studio-dev-server.js"
-import { hasEnvValue, readEnvFile } from "./env-file.js"
+import { readEnvFile } from "./env-file.js"
 import { fieldMaskingTierFromProject, type FieldMaskingTier } from "./field-masking-tier.js"
 import { projectHasVersionedModels } from "./model-versioning.js"
 
@@ -404,12 +404,18 @@ ${studioService}
     : `      - server
       - studio
       - control-plane`
-  // In dev the database is published only when something on the host needs to reach it, which is
-  // normally a host engine build. A project that names a port is asking for one too: without this,
-  // `SUPATYPE_DEV_DB_PORT` was honoured for the number and ignored for whether the port existed,
-  // so a seed connecting over TCP got ECONNREFUSED and nothing said why.
-  const dbPortRequested = hasEnvValue(cwd, "SUPATYPE_DEV_DB_PORT")
-  const publishDbToHost = !devLocal || hasEngineOverride(config) || dbPortRequested
+  // The database is always reachable from the host.
+  //
+  // It used to be published in dev only when something was known to need it, which was a host
+  // engine build or a project that had named `SUPATYPE_DEV_DB_PORT`. Seeding is now a host
+  // process: the CLI resolves a connection string and the engine connects over TCP. Under the old
+  // rule a fresh `supatype init` produced a stack whose database nothing on the host could reach,
+  // so the first `supatype seed` got ECONNREFUSED and the remedy was an environment variable
+  // nobody had reason to know about.
+  //
+  // This exposes nothing new: the dev port below is bound to `127.0.0.1`, so it is reachable from
+  // this machine and from nowhere else.
+  const publishDbToHost = true
   const dbPorts = publishDbToHost
     ? devLocal
       ? `    ports:

package/src/type-extractor.ts

@@ -2904,6 +2904,104 @@ const TIME_UNITS = [
 /** Granularities for `StartOf<>`. */
 const TRUNC_UNITS = ["day", "week", "month", "year"] as const
 
+/**
+ * `After<Base, { days: 30, hours: 9 }>` / `Before<...>`: a point in time plus or minus a
+ * multi-unit duration.
+ *
+ * The interval is re-assembled from parsed integers and matched keywords, exactly as
+ * `parseDurationOperand` does, so no author-supplied text reaches Postgres. A permissive
+ * `"30 days 9 hours"` string would be raw SQL by another name.
+ *
+ * Direction is in the operand name rather than the sign of a component, which is the rule
+ * `Ago`/`FromNow` already follow: a negative amount is refused with a message naming the
+ * opposite operand, because relying on a double negative reads wrongly.
+ */
+function parseOffsetOperand(
+  ref: "After" | "Before",
+  args: readonly ts.TypeNode[],
+  sourceFile: ts.SourceFile,
+): Record<string, unknown> {
+  if (args.length !== 2) {
+    throw new Error(
+      `\`${ref}<>\` takes a base and an interval, as in ` +
+        `\`${ref}<StartOf<"day">, { days: 30, hours: 9 }>\`.`,
+    )
+  }
+
+  const base = parseAccessOperand(args[0]!, sourceFile)
+  const baseKind = typeof base["kind"] === "string" ? base["kind"] : ""
+  if (baseKind !== "now" && baseKind !== "startOf") {
+    throw new Error(
+      `\`${ref}<>\` measures from a point in time, so its base must be \`Now\` or ` +
+        `\`StartOf<unit>\`. A column or a claim depends on the row or the caller and ` +
+        `cannot be offset.`,
+    )
+  }
+
+  const intervalNode = args[1]!
+  if (!ts.isTypeLiteralNode(intervalNode)) {
+    throw new Error(
+      `\`${ref}<>\` takes the interval as an object, as in \`{ days: 30, hours: 9 }\`.`,
+    )
+  }
+
+  const opposite = ref === "After" ? "Before" : "After"
+  const interval: Record<string, number> = {}
+
+  for (const member of intervalNode.members) {
+    if (!ts.isPropertySignature(member) || !member.name || !member.type) {
+      throw new Error(`\`${ref}<>\` interval members must be \`unit: amount\` pairs.`)
+    }
+    const unit = member.name.getText(sourceFile).replace(/["']/g, "")
+    if (!TIME_UNITS.includes(unit as (typeof TIME_UNITS)[number])) {
+      throw new Error(
+        `\`${unit}\` is not a unit of time. Use one of: ${TIME_UNITS.join(", ")} (plural).`,
+      )
+    }
+
+    const amountNode = member.type
+    // A negative literal is a prefix-unary expression, not a numeric literal, so it has
+    // to be recognised separately or it is refused for the wrong reason and the message
+    // misses the real advice.
+    if (
+      ts.isLiteralTypeNode(amountNode) &&
+      ts.isPrefixUnaryExpression(amountNode.literal) &&
+      amountNode.literal.operator === ts.SyntaxKind.MinusToken
+    ) {
+      throw new Error(
+        `\`${ref}<>\` does not take a negative amount. For the other direction use ` +
+          `\`${opposite}<>\`, which reads correctly instead of relying on a double negative.`,
+      )
+    }
+    if (!ts.isLiteralTypeNode(amountNode) || !ts.isNumericLiteral(amountNode.literal)) {
+      throw new Error(`\`${unit}\` needs a number literal amount, as in \`{ ${unit}: 30 }\`.`)
+    }
+    const amount = Number(amountNode.literal.text)
+    if (!Number.isInteger(amount)) {
+      throw new Error(
+        `\`{ ${unit}: ${amount} }\` must be a whole number of units: Postgres intervals ` +
+          `take integers, so a fraction would be silently truncated or rejected.`,
+      )
+    }
+    if (unit in interval) {
+      throw new Error(`\`${ref}<>\` names \`${unit}\` twice; give each unit once.`)
+    }
+    interval[unit] = amount
+  }
+
+  // An all-zero interval means the base unchanged, which is never what an author wrote.
+  // The engine refuses it too, but saying so here names the operand at the point it was
+  // written rather than at push.
+  if (Object.values(interval).every((amount) => amount === 0)) {
+    throw new Error(
+      `\`${ref}<>\` was given an empty interval, which means the base unchanged. ` +
+        `Give at least one non-zero unit, as in \`{ days: 30 }\`.`,
+    )
+  }
+
+  return { kind: ref === "After" ? "after" : "before", base, interval }
+}
+
 /**
  * `Ago<30, "days">` / `FromNow<7, "days">`.
  *
@@ -3062,6 +3160,9 @@ function parseAccessOperand(
       case "Ago":
       case "FromNow":
         return parseDurationOperand(ref, operandArgs, sourceFile)
+      case "After":
+      case "Before":
+        return parseOffsetOperand(ref, operandArgs, sourceFile)
       case "Claim": {
         const pathArg = typeNode.typeArguments?.[0]
         if (!pathArg || !ts.isLiteralTypeNode(pathArg) || !ts.isStringLiteral(pathArg.literal)) {

package/src/type-generation.ts

@@ -21,6 +21,19 @@ import { generateProjectClient } from "./client-generator.js"
 /** The client a project imports, beside the generated types. */
 const PROJECT_CLIENT_FILENAME = "client.ts"
 
+/**
+ * Where generated output goes when a project has not said otherwise.
+ *
+ * Exported because two commands need the same answer: `generate` writes these files and
+ * `seed` reads one of them, and when they disagreed the builder was written to a path the
+ * seed run then reported as missing.
+ */
+export const DEFAULT_TYPES_PATH = "types/database.ts"
+export const DEFAULT_CLIENT_PATH = "supatype/generated/index.d.ts"
+
+/** The seed builder, beside the client, because both are generated from the same schema. */
+const SEED_BUILDER_FILENAME = "seed.ts"
+
 export interface GenerateTypesRequest {
   cwd: string
   ast: unknown
@@ -30,6 +43,39 @@ export interface GenerateTypesRequest {
   clientPath?: string | undefined
 }
 
+/**
+ * Where the generated seed builder lives for this project.
+ *
+ * One rule, exported, because two things need the answer and a seed run that looked
+ * somewhere else would report a missing builder for a file that had just been written.
+ */
+export function seedBuilderPath(req: {
+  typesPath?: string | undefined
+  clientPath?: string | undefined
+}): string | undefined {
+  const directory = req.clientPath ?? req.typesPath
+  if (directory === undefined || directory === "") return undefined
+  return join(dirname(directory), SEED_BUILDER_FILENAME)
+}
+
+/**
+ * The same answer for a project that has configured nothing.
+ *
+ * `generate` writes with the defaults applied, so a reader must resolve them the same way or
+ * it looks for a file beside a path the project never set.
+ */
+export function seedBuilderPathWithDefaults(output?: {
+  types?: string | undefined
+  client?: string | undefined
+}): string {
+  return (
+    seedBuilderPath({
+      typesPath: output?.types ?? DEFAULT_TYPES_PATH,
+      clientPath: output?.client ?? DEFAULT_CLIENT_PATH,
+    }) ?? join(dirname(DEFAULT_CLIENT_PATH), SEED_BUILDER_FILENAME)
+  )
+}
+
 /** Writes what was asked for and returns one message per file, for the caller to report. */
 export async function writeGeneratedTypes(req: GenerateTypesRequest): Promise<string[]> {
   const written: string[] = []
@@ -52,6 +98,24 @@ export async function writeGeneratedTypes(req: GenerateTypesRequest): Promise<st
     written.push(`Types written to ${req.typesPath}`)
   }
 
+  const seedPath = seedBuilderPath(req)
+  if (seedPath !== undefined) {
+    await ensureEngine()
+    const result = await engineRequest<{ code?: string; message?: string }>("/generate", {
+      ast: req.ast,
+      lang: "typescript",
+      artifact: "seed",
+    })
+    const code = result.code ?? result.message
+    if (code === undefined) {
+      throw new Error("Engine returned no output for the seed builder.")
+    }
+    const outPath = resolve(req.cwd, seedPath)
+    mkdirSync(dirname(outPath), { recursive: true })
+    writeFileSync(outPath, code, "utf8")
+    written.push(`Seed builder written to ${toPosix(seedPath)}`)
+  }
+
   written.push(...writeAstDerivedOutputs(req))
 
   return written