@prisma-next-idb/family-idb 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Prisma IDB
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bin/prisma-next-idb.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/bin/prisma-next-idb.mjs

@@ -0,0 +1,281 @@
+#!/usr/bin/env node
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { dirname, join, relative } from "pathe";
+import { parseArgs } from "node:util";
+//#region src/core/chain-order.ts
+/**
+* Walk an unordered set of migration packages by `metadata.from`/`to` edges
+* to produce a chain-ordered list. Starts at the package whose
+* `from === null` (the baseline) and follows each `to` to the next
+* package's matching `from`.
+*
+* Throws on:
+* - No baseline (no package with `from === null`)
+* - Multiple baselines (two packages with `from === null`)
+* - Broken edge (no package whose `from` matches the cursor)
+* - Cycle (revisited hash)
+* - Orphan package (package left unvisited after chain completes)
+*/
+function chainOrderByMetadata(unordered) {
+	if (unordered.size === 0) return [];
+	const byFrom = /* @__PURE__ */ new Map();
+	for (const pkg of unordered.values()) {
+		const from = pkg.metadata.from;
+		const existing = byFrom.get(from);
+		if (existing) throw new Error(`Migration chain conflict: ${existing.dirName} and ${pkg.dirName} both declare from === ${JSON.stringify(from)}. The chain must be linear.`);
+		byFrom.set(from, pkg);
+	}
+	const ordered = [];
+	const visited = /* @__PURE__ */ new Set();
+	let cursor = null;
+	while (true) {
+		const next = byFrom.get(cursor);
+		if (!next) {
+			if (ordered.length === unordered.size) break;
+			const orphans = [...unordered.keys()].filter((d) => !visited.has(d));
+			throw new Error(`Migration chain broken: no package declares from === ${JSON.stringify(cursor)}. Orphan package(s) not reachable from the baseline: ${orphans.join(", ")}. Either the migrations directory has been hand-edited or a package was deleted; re-emit the affected migration with \`node migration.ts\`.`);
+		}
+		if (visited.has(next.dirName)) throw new Error(`Migration chain cycle detected at ${next.dirName}.`);
+		visited.add(next.dirName);
+		ordered.push(next);
+		cursor = next.metadata.to;
+	}
+	return ordered;
+}
+//#endregion
+//#region src/core/contract-space-codegen.ts
+/**
+* Read every migration package under `<migrationsDir>/app/`, validate the
+* chain's connectivity, then emit a generated TypeScript module that
+* JSON-imports each package's `migration.json` + `ops.json` and assembles
+* them into a `ContractSpace` via `contractSpaceFromJson`. The head ref
+* is inlined as `{ hash, invariants }` derived from the last package's
+* metadata — no on-disk `refs/head.json` is written.
+*
+* (We deliberately avoid writing `migrations/refs/` because the framework's
+* contract-space layout treats top-level `migrations/<subdir>/` as a
+* per-space directory; an orphan `refs/` collides with that. Extension
+* packages — postgis, paradedb, etc. — DO write `migrations/refs/head.json`
+* because their package root IS their single space and there's no
+* ambiguity. App-level layouts use `migrations/app/` for the app space, and
+* the head ref for the app space comes from the latest package's `to`.)
+*
+* Idempotent: re-running produces byte-identical output (modulo
+* migration package list changes). Exit code 0 on success.
+*/
+async function generateContractSpace(opts) {
+	const appDir = join(opts.migrationsDir ?? join(opts.cwd, "migrations"), "app");
+	const contractPath = opts.contractPath ?? join(opts.cwd, "src/lib/prisma/contract.json");
+	const outPath = opts.outPath ?? join(opts.cwd, "src/lib/prisma/contract-space.generated.ts");
+	const packages = await loadPackages(appDir);
+	if (packages.length === 0) process.stderr.write("Warning: no migration packages found in migrations/app/.\nThe generated module will have an empty migrations list, which breaks\n`createAutoMigratingIdbClient` on a fresh database.\nRun `prisma-next-idb generate-baseline` first to create the initial migration.\n\n");
+	const outDir = dirname(outPath);
+	await mkdir(outDir, { recursive: true });
+	await writeFile(outPath, renderModule({
+		outDir,
+		contractPath,
+		appDir,
+		packages
+	}), "utf-8");
+	process.stdout.write(`Wrote ${outPath} (${packages.length} migration${packages.length === 1 ? "" : "s"})\n`);
+	return 0;
+}
+async function loadPackages(appDir) {
+	let dirs;
+	try {
+		dirs = (await readdir(appDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
+	} catch (err) {
+		if (err.code === "ENOENT") return [];
+		throw err;
+	}
+	const unordered = /* @__PURE__ */ new Map();
+	for (const dirName of dirs) {
+		const metaPath = join(appDir, dirName, "migration.json");
+		const opsPath = join(appDir, dirName, "ops.json");
+		try {
+			const metaRaw = await readFile(metaPath, "utf-8");
+			const metadata = JSON.parse(metaRaw);
+			await readFile(opsPath, "utf-8");
+			unordered.set(dirName, {
+				dirName,
+				metadata
+			});
+		} catch (err) {
+			process.stderr.write(`Skipping ${dirName}: missing or unreadable migration.json/ops.json (${err.message})\n`);
+		}
+	}
+	return chainOrderByMetadata(unordered);
+}
+function renderModule(input) {
+	const contractImportPath = toModuleSpecifier(relative(input.outDir, input.contractPath));
+	const importLines = [
+		"// THIS FILE IS AUTO-GENERATED — do not edit by hand.",
+		"// Regenerate with: prisma-next-idb generate-contract-space",
+		"",
+		`import type { Contract } from "${contractImportPath.replace(/\.json$/i, "")}";`,
+		"import { contractSpaceFromJson } from \"@prisma-next/migration-tools/spaces\";",
+		`import contractJson from "${contractImportPath}" with { type: "json" };`
+	];
+	for (const pkg of input.packages) {
+		const id = identFromDir(pkg.dirName);
+		const metaPath = toModuleSpecifier(relative(input.outDir, join(input.appDir, pkg.dirName, "migration.json")));
+		const opsPath = toModuleSpecifier(relative(input.outDir, join(input.appDir, pkg.dirName, "ops.json")));
+		importLines.push(`import ${id}_meta from "${metaPath}" with { type: "json" };`);
+		importLines.push(`import ${id}_ops from "${opsPath}" with { type: "json" };`);
+	}
+	const last = input.packages[input.packages.length - 1];
+	const headRefLiteral = last === void 0 ? "{ hash: \"\", invariants: [] as const }" : `{ hash: ${identFromDir(last.dirName)}_meta.to, invariants: (${identFromDir(last.dirName)}_meta.providedInvariants ?? []) as readonly string[] }`;
+	const migrationsBody = input.packages.length === 0 ? "  migrations: []," : [
+		"  migrations: [",
+		input.packages.map((pkg) => {
+			const id = identFromDir(pkg.dirName);
+			return `    { dirName: ${JSON.stringify(pkg.dirName)}, metadata: ${id}_meta, ops: ${id}_ops },`;
+		}).join("\n"),
+		"  ],"
+	].join("\n");
+	return [
+		...importLines,
+		"",
+		"export const contractSpace = contractSpaceFromJson<Contract>({",
+		"  contractJson,",
+		migrationsBody,
+		`  headRef: ${headRefLiteral},`,
+		"});",
+		""
+	].join("\n");
+}
+function identFromDir(dirName) {
+	return `mig_${dirName.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+}
+/**
+* Coerce a `pathe` relative path into a TypeScript module specifier.
+* - Adds a leading `./` if the path doesn't already start with `.` or `/`.
+* - Leaves absolute and parent-relative paths alone.
+*/
+function toModuleSpecifier(p) {
+	if (p.startsWith(".") || p.startsWith("/")) return p;
+	return `./${p}`;
+}
+//#endregion
+//#region src/bin/prisma-next-idb.ts
+/**
+* `prisma-next-idb` — IDB-target-specific CLI tooling.
+*
+* Subcommands:
+*
+* - `generate-baseline` — auto-generate the first migration package
+*   (`from: null`) from the current `contract.json`.  Only valid on a
+*   fresh project with no migrations yet.
+* - `generate-migration` — plan and write the next incremental migration
+*   package by diffing the head migration's `end-contract.json` against the
+*   current `contract.json`. Requires at least one migration to already exist.
+* - `generate-contract-space` — re-write
+*   `<project>/src/lib/prisma/contract-space.generated.ts` (or the path
+*   specified by `--out`) from the on-disk `migrations/app/` packages.
+* - `preflight` — walk the migration chain from empty → tip against a
+*   `fake-indexeddb` shadow, reporting per-step success/failure.
+*
+* Why a separate binary from `prisma-next`: the framework CLI is generic
+* (target-discovery via config); these commands are IDB-specific and own an
+* opinionated layout. Keeping them separate avoids growing the framework CLI
+* surface with target-specific subcommands.
+*
+* Typical new-project workflow:
+*   1. prisma-next contract emit               # generate contract.json
+*   2. prisma-next-idb generate-baseline       # create migrations/app/<ts>_baseline/
+*   3. prisma-next-idb generate-contract-space # bundle into contract-space.generated.ts
+*   4. prisma-next-idb preflight               # (optional) validate chain in CI
+*
+* Adding a subsequent migration:
+*   1. prisma-next contract emit               # update contract.json after schema change
+*   2. prisma-next-idb generate-migration \   # plan incremental migration
+*        --name <slug>                         # e.g. --name add_posts
+*   3. prisma-next-idb generate-contract-space # re-bundle contract-space.generated.ts
+*   4. prisma-next-idb preflight               # (optional) validate chain in CI
+*/
+function parseFlags() {
+	const { values } = parseArgs({
+		allowPositionals: true,
+		strict: false,
+		options: {
+			contract: { type: "string" },
+			"migrations-dir": { type: "string" },
+			out: { type: "string" },
+			name: { type: "string" }
+		}
+	});
+	return {
+		contract: values["contract"],
+		migrationsDir: values["migrations-dir"],
+		out: values["out"],
+		name: values["name"]
+	};
+}
+async function main() {
+	const { positionals } = parseArgs({
+		allowPositionals: true,
+		strict: false
+	});
+	const subcommand = positionals[0];
+	const flags = parseFlags();
+	switch (subcommand) {
+		case "generate-baseline": {
+			const { generateBaseline } = await import("../generate-baseline-Dg3vfBpB.mjs");
+			return generateBaseline({
+				cwd: process.cwd(),
+				...flags.contract !== void 0 && { contractPath: flags.contract },
+				...flags.migrationsDir !== void 0 && { migrationsDir: flags.migrationsDir },
+				...flags.name !== void 0 && { name: flags.name }
+			});
+		}
+		case "generate-migration": {
+			if (flags.name === void 0) {
+				process.stderr.write("generate-migration: --name <slug> is required.\n");
+				return 2;
+			}
+			const { generateMigration } = await import("../generate-migration-D8bDx9jo.mjs");
+			return generateMigration({
+				cwd: process.cwd(),
+				name: flags.name,
+				...flags.contract !== void 0 && { contractPath: flags.contract },
+				...flags.migrationsDir !== void 0 && { migrationsDir: flags.migrationsDir }
+			});
+		}
+		case "generate-contract-space": return generateContractSpace({
+			cwd: process.cwd(),
+			...flags.contract !== void 0 && { contractPath: flags.contract },
+			...flags.migrationsDir !== void 0 && { migrationsDir: flags.migrationsDir },
+			...flags.out !== void 0 && { outPath: flags.out }
+		});
+		case "preflight": {
+			const { runPreflight } = await import("../preflight-D8GLQXy3.mjs");
+			return runPreflight({
+				cwd: process.cwd(),
+				...flags.migrationsDir !== void 0 && { migrationsDir: flags.migrationsDir }
+			});
+		}
+		case void 0:
+		case "help":
+		case "--help":
+		case "-h":
+			printHelp();
+			return 0;
+		default:
+			process.stderr.write(`Unknown command: ${subcommand}\n\n`);
+			printHelp();
+			return 2;
+	}
+}
+function printHelp() {
+	process.stdout.write("prisma-next-idb — IDB-target tooling for Prisma Next\n\nUsage:\n  prisma-next-idb <command> [flags]\n\nCommands:\n  generate-baseline         Create the initial migration package from contract.json\n  generate-migration        Plan the next incremental migration (requires --name)\n  generate-contract-space   Regenerate contract-space.generated.ts\n  preflight                 Validate the migration chain against fake-indexeddb\n  help                      Show this message\n\nFlags (all commands):\n  --contract <path>         Path to contract.json (default: src/lib/prisma/contract.json)\n  --migrations-dir <path>   Path to migrations root (default: migrations/)\n\nFlags (generate-baseline only):\n  --name <slug>             Directory slug (default: baseline)\n\nFlags (generate-migration only):\n  --name <slug>             Directory slug, e.g. add_posts (required)\n\nFlags (generate-contract-space only):\n  --out <path>              Output file path (default: src/lib/prisma/contract-space.generated.ts)\n\nNew-project workflow:\n  1. prisma-next contract emit                          # generate contract.json\n  2. prisma-next-idb generate-baseline \\               # create baseline migration\n       --contract src/prisma/contract.json             #   (if your layout differs)\n  3. prisma-next-idb generate-contract-space \\         # bundle into contract-space.generated.ts\n       --contract src/prisma/contract.json \\           #   (same override if needed)\n       --out src/prisma/contract-space.generated.ts\n  4. prisma-next-idb preflight                         # validate chain (CI)\n\nAdding a subsequent migration:\n  1. prisma-next contract emit                          # update contract.json\n  2. prisma-next-idb generate-migration --name <slug>  # plan incremental migration\n  3. prisma-next-idb generate-contract-space           # re-bundle contract-space\n  4. prisma-next-idb preflight                         # validate chain (CI)\n");
+}
+main().then((code) => {
+	process.exit(code);
+}, (err) => {
+	process.stderr.write(`${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
+	process.exit(1);
+});
+//#endregion
+export { chainOrderByMetadata as t };
+
+//# sourceMappingURL=prisma-next-idb.mjs.map

package/dist/bin/prisma-next-idb.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-next-idb.mjs","names":[],"sources":["../../src/core/chain-order.ts","../../src/core/contract-space-codegen.ts","../../src/bin/prisma-next-idb.ts"],"sourcesContent":["import type { MigrationMetadata } from \"@prisma-next/migration-tools/metadata\";\n\n/**\n * Minimal shape that {@link chainOrderByMetadata} needs from each package.\n *\n * Callers typically have richer types (ops, file paths) — just make sure\n * `dirName` and `metadata.from` are present.\n */\nexport interface ChainablePackage {\n  readonly dirName: string;\n  readonly metadata: Pick<MigrationMetadata, \"from\" | \"to\">;\n}\n\n/**\n * Walk an unordered set of migration packages by `metadata.from`/`to` edges\n * to produce a chain-ordered list. Starts at the package whose\n * `from === null` (the baseline) and follows each `to` to the next\n * package's matching `from`.\n *\n * Throws on:\n * - No baseline (no package with `from === null`)\n * - Multiple baselines (two packages with `from === null`)\n * - Broken edge (no package whose `from` matches the cursor)\n * - Cycle (revisited hash)\n * - Orphan package (package left unvisited after chain completes)\n */\nexport function chainOrderByMetadata<P extends ChainablePackage>(unordered: ReadonlyMap<string, P>): P[] {\n  if (unordered.size === 0) return [];\n\n  const byFrom = new Map<string | null, P>();\n  for (const pkg of unordered.values()) {\n    const from = pkg.metadata.from;\n    const existing = byFrom.get(from);\n    if (existing) {\n      throw new Error(\n        `Migration chain conflict: ${existing.dirName} and ${pkg.dirName} both ` +\n          `declare from === ${JSON.stringify(from)}. The chain must be linear.`\n      );\n    }\n    byFrom.set(from, pkg);\n  }\n\n  const ordered: P[] = [];\n  const visited = new Set<string>();\n  let cursor: string | null = null;\n  while (true) {\n    const next = byFrom.get(cursor);\n    if (!next) {\n      if (ordered.length === unordered.size) break; // chain complete\n      const orphans = [...unordered.keys()].filter((d) => !visited.has(d));\n      throw new Error(\n        `Migration chain broken: no package declares from === ${JSON.stringify(cursor)}. ` +\n          `Orphan package(s) not reachable from the baseline: ${orphans.join(\", \")}. ` +\n          \"Either the migrations directory has been hand-edited or a package was \" +\n          \"deleted; re-emit the affected migration with `node migration.ts`.\"\n      );\n    }\n    if (visited.has(next.dirName)) {\n      throw new Error(`Migration chain cycle detected at ${next.dirName}.`);\n    }\n    visited.add(next.dirName);\n    ordered.push(next);\n    cursor = next.metadata.to;\n  }\n\n  return ordered;\n}\n","import { mkdir, readdir, readFile, writeFile } from \"node:fs/promises\";\nimport type { MigrationMetadata } from \"@prisma-next/migration-tools/metadata\";\nimport { dirname, join, relative } from \"pathe\";\nimport { chainOrderByMetadata, type ChainablePackage } from \"./chain-order\";\n\n/**\n * Options for {@link generateContractSpace}.\n *\n * All paths default to framework-conventional values but **should be\n * overridden** when the project's layout differs. The defaults are:\n *\n * - migrations: `<cwd>/migrations/`\n * - contract:   `<cwd>/src/lib/prisma/contract.json`\n * - output:     `<cwd>/src/lib/prisma/contract-space.generated.ts`\n *\n * Pass explicit values (or the corresponding CLI flags) for any project\n * that keeps its contract and generated files elsewhere — Next.js, Nuxt,\n * plain Vite, etc. all typically use different paths.\n */\nexport interface GenerateContractSpaceOptions {\n  readonly cwd: string;\n  readonly migrationsDir?: string;\n  readonly contractPath?: string;\n  readonly outPath?: string;\n}\n\ninterface LoadedPackage extends ChainablePackage {\n  readonly metadata: MigrationMetadata;\n}\n\n/**\n * Read every migration package under `<migrationsDir>/app/`, validate the\n * chain's connectivity, then emit a generated TypeScript module that\n * JSON-imports each package's `migration.json` + `ops.json` and assembles\n * them into a `ContractSpace` via `contractSpaceFromJson`. The head ref\n * is inlined as `{ hash, invariants }` derived from the last package's\n * metadata — no on-disk `refs/head.json` is written.\n *\n * (We deliberately avoid writing `migrations/refs/` because the framework's\n * contract-space layout treats top-level `migrations/<subdir>/` as a\n * per-space directory; an orphan `refs/` collides with that. Extension\n * packages — postgis, paradedb, etc. — DO write `migrations/refs/head.json`\n * because their package root IS their single space and there's no\n * ambiguity. App-level layouts use `migrations/app/` for the app space, and\n * the head ref for the app space comes from the latest package's `to`.)\n *\n * Idempotent: re-running produces byte-identical output (modulo\n * migration package list changes). Exit code 0 on success.\n */\nexport async function generateContractSpace(opts: GenerateContractSpaceOptions): Promise<number> {\n  const migrationsDir = opts.migrationsDir ?? join(opts.cwd, \"migrations\");\n  const appDir = join(migrationsDir, \"app\");\n  const contractPath = opts.contractPath ?? join(opts.cwd, \"src/lib/prisma/contract.json\");\n  const outPath = opts.outPath ?? join(opts.cwd, \"src/lib/prisma/contract-space.generated.ts\");\n\n  const packages = await loadPackages(appDir);\n  validateChain(packages);\n\n  // Warn when no packages exist — the output module will have an empty\n  // migrations list and `hash: \"\"`, which breaks createAutoMigratingIdbClient\n  // on a fresh database (walkChain throws: \"no migration with from === null\").\n  // The user should run `prisma-next-idb generate-baseline` first.\n  if (packages.length === 0) {\n    process.stderr.write(\n      \"Warning: no migration packages found in migrations/app/.\\n\" +\n        \"The generated module will have an empty migrations list, which breaks\\n\" +\n        \"`createAutoMigratingIdbClient` on a fresh database.\\n\" +\n        \"Run `prisma-next-idb generate-baseline` first to create the initial migration.\\n\\n\"\n    );\n  }\n\n  // Emit the generated module. The head ref is derived inline.\n  const outDir = dirname(outPath);\n  await mkdir(outDir, { recursive: true });\n  const source = renderModule({\n    outDir,\n    contractPath,\n    appDir,\n    packages,\n  });\n  await writeFile(outPath, source, \"utf-8\");\n\n  process.stdout.write(`Wrote ${outPath} (${packages.length} migration${packages.length === 1 ? \"\" : \"s\"})\\n`);\n  return 0;\n}\n\nasync function loadPackages(appDir: string): Promise<LoadedPackage[]> {\n  let dirs: string[];\n  try {\n    dirs = (await readdir(appDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return [];\n    throw err;\n  }\n\n  // Load all packages unordered, then chain-walk to derive order. Directory\n  // name lexicographic order is unreliable because timestamp formats can\n  // mix (e.g. framework's `migration plan` writes `T0337`, hand-authored\n  // baselines may use `T120000`). The truth is in metadata.from/to edges.\n  const unordered = new Map<string, LoadedPackage>();\n  for (const dirName of dirs) {\n    const metaPath = join(appDir, dirName, \"migration.json\");\n    const opsPath = join(appDir, dirName, \"ops.json\");\n    try {\n      const metaRaw = await readFile(metaPath, \"utf-8\");\n      const metadata = JSON.parse(metaRaw) as MigrationMetadata;\n      // existence check for ops.json — we don't parse here because the\n      // generated module JSON-imports the file at build time.\n      await readFile(opsPath, \"utf-8\");\n      unordered.set(dirName, { dirName, metadata });\n    } catch (err) {\n      process.stderr.write(\n        `Skipping ${dirName}: missing or unreadable migration.json/ops.json ` + `(${(err as Error).message})\\n`\n      );\n    }\n  }\n\n  return chainOrderByMetadata(unordered);\n}\n\n/**\n * No-op — `chainOrderByMetadata` already enforces all invariants during\n * {@link loadPackages}. Kept as a named hook so callers can compose their\n * own package list and re-validate without calling the full load path.\n */\nfunction validateChain(_packages: ReadonlyArray<LoadedPackage>): void {\n  // Validation happens inside `chainOrderByMetadata` during load. No-op here.\n}\n\ninterface RenderInput {\n  readonly outDir: string;\n  readonly contractPath: string;\n  readonly appDir: string;\n  readonly packages: ReadonlyArray<LoadedPackage>;\n}\n\nfunction renderModule(input: RenderInput): string {\n  const contractImportPath = toModuleSpecifier(relative(input.outDir, input.contractPath));\n\n  // Local `Contract` import — picks up the IDB-narrowed type from the\n  // user's `contract.d.ts` rather than the framework's wider `Contract`.\n  // `contract.json` and `contract.d.ts` share a stem, so the .ts module\n  // specifier matches via TypeScript's `.json` → bare-import resolution.\n  const contractTypeSpecifier = contractImportPath.replace(/\\.json$/i, \"\");\n\n  const importLines: string[] = [\n    \"// THIS FILE IS AUTO-GENERATED — do not edit by hand.\",\n    \"// Regenerate with: prisma-next-idb generate-contract-space\",\n    \"\",\n    `import type { Contract } from \"${contractTypeSpecifier}\";`,\n    'import { contractSpaceFromJson } from \"@prisma-next/migration-tools/spaces\";',\n    `import contractJson from \"${contractImportPath}\" with { type: \"json\" };`,\n  ];\n\n  for (const pkg of input.packages) {\n    const id = identFromDir(pkg.dirName);\n    const metaPath = toModuleSpecifier(relative(input.outDir, join(input.appDir, pkg.dirName, \"migration.json\")));\n    const opsPath = toModuleSpecifier(relative(input.outDir, join(input.appDir, pkg.dirName, \"ops.json\")));\n    importLines.push(`import ${id}_meta from \"${metaPath}\" with { type: \"json\" };`);\n    importLines.push(`import ${id}_ops from \"${opsPath}\" with { type: \"json\" };`);\n  }\n\n  // Inline head ref derivation. The hash comes from the last package's\n  // `to`; invariants come from its `providedInvariants` (empty for the\n  // IDB app target today — no extension-contributed invariants).\n  const last = input.packages[input.packages.length - 1];\n  const headRefLiteral =\n    last === undefined\n      ? '{ hash: \"\", invariants: [] as const }'\n      : `{ hash: ${identFromDir(last.dirName)}_meta.to, invariants: (${identFromDir(last.dirName)}_meta.providedInvariants ?? []) as readonly string[] }`;\n\n  const migrationsBody =\n    input.packages.length === 0\n      ? \"  migrations: [],\"\n      : [\n          \"  migrations: [\",\n          input.packages\n            .map((pkg) => {\n              const id = identFromDir(pkg.dirName);\n              return `    { dirName: ${JSON.stringify(pkg.dirName)}, metadata: ${id}_meta, ops: ${id}_ops },`;\n            })\n            .join(\"\\n\"),\n          \"  ],\",\n        ].join(\"\\n\");\n\n  return [\n    ...importLines,\n    \"\",\n    \"export const contractSpace = contractSpaceFromJson<Contract>({\",\n    \"  contractJson,\",\n    migrationsBody,\n    `  headRef: ${headRefLiteral},`,\n    \"});\",\n    \"\",\n  ].join(\"\\n\");\n}\n\nfunction identFromDir(dirName: string): string {\n  return `mig_${dirName.replace(/[^a-zA-Z0-9_]/g, \"_\")}`;\n}\n\n/**\n * Coerce a `pathe` relative path into a TypeScript module specifier.\n * - Adds a leading `./` if the path doesn't already start with `.` or `/`.\n * - Leaves absolute and parent-relative paths alone.\n */\nfunction toModuleSpecifier(p: string): string {\n  if (p.startsWith(\".\") || p.startsWith(\"/\")) return p;\n  return `./${p}`;\n}\n","#!/usr/bin/env node\n/**\n * `prisma-next-idb` — IDB-target-specific CLI tooling.\n *\n * Subcommands:\n *\n * - `generate-baseline` — auto-generate the first migration package\n *   (`from: null`) from the current `contract.json`.  Only valid on a\n *   fresh project with no migrations yet.\n * - `generate-migration` — plan and write the next incremental migration\n *   package by diffing the head migration's `end-contract.json` against the\n *   current `contract.json`. Requires at least one migration to already exist.\n * - `generate-contract-space` — re-write\n *   `<project>/src/lib/prisma/contract-space.generated.ts` (or the path\n *   specified by `--out`) from the on-disk `migrations/app/` packages.\n * - `preflight` — walk the migration chain from empty → tip against a\n *   `fake-indexeddb` shadow, reporting per-step success/failure.\n *\n * Why a separate binary from `prisma-next`: the framework CLI is generic\n * (target-discovery via config); these commands are IDB-specific and own an\n * opinionated layout. Keeping them separate avoids growing the framework CLI\n * surface with target-specific subcommands.\n *\n * Typical new-project workflow:\n *   1. prisma-next contract emit               # generate contract.json\n *   2. prisma-next-idb generate-baseline       # create migrations/app/<ts>_baseline/\n *   3. prisma-next-idb generate-contract-space # bundle into contract-space.generated.ts\n *   4. prisma-next-idb preflight               # (optional) validate chain in CI\n *\n * Adding a subsequent migration:\n *   1. prisma-next contract emit               # update contract.json after schema change\n *   2. prisma-next-idb generate-migration \\   # plan incremental migration\n *        --name <slug>                         # e.g. --name add_posts\n *   3. prisma-next-idb generate-contract-space # re-bundle contract-space.generated.ts\n *   4. prisma-next-idb preflight               # (optional) validate chain in CI\n */\nimport { parseArgs } from \"node:util\";\nimport { generateContractSpace } from \"../core/contract-space-codegen\";\n\n/**\n * Flags shared across all subcommands.\n *\n * `--contract <path>` and `--migrations-dir <path>` let callers override the\n * defaults for any project layout (Next.js, Nuxt, plain Vite, etc.). Without\n * them the commands fall back to framework-conventional defaults, but those\n * defaults are just starting points — every project that uses a different\n * layout should pass explicit paths.\n */\ninterface ParsedFlags {\n  /** Path to contract.json. */\n  contract: string | undefined;\n  /** Path to the migrations root (contains `app/` subdirectory). */\n  migrationsDir: string | undefined;\n  /** Output path for `generate-contract-space`. */\n  out: string | undefined;\n  /** Slug suffix for the migration directory name. */\n  name: string | undefined;\n}\n\nfunction parseFlags(): ParsedFlags {\n  const { values } = parseArgs({\n    allowPositionals: true,\n    strict: false,\n    options: {\n      contract: { type: \"string\" },\n      \"migrations-dir\": { type: \"string\" },\n      out: { type: \"string\" },\n      name: { type: \"string\" },\n    },\n  });\n  return {\n    // parseArgs with strict:false widens all values to string|boolean|undefined;\n    // our options are all declared type:\"string\" so at runtime these are always\n    // string|undefined — the cast is safe.\n    contract: values[\"contract\"] as string | undefined,\n    migrationsDir: values[\"migrations-dir\"] as string | undefined,\n    out: values[\"out\"] as string | undefined,\n    name: values[\"name\"] as string | undefined,\n  };\n}\n\nasync function main(): Promise<number> {\n  const { positionals } = parseArgs({ allowPositionals: true, strict: false });\n  const subcommand = positionals[0];\n  const flags = parseFlags();\n\n  switch (subcommand) {\n    case \"generate-baseline\": {\n      const { generateBaseline } = await import(\"../core/generate-baseline\");\n      return generateBaseline({\n        cwd: process.cwd(),\n        // exactOptionalPropertyTypes: omit the key entirely when undefined rather\n        // than passing `key: undefined`, which violates the readonly optional contract.\n        ...(flags.contract !== undefined && { contractPath: flags.contract }),\n        ...(flags.migrationsDir !== undefined && { migrationsDir: flags.migrationsDir }),\n        ...(flags.name !== undefined && { name: flags.name }),\n      });\n    }\n    case \"generate-migration\": {\n      if (flags.name === undefined) {\n        process.stderr.write(\"generate-migration: --name <slug> is required.\\n\");\n        return 2;\n      }\n      const { generateMigration } = await import(\"../core/generate-migration\");\n      return generateMigration({\n        cwd: process.cwd(),\n        name: flags.name,\n        ...(flags.contract !== undefined && { contractPath: flags.contract }),\n        ...(flags.migrationsDir !== undefined && { migrationsDir: flags.migrationsDir }),\n      });\n    }\n    case \"generate-contract-space\":\n      return generateContractSpace({\n        cwd: process.cwd(),\n        ...(flags.contract !== undefined && { contractPath: flags.contract }),\n        ...(flags.migrationsDir !== undefined && { migrationsDir: flags.migrationsDir }),\n        ...(flags.out !== undefined && { outPath: flags.out }),\n      });\n    case \"preflight\": {\n      const { runPreflight } = await import(\"../core/preflight\");\n      return runPreflight({\n        cwd: process.cwd(),\n        ...(flags.migrationsDir !== undefined && { migrationsDir: flags.migrationsDir }),\n      });\n    }\n    case undefined:\n    case \"help\":\n    case \"--help\":\n    case \"-h\":\n      printHelp();\n      return 0;\n    default:\n      process.stderr.write(`Unknown command: ${subcommand}\\n\\n`);\n      printHelp();\n      return 2;\n  }\n}\n\nfunction printHelp(): void {\n  process.stdout.write(\n    \"prisma-next-idb — IDB-target tooling for Prisma Next\\n\" +\n      \"\\n\" +\n      \"Usage:\\n\" +\n      \"  prisma-next-idb <command> [flags]\\n\" +\n      \"\\n\" +\n      \"Commands:\\n\" +\n      \"  generate-baseline         Create the initial migration package from contract.json\\n\" +\n      \"  generate-migration        Plan the next incremental migration (requires --name)\\n\" +\n      \"  generate-contract-space   Regenerate contract-space.generated.ts\\n\" +\n      \"  preflight                 Validate the migration chain against fake-indexeddb\\n\" +\n      \"  help                      Show this message\\n\" +\n      \"\\n\" +\n      \"Flags (all commands):\\n\" +\n      \"  --contract <path>         Path to contract.json (default: src/lib/prisma/contract.json)\\n\" +\n      \"  --migrations-dir <path>   Path to migrations root (default: migrations/)\\n\" +\n      \"\\n\" +\n      \"Flags (generate-baseline only):\\n\" +\n      \"  --name <slug>             Directory slug (default: baseline)\\n\" +\n      \"\\n\" +\n      \"Flags (generate-migration only):\\n\" +\n      \"  --name <slug>             Directory slug, e.g. add_posts (required)\\n\" +\n      \"\\n\" +\n      \"Flags (generate-contract-space only):\\n\" +\n      \"  --out <path>              Output file path (default: src/lib/prisma/contract-space.generated.ts)\\n\" +\n      \"\\n\" +\n      \"New-project workflow:\\n\" +\n      \"  1. prisma-next contract emit                          # generate contract.json\\n\" +\n      \"  2. prisma-next-idb generate-baseline \\\\               # create baseline migration\\n\" +\n      \"       --contract src/prisma/contract.json             #   (if your layout differs)\\n\" +\n      \"  3. prisma-next-idb generate-contract-space \\\\         # bundle into contract-space.generated.ts\\n\" +\n      \"       --contract src/prisma/contract.json \\\\           #   (same override if needed)\\n\" +\n      \"       --out src/prisma/contract-space.generated.ts\\n\" +\n      \"  4. prisma-next-idb preflight                         # validate chain (CI)\\n\" +\n      \"\\n\" +\n      \"Adding a subsequent migration:\\n\" +\n      \"  1. prisma-next contract emit                          # update contract.json\\n\" +\n      \"  2. prisma-next-idb generate-migration --name <slug>  # plan incremental migration\\n\" +\n      \"  3. prisma-next-idb generate-contract-space           # re-bundle contract-space\\n\" +\n      \"  4. prisma-next-idb preflight                         # validate chain (CI)\\n\"\n  );\n}\n\nmain().then(\n  (code) => {\n    process.exit(code);\n  },\n  (err: unknown) => {\n    process.stderr.write(`${err instanceof Error ? (err.stack ?? err.message) : String(err)}\\n`);\n    process.exit(1);\n  }\n);\n"],"mappings":"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"}

