@prisma-idb/family-idb 0.0.0

package/dist/contract-space-codegen--gfuyap2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-space-codegen--gfuyap2.mjs","names":[],"sources":["../src/core/contract-space-codegen.ts"],"sourcesContent":["import { mkdir, readdir, readFile, writeFile } from \"node:fs/promises\";\nimport type { MigrationMetadata } from \"@prisma/orm-toolchain/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 * The CLI (`prisma-idb migration contract-space`) resolves all three\n * paths before calling this function — from explicit flags, or otherwise\n * from `prisma.config.ts` (`contract.output`, `migrations.dir`) via\n * `requireContractPath`/`resolveMigrationsDir` (`cli/migration/paths.ts`).\n * Direct callers (tests) must supply them explicitly.\n */\nexport interface GenerateContractSpaceOptions {\n  readonly migrationsDir: string;\n  readonly contractPath: string;\n  readonly outPath: string;\n  /** Output sinks. Default to `process.stdout`/`process.stderr`. */\n  readonly out?: (line: string) => void;\n  readonly err?: (line: string) => void;\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 out = opts.out ?? ((line: string) => process.stdout.write(line));\n  const err = opts.err ?? ((line: string) => process.stderr.write(line));\n  const migrationsDir = opts.migrationsDir;\n  const appDir = join(migrationsDir, \"app\");\n  const contractPath = opts.contractPath;\n  const outPath = opts.outPath;\n\n  const packages = await loadPackages(appDir, err);\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-idb migration plan` first.\n  if (packages.length === 0) {\n    err(\n      `Warning: no migration packages found in ${relative(process.cwd(), appDir)}/.\\n` +\n        \"The generated module will have an empty migrations list, which breaks\\n\" +\n        \"`createAutoMigratingIdbClient` on a fresh database.\\n\" +\n        \"Run `prisma-idb migration plan` 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  out(`Wrote ${outPath} (${packages.length} migration${packages.length === 1 ? \"\" : \"s\"})\\n`);\n  return 0;\n}\n\nasync function loadPackages(appDir: string, err: (line: string) => void): 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 (dirErr) {\n    if ((dirErr as NodeJS.ErrnoException).code === \"ENOENT\") return [];\n    throw dirErr;\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 (loadErr) {\n      err(`Skipping ${dirName}: missing or unreadable migration.json/ops.json ` + `(${(loadErr as Error).message})\\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-idb migration contract-space\",\n    \"\",\n    `import type { Contract } from \"${contractTypeSpecifier}\";`,\n    'import { contractSpaceFromJson } from \"@prisma/orm-toolchain/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"],"mappings":"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"}

package/dist/exports/cli.d.mts

@@ -0,0 +1,26 @@
+import { Cli, HostProcess } from "@prisma/cli-engine";
+//#region src/cli/family.d.ts
+/**
+ * The unit this package contributes to a `@prisma/cli-engine` shell: its
+ * config section (reused from the ORM family, see `config-section.ts`) and
+ * its 3 commands. These have no generic equivalent — the real `prisma` CLI's
+ * `migration new`/`plan`/etc. work against a live database or a SQL/Mongo
+ * on-disk model; ours works against `fake-indexeddb` and a hand-rolled
+ * contract-space convention.
+ */
+declare const idbCommandFamily: import("@prisma/cli-engine").CommandFamily;
+//#endregion
+//#region src/cli/cli.d.ts
+declare const BIN_NAME = "prisma-idb";
+declare const BIN_GROUPS: {
+  readonly migration: {
+    readonly brief: "On-disk migration management commands";
+    readonly description: string;
+  };
+};
+declare function createIdbCli(): Cli;
+/** Parses, executes and settles one invocation; returns the exit code. */
+declare function runIdbCli(proc: HostProcess): Promise<number>;
+//#endregion
+export { BIN_GROUPS, BIN_NAME, createIdbCli, idbCommandFamily, runIdbCli };
+//# sourceMappingURL=cli.d.mts.map

package/dist/exports/cli.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.mts","names":[],"sources":["../../src/cli/family.ts","../../src/cli/cli.ts"],"mappings":";;;;;;;;;;cAqBa,+CAAgB;;;cCfhB;cAEA;;;;;;iBASG,gBAAgB;;iBA6DV,UAAU,MAAM,cAAc"}

