@prisma-next/ts-render 0.0.1

package/README.md

@@ -0,0 +1,48 @@
+# @prisma-next/ts-render
+
+> **Internal package.** This package is an implementation detail of [`prisma-next`](https://www.npmjs.com/package/prisma-next)
+> and is published only to support its runtime. Its API is unstable and may change
+> without notice. Do not depend on this package directly; install `prisma-next` instead.
+
+TypeScript source-text rendering utilities shared by any Prisma Next component that has to emit hand-editable `.ts` files — today the Postgres and Mongo migration-authoring surfaces, later any new target that ships a migration-authoring experience.
+
+## Overview
+
+Two small pieces:
+
+- **`TsExpression`** — abstract base class for any node that renders as a TypeScript expression in a generated source file. Subclasses supply `renderTypeScript(): string` and `importRequirements(): readonly ImportRequirement[]`. Hierarchical so that composite nodes (e.g. a `DataTransformCall` containing slot expressions) can recurse into their children.
+- **`jsonToTsSource(value)`** — pure JSON-to-TypeScript-source printer. Accepts `unknown` for ergonomics with structural types whose fields happen to be JSON-compatible, and throws at runtime on anything that is not a JSON primitive / array / object.
+
+## Codec → TS pipeline
+
+`jsonToTsSource` is deliberately the **second** stage of a two-stage pipeline:
+
+```text
+jsValue  →  codec.encodeJson  →  JsonValue  →  jsonToTsSource  →  TS source text
+```
+
+Stage 1 (`codec.encodeJson`) is a codec responsibility — date serialization, opaque domain types (vector, bigint, uuid), JSON canonicalization. Stage 2 (this module) is a pure printer that must never grow type-specific branches. To render a non-JSON JS value (`Date`, `Vector`, `BigInt`, `Buffer`, …), encode it through the relevant codec's `encodeJson` first.
+
+## Usage
+
+```ts
+import { type ImportRequirement, TsExpression, jsonToTsSource } from '@prisma-next/ts-render';
+
+class CreateTableCall extends TsExpression {
+  constructor(
+    readonly schema: string,
+    readonly table: string,
+    readonly columns: ReadonlyArray<{ name: string; typeSql: string; nullable: boolean }>,
+  ) {
+    super();
+  }
+
+  override renderTypeScript(): string {
+    return `createTable(${jsonToTsSource(this.schema)}, ${jsonToTsSource(this.table)}, ${jsonToTsSource(this.columns)})`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [{ moduleSpecifier: '@prisma-next/target-postgres/migration', symbol: 'createTable' }];
+  }
+}
+```

package/dist/index.d.mts

@@ -0,0 +1,90 @@
+//#region src/json-to-ts-source.d.ts
+/**
+ * Pure JSON-to-TypeScript-source printer.
+ *
+ * This module is the second stage of the codec → TS pipeline:
+ *
+ *     jsValue  →  codec.encodeJson  →  JsonValue  →  jsonToTsSource  →  TS source text
+ *
+ * Stage 1 (`codec.encodeJson`) is a codec responsibility — date serialization,
+ * opaque domain types (vector, bigint, uuid), JSON canonicalization. Stage 2
+ * (this module) is a pure JSON-to-TS printer that must never grow type-specific
+ * branches.
+ *
+ * To render a non-JSON JS value (Date, Vector, BigInt, Buffer, …), encode it
+ * through the relevant codec's `encodeJson` first. Adding special cases to
+ * this file is not the answer — that's what codecs are for.
+ */
+type JsonValue = string | number | boolean | null | readonly JsonValue[] | JsonObject;
+type JsonObject = {
+  readonly [key: string]: JsonValue | undefined;
+};
+/**
+ * Render a JSON-compatible value as a TypeScript source-text literal.
+ *
+ * Accepts `unknown` for ergonomics with structural types (e.g. `ColumnSpec`,
+ * `ForeignKeySpec`) whose fields are all JSON-compatible but whose interfaces
+ * lack the index signature TypeScript requires for `JsonObject` assignability.
+ * Non-JSON values (Date, Symbol, Function, etc.) throw at runtime.
+ */
+declare function jsonToTsSource(value: unknown): string;
+//#endregion
+//#region src/ts-expression.d.ts
+/**
+ * Declarative contribution to the `import` block of a rendered TypeScript
+ * source file. Each node in an IR declares which symbols it needs from which
+ * modules; the top-level renderer deduplicates across nodes and emits one
+ * `import { a, b, c } from "…"` line per module.
+ *
+ * `kind` defaults to `"named"` (e.g. `import { a } from "m"`). Setting it to
+ * `"default"` emits `import a from "m"`. `attributes`, if provided, emits an
+ * import attributes clause (`with { type: "json" }`) verbatim — required for
+ * JSON module imports in the rendered scaffolds.
+ */
+interface ImportRequirement {
+  readonly moduleSpecifier: string;
+  readonly symbol: string;
+  readonly kind?: 'named' | 'default';
+  readonly attributes?: Readonly<Record<string, string>>;
+}
+/**
+ * Abstract base class for any IR node that can be emitted as a TypeScript
+ * expression and declare its own import requirements.
+ *
+ * A top-level renderer walks an array of these polymorphically, concatenates
+ * `renderTypeScript()` results, and aggregates `importRequirements()` into a
+ * deduplicated import block.
+ */
+declare abstract class TsExpression {
+  abstract renderTypeScript(): string;
+  abstract importRequirements(): readonly ImportRequirement[];
+}
+//#endregion
+//#region src/render-imports.d.ts
+/**
+ * Render an aggregated `import` block from a flat list of
+ * `ImportRequirement`s. Each target's migration renderer collects
+ * requirements polymorphically from its call nodes and pipes them here.
+ *
+ * The emitter invariants:
+ *
+ * - **One line per module specifier.** Named imports are aggregated and
+ *   emitted sorted alphabetically; a single default symbol is combined
+ *   onto the same line when attributes agree (`import def, { a, b } from "m";`).
+ * - **At most one default symbol per module.** Two conflicting default
+ *   symbols on the same specifier throw — the user's renderer can't
+ *   guess which one they meant.
+ * - **Attribute unanimity per module.** All requirements for the same
+ *   module specifier must carry the same (or no) `attributes` map.
+ *   Divergent attribute maps throw — they can't collapse to one line
+ *   and there's no user-resolvable recovery at this layer.
+ * - **Deterministic ordering.** Modules are emitted sorted by specifier;
+ *   within a module, named symbols are emitted sorted alphabetically.
+ *
+ * Returns a string containing one import line per module, joined by `\n`
+ * (no trailing newline). An empty requirement list returns `""`.
+ */
+declare function renderImports(requirements: readonly ImportRequirement[]): string;
+//#endregion
+export { type ImportRequirement, type JsonObject, type JsonValue, TsExpression, jsonToTsSource, renderImports };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/json-to-ts-source.ts","../src/ts-expression.ts","../src/render-imports.ts"],"sourcesContent":[],"mappings":";;AAiBA;AACA;AAUA;;;;ACjBA;AAeA;;;;ACDA;;;;KFRY,SAAA,+CAAwD,cAAc;KACtE,UAAA;0BAAuC;;;;;;;;;;iBAUnC,cAAA;;;;AAXhB;AACA;AAUA;;;;ACjBA;AAeA;;;UAfiB,iBAAA;ECcD,SAAA,eAAa,EAAA,MAAwB;;;wBDV7B,SAAS;;;;;;;;;;uBAWX,YAAA;;0CAEoB;;;;ADX1C;AACA;AAUA;;;;ACjBA;AAeA;;;;ACDA;;;;;;;;;;;;iBAAgB,aAAA,wBAAqC"}

package/dist/index.mjs

@@ -0,0 +1,147 @@
+//#region src/json-to-ts-source.ts
+/**
+* Render a JSON-compatible value as a TypeScript source-text literal.
+*
+* Accepts `unknown` for ergonomics with structural types (e.g. `ColumnSpec`,
+* `ForeignKeySpec`) whose fields are all JSON-compatible but whose interfaces
+* lack the index signature TypeScript requires for `JsonObject` assignability.
+* Non-JSON values (Date, Symbol, Function, etc.) throw at runtime.
+*/
+function jsonToTsSource(value) {
+	if (value === void 0) return "undefined";
+	if (value === null) return "null";
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "[]";
+		const items = value.map((v) => jsonToTsSource(v));
+		const singleLine = `[${items.join(", ")}]`;
+		if (singleLine.length <= 80) return singleLine;
+		return `[\n${items.map((i) => `  ${i}`).join(",\n")},\n]`;
+	}
+	if (typeof value === "object") {
+		const entries = Object.entries(value).filter(([, v]) => v !== void 0);
+		if (entries.length === 0) return "{}";
+		const items = entries.map(([k, v]) => `${renderKey(k)}: ${jsonToTsSource(v)}`);
+		const singleLine = `{ ${items.join(", ")} }`;
+		if (singleLine.length <= 80) return singleLine;
+		return `{\n${items.map((i) => `  ${i}`).join(",\n")},\n}`;
+	}
+	throw new Error(`jsonToTsSource: unsupported value type "${typeof value}"`);
+}
+function renderKey(key) {
+	if (key === "__proto__") return JSON.stringify(key);
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+
+//#endregion
+//#region src/render-imports.ts
+/**
+* Render an aggregated `import` block from a flat list of
+* `ImportRequirement`s. Each target's migration renderer collects
+* requirements polymorphically from its call nodes and pipes them here.
+*
+* The emitter invariants:
+*
+* - **One line per module specifier.** Named imports are aggregated and
+*   emitted sorted alphabetically; a single default symbol is combined
+*   onto the same line when attributes agree (`import def, { a, b } from "m";`).
+* - **At most one default symbol per module.** Two conflicting default
+*   symbols on the same specifier throw — the user's renderer can't
+*   guess which one they meant.
+* - **Attribute unanimity per module.** All requirements for the same
+*   module specifier must carry the same (or no) `attributes` map.
+*   Divergent attribute maps throw — they can't collapse to one line
+*   and there's no user-resolvable recovery at this layer.
+* - **Deterministic ordering.** Modules are emitted sorted by specifier;
+*   within a module, named symbols are emitted sorted alphabetically.
+*
+* Returns a string containing one import line per module, joined by `\n`
+* (no trailing newline). An empty requirement list returns `""`.
+*/
+function renderImports(requirements) {
+	return [...aggregateByModule(requirements).entries()].sort(([a], [b]) => a.localeCompare(b)).map(([moduleSpecifier, group]) => renderModuleImport(moduleSpecifier, group)).join("\n");
+}
+function aggregateByModule(requirements) {
+	const byModule = /* @__PURE__ */ new Map();
+	for (const req of requirements) {
+		let group = byModule.get(req.moduleSpecifier);
+		if (!group) {
+			group = {
+				named: /* @__PURE__ */ new Set(),
+				defaultSymbol: null,
+				attributes: null,
+				attributesSet: false
+			};
+			byModule.set(req.moduleSpecifier, group);
+		}
+		mergeRequirementIntoGroup(req, group);
+	}
+	return byModule;
+}
+function mergeRequirementIntoGroup(req, group) {
+	if ((req.kind ?? "named") === "default") {
+		if (group.defaultSymbol !== null && group.defaultSymbol !== req.symbol) throw new Error(`Conflicting default imports for module "${req.moduleSpecifier}": "${group.defaultSymbol}" and "${req.symbol}". Only one default symbol is allowed per module.`);
+		group.defaultSymbol = req.symbol;
+	} else group.named.add(req.symbol);
+	mergeAttributes(req, group);
+}
+function mergeAttributes(req, group) {
+	const incoming = req.attributes ?? null;
+	if (!group.attributesSet) {
+		group.attributes = incoming;
+		group.attributesSet = true;
+		return;
+	}
+	if (!attributesEqual(group.attributes, incoming)) throw new Error(`Conflicting import attributes for module "${req.moduleSpecifier}": ${stringifyAttributes(group.attributes)} vs ${stringifyAttributes(incoming)}.`);
+}
+function attributesEqual(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null) return false;
+	const aKeys = Object.keys(a).sort();
+	const bKeys = Object.keys(b).sort();
+	if (aKeys.length !== bKeys.length) return false;
+	for (let i = 0; i < aKeys.length; i++) {
+		const key = aKeys[i];
+		if (key !== bKeys[i]) return false;
+		if (a[key] !== b[key]) return false;
+	}
+	return true;
+}
+function stringifyAttributes(attrs) {
+	if (attrs === null) return "(none)";
+	return `{ ${Object.entries(attrs).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join(", ")} }`;
+}
+function renderModuleImport(moduleSpecifier, group) {
+	return `import ${buildImportClause(group)} from '${moduleSpecifier}'${buildAttributesClause(group.attributes)};`;
+}
+function buildImportClause(group) {
+	const named = [...group.named].sort();
+	const hasNamed = named.length > 0;
+	const hasDefault = group.defaultSymbol !== null;
+	if (hasDefault && hasNamed) return `${group.defaultSymbol}, { ${named.join(", ")} }`;
+	if (hasDefault) return group.defaultSymbol;
+	return `{ ${named.join(", ")} }`;
+}
+function buildAttributesClause(attrs) {
+	if (attrs === null) return "";
+	const entries = Object.entries(attrs).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
+	if (entries.length === 0) return "";
+	return ` with { ${entries.join(", ")} }`;
+}
+
+//#endregion
+//#region src/ts-expression.ts
+/**
+* Abstract base class for any IR node that can be emitted as a TypeScript
+* expression and declare its own import requirements.
+*
+* A top-level renderer walks an array of these polymorphically, concatenates
+* `renderTypeScript()` results, and aggregates `importRequirements()` into a
+* deduplicated import block.
+*/
+var TsExpression = class {};
+
+//#endregion
+export { TsExpression, jsonToTsSource, renderImports };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/json-to-ts-source.ts","../src/render-imports.ts","../src/ts-expression.ts"],"sourcesContent":["/**\n * Pure JSON-to-TypeScript-source printer.\n *\n * This module is the second stage of the codec → TS pipeline:\n *\n *     jsValue  →  codec.encodeJson  →  JsonValue  →  jsonToTsSource  →  TS source text\n *\n * Stage 1 (`codec.encodeJson`) is a codec responsibility — date serialization,\n * opaque domain types (vector, bigint, uuid), JSON canonicalization. Stage 2\n * (this module) is a pure JSON-to-TS printer that must never grow type-specific\n * branches.\n *\n * To render a non-JSON JS value (Date, Vector, BigInt, Buffer, …), encode it\n * through the relevant codec's `encodeJson` first. Adding special cases to\n * this file is not the answer — that's what codecs are for.\n */\n\nexport type JsonValue = string | number | boolean | null | readonly JsonValue[] | JsonObject;\nexport type JsonObject = { readonly [key: string]: JsonValue | undefined };\n\n/**\n * Render a JSON-compatible value as a TypeScript source-text literal.\n *\n * Accepts `unknown` for ergonomics with structural types (e.g. `ColumnSpec`,\n * `ForeignKeySpec`) whose fields are all JSON-compatible but whose interfaces\n * lack the index signature TypeScript requires for `JsonObject` assignability.\n * Non-JSON values (Date, Symbol, Function, etc.) throw at runtime.\n */\nexport function jsonToTsSource(value: unknown): string {\n  if (value === undefined) return 'undefined';\n  if (value === null) return 'null';\n  if (typeof value === 'string') return JSON.stringify(value);\n  if (typeof value === 'number' || typeof value === 'boolean') return String(value);\n  if (Array.isArray(value)) {\n    if (value.length === 0) return '[]';\n    const items = value.map((v: unknown) => jsonToTsSource(v));\n    const singleLine = `[${items.join(', ')}]`;\n    if (singleLine.length <= 80) return singleLine;\n    return `[\\n${items.map((i) => `  ${i}`).join(',\\n')},\\n]`;\n  }\n  if (typeof value === 'object') {\n    const entries = Object.entries(value).filter(([, v]) => v !== undefined);\n    if (entries.length === 0) return '{}';\n    const items = entries.map(([k, v]) => `${renderKey(k)}: ${jsonToTsSource(v)}`);\n    const singleLine = `{ ${items.join(', ')} }`;\n    if (singleLine.length <= 80) return singleLine;\n    return `{\\n${items.map((i) => `  ${i}`).join(',\\n')},\\n}`;\n  }\n  throw new Error(`jsonToTsSource: unsupported value type \"${typeof value}\"`);\n}\n\nfunction renderKey(key: string): string {\n  if (key === '__proto__') return JSON.stringify(key);\n  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);\n}\n","import type { ImportRequirement } from './ts-expression';\n\n/**\n * Render an aggregated `import` block from a flat list of\n * `ImportRequirement`s. Each target's migration renderer collects\n * requirements polymorphically from its call nodes and pipes them here.\n *\n * The emitter invariants:\n *\n * - **One line per module specifier.** Named imports are aggregated and\n *   emitted sorted alphabetically; a single default symbol is combined\n *   onto the same line when attributes agree (`import def, { a, b } from \"m\";`).\n * - **At most one default symbol per module.** Two conflicting default\n *   symbols on the same specifier throw — the user's renderer can't\n *   guess which one they meant.\n * - **Attribute unanimity per module.** All requirements for the same\n *   module specifier must carry the same (or no) `attributes` map.\n *   Divergent attribute maps throw — they can't collapse to one line\n *   and there's no user-resolvable recovery at this layer.\n * - **Deterministic ordering.** Modules are emitted sorted by specifier;\n *   within a module, named symbols are emitted sorted alphabetically.\n *\n * Returns a string containing one import line per module, joined by `\\n`\n * (no trailing newline). An empty requirement list returns `\"\"`.\n */\nexport function renderImports(requirements: readonly ImportRequirement[]): string {\n  const byModule = aggregateByModule(requirements);\n  const entries = [...byModule.entries()].sort(([a], [b]) => a.localeCompare(b));\n  return entries\n    .map(([moduleSpecifier, group]) => renderModuleImport(moduleSpecifier, group))\n    .join('\\n');\n}\n\ninterface ModuleImportGroup {\n  readonly named: Set<string>;\n  defaultSymbol: string | null;\n  attributes: Readonly<Record<string, string>> | null;\n  attributesSet: boolean;\n}\n\nfunction aggregateByModule(\n  requirements: readonly ImportRequirement[],\n): Map<string, ModuleImportGroup> {\n  const byModule = new Map<string, ModuleImportGroup>();\n  for (const req of requirements) {\n    let group = byModule.get(req.moduleSpecifier);\n    if (!group) {\n      group = { named: new Set(), defaultSymbol: null, attributes: null, attributesSet: false };\n      byModule.set(req.moduleSpecifier, group);\n    }\n    mergeRequirementIntoGroup(req, group);\n  }\n  return byModule;\n}\n\nfunction mergeRequirementIntoGroup(req: ImportRequirement, group: ModuleImportGroup): void {\n  const kind = req.kind ?? 'named';\n  if (kind === 'default') {\n    if (group.defaultSymbol !== null && group.defaultSymbol !== req.symbol) {\n      throw new Error(\n        `Conflicting default imports for module \"${req.moduleSpecifier}\": ` +\n          `\"${group.defaultSymbol}\" and \"${req.symbol}\". Only one default symbol is allowed per module.`,\n      );\n    }\n    group.defaultSymbol = req.symbol;\n  } else {\n    group.named.add(req.symbol);\n  }\n  mergeAttributes(req, group);\n}\n\nfunction mergeAttributes(req: ImportRequirement, group: ModuleImportGroup): void {\n  const incoming = req.attributes ?? null;\n  if (!group.attributesSet) {\n    group.attributes = incoming;\n    group.attributesSet = true;\n    return;\n  }\n  if (!attributesEqual(group.attributes, incoming)) {\n    throw new Error(\n      `Conflicting import attributes for module \"${req.moduleSpecifier}\": ` +\n        `${stringifyAttributes(group.attributes)} vs ${stringifyAttributes(incoming)}.`,\n    );\n  }\n}\n\nfunction attributesEqual(\n  a: Readonly<Record<string, string>> | null,\n  b: Readonly<Record<string, string>> | null,\n): boolean {\n  if (a === b) return true;\n  if (a === null || b === null) return false;\n  const aKeys = Object.keys(a).sort();\n  const bKeys = Object.keys(b).sort();\n  if (aKeys.length !== bKeys.length) return false;\n  for (let i = 0; i < aKeys.length; i++) {\n    const key = aKeys[i];\n    if (key !== bKeys[i]) return false;\n    if (a[key as string] !== b[key as string]) return false;\n  }\n  return true;\n}\n\nfunction stringifyAttributes(attrs: Readonly<Record<string, string>> | null): string {\n  if (attrs === null) return '(none)';\n  const entries = Object.entries(attrs)\n    .sort(([a], [b]) => a.localeCompare(b))\n    .map(([k, v]) => `${k}: ${JSON.stringify(v)}`);\n  return `{ ${entries.join(', ')} }`;\n}\n\nfunction renderModuleImport(moduleSpecifier: string, group: ModuleImportGroup): string {\n  const clause = buildImportClause(group);\n  const attrs = buildAttributesClause(group.attributes);\n  return `import ${clause} from '${moduleSpecifier}'${attrs};`;\n}\n\nfunction buildImportClause(group: ModuleImportGroup): string {\n  const named = [...group.named].sort();\n  const hasNamed = named.length > 0;\n  const hasDefault = group.defaultSymbol !== null;\n  if (hasDefault && hasNamed) {\n    return `${group.defaultSymbol}, { ${named.join(', ')} }`;\n  }\n  if (hasDefault) {\n    return group.defaultSymbol as string;\n  }\n  return `{ ${named.join(', ')} }`;\n}\n\nfunction buildAttributesClause(attrs: Readonly<Record<string, string>> | null): string {\n  if (attrs === null) return '';\n  const entries = Object.entries(attrs)\n    .sort(([a], [b]) => a.localeCompare(b))\n    .map(([k, v]) => `${k}: ${JSON.stringify(v)}`);\n  if (entries.length === 0) return '';\n  return ` with { ${entries.join(', ')} }`;\n}\n","/**\n * Declarative contribution to the `import` block of a rendered TypeScript\n * source file. Each node in an IR declares which symbols it needs from which\n * modules; the top-level renderer deduplicates across nodes and emits one\n * `import { a, b, c } from \"…\"` line per module.\n *\n * `kind` defaults to `\"named\"` (e.g. `import { a } from \"m\"`). Setting it to\n * `\"default\"` emits `import a from \"m\"`. `attributes`, if provided, emits an\n * import attributes clause (`with { type: \"json\" }`) verbatim — required for\n * JSON module imports in the rendered scaffolds.\n */\nexport interface ImportRequirement {\n  readonly moduleSpecifier: string;\n  readonly symbol: string;\n  readonly kind?: 'named' | 'default';\n  readonly attributes?: Readonly<Record<string, string>>;\n}\n\n/**\n * Abstract base class for any IR node that can be emitted as a TypeScript\n * expression and declare its own import requirements.\n *\n * A top-level renderer walks an array of these polymorphically, concatenates\n * `renderTypeScript()` results, and aggregates `importRequirements()` into a\n * deduplicated import block.\n */\nexport abstract class TsExpression {\n  abstract renderTypeScript(): string;\n  abstract importRequirements(): readonly ImportRequirement[];\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@prisma-next/ts-render",
+  "version": "0.0.1",
+  "type": "module",
+  "sideEffects": false,
+  "description": "TypeScript source-text rendering utilities: JSON-to-TS literal printer and abstract expression base class",
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check . --error-on-warnings",
+    "lint:fix": "biome check --write .",
+    "lint:fix:unsafe": "biome check --write --unsafe .",
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@prisma-next/tsconfig": "workspace:*",
+    "@prisma-next/tsdown": "workspace:*",
+    "tsdown": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/1-framework/1-core/ts-render"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { type JsonObject, type JsonValue, jsonToTsSource } from './json-to-ts-source';
+export { renderImports } from './render-imports';
+export { type ImportRequirement, TsExpression } from './ts-expression';

package/src/json-to-ts-source.ts

@@ -0,0 +1,55 @@
+/**
+ * Pure JSON-to-TypeScript-source printer.
+ *
+ * This module is the second stage of the codec → TS pipeline:
+ *
+ *     jsValue  →  codec.encodeJson  →  JsonValue  →  jsonToTsSource  →  TS source text
+ *
+ * Stage 1 (`codec.encodeJson`) is a codec responsibility — date serialization,
+ * opaque domain types (vector, bigint, uuid), JSON canonicalization. Stage 2
+ * (this module) is a pure JSON-to-TS printer that must never grow type-specific
+ * branches.
+ *
+ * To render a non-JSON JS value (Date, Vector, BigInt, Buffer, …), encode it
+ * through the relevant codec's `encodeJson` first. Adding special cases to
+ * this file is not the answer — that's what codecs are for.
+ */
+
+export type JsonValue = string | number | boolean | null | readonly JsonValue[] | JsonObject;
+export type JsonObject = { readonly [key: string]: JsonValue | undefined };
+
+/**
+ * Render a JSON-compatible value as a TypeScript source-text literal.
+ *
+ * Accepts `unknown` for ergonomics with structural types (e.g. `ColumnSpec`,
+ * `ForeignKeySpec`) whose fields are all JSON-compatible but whose interfaces
+ * lack the index signature TypeScript requires for `JsonObject` assignability.
+ * Non-JSON values (Date, Symbol, Function, etc.) throw at runtime.
+ */
+export function jsonToTsSource(value: unknown): string {
+  if (value === undefined) return 'undefined';
+  if (value === null) return 'null';
+  if (typeof value === 'string') return JSON.stringify(value);
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return '[]';
+    const items = value.map((v: unknown) => jsonToTsSource(v));
+    const singleLine = `[${items.join(', ')}]`;
+    if (singleLine.length <= 80) return singleLine;
+    return `[\n${items.map((i) => `  ${i}`).join(',\n')},\n]`;
+  }
+  if (typeof value === 'object') {
+    const entries = Object.entries(value).filter(([, v]) => v !== undefined);
+    if (entries.length === 0) return '{}';
+    const items = entries.map(([k, v]) => `${renderKey(k)}: ${jsonToTsSource(v)}`);
+    const singleLine = `{ ${items.join(', ')} }`;
+    if (singleLine.length <= 80) return singleLine;
+    return `{\n${items.map((i) => `  ${i}`).join(',\n')},\n}`;
+  }
+  throw new Error(`jsonToTsSource: unsupported value type "${typeof value}"`);
+}
+
+function renderKey(key: string): string {
+  if (key === '__proto__') return JSON.stringify(key);
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}