package/dist/exports/config-types.d.mts

@@ -0,0 +1,39 @@
+import { Contract } from "@prisma-next/contract/types";
+import { ContractConfig, PrismaNextConfig, defineConfig as defineConfig$1 } from "@prisma-next/config/config-types";
+
+//#region src/exports/config-types.d.ts
+declare const defineConfig: typeof defineConfig$1;
+/**
+ * Wraps an in-memory contract object for use in `prisma-next.config.ts`.
+ *
+ * Use this with the no-emit (TypeScript-first) workflow per ADR 006.
+ *
+ * @example
+ * ```ts
+ * import { typescriptContract } from '@prisma-next-idb/family-idb/config-types';
+ * import contract from './prisma/contract';
+ *
+ * export default {
+ *   family: idbFamily,
+ *   target: idbTarget,
+ *   contract: typescriptContract(contract, 'src/prisma/contract.json'),
+ * };
+ * ```
+ */
+declare function typescriptContract(contract: Contract, output?: string): ContractConfig;
+/**
+ * Loads a contract from a TypeScript file at `contractPath` and wraps it for
+ * use in `prisma-next.config.ts`. The file must export the contract as
+ * `default` or `contract`.
+ *
+ * @example
+ * ```ts
+ * export default {
+ *   contract: typescriptContractFromPath('./prisma/contract.ts'),
+ * };
+ * ```
+ */
+declare function typescriptContractFromPath(contractPath: string, output?: string): ContractConfig;
+//#endregion
+export { type PrismaNextConfig, defineConfig, typescriptContract, typescriptContractFromPath };
+//# sourceMappingURL=config-types.d.mts.map