package/dist/exports/cli.mjs

@@ -0,0 +1,2 @@
+import { a as idbCommandFamily, i as runIdbCli, n as BIN_NAME, r as createIdbCli, t as BIN_GROUPS } from "../cli-Dlaym_DD.mjs";
+export { BIN_GROUPS, BIN_NAME, createIdbCli, idbCommandFamily, runIdbCli };

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

@@ -0,0 +1,38 @@
+import { Contract } from "@prisma/orm-framework/contract/types";
+import { ContractConfig, PrismaNextConfig, defineConfig as defineConfig$1 } from "@prisma/orm-framework/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.config.ts`.
+ *
+ * Use this with the no-emit (TypeScript-first) workflow per ADR 006.
+ *
+ * @example
+ * ```ts
+ * import { typescriptContract } from '@prisma-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.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,qBAAY;;;;;;;;;;;;;;;;;;iBAyBT,mBAAmB,UAAU,UAAU,kBAAkB;;;;;;;;;;;;;iBAqBzD,2BAA2B,sBAAsB,kBAAkB"}

package/dist/exports/config-types.mjs

@@ -0,0 +1,66 @@
+import { ok } from "@prisma/orm-framework/utils/result";
+import { extname } from "pathe";
+import { pathToFileURL } from "node:url";
+import { defineConfig as defineConfig$1 } from "@prisma/orm-framework/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.config.ts`.
+*
+* Use this with the no-emit (TypeScript-first) workflow per ADR 006.
+*
+* @example
+* ```ts
+* import { typescriptContract } from '@prisma-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.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":["// Adapted from Prisma ORM's SQL contract config helpers.\n// These helpers are fully family-agnostic — they wrap any Contract object\n// in a ContractSourceProvider that the Prisma CLI config loader understands.\nimport { pathToFileURL } from \"node:url\";\nimport type { ContractConfig, PrismaNextConfig } from \"@prisma/orm-framework/config/config-types\";\nimport { defineConfig as coreDefineConfig } from \"@prisma/orm-framework/config/config-types\";\nimport type { Contract } from \"@prisma/orm-framework/contract/types\";\nimport { ok } from \"@prisma/orm-framework/utils/result\";\nimport { extname } from \"pathe\";\n\n// Re-export defineConfig so users only need @prisma-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.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-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.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,59 @@
+import { n as InterpretPslOptions, r as interpretPslDocumentToIdbContract, t as ContractProjection } from "../psl-interpreter-C0suaXu2.mjs";
+import { ContractConfig } from "@prisma/orm-framework/config/config-types";
+//#region src/core/psl-provider.d.ts
+/**
+ * Removes `@idb.exclude`/`@@idb.exclude` from raw PSL text — the `idb`
+ * namespace family-idb owns (`psl-interpreter.ts`'s `IDB_EXCLUDE_ATTR`).
+ * A foreign PSL parser (e.g. the SQL family's) doesn't recognize this
+ * namespace and hard-errors on it (`PSL_EXTENSION_NAMESPACE_NOT_COMPOSED`);
+ * stripping it is the text-level equivalent of what family-idb itself
+ * already does for these same fields under `projection: "full"`, where the
+ * attribute is documented as a no-op. Use this when sharing a schema.prisma
+ * authored for family-idb with a different family's schema loader — the
+ * server always wants every field these attributes would otherwise hide
+ * from the client.
+ */
+declare function stripIdbExcludeAttributes(schema: string): string;
+interface PrismaIdbContractOptions {
+  readonly output?: string;
+  /**
+   * `"client"` projects out anything marked `@idb.exclude`/`@@idb.exclude`
+   * (ADR 012). Pass a distinct `output` alongside this so the client and
+   * full/server contracts don't collide on the same file.
+   * @default "full"
+   */
+  readonly projection?: ContractProjection;
+  /**
+   * Runs on the raw schema text right after it's read, before parsing.
+   * Lets a downstream package (e.g. `@prisma-idb/sync-server`) append
+   * synthetic model/enum declarations — the appended text goes through the
+   * exact same parse → interpret → hash pipeline as hand-authored PSL, so
+   * `storageHash` reflects it correctly (it's computed *inside*
+   * `interpretPslDocumentToIdbContract`, from whatever this returns).
+   */
+  readonly injectSchemaText?: (schema: string) => string;
+}
+/**
+ * Creates a `ContractConfig` that reads an IDB schema from a `.prisma` file.
+ *
+ * Use this in `prisma.config.ts` as the `contract:` value when you prefer
+ * PSL authoring over the TypeScript-first `defineContract()` helper.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from '@prisma-idb/family-idb/config-types';
+ * import { prismaIdbContract } from '@prisma-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 ContractProjection, type InterpretPslOptions, type PrismaIdbContractOptions, interpretPslDocumentToIdbContract, prismaIdbContract, stripIdbExcludeAttributes };
+//# 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-provider.ts"],"mappings":";;;;;;;;;;;;;;;iBAuBgB,0BAA0B;UA6BzB;WACN;;;;;;;WAOA,aAAa;;;;;;;;;WASb,oBAAoB;;;;;;;;;;;;;;;;;;;;;;iBAuBf,kBAAkB,oBAAoB,UAAU,2BAA2B"}

package/dist/exports/contract-psl.mjs

@@ -0,0 +1,97 @@
+import { t as interpretPslDocumentToIdbContract } from "../psl-interpreter-C6Q4okuO.mjs";
+import { notOk } from "@prisma/orm-framework/utils/result";
+import { readFile } from "node:fs/promises";
+import { buildSymbolTable, rangeToPslSpan } from "@prisma/orm-framework/psl-parser";
+import { withSeedDiagnostics } from "@prisma/orm-framework/psl-parser/interpret";
+import { parse } from "@prisma/orm-framework/psl-parser/syntax";
+import { basename, extname } from "pathe";
+//#region src/core/psl-provider.ts
+/**
+* Removes `@idb.exclude`/`@@idb.exclude` from raw PSL text — the `idb`
+* namespace family-idb owns (`psl-interpreter.ts`'s `IDB_EXCLUDE_ATTR`).
+* A foreign PSL parser (e.g. the SQL family's) doesn't recognize this
+* namespace and hard-errors on it (`PSL_EXTENSION_NAMESPACE_NOT_COMPOSED`);
+* stripping it is the text-level equivalent of what family-idb itself
+* already does for these same fields under `projection: "full"`, where the
+* attribute is documented as a no-op. Use this when sharing a schema.prisma
+* authored for family-idb with a different family's schema loader — the
+* server always wants every field these attributes would otherwise hide
+* from the client.
+*/
+function stripIdbExcludeAttributes(schema) {
+	return schema.replace(/^[ \t]*@@idb\.exclude\b.*\n?/gm, "").replace(/[ \t]*@idb\.exclude\b/g, "");
+}
+function defaultOutputFromSchemaPath(schemaPath) {
+	const ext = extname(schemaPath);
+	if (ext.length === 0) return `${schemaPath}.json`;
+	const base = schemaPath.slice(0, -ext.length);
+	if (basename(base) === "schema") return `${base.slice(0, -6)}contract.json`;
+	return `${base}.json`;
+}
+function mapParseDiagnostics(diagnostics, sourceFile, sourceId) {
+	return diagnostics.map((d) => ({
+		code: d.code,
+		message: d.message,
+		sourceId,
+		span: rangeToPslSpan(d.range, sourceFile)
+	}));
+}
+/**
+* Creates a `ContractConfig` that reads an IDB schema from a `.prisma` file.
+*
+* Use this in `prisma.config.ts` as the `contract:` value when you prefer
+* PSL authoring over the TypeScript-first `defineContract()` helper.
+*
+* @example
+* ```ts
+* import { defineConfig } from '@prisma-idb/family-idb/config-types';
+* import { prismaIdbContract } from '@prisma-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`.
+*/
+function prismaIdbContract(schemaPath, options) {
+	return {
+		source: {
+			inputs: [schemaPath],
+			load: async (context) => {
+				const [absoluteSchemaPath] = context.resolvedInputs;
+				if (absoluteSchemaPath === void 0) throw new Error("prismaIdbContract: context.resolvedInputs is empty. The CLI config loader should populate it positional-matched with source.inputs.");
+				let schema;
+				try {
+					schema = await readFile(absoluteSchemaPath, "utf-8");
+				} catch (error) {
+					const message = String(error);
+					return notOk({
+						summary: `Failed to read Prisma schema at "${schemaPath}"`,
+						diagnostics: [{
+							code: "PSL_SCHEMA_READ_FAILED",
+							message,
+							sourceId: schemaPath
+						}]
+					});
+				}
+				if (options?.injectSchemaText) schema = options.injectSchemaText(schema);
+				const { document, sourceFile, diagnostics: parseDiagnostics } = parse(schema);
+				const { table, diagnostics: symbolDiagnostics } = buildSymbolTable({
+					document,
+					sourceFile,
+					pslBlockDescriptors: {}
+				});
+				const seedDiagnostics = [...mapParseDiagnostics(parseDiagnostics, sourceFile, schemaPath), ...mapParseDiagnostics(symbolDiagnostics, sourceFile, schemaPath)];
+				return withSeedDiagnostics(interpretPslDocumentToIdbContract(table, schemaPath, options?.projection !== void 0 ? { projection: options.projection } : void 0), seedDiagnostics);
+			}
+		},
+		output: options?.output ?? defaultOutputFromSchemaPath(schemaPath)
+	};
+}
+//#endregion
+export { interpretPslDocumentToIdbContract, prismaIdbContract, stripIdbExcludeAttributes };
+
+//# sourceMappingURL=contract-psl.mjs.map