package/src/render-imports.ts

@@ -0,0 +1,138 @@
+import type { ImportRequirement } from './ts-expression';
+
+/**
+ * Render an aggregated `import` block from a flat list of
+ * `ImportRequirement`s. Each target's migration renderer collects
+ * requirements polymorphically from its call nodes and pipes them here.
+ *
+ * The emitter invariants:
+ *
+ * - **One line per module specifier.** Named imports are aggregated and
+ *   emitted sorted alphabetically; a single default symbol is combined
+ *   onto the same line when attributes agree (`import def, { a, b } from "m";`).
+ * - **At most one default symbol per module.** Two conflicting default
+ *   symbols on the same specifier throw — the user's renderer can't
+ *   guess which one they meant.
+ * - **Attribute unanimity per module.** All requirements for the same
+ *   module specifier must carry the same (or no) `attributes` map.
+ *   Divergent attribute maps throw — they can't collapse to one line
+ *   and there's no user-resolvable recovery at this layer.
+ * - **Deterministic ordering.** Modules are emitted sorted by specifier;
+ *   within a module, named symbols are emitted sorted alphabetically.
+ *
+ * Returns a string containing one import line per module, joined by `\n`
+ * (no trailing newline). An empty requirement list returns `""`.
+ */
+export function renderImports(requirements: readonly ImportRequirement[]): string {
+  const byModule = aggregateByModule(requirements);
+  const entries = [...byModule.entries()].sort(([a], [b]) => a.localeCompare(b));
+  return entries
+    .map(([moduleSpecifier, group]) => renderModuleImport(moduleSpecifier, group))
+    .join('\n');
+}
+
+interface ModuleImportGroup {
+  readonly named: Set<string>;
+  defaultSymbol: string | null;
+  attributes: Readonly<Record<string, string>> | null;
+  attributesSet: boolean;
+}
+
+function aggregateByModule(
+  requirements: readonly ImportRequirement[],
+): Map<string, ModuleImportGroup> {
+  const byModule = new Map<string, ModuleImportGroup>();
+  for (const req of requirements) {
+    let group = byModule.get(req.moduleSpecifier);
+    if (!group) {
+      group = { named: new Set(), defaultSymbol: null, attributes: null, attributesSet: false };
+      byModule.set(req.moduleSpecifier, group);
+    }
+    mergeRequirementIntoGroup(req, group);
+  }
+  return byModule;
+}
+
+function mergeRequirementIntoGroup(req: ImportRequirement, group: ModuleImportGroup): void {
+  const kind = req.kind ?? 'named';
+  if (kind === 'default') {
+    if (group.defaultSymbol !== null && group.defaultSymbol !== req.symbol) {
+      throw new Error(
+        `Conflicting default imports for module "${req.moduleSpecifier}": ` +
+          `"${group.defaultSymbol}" and "${req.symbol}". Only one default symbol is allowed per module.`,
+      );
+    }
+    group.defaultSymbol = req.symbol;
+  } else {
+    group.named.add(req.symbol);
+  }
+  mergeAttributes(req, group);
+}
+
+function mergeAttributes(req: ImportRequirement, group: ModuleImportGroup): void {
+  const incoming = req.attributes ?? null;
+  if (!group.attributesSet) {
+    group.attributes = incoming;
+    group.attributesSet = true;
+    return;
+  }
+  if (!attributesEqual(group.attributes, incoming)) {
+    throw new Error(
+      `Conflicting import attributes for module "${req.moduleSpecifier}": ` +
+        `${stringifyAttributes(group.attributes)} vs ${stringifyAttributes(incoming)}.`,
+    );
+  }
+}
+
+function attributesEqual(
+  a: Readonly<Record<string, string>> | null,
+  b: Readonly<Record<string, string>> | null,
+): boolean {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  const aKeys = Object.keys(a).sort();
+  const bKeys = Object.keys(b).sort();
+  if (aKeys.length !== bKeys.length) return false;
+  for (let i = 0; i < aKeys.length; i++) {
+    const key = aKeys[i];
+    if (key !== bKeys[i]) return false;
+    if (a[key as string] !== b[key as string]) return false;
+  }
+  return true;
+}
+
+function stringifyAttributes(attrs: Readonly<Record<string, string>> | null): string {
+  if (attrs === null) return '(none)';
+  const entries = Object.entries(attrs)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
+  return `{ ${entries.join(', ')} }`;
+}
+
+function renderModuleImport(moduleSpecifier: string, group: ModuleImportGroup): string {
+  const clause = buildImportClause(group);
+  const attrs = buildAttributesClause(group.attributes);
+  return `import ${clause} from '${moduleSpecifier}'${attrs};`;
+}
+
+function buildImportClause(group: ModuleImportGroup): string {
+  const named = [...group.named].sort();
+  const hasNamed = named.length > 0;
+  const hasDefault = group.defaultSymbol !== null;
+  if (hasDefault && hasNamed) {
+    return `${group.defaultSymbol}, { ${named.join(', ')} }`;
+  }
+  if (hasDefault) {
+    return group.defaultSymbol as string;
+  }
+  return `{ ${named.join(', ')} }`;
+}
+
+function buildAttributesClause(attrs: Readonly<Record<string, string>> | null): string {
+  if (attrs === null) return '';
+  const entries = Object.entries(attrs)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
+  if (entries.length === 0) return '';
+  return ` with { ${entries.join(', ')} }`;
+}