package/dist/exports/config-types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-types.d.mts","names":[],"sources":["../../src/exports/config-types.ts"],"mappings":";;;;cAYa,YAAA,SAAY,cAAmB;;;;AAAA;AAyB5C;;;;;;;;;AAAuF;AAqBvF;;;iBArBgB,kBAAA,CAAmB,QAAA,EAAU,QAAA,EAAU,MAAA,YAAkB,cAAc;;;;;AAqBU;;;;;;;;iBAAjF,0BAAA,CAA2B,YAAA,UAAsB,MAAA,YAAkB,cAAc"}

package/dist/exports/config-types.mjs

@@ -0,0 +1,66 @@
+import { ok } from "@prisma-next/utils/result";
+import { extname } from "pathe";
+import { pathToFileURL } from "node:url";
+import { defineConfig as defineConfig$1 } from "@prisma-next/config/config-types";
+//#region src/exports/config-types.ts
+const defineConfig = defineConfig$1;
+function defaultOutputFromContractPath(contractPath) {
+	const ext = extname(contractPath);
+	if (ext.length === 0) return `${contractPath}.json`;
+	return `${contractPath.slice(0, -ext.length)}.json`;
+}
+/**
+* Wraps an in-memory contract object for use in `prisma-next.config.ts`.
+*
+* Use this with the no-emit (TypeScript-first) workflow per ADR 006.
+*
+* @example
+* ```ts
+* import { typescriptContract } from '@prisma-next-idb/family-idb/config-types';
+* import contract from './prisma/contract';
+*
+* export default {
+*   family: idbFamily,
+*   target: idbTarget,
+*   contract: typescriptContract(contract, 'src/prisma/contract.json'),
+* };
+* ```
+*/
+function typescriptContract(contract, output) {
+	return {
+		source: { load: async () => ok(contract) },
+		...output !== void 0 ? { output } : {}
+	};
+}
+/**
+* Loads a contract from a TypeScript file at `contractPath` and wraps it for
+* use in `prisma-next.config.ts`. The file must export the contract as
+* `default` or `contract`.
+*
+* @example
+* ```ts
+* export default {
+*   contract: typescriptContractFromPath('./prisma/contract.ts'),
+* };
+* ```
+*/
+function typescriptContractFromPath(contractPath, output) {
+	return {
+		source: {
+			inputs: [contractPath],
+			load: async (context) => {
+				const [absolutePath] = context.resolvedInputs;
+				if (absolutePath === void 0) throw new Error("typescriptContractFromPath: context.resolvedInputs is empty. The CLI config loader should populate it positional-matched with source.inputs.");
+				const mod = await import(pathToFileURL(absolutePath).href);
+				const contract = mod.default ?? mod.contract;
+				if (contract === void 0) throw new Error(`typescriptContractFromPath: module at "${absolutePath}" has no "default" or "contract" export.`);
+				return ok(contract);
+			}
+		},
+		output: output ?? defaultOutputFromContractPath(contractPath)
+	};
+}
+//#endregion
+export { defineConfig, typescriptContract, typescriptContractFromPath };
+
+//# sourceMappingURL=config-types.mjs.map