package/dist/exports/contract-psl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-psl.mjs","names":[],"sources":["../../src/core/psl-provider.ts"],"sourcesContent":["import { readFile } from \"node:fs/promises\";\nimport type { ContractConfig, ContractSourceDiagnostic } from \"@prisma/orm-framework/config/config-types\";\nimport { buildSymbolTable, rangeToPslSpan } from \"@prisma/orm-framework/psl-parser\";\nimport { withSeedDiagnostics } from \"@prisma/orm-framework/psl-parser/interpret\";\nimport type { ParseDiagnostic, SourceFile } from \"@prisma/orm-framework/psl-parser/syntax\";\nimport { parse } from \"@prisma/orm-framework/psl-parser/syntax\";\nimport { notOk } from \"@prisma/orm-framework/utils/result\";\nimport { extname, basename } from \"pathe\";\nimport type { ContractProjection } from \"./psl-interpreter\";\nimport { interpretPslDocumentToIdbContract } from \"./psl-interpreter\";\n\n/**\n * Removes `@idb.exclude`/`@@idb.exclude` from raw PSL text — the `idb`\n * namespace family-idb owns (`psl-interpreter.ts`'s `IDB_EXCLUDE_ATTR`).\n * A foreign PSL parser (e.g. the SQL family's) doesn't recognize this\n * namespace and hard-errors on it (`PSL_EXTENSION_NAMESPACE_NOT_COMPOSED`);\n * stripping it is the text-level equivalent of what family-idb itself\n * already does for these same fields under `projection: \"full\"`, where the\n * attribute is documented as a no-op. Use this when sharing a schema.prisma\n * authored for family-idb with a different family's schema loader — the\n * server always wants every field these attributes would otherwise hide\n * from the client.\n */\nexport function stripIdbExcludeAttributes(schema: string): string {\n  return schema\n    .replace(/^[ \\t]*@@idb\\.exclude\\b.*\\n?/gm, \"\") // model-level: drop the whole line, incl. trailing comments\n    .replace(/[ \\t]*@idb\\.exclude\\b/g, \"\"); // field-level: drop just the token, keep the field\n}\n\nfunction defaultOutputFromSchemaPath(schemaPath: string): string {\n  const ext = extname(schemaPath);\n  if (ext.length === 0) return `${schemaPath}.json`;\n  const base = schemaPath.slice(0, -ext.length);\n  if (basename(base) === \"schema\") {\n    return `${base.slice(0, -\"schema\".length)}contract.json`;\n  }\n  return `${base}.json`;\n}\n\nfunction mapParseDiagnostics(\n  diagnostics: readonly ParseDiagnostic[],\n  sourceFile: SourceFile,\n  sourceId: string\n): ContractSourceDiagnostic[] {\n  return diagnostics.map((d) => ({\n    code: d.code as string,\n    message: d.message,\n    sourceId,\n    span: rangeToPslSpan(d.range, sourceFile),\n  }));\n}\n\nexport interface PrismaIdbContractOptions {\n  readonly output?: string;\n  /**\n   * `\"client\"` projects out anything marked `@idb.exclude`/`@@idb.exclude`\n   * (ADR 012). Pass a distinct `output` alongside this so the client and\n   * full/server contracts don't collide on the same file.\n   * @default \"full\"\n   */\n  readonly projection?: ContractProjection;\n  /**\n   * Runs on the raw schema text right after it's read, before parsing.\n   * Lets a downstream package (e.g. `@prisma-idb/sync-server`) append\n   * synthetic model/enum declarations — the appended text goes through the\n   * exact same parse → interpret → hash pipeline as hand-authored PSL, so\n   * `storageHash` reflects it correctly (it's computed *inside*\n   * `interpretPslDocumentToIdbContract`, from whatever this returns).\n   */\n  readonly injectSchemaText?: (schema: string) => string;\n}\n\n/**\n * Creates a `ContractConfig` that reads an IDB schema from a `.prisma` file.\n *\n * Use this in `prisma.config.ts` as the `contract:` value when you prefer\n * PSL authoring over the TypeScript-first `defineContract()` helper.\n *\n * @example\n * ```ts\n * import { defineConfig } from '@prisma-idb/family-idb/config-types';\n * import { prismaIdbContract } from '@prisma-idb/family-idb/contract-psl';\n *\n * export default defineConfig({\n *   // ...\n *   contract: prismaIdbContract('./src/prisma/schema.prisma'),\n * });\n * ```\n *\n * The emitted `contract.json` lands next to the schema file by default\n * (`schema.prisma` → `contract.json`). Override with `options.output`.\n */\nexport function prismaIdbContract(schemaPath: string, options?: PrismaIdbContractOptions): ContractConfig {\n  return {\n    source: {\n      inputs: [schemaPath],\n      load: async (context) => {\n        const [absoluteSchemaPath] = context.resolvedInputs;\n        if (absoluteSchemaPath === undefined) {\n          throw new Error(\n            \"prismaIdbContract: context.resolvedInputs is empty. The CLI config loader should populate it positional-matched with source.inputs.\"\n          );\n        }\n\n        let schema: string;\n        try {\n          schema = await readFile(absoluteSchemaPath, \"utf-8\");\n        } catch (error) {\n          const message = String(error);\n          return notOk({\n            summary: `Failed to read Prisma schema at \"${schemaPath}\"`,\n            diagnostics: [\n              {\n                code: \"PSL_SCHEMA_READ_FAILED\",\n                message,\n                sourceId: schemaPath,\n              },\n            ],\n          });\n        }\n\n        if (options?.injectSchemaText) {\n          schema = options.injectSchemaText(schema);\n        }\n\n        const { document, sourceFile, diagnostics: parseDiagnostics } = parse(schema);\n        const { table, diagnostics: symbolDiagnostics } = buildSymbolTable({\n          document,\n          sourceFile,\n          pslBlockDescriptors: {},\n        });\n\n        // Do not short-circuit on provider-level diagnostics — the fault-tolerant\n        // parser/symbol-table still produce a usable table, and the interpreter\n        // may surface its own diagnostics in the same response.\n        const seedDiagnostics = [\n          ...mapParseDiagnostics(parseDiagnostics, sourceFile, schemaPath),\n          ...mapParseDiagnostics(symbolDiagnostics, sourceFile, schemaPath),\n        ];\n\n        const interpreted = withSeedDiagnostics(\n          interpretPslDocumentToIdbContract(\n            table,\n            schemaPath,\n            options?.projection !== undefined ? { projection: options.projection } : undefined\n          ),\n          seedDiagnostics\n        );\n        // Return the full Result so seed diagnostics (parse + symbol-table\n        // findings) survive the success path — the config loader surfaces\n        // them alongside the contract.\n        return interpreted;\n      },\n    },\n    output: options?.output ?? defaultOutputFromSchemaPath(schemaPath),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,0BAA0B,QAAwB;CAChE,OAAO,OACJ,QAAQ,kCAAkC,EAAE,CAAC,CAC7C,QAAQ,0BAA0B,EAAE;AACzC;AAEA,SAAS,4BAA4B,YAA4B;CAC/D,MAAM,MAAM,QAAQ,UAAU;CAC9B,IAAI,IAAI,WAAW,GAAG,OAAO,GAAG,WAAW;CAC3C,MAAM,OAAO,WAAW,MAAM,GAAG,CAAC,IAAI,MAAM;CAC5C,IAAI,SAAS,IAAI,MAAM,UACrB,OAAO,GAAG,KAAK,MAAM,GAAG,EAAgB,EAAE;CAE5C,OAAO,GAAG,KAAK;AACjB;AAEA,SAAS,oBACP,aACA,YACA,UAC4B;CAC5B,OAAO,YAAY,KAAK,OAAO;EAC7B,MAAM,EAAE;EACR,SAAS,EAAE;EACX;EACA,MAAM,eAAe,EAAE,OAAO,UAAU;CAC1C,EAAE;AACJ;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,kBAAkB,YAAoB,SAAoD;CACxG,OAAO;EACL,QAAQ;GACN,QAAQ,CAAC,UAAU;GACnB,MAAM,OAAO,YAAY;IACvB,MAAM,CAAC,sBAAsB,QAAQ;IACrC,IAAI,uBAAuB,KAAA,GACzB,MAAM,IAAI,MACR,qIACF;IAGF,IAAI;IACJ,IAAI;KACF,SAAS,MAAM,SAAS,oBAAoB,OAAO;IACrD,SAAS,OAAO;KACd,MAAM,UAAU,OAAO,KAAK;KAC5B,OAAO,MAAM;MACX,SAAS,oCAAoC,WAAW;MACxD,aAAa,CACX;OACE,MAAM;OACN;OACA,UAAU;MACZ,CACF;KACF,CAAC;IACH;IAEA,IAAI,SAAS,kBACX,SAAS,QAAQ,iBAAiB,MAAM;IAG1C,MAAM,EAAE,UAAU,YAAY,aAAa,qBAAqB,MAAM,MAAM;IAC5E,MAAM,EAAE,OAAO,aAAa,sBAAsB,iBAAiB;KACjE;KACA;KACA,qBAAqB,CAAC;IACxB,CAAC;IAKD,MAAM,kBAAkB,CACtB,GAAG,oBAAoB,kBAAkB,YAAY,UAAU,GAC/D,GAAG,oBAAoB,mBAAmB,YAAY,UAAU,CAClE;IAaA,OAXoB,oBAClB,kCACE,OACA,YACA,SAAS,eAAe,KAAA,IAAY,EAAE,YAAY,QAAQ,WAAW,IAAI,KAAA,CAC3E,GACA,eAKe;GACnB;EACF;EACA,QAAQ,SAAS,UAAU,4BAA4B,UAAU;CACnE;AACF"}

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