package/src/ts-expression.ts

@@ -0,0 +1,30 @@
+/**
+ * Declarative contribution to the `import` block of a rendered TypeScript
+ * source file. Each node in an IR declares which symbols it needs from which
+ * modules; the top-level renderer deduplicates across nodes and emits one
+ * `import { a, b, c } from "…"` line per module.
+ *
+ * `kind` defaults to `"named"` (e.g. `import { a } from "m"`). Setting it to
+ * `"default"` emits `import a from "m"`. `attributes`, if provided, emits an
+ * import attributes clause (`with { type: "json" }`) verbatim — required for
+ * JSON module imports in the rendered scaffolds.
+ */
+export interface ImportRequirement {
+  readonly moduleSpecifier: string;
+  readonly symbol: string;
+  readonly kind?: 'named' | 'default';
+  readonly attributes?: Readonly<Record<string, string>>;
+}
+
+/**
+ * Abstract base class for any IR node that can be emitted as a TypeScript
+ * expression and declare its own import requirements.
+ *
+ * A top-level renderer walks an array of these polymorphically, concatenates
+ * `renderTypeScript()` results, and aggregates `importRequirements()` into a
+ * deduplicated import block.
+ */
+export abstract class TsExpression {
+  abstract renderTypeScript(): string;
+  abstract importRequirements(): readonly ImportRequirement[];
+}