package/dist/exports/config-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-types.mjs","names":["coreDefineConfig"],"sources":["../../src/exports/config-types.ts"],"sourcesContent":["// Ported from @prisma-next/sql-contract-ts/src/config-types.ts.\n// These helpers are fully family-agnostic — they wrap any Contract object\n// in a ContractSourceProvider that the prisma-next CLI config loader understands.\nimport { pathToFileURL } from \"node:url\";\nimport type { ContractConfig, PrismaNextConfig } from \"@prisma-next/config/config-types\";\nimport { defineConfig as coreDefineConfig } from \"@prisma-next/config/config-types\";\nimport type { Contract } from \"@prisma-next/contract/types\";\nimport { ok } from \"@prisma-next/utils/result\";\nimport { extname } from \"pathe\";\n\n// Re-export defineConfig so users only need @prisma-next-idb/family-idb.\nexport { type PrismaNextConfig };\nexport const defineConfig = coreDefineConfig;\n\nfunction defaultOutputFromContractPath(contractPath: string): string {\n  const ext = extname(contractPath);\n  if (ext.length === 0) return `${contractPath}.json`;\n  return `${contractPath.slice(0, -ext.length)}.json`;\n}\n\n/**\n * Wraps an in-memory contract object for use in `prisma-next.config.ts`.\n *\n * Use this with the no-emit (TypeScript-first) workflow per ADR 006.\n *\n * @example\n * ```ts\n * import { typescriptContract } from '@prisma-next-idb/family-idb/config-types';\n * import contract from './prisma/contract';\n *\n * export default {\n *   family: idbFamily,\n *   target: idbTarget,\n *   contract: typescriptContract(contract, 'src/prisma/contract.json'),\n * };\n * ```\n */\nexport function typescriptContract(contract: Contract, output?: string): ContractConfig {\n  return {\n    source: {\n      load: async () => ok(contract),\n    },\n    ...(output !== undefined ? { output } : {}),\n  };\n}\n\n/**\n * Loads a contract from a TypeScript file at `contractPath` and wraps it for\n * use in `prisma-next.config.ts`. The file must export the contract as\n * `default` or `contract`.\n *\n * @example\n * ```ts\n * export default {\n *   contract: typescriptContractFromPath('./prisma/contract.ts'),\n * };\n * ```\n */\nexport function typescriptContractFromPath(contractPath: string, output?: string): ContractConfig {\n  return {\n    source: {\n      inputs: [contractPath],\n      load: async (context) => {\n        const [absolutePath] = context.resolvedInputs;\n        if (absolutePath === undefined) {\n          throw new Error(\n            \"typescriptContractFromPath: context.resolvedInputs is empty. The CLI config loader should populate it positional-matched with source.inputs.\"\n          );\n        }\n        const mod = await import(pathToFileURL(absolutePath).href);\n        const contract: Contract | undefined = mod.default ?? mod.contract;\n        if (contract === undefined) {\n          throw new Error(\n            `typescriptContractFromPath: module at \"${absolutePath}\" has no \"default\" or \"contract\" export.`\n          );\n        }\n        return ok(contract);\n      },\n    },\n    output: output ?? defaultOutputFromContractPath(contractPath),\n  };\n}\n"],"mappings":";;;;;AAYA,MAAa,eAAeA;AAE5B,SAAS,8BAA8B,cAA8B;CACnE,MAAM,MAAM,QAAQ,YAAY;CAChC,IAAI,IAAI,WAAW,GAAG,OAAO,GAAG,aAAa;CAC7C,OAAO,GAAG,aAAa,MAAM,GAAG,CAAC,IAAI,MAAM,EAAE;AAC/C;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,mBAAmB,UAAoB,QAAiC;CACtF,OAAO;EACL,QAAQ,EACN,MAAM,YAAY,GAAG,QAAQ,EAC/B;EACA,GAAI,WAAW,KAAA,IAAY,EAAE,OAAO,IAAI,CAAC;CAC3C;AACF;;;;;;;;;;;;;AAcA,SAAgB,2BAA2B,cAAsB,QAAiC;CAChG,OAAO;EACL,QAAQ;GACN,QAAQ,CAAC,YAAY;GACrB,MAAM,OAAO,YAAY;IACvB,MAAM,CAAC,gBAAgB,QAAQ;IAC/B,IAAI,iBAAiB,KAAA,GACnB,MAAM,IAAI,MACR,8IACF;IAEF,MAAM,MAAM,MAAM,OAAO,cAAc,YAAY,CAAC,CAAC;IACrD,MAAM,WAAiC,IAAI,WAAW,IAAI;IAC1D,IAAI,aAAa,KAAA,GACf,MAAM,IAAI,MACR,0CAA0C,aAAa,yCACzD;IAEF,OAAO,GAAG,QAAQ;GACpB;EACF;EACA,QAAQ,UAAU,8BAA8B,YAAY;CAC9D;AACF"}