@@ -0,0 +1,98 @@
+import { t as ContractProjection } from "../psl-interpreter-C0suaXu2.mjs";
+import { Contract } from "@prisma/orm-framework/contract/types";
+import { IdbReferentialAction, IdbStorage } from "@prisma-idb/target-idb/pack";
+//#region src/core/contract-builder.d.ts
+type PrismaScalarType = "String" | "Int" | "Float" | "Boolean" | "DateTime" | "BigInt" | "Decimal" | "Json" | "Bytes";
+/**
+ * A field spec string: the Prisma scalar type name, optionally suffixed with
+ * `?` to indicate the field is nullable (e.g. `"String"`, `"Int?"`, `"DateTime?"`).
+ */
+type FieldSpec = PrismaScalarType | `${PrismaScalarType}?`;
+type RelationDef = {
+  readonly to: string;
+  readonly cardinality: "1:1" | "1:N" | "N:1";
+  readonly on: {
+    readonly local: readonly string[];
+    readonly target: readonly string[];
+  };
+  readonly onDelete?: IdbReferentialAction;
+  readonly onUpdate?: IdbReferentialAction;
+};
+type IndexDef = {
+  readonly keyPath: string;
+  readonly unique?: boolean;
+  readonly multiEntry?: boolean;
+};
+type ModelDef = {
+  readonly store: string;
+  readonly key: string;
+  /** All scalar fields on the model. Use `"Type"` for non-nullable, `"Type?"` for nullable. */
+  readonly fields: Record<string, FieldSpec>;
+  readonly indexes?: Record<string, IndexDef>;
+  readonly relations?: Record<string, RelationDef>;
+  /**
+   * Literal default values, keyed by field name — feeds the `setDefault`
+   * referential action (a child's FK field is reset to its own declared
+   * default when its parent is deleted/updated with `onDelete`/`onUpdate:
+   * "setDefault"`). A sibling map to `fields`, deliberately not folded into
+   * `FieldSpec` (a bare type string) to avoid widening that type.
+   *
+   * Does NOT feed `create()`'s default-filling — the TS-DSL authoring path
+   * has no `execution.mutations.defaults` support at all yet (a separate,
+   * larger, pre-existing gap). Use the PSL authoring path's `@default(...)`
+   * if you need create-time defaults; this map only backs `setDefault`.
+   */
+  readonly fieldDefaults?: Record<string, string | number | boolean>;
+  /** Server-only model — dropped when `defineContract` runs with `{ projection: "client" }`. See ADR 012. */
+  readonly exclude?: boolean;
+  /** Server-only fields on an otherwise-synced model — dropped in client projection. See ADR 012. */
+  readonly excludeFields?: readonly string[];
+};
+type DefineContractInput = {
+  /** Pass the default export of `@prisma-idb/family-idb/pack`. */
+  readonly family: {
+    readonly familyId: "idb";
+    readonly id: string;
+  };
+  /** Pass the default export of `@prisma-idb/target-idb/pack`. */
+  readonly target: {
+    readonly targetId: string;
+    readonly id: string;
+  };
+  readonly models: Record<string, ModelDef>;
+};
+type DefineContractOptions = {
+  /** @default "full" */
+  readonly projection?: ContractProjection;
+};
+/**
+ * Builds a typed IDB contract from a developer-friendly model definition.
+ *
+ * This is the TypeScript-first (no-emit) authoring path per ADR 006. The
+ * returned contract object can be passed directly to `createIdbClient()` or
+ * to `typescriptContract()` for config-file usage.
+ *
+ * @example
+ * ```ts
+ * import { defineContract } from '@prisma-idb/family-idb/contract-ts';
+ * import idbFamily from '@prisma-idb/family-idb/pack';
+ * import idbTarget from '@prisma-idb/target-idb/pack';
+ *
+ * export default defineContract({
+ *   family: idbFamily,
+ *   target: idbTarget,
+ *   models: {
+ *     User: {
+ *       store: 'users',
+ *       key: 'id',
+ *       fields: { id: 'String', name: 'String?', email: 'String' },
+ *       indexes: { byEmail: { keyPath: 'email', unique: true } },
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare function defineContract(input: DefineContractInput, options?: DefineContractOptions): Contract<IdbStorage>;
+//#endregion
+export { type ContractProjection, type DefineContractInput, type DefineContractOptions, type FieldSpec, type IndexDef, type ModelDef, type RelationDef, defineContract };
+//# sourceMappingURL=contract-ts.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract-ts.d.mts","names":[],"sources":["../../src/core/contract-builder.ts"],"mappings":";;;;KAgBK;;;;;KAMO,YAAY,sBAAsB;KAgBlC;WACD;WACA;WACA;aACE;aACA;;WAEF,WAAW;WACX,WAAW;;KAGV;WACD;WACA;WACA;;KAGC;WACD;WACA;;WAEA,QAAQ,eAAe;WACvB,UAAU,eAAe;WACzB,YAAY,eAAe;;;;;;;;;;;;;WAa3B,gBAAgB;;WAEhB;;WAEA;;KAGC;;WAED;aAAmB;aAA0B;;;WAE7C;aAAmB;aAA2B;;WAC9C,QAAQ,eAAe;;KAGtB;;WAED,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoUR,eAAe,OAAO,qBAAqB,UAAU,wBAAwB,SAAS"}