package/dist/exports/contract-psl.d.mts

@@ -0,0 +1,48 @@
+import { Contract } from "@prisma-next/contract/types";
+import { PslDocumentAst } from "@prisma-next/framework-components/psl-ast";
+import { Result } from "@prisma-next/utils/result";
+import { ContractConfig, ContractSourceDiagnostics } from "@prisma-next/config/config-types";
+import { IdbStorage } from "@prisma-next-idb/target-idb/pack";
+
+//#region src/core/psl-interpreter.d.ts
+/**
+ * Interprets a parsed PSL document AST and produces an IDB `Contract`.
+ *
+ * This is the IDB equivalent of `interpretPslDocumentToSqlContract` from the
+ * SQL family. It handles IDB-specific constraints:
+ *
+ * - No namespace blocks (IDB has a single implicit `__unbound__` namespace)
+ * - No compound primary keys (IDB `keyPath` must be a single field)
+ * - Relations are FK-side (`@relation`) + backrelation list fields
+ * - Indexes map directly to `IDBObjectStore.createIndex()` calls
+ */
+declare function interpretPslDocumentToIdbContract(ast: PslDocumentAst, sourceId: string): Result<Contract<IdbStorage>, ContractSourceDiagnostics>;
+//#endregion
+//#region src/core/psl-provider.d.ts
+interface PrismaIdbContractOptions {
+  readonly output?: string;
+}
+/**
+ * Creates a `ContractConfig` that reads an IDB schema from a `.prisma` file.
+ *
+ * Use this in `prisma-next.config.ts` as the `contract:` value when you prefer
+ * PSL authoring over the TypeScript-first `defineContract()` helper.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from '@prisma-next-idb/family-idb/config-types';
+ * import { prismaIdbContract } from '@prisma-next-idb/family-idb/contract-psl';
+ *
+ * export default defineConfig({
+ *   // ...
+ *   contract: prismaIdbContract('./src/prisma/schema.prisma'),
+ * });
+ * ```
+ *
+ * The emitted `contract.json` lands next to the schema file by default
+ * (`schema.prisma` → `contract.json`). Override with `options.output`.
+ */
+declare function prismaIdbContract(schemaPath: string, options?: PrismaIdbContractOptions): ContractConfig;
+//#endregion
+export { type PrismaIdbContractOptions, interpretPslDocumentToIdbContract, prismaIdbContract };
+//# sourceMappingURL=contract-psl.d.mts.map

package/dist/exports/contract-psl.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-psl.d.mts","names":[],"sources":["../../src/core/psl-interpreter.ts","../../src/core/psl-provider.ts"],"mappings":";;;;;;;;;AAiXA;;;;;;;;;iBAAgB,iCAAA,CACd,GAAA,EAAK,cAAA,EACL,QAAA,WACC,MAAA,CAAO,QAAA,CAAS,UAAA,GAAa,yBAAA;;;UCzVf,wBAAA;EAAA,SACN,MAAM;AAAA;;;;ADqVjB;;;;;;;;;;;;;;;;;iBC9TgB,iBAAA,CAAkB,UAAA,UAAoB,OAAA,GAAU,wBAAA,GAA2B,cAAc"}