@skmdev/prisma-fixtures 0.1.1 → 1.0.0-rc.1

package/README.md

@@ -1,13 +1,18 @@
 # @skmdev/prisma-fixtures
 
 Load YAML or JSON fixtures into Prisma using named references, generated data and
-processors. The CLI can initialize a generated Prisma 7 client from your Prisma
-config; the API also accepts a client you create.
-
-Requires Node.js 22.18+; tested with Prisma 7.10 and PostgreSQL. Prisma itself is
-provided by your application, not installed as a runtime dependency of this package.
-
-- [Quick start](#quick-start)
+processors. The CLI supports generated Prisma 7 clients and emitted Prisma 8
+contracts; the API also accepts a client you create.
+
+Requires Node.js 22.18+. The retained path uses Prisma 7.10; the Prisma 8 release
+candidate targets `prisma@8.0.0-rc.17`,
+`@prisma/orm-postgres@8.0.0-rc.12` and PostgreSQL 17+. Prisma itself is provided
+by your application, not installed as a runtime dependency of this package.
+Install `@skmdev/prisma-fixtures@1.0.0-rc.1` after it is published to npm `next`,
+or test it before publication through the local tarball workflow below.
+
+- [Prisma 7 quick start](#prisma-7-quick-start)
+- [Prisma 8 migration preview](#prisma-8-migration-preview)
 - [Fixture format](#fixture-format)
 - [Processors](#processors)
 - [API and persistence](#api-and-persistence)
@@ -17,7 +22,7 @@ provided by your application, not installed as a runtime dependency of this pack
 - [Compatibility and attribution](#compatibility-and-attribution)
 - [Contributing and releases](CONTRIBUTING.md)
 
-## Quick start
+## Prisma 7 quick start
 
 Start with an existing Prisma 7 application that has:
 
@@ -127,11 +132,141 @@ Migration history and tables preserved by `preserveTables` or Prisma's
 See the [framework and runtime examples](examples/README.md) for standalone apps
 with Argon2 password processors and API endpoints. NestJS demonstrates a CommonJS client.
 
+## Prisma 8 migration preview
+
+Prisma 8 support in this checkout uses separately versioned release candidates:
+
+```sh
+npm install @prisma/orm-postgres@8.0.0-rc.12
+npm install --save-dev prisma@8.0.0-rc.17
+```
+
+After the fixture RC is published, install its exact version:
+
+```sh
+npm install --save-dev @skmdev/prisma-fixtures@1.0.0-rc.1
+```
+
+`npm install --save-dev @skmdev/prisma-fixtures@next` discovers the current
+prerelease, while the exact version gives reproducible installs. Before
+`1.0.0-rc.1` is published, build the fixture package from this repository. Its
+baseline package version, and therefore the tarball name, remains `0.1.1` until
+the Prepare release action creates the version-bump pull request:
+
+```sh
+# In this repository
+npm ci
+npm pack
+
+# In the Prisma application
+npm install --no-save /path/to/skmdev-prisma-fixtures-1.0.0-rc.1.tgz
+```
+
+An existing multi-file Prisma 7 schema can be the source for an emitted Prisma 8
+contract. Configure `prisma.config.ts`:
+
+```ts
+import { defineConfig, prisma7Schema } from '@prisma/orm-postgres/config'
+import { definePrismaConfig } from 'prisma/config'
+
+export default definePrismaConfig({
+  orm: defineConfig({
+    contract: prisma7Schema('./prisma/schema'),
+    output: './src/generated/prisma',
+    db: { connection: process.env.DATABASE_URL },
+  }),
+})
+```
+
+Emit `contract.json` and `contract.d.ts`, then derive the fixture JSON Schema
+offline from that contract:
+
+```sh
+npx prisma contract emit
+npx prisma-fixtures-generator src/generated/prisma/contract.json src/generated/prisma-fixtures
+npx prisma-fixtures --lint --schema src/generated/prisma-fixtures/schema.json
+```
+
+After creating the database schema with `prisma db init` or your migration
+workflow, load or reset fixtures directly:
+
+```sh
+npx prisma-fixtures
+npx prisma-fixtures --reset
+```
+
+With no `client` in `.prisma-fixtures`, the CLI reads the v8 config, loads the
+emitted contract and constructs the PostgreSQL fixture adapter. To select it
+explicitly, point the existing configured-client shape at `contract.json`:
+
+```json
+{
+  "fixtures": ["./fixtures"],
+  "client": {
+    "module": "./src/generated/prisma/contract.json",
+    "adapter": "pg"
+  }
+}
+```
+
+Application routes should use the native Prisma 8 `db.orm` API. Only fixture
+loading needs the compatibility bridge:
+
+```ts
+import postgres from '@prisma/orm-postgres/runtime'
+import {
+  createPrisma8FixtureClient,
+  PrismaFixtures,
+} from '@skmdev/prisma-fixtures'
+import type { Contract } from './src/generated/prisma/contract.js'
+import contractJson from './src/generated/prisma/contract.json' with { type: 'json' }
+
+const db = postgres<Contract>({
+  contractJson,
+  url: process.env.DATABASE_URL!,
+})
+const client = createPrisma8FixtureClient(db)
+
+try {
+  await new PrismaFixtures().load(client)
+} finally {
+  await client.$disconnect()
+}
+```
+
+`createPrisma8FixtureClient(db)` exposes the legacy fixture-facing delegates,
+`$transaction` and `$disconnect` on top of the native v8 client. Prisma 8 fixture
+transactions set PostgreSQL's `transaction_timeout`, so this path requires
+PostgreSQL 17 or newer and retains rollback when the configured timeout expires.
+Enable TypeScript's `resolveJsonModule`; use `contract.js` with NodeNext ESM or
+`contract.d` with bundler module resolution for the generated `Contract` type.
+
+The v8 bridge decodes scalar fixture values with the contract's PostgreSQL codecs,
+including nested creates, connections and scalar lists. Quote large integers and
+decimals to preserve precision; use base64 strings for binary fields. JSON fields
+remain JSON. Dates use the emitted codec's ISO format: `Temporal.Instant` takes
+a timezone such as `2026-01-02T03:04:05Z`, while `Temporal.PlainDateTime` takes
+`2026-01-02T03:04:05` without a timezone. Processors can also supply the codec's
+native values directly.
+
+If your contract uses Temporal codecs and your runtime has no `Temporal`, install
+the application's polyfill and preload it before constructing the client:
+
+```sh
+npm install temporal-polyfill@1.0.5
+npx prisma-fixtures --require temporal-polyfill/full/global
+```
+
+For programmatic loading, use `import 'temporal-polyfill/full/global'` before
+creating `db`. The fixture package does not install a global polyfill itself.
+
 ## Fixture format
 
-Each `.yml`, `.yaml` or `.json` file describes one entity. `User` and `user` both
-resolve to the `user` delegate. Directory files are sorted; reference dependencies
-determine insert order. Fixture names must be unique across all files.
+Each `.yml`, `.yaml` or `.json` file describes one entity. Prisma 8 accepts
+namespace-qualified entities such as `public.User`; `User` and `user` are also
+available when that model name is unambiguous across namespaces. Prisma 7 resolves
+`User` and `user` to the `user` delegate. Directory files are sorted; reference
+dependencies determine insert order. Fixture names must be unique across all files.
 
 | Feature                  | Example                          | Meaning                                                       |
 | ------------------------ | -------------------------------- | ------------------------------------------------------------- |
@@ -346,6 +481,9 @@ seed script, use `try`/`finally` as in the runnable example above.
   then loads the fixtures and returns the same record map as `loadFixtures`.
   `FixtureResetOptions` combines `seed`, `refDate` and `preserveTables`. Passing
   the writer as the third argument remains supported.
+- `createPrisma8FixtureClient(db)` adapts a native Prisma 8 PostgreSQL client to
+  the fixture delegate, transaction and disconnect interface. Application queries
+  continue to use the original native `db`.
 - Package-owned failures are `FixtureError` instances with a stable `code`, safe
   `stage`/source/fixture/path context and the original private `cause` for API
   callers. Opaque provider, hook and database messages are not copied into the
@@ -372,7 +510,8 @@ const records = await prisma.$transaction(
 Cleanup currently supports **PostgreSQL only** and requires `$executeRawUnsafe`.
 It truncates all ordinary/partitioned tables across all non-system schemas in the
 connected database, including implicit join tables. Tables, schema, indexes,
-constraints, sequence values and `_prisma_migrations` records are preserved.
+constraints, sequence values, `_prisma_migrations` records and Prisma 8's
+`prisma_contract` schema are preserved.
 Each `preserveTables` entry names one existing table as `schema.table`;
 its data and sequence state are also preserved. Unknown tables and
 duplicate or malformed entries fail before truncation.
@@ -399,17 +538,17 @@ applied. Rollback cannot undo external side effects in templates or processors.
 
 Run these commands from your project directory:
 
-| Command                                                            | Purpose                                                                        |
-| ------------------------------------------------------------------ | ------------------------------------------------------------------------------ |
-| `npx prisma-fixtures init`                                         | Create config and fixture directory without overwriting an existing config     |
-| `npx prisma-fixtures`                                              | Load configured fixtures; equivalent to the Quick start's `npx prisma db seed` |
-| `npx prisma-fixtures ./fixtures --list`                            | List fixture names and entities without executing code                         |
-| `npx prisma-fixtures --lint`                                       | Check fixtures without a client or database                                    |
-| `npx prisma-fixtures --clean`                                      | Clear database data without reading fixtures (PostgreSQL only)                 |
-| `npx prisma-fixtures --reset`                                      | Clear database data, then load fixtures (PostgreSQL only)                      |
-| `npx prisma-fixtures --seed 42 --refDate 2026-01-01T00:00:00.000Z` | Reproduce generated values and random references                               |
-| `npx prisma-fixtures --config ./test/.prisma-fixtures`             | Use a different config file                                                    |
-| `npx prisma-fixtures --help`                                       | Show all options                                                               |
+| Command                                                            | Purpose                                                                    |
+| ------------------------------------------------------------------ | -------------------------------------------------------------------------- |
+| `npx prisma-fixtures init`                                         | Create config and fixture directory without overwriting an existing config |
+| `npx prisma-fixtures`                                              | Load configured fixtures; used directly by v8 and by the v7 seed command   |
+| `npx prisma-fixtures ./fixtures --list`                            | List fixture names and entities without executing code                     |
+| `npx prisma-fixtures --lint`                                       | Check fixtures without a client or database                                |
+| `npx prisma-fixtures --clean`                                      | Clear database data without reading fixtures (PostgreSQL only)             |
+| `npx prisma-fixtures --reset`                                      | Clear database data, then load fixtures (PostgreSQL only)                  |
+| `npx prisma-fixtures --seed 42 --refDate 2026-01-01T00:00:00.000Z` | Reproduce generated values and random references                           |
+| `npx prisma-fixtures --config ./test/.prisma-fixtures`             | Use a different config file                                                |
+| `npx prisma-fixtures --help`                                       | Show all options                                                           |
 
 Use only one of `--clean`, `--reset`, `--list` and `--lint` at a time. Clean and
 reset affect tables beyond those in your fixtures; see [cleanup and reset](#cleanup-and-reset).
@@ -420,8 +559,8 @@ To reuse an existing directory during setup, run
 
 ### Configuration
 
-`.prisma-fixtures` is JSON. Start with the config from Quick start and add only
-the options you need:
+`.prisma-fixtures` is JSON. Start with the config from the Prisma 7 quick start
+or Prisma 8 preview and add only the options you need:
 
 ```json
 {
@@ -448,28 +587,32 @@ positional paths and CLI flags are relative to the working directory and overrid
 matching config fields. Multiple fixture paths form one load and one transaction.
 Discovery checks only the current directory; an explicit `--config` file must exist.
 
-When `client` is omitted, `--clean` and `--reset` also preserve the PostgreSQL
-tables listed in Prisma's `tables.external` (with
-`experimental.externalTables` enabled). These `schema.table` entries are combined
-with any explicit `preserveTables` entries. For example,
-`tables: { external: ['public.flyway_schema_history'] }` in `prisma.config.ts`
-preserves that table without repeating it in `.prisma-fixtures`. Direct API calls
-still use only the options passed to them. Ordinary loading ignores the preserve
-list and never deletes data.
+When `client` is omitted, `--clean` and `--reset` also preserve Prisma 7
+`tables.external` entries from the adjacent config when
+`experimental.externalTables` is enabled. Every Prisma 8 adapter preserves emitted
+contract tables whose control is `external`, `observed` or `tolerated`. This applies
+to CLI clients constructed from inferred or explicit `contract.json` paths and to
+programmatic transactions created by `createPrisma8FixtureClient(db)`. These tables
+are combined with explicit `preserveTables` entries. Ordinary loading ignores the
+preserve list and never deletes data.
 
 ### Client discovery and overrides
 
 For write commands with no explicit `client`, the CLI reads the adjacent Prisma
-config's schema and datasource, resolves the static `prisma-client` output path,
-and uses your installed `@prisma/adapter-pg`. Run `prisma generate` first.
-For inferred `.ts`/`.cts` clients, it uses existing compiled output described by
-`tsconfig.json` with `rootDir` and `outDir`, or the project's installed `ts-node`
-when no loader is registered. Native ESM `.mts` clients work with Node's type
-stripping; see the [Hono generator](examples/hono/prisma/schema/00_base.prisma).
+config. A Prisma 8 `definePrismaConfig({ orm: ... })` config resolves its emitted
+`contract.json` output and constructs `createPrisma8FixtureClient(db)` with the
+installed `@prisma/orm-postgres` runtime. Run `prisma contract emit` first.
 
-An explicit `client` can be an object with `module` (generated client path),
-`adapter: 'pg'` and optional `guard`, or a legacy module path exporting a client
-or factory. `--client` overrides either form with a legacy module path.
+The retained Prisma 7 path resolves the static `prisma-client` output and uses
+the installed `@prisma/adapter-pg`; run `prisma generate` first. For inferred
+`.ts`/`.cts` v7 clients, the CLI uses compiled output described by `tsconfig.json`
+or the project's installed `ts-node`. Native ESM `.mts` clients work with Node's
+type stripping.
+
+An explicit `client` object uses `module`, `adapter: 'pg'` and an optional
+`guard`. `module` can name a v8 `contract.json` or a generated v7 client. A legacy
+module path exporting a client or factory remains supported, and `--client`
+overrides either configured form with that path.
 
 | CLI-only option                    | Purpose                                                                              |
 | ---------------------------------- | ------------------------------------------------------------------------------------ |
@@ -493,6 +636,8 @@ in the application's transaction guard.
 
 The CLI wraps writes in one transaction (60-second timeout; override with
 `--timeout <ms>`) and always disconnects a successfully acquired valid client.
+Prisma 8 enforces this with PostgreSQL 17+'s `transaction_timeout`; Prisma 7 uses
+its client transaction timeout option.
 `--list` and `--lint` skip all hooks, Prisma config loading and client imports;
 `--list` only parses the JSON config and fixture documents.
 Package diagnostics include a stable code and available filename, fixture name
@@ -527,7 +672,20 @@ such as Prettier.
 
 ### Generate a schema from your Prisma models
 
-Add a generator to `prisma/schema.prisma`:
+For Prisma 8, emit the contract and pass it to the generator's offline contract
+mode:
+
+```sh
+npx prisma contract emit
+npx prisma-fixtures-generator src/generated/prisma/contract.json src/generated/prisma-fixtures
+```
+
+This writes `src/generated/prisma-fixtures/schema.json`. Contract validation
+fails closed: dictionary fields and unknown codec IDs, including unsupported
+extension-provided codecs, stop generation instead of producing a permissive or
+incorrect schema.
+
+For Prisma 7, add the legacy generator block to `prisma/schema.prisma`:
 
 ```prisma
 generator fixtures {
@@ -538,8 +696,8 @@ generator fixtures {
 
 Run `npx prisma generate`. This creates `generated/fixtures/schema.json` from
 Prisma's model and create-input metadata. Output paths are relative to
-`schema.prisma`; regenerate after changing your models. No database connection
-is needed for this generator.
+`schema.prisma`; regenerate after changing your models. Neither generator mode
+needs a database connection.
 
 Use the same schema for CLI lint by adding `schema` to `.prisma-fixtures`:
 
@@ -556,12 +714,15 @@ Or pass it explicitly:
 npx prisma-fixtures ./fixtures --lint --schema ./generated/fixtures/schema.json
 ```
 
-The generated schema selects fields by `entity`, accepts model and delegate
-names, and checks known fields, scalar types, enums, nullability, lists and
-required create inputs. Both nested relation inputs and direct foreign keys are
-supported. References, Faker, EJS and parameter expressions remain dynamic
-strings; their evaluated types are checked when loading. References and records
-with an `id` (including arrays) are allowed for `connectedFields` shorthand.
+The generated schema selects fields by `entity`. Prisma 8 schemas include
+namespace-qualified names such as `public.User`, plus unqualified model and
+delegate aliases when they are unambiguous; Prisma 7 schemas accept model and
+delegate names. The schema checks known fields, scalar types, enums, nullability,
+lists and required create inputs. Both nested relation inputs and direct foreign
+keys are supported. References, Faker, EJS and parameter expressions remain
+dynamic strings; their evaluated types are checked when loading. References and
+records with an `id` (including arrays) are allowed for `connectedFields`
+shorthand.
 
 Documents with a `processor` skip model item validation because the processor
 may add, remove or transform fields; their fixture structure is still checked.
@@ -616,6 +777,13 @@ visited nodes per validated value. No fixture values are logged by the engine.
 
 ## Compatibility and attribution
 
+The Prisma 8 release candidate is tested against the exact RC pair documented
+above and PostgreSQL 17+. Prisma 8 CLI and runtime packages have separate version
+numbers. Prisma 7.10 support, its generator RPC and existing client injection
+remain available for legacy consumers. A stable fixture package `1.0.0` requires
+stable Prisma 8 CLI and runtime releases and successful migration verification
+against those stable versions.
+
 Legacy Faker aliases `name.firstName`, `name.lastName`, `name.title`,
 `internet.userName` and `random.number` remain supported. This is syntax
 compatibility, not identical random output or complete emulation of every removed

package/dist/cli.js

@@ -17,6 +17,7 @@ const load_options_1 = require("./load-options");
 const prisma_config_1 = require("./prisma-config");
 const fixture_config_1 = require("./fixture-config");
 const index_1 = require("./index");
+const prisma8_client_1 = require("./prisma8-client");
 const help = `Usage: prisma-fixtures [path...] [--client <module>] [options]
        prisma-fixtures init [fixtures-directory]
 
@@ -276,8 +277,16 @@ async function loadClient(config, values) {
         if (typeof databaseUrl !== 'string' || !databaseUrl.trim()) {
             throw new Error('DATABASE_URL is required');
         }
-        const generated = await importGeneratedClient(clientConfig.module, requireFromCwd);
-        candidate = createGeneratedClient(generated, requireFromCwd, databaseUrl);
+        if (node_path_1.default.extname(clientConfig.module) === '.json') {
+            const { default: postgres } = (await import((0, node_url_1.pathToFileURL)(requireFromCwd.resolve('@prisma/orm-postgres/runtime'))
+                .href));
+            const contractJson = JSON.parse(node_fs_1.default.readFileSync(clientConfig.module, 'utf8'));
+            candidate = (0, prisma8_client_1.createPrisma8FixtureClient)(postgres({ contractJson, url: databaseUrl }));
+        }
+        else {
+            const generated = await importGeneratedClient(clientConfig.module, requireFromCwd);
+            candidate = createGeneratedClient(generated, requireFromCwd, databaseUrl);
+        }
     }
     if (!candidate ||
         typeof candidate !== 'object' ||

package/dist/contract-fixture-schema.d.ts

@@ -0,0 +1,8 @@
+type JsonSchema = Record<string, unknown>;
+type FixtureSchema = JsonSchema & {
+    properties: Record<string, JsonSchema>;
+    definitions: Record<string, JsonSchema>;
+    allOf?: JsonSchema[];
+};
+export declare function buildContractFixtureSchema(value: unknown): FixtureSchema;
+export {};

package/dist/contract-fixture-schema.js

@@ -0,0 +1,351 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildContractFixtureSchema = buildContractFixtureSchema;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const baseFixtureSchema = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(__dirname, '../schema/fixture.schema.json'), 'utf8'));
+const dynamicString = () => ({
+    type: 'string',
+    pattern: '(?:^@(?!@)|<%|\\{\\{|<\\{|\\(\\$current(?:[+*/-][0-9]+)?\\))',
+});
+const internalRef = (name) => ({
+    $ref: `#/definitions/${encodeURIComponent(name.replaceAll('~', '~0').replaceAll('/', '~1'))}`,
+});
+const invalid = (message) => {
+    throw new Error(`Invalid Prisma v8 PostgreSQL contract: ${message}`);
+};
+const object = (value, location) => {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        invalid(`${location} must be an object`);
+    return value;
+};
+const text = (value, location) => {
+    if (typeof value !== 'string' || !value)
+        invalid(`${location} must be a non-empty string`);
+    return value;
+};
+function buildContractFixtureSchema(value) {
+    const contract = contractMetadata(value);
+    const schema = structuredClone(baseFixtureSchema);
+    const definitions = schema.definitions;
+    const aliasOwners = new Map();
+    for (const [namespace, entry] of Object.entries(contract.domain.namespaces)) {
+        for (const model of Object.keys(object(entry.models, `${namespace}.models`))) {
+            const owner = `${namespace}.${model}`;
+            for (const alias of new Set([
+                owner,
+                model,
+                model[0].toLowerCase() + model.slice(1),
+            ])) {
+                aliasOwners.set(alias, aliasOwners.has(alias) && aliasOwners.get(alias) !== owner
+                    ? null
+                    : owner);
+            }
+        }
+    }
+    const aliases = (namespace, model) => [...aliasOwners]
+        .filter(([, owner]) => owner === `${namespace}.${model}`)
+        .map(([alias]) => alias);
+    const enumValues = (namespace, field) => {
+        if (!field.valueSet)
+            return undefined;
+        const ref = field.valueSet;
+        const refNamespace = ref.namespaceId === '__unbound__' ? namespace : ref.namespaceId;
+        const values = ref.plane === 'domain' && ref.entityKind === 'enum'
+            ? contract.domain.namespaces[refNamespace]?.enum?.[ref.entityName]?.members.map(({ value }) => value)
+            : ref.plane === 'storage' && ref.entityKind === 'valueSet'
+                ? contract.storage.namespaces[refNamespace]?.entries.valueSet?.[ref.entityName]?.values
+                : undefined;
+        if (!values)
+            invalid(`field value set ${refNamespace}.${ref.entityName} is invalid`);
+        return values;
+    };
+    const typeSchema = (namespace, value) => {
+        const type = object(value, 'field type');
+        if (type.kind === 'scalar')
+            return scalarSchema(text(type.codecId, 'codecId'));
+        if (type.kind === 'valueObject') {
+            const name = text(type.name, 'value object name');
+            const definitionName = `PrismaContractValueObject_${JSON.stringify([namespace, name])}`;
+            if (!(definitionName in definitions)) {
+                const valueObject = contract.domain.namespaces[namespace]?.valueObjects?.[name] ??
+                    invalid(`value object ${namespace}.${name} does not exist`);
+                definitions[definitionName] = {};
+                definitions[definitionName] = objectSchema(namespace, valueObject.fields, {});
+            }
+            return internalRef(definitionName);
+        }
+        if (type.kind === 'union' &&
+            Array.isArray(type.members) &&
+            type.members.length)
+            return {
+                anyOf: type.members.map((member) => typeSchema(namespace, member)),
+            };
+        return invalid('field type kind is invalid');
+    };
+    const fieldSchema = (namespace, field) => {
+        if (typeof field.nullable !== 'boolean')
+            invalid('field nullable must be boolean');
+        if (field.many !== undefined && field.many !== true)
+            invalid('field many must be true when present');
+        if (field.dict)
+            invalid('dictionary fields are not supported');
+        const values = enumValues(namespace, field);
+        const value = values ? { enum: values } : typeSchema(namespace, field.type);
+        let result = field.many
+            ? { type: 'array', items: { anyOf: [value, dynamicString()] } }
+            : value;
+        const acceptsString = values === undefined &&
+            !field.many &&
+            field.type.kind === 'scalar' &&
+            (stringCodec(field.type.codecId) || jsonCodec(field.type.codecId));
+        if (!acceptsString)
+            result = { anyOf: [result, dynamicString()] };
+        if (field.nullable)
+            result = { anyOf: [result, { type: 'null' }] };
+        return result;
+    };
+    const connection = () => ({
+        allOf: [
+            internalRef('safeObject'),
+            {
+                minProperties: 1,
+                propertyNames: { not: { enum: ['connect', 'create'] } },
+            },
+        ],
+    });
+    const ensureModel = (namespace, name) => {
+        const definitionName = `PrismaContractModel_${JSON.stringify([namespace, name])}`;
+        if (definitionName in definitions)
+            return definitionName;
+        const model = contract.domain.namespaces[namespace]?.models[name];
+        if (!model)
+            invalid(`relation target ${namespace}.${name} does not exist`);
+        definitions[definitionName] = {};
+        definitions[definitionName] = objectSchema(namespace, model.fields, model.relations, model, name);
+        return definitionName;
+    };
+    const ensureNestedModel = (sourceNamespace, sourceName, sourceModel, relationName, relation) => {
+        const namespace = text(relation.to?.namespace, 'relation namespace');
+        const name = text(relation.to?.model, 'relation model');
+        const omitted = parentInjectedFields(contract, sourceNamespace, sourceName, sourceModel, relation);
+        if (!omitted.length)
+            return ensureModel(namespace, name);
+        const definitionName = `PrismaContractNested_${JSON.stringify([sourceNamespace, sourceName, relationName])}`;
+        if (definitionName in definitions)
+            return definitionName;
+        const model = contract.domain.namespaces[namespace]?.models[name];
+        if (!model)
+            invalid(`relation target ${namespace}.${name} does not exist`);
+        definitions[definitionName] = {};
+        definitions[definitionName] = objectSchema(namespace, model.fields, model.relations, model, name, new Set(omitted));
+        return definitionName;
+    };
+    const relationSchema = (namespace, modelName, model, relationName, relation) => {
+        if (!['1:1', 'N:1', '1:N', 'N:M'].includes(relation.cardinality))
+            invalid('relation cardinality is invalid');
+        const target = internalRef(model && modelName
+            ? ensureNestedModel(namespace, modelName, model, relationName, relation)
+            : ensureModel(text(relation.to?.namespace, 'relation namespace'), text(relation.to?.model, 'relation model')));
+        const oneOrMany = (item) => ({
+            anyOf: [
+                item,
+                dynamicString(),
+                { type: 'array', items: { anyOf: [item, dynamicString()] } },
+            ],
+        });
+        const selector = connection();
+        const alternatives = [
+            dynamicString(),
+            selector,
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    connect: oneOrMany(selector),
+                    create: oneOrMany(target),
+                },
+                oneOf: [{ required: ['connect'] }, { required: ['create'] }],
+            },
+        ];
+        if (relation.cardinality === '1:N' || relation.cardinality === 'N:M')
+            alternatives.push({
+                type: 'array',
+                items: { anyOf: [dynamicString(), selector] },
+            });
+        if (relation.nullable)
+            alternatives.push({ type: 'null' });
+        return { anyOf: alternatives };
+    };
+    function objectSchema(namespace, fields, relations, model, modelName, omittedRequiredFields = new Set()) {
+        const properties = Object.fromEntries(Object.entries(object(fields, `${namespace} fields`)).map(([name, field]) => [name, fieldSchema(namespace, field)]));
+        const required = Object.entries(fields)
+            .filter(([name, field]) => !field.nullable &&
+            !omittedRequiredFields.has(name) &&
+            !hasDefault(contract, model, name))
+            .map(([name]) => name);
+        const relationRequirements = [];
+        for (const [name, relation] of Object.entries(object(relations, `${namespace} relations`))) {
+            properties[name] = relationSchema(namespace, modelName, model, name, relation);
+            if (relation.nullable === false &&
+                (relation.cardinality === 'N:1' ||
+                    (relation.cardinality === '1:1' &&
+                        ownsForeignKey(contract, model, relation)))) {
+                const local = relation.on?.localFields.filter((field) => required.includes(field));
+                if (local?.length) {
+                    for (const field of local)
+                        required.splice(required.indexOf(field), 1);
+                    relationRequirements.push({
+                        anyOf: [{ required: local }, { required: [name] }],
+                    });
+                }
+            }
+        }
+        return {
+            type: 'object',
+            additionalProperties: false,
+            properties,
+            ...(required.length ? { required } : {}),
+            ...(relationRequirements.length ? { allOf: relationRequirements } : {}),
+        };
+    }
+    const entityNames = [];
+    const conditions = [];
+    for (const [namespace, entry] of Object.entries(contract.domain.namespaces)) {
+        for (const [name, model] of Object.entries(entry.models)) {
+            const modelAliases = aliases(namespace, name);
+            const relations = Object.keys(model.relations);
+            const scalars = Object.keys(model.fields);
+            entityNames.push(...modelAliases);
+            conditions.push({
+                if: {
+                    required: ['entity'],
+                    properties: { entity: { enum: modelAliases } },
+                },
+                then: {
+                    properties: {
+                        connectedFields: relations.length
+                            ? { items: { enum: relations } }
+                            : { maxItems: 0 },
+                        deferredFields: scalars.length
+                            ? { items: { enum: scalars } }
+                            : { maxItems: 0 },
+                    },
+                    allOf: [
+                        {
+                            if: { not: { required: ['processor'] } },
+                            then: {
+                                properties: {
+                                    items: {
+                                        additionalProperties: internalRef(ensureModel(namespace, name)),
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+            });
+        }
+    }
+    schema.properties.entity = entityNames.length
+        ? {
+            description: 'Prisma v8 namespace-qualified model or an unambiguous model alias.',
+            type: 'string',
+            enum: [...new Set(entityNames)],
+        }
+        : { description: 'No Prisma models are available.', not: {} };
+    schema.allOf = [...(schema.allOf ?? []), ...conditions];
+    return schema;
+}
+function contractMetadata(value) {
+    const root = object(value, 'contract');
+    if (root.schemaVersion !== '1')
+        invalid('schemaVersion must be "1"');
+    if (root.targetFamily !== 'sql' || root.target !== 'postgres')
+        invalid('contract must target PostgreSQL');
+    const domain = object(root.domain, 'domain');
+    const storage = object(root.storage, 'storage');
+    object(root.roots, 'roots');
+    object(domain.namespaces, 'domain.namespaces');
+    object(storage.namespaces, 'storage.namespaces');
+    return root;
+}
+function hasDefault(contract, model, name) {
+    if (!model)
+        return false;
+    const field = model.storage.fields[name];
+    if (!field)
+        return false;
+    const column = contract.storage.namespaces[model.storage.namespaceId]?.entries.table[model.storage.table]?.columns[field.column];
+    return ((column !== undefined && 'default' in column) ||
+        (contract.execution?.mutations.defaults.some(({ ref, onCreate }) => onCreate !== undefined &&
+            ref.namespace === model.storage.namespaceId &&
+            ref.table === model.storage.table &&
+            ref.column === field.column) ??
+            false));
+}
+function parentInjectedFields(contract, sourceNamespace, sourceName, sourceModel, relation) {
+    if (!relation.on ||
+        (relation.cardinality !== '1:N' && relation.cardinality !== '1:1'))
+        return [];
+    const target = contract.domain.namespaces[relation.to.namespace]?.models[relation.to.model];
+    if (!target ||
+        !relation.on.localFields.every((field) => field in sourceModel.fields) ||
+        !relation.on.targetFields.every((field) => field in target.fields))
+        return [];
+    const inverse = Object.values(target.relations).find((candidate) => candidate.to.namespace === sourceNamespace &&
+        candidate.to.model === sourceName &&
+        candidate.on !== undefined &&
+        sameFields(candidate.on.localFields, relation.on.targetFields) &&
+        sameFields(candidate.on.targetFields, relation.on.localFields) &&
+        ownsForeignKey(contract, target, candidate));
+    return inverse ? relation.on.targetFields : [];
+}
+function sameFields(left, right) {
+    return (left.length === right.length &&
+        left.every((field, index) => field === right[index]));
+}
+function ownsForeignKey(contract, model, relation) {
+    if (!model || !relation.on)
+        return false;
+    const sourceColumns = relation.on.localFields.map((field) => model.storage.fields[field]?.column);
+    const target = contract.domain.namespaces[relation.to.namespace]?.models[relation.to.model];
+    const targetColumns = relation.on.targetFields.map((field) => target?.storage.fields[field]?.column);
+    if (!target ||
+        sourceColumns.some((column) => column === undefined) ||
+        targetColumns.some((column) => column === undefined))
+        return false;
+    const table = contract.storage.namespaces[model.storage.namespaceId]?.entries.table[model.storage.table];
+    return table?.foreignKeys.some(({ source, target: foreignTarget }) => source.namespaceId === model.storage.namespaceId &&
+        source.tableName === model.storage.table &&
+        sameFields(source.columns, sourceColumns) &&
+        foreignTarget.namespaceId === target.storage.namespaceId &&
+        foreignTarget.tableName === target.storage.table &&
+        sameFields(foreignTarget.columns, targetColumns));
+}
+const jsonCodec = (codecId) => codecId === 'pg/json@1' || codecId === 'pg/jsonb@1';
+const stringCodec = (codecId) => /^(?:pg\/(?:text|enum|char|varchar|bit|varbit|date-(?:string|temporal)|timestamp-(?:string|temporal)|timestamptz-(?:string|temporal|date)|time-(?:string|temporal)|timetz|interval|bytea|uuid|inet|tsquery)|sql\/(?:char|varchar|text))@1$/.test(codecId);
+const scalarSchema = (codecId) => {
+    if (jsonCodec(codecId))
+        return internalRef('jsonValue');
+    if (codecId === 'pg/bool@1')
+        return { type: 'boolean' };
+    if (/^(?:pg\/(?:int|int2|int4|int8number)|sql\/int)@1$/.test(codecId))
+        return { type: 'integer' };
+    if (/^pg\/(?:int8|unboundedint)@1$/.test(codecId))
+        return {
+            anyOf: [{ type: 'integer' }, { type: 'string', pattern: '^-?[0-9]+$' }],
+        };
+    if (/^(?:pg\/(?:float|float4|float8)|sql\/float)@1$/.test(codecId))
+        return { type: 'number' };
+    if (codecId === 'pg/numeric@1')
+        return { anyOf: [{ type: 'number' }, { type: 'string' }] };
+    if (codecId === 'pg/text-array@1')
+        return { type: 'array', items: { type: 'string' } };
+    if (stringCodec(codecId))
+        return { type: 'string' };
+    return invalid(`field type codec ${codecId} is not supported`);
+};

package/dist/fixture-document.js

@@ -295,8 +295,10 @@ function assertFixtureDefinition(value) {
 function assertFixtureMetadata(metadata, file) {
     const { entity, parameters, processor, locale, connectedFields, deferredFields, } = metadata;
     if (typeof entity !== 'string' ||
-        !NAME_PATTERN.test(entity) ||
-        exports.DANGEROUS_KEYS.has(entity) ||
+        entity.split('.').length > 2 ||
+        entity
+            .split('.')
+            .some((part) => !NAME_PATTERN.test(part) || exports.DANGEROUS_KEYS.has(part)) ||
         !isFixtureRecord(parameters) ||
         (processor !== undefined &&
             (typeof processor !== 'string' || !processor)) ||

package/dist/generator.js

@@ -5,21 +5,42 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
 const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
 const generator_helper_1 = require("@prisma/generator-helper");
+const contract_fixture_schema_1 = require("./contract-fixture-schema");
 const fixture_schema_1 = require("./fixture-schema");
-(0, generator_helper_1.generatorHandler)({
-    onManifest() {
-        return {
-            prettyName: 'Prisma Fixtures',
-            defaultOutput: './generated/fixtures',
-        };
-    },
-    async onGenerate(options) {
-        const output = options.generator.output?.value;
-        if (!output)
-            throw new Error('Prisma Fixtures generator requires an output path');
-        node_fs_1.default.mkdirSync(output, { recursive: true });
-        node_fs_1.default.writeFileSync(node_path_1.default.join(output, 'schema.json'), `${JSON.stringify((0, fixture_schema_1.buildFixtureSchema)(options.dmmf), null, 2)}\n`);
-    },
-});
+const writeSchema = (output, schema) => {
+    node_fs_1.default.mkdirSync(output, { recursive: true });
+    node_fs_1.default.writeFileSync(node_path_1.default.join(output, 'schema.json'), `${JSON.stringify(schema, null, 2)}\n`);
+};
+const args = process.argv.slice(2);
+if (args.length) {
+    if (args.length !== 2)
+        throw new Error('Usage: prisma-fixtures-generator <contract.json> <output-directory>');
+    const [contractPath, output] = args;
+    const contract = JSON.parse(node_fs_1.default.readFileSync(contractPath, 'utf8'));
+    const consumerRequire = (0, node_module_1.createRequire)(node_path_1.default.join(process.cwd(), 'package.json'));
+    const runtime = consumerRequire.resolve('@prisma/orm-postgres/target/runtime');
+    void import((0, node_url_1.pathToFileURL)(runtime).href).then(({ PostgresContractSerializer }) => {
+        new PostgresContractSerializer().deserializeContract(contract);
+        writeSchema(output, (0, contract_fixture_schema_1.buildContractFixtureSchema)(contract));
+    });
+}
+else {
+    (0, generator_helper_1.generatorHandler)({
+        onManifest() {
+            return {
+                prettyName: 'Prisma Fixtures',
+                defaultOutput: './generated/fixtures',
+            };
+        },
+        async onGenerate(options) {
+            const output = options.generator.output?.value;
+            if (!output)
+                throw new Error('Prisma Fixtures generator requires an output path');
+            writeSchema(output, (0, fixture_schema_1.buildFixtureSchema)(options.dmmf));
+        },
+    });
+}

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { type FixtureDefinition, readFixtureDocuments } from './fixture-document';
 import { type FixtureCleanupOptions } from './cleanup-options';
 import { type FixtureLoadOptions, type FixtureResetOptions } from './load-options';
+export { createPrisma8FixtureClient } from './prisma8-client';
 export type { FixtureDefinition } from './fixture-document';
 export { FixtureError } from './fixture-error';
 export type { FixtureErrorCode, FixtureErrorContext } from './fixture-error';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrismaFixtures = exports.readFixtureDefinitions = exports.FixtureError = void 0;
+exports.PrismaFixtures = exports.readFixtureDefinitions = exports.FixtureError = exports.createPrisma8FixtureClient = void 0;
 exports.loadFixtures = loadFixtures;
 exports.cleanFixtures = cleanFixtures;
 exports.resetFixtures = resetFixtures;
@@ -11,6 +11,9 @@ const cleanup_options_1 = require("./cleanup-options");
 const load_options_1 = require("./load-options");
 const fixture_error_1 = require("./fixture-error");
 const fixture_config_1 = require("./fixture-config");
+const prisma8_client_1 = require("./prisma8-client");
+var prisma8_client_2 = require("./prisma8-client");
+Object.defineProperty(exports, "createPrisma8FixtureClient", { enumerable: true, get: function () { return prisma8_client_2.createPrisma8FixtureClient; } });
 var fixture_error_2 = require("./fixture-error");
 Object.defineProperty(exports, "FixtureError", { enumerable: true, get: function () { return fixture_error_2.FixtureError; } });
 exports.readFixtureDefinitions = fixture_document_1.readFixtureDocuments;
@@ -45,11 +48,17 @@ async function loadFixtures(client, definitions, optionsOrWrite, finalWrite) {
     return writeFixtures(fixtures, write);
 }
 async function cleanFixtures(client, options) {
-    const { preserveTables = [] } = (0, cleanup_options_1.normalizeCleanupOptions)(options);
+    const { preserveTables: requestedTables = [] } = (0, cleanup_options_1.normalizeCleanupOptions)(options);
     if (client === null ||
         (typeof client !== 'object' && typeof client !== 'function')) {
         throw new Error('Invalid fixture cleaner arguments');
     }
+    const preserveTables = [
+        ...new Set([
+            ...requestedTables,
+            ...(prisma8_client_1.prisma8PreservedTables.get(client) ?? []),
+        ]),
+    ];
     const execute = client.$executeRawUnsafe;
     if (typeof execute !== 'function') {
         throw new Error('Fixture cleaner requires $executeRawUnsafe');
@@ -86,7 +95,7 @@ BEGIN
       FROM pg_catalog.pg_class AS candidate
       JOIN pg_catalog.pg_namespace AS namespace ON namespace.oid = candidate.relnamespace
       WHERE candidate.relkind IN ('r', 'p')
-        AND namespace.nspname <> 'information_schema'
+        AND namespace.nspname NOT IN ('information_schema', 'prisma_contract')
         AND namespace.nspname !~ '^pg_'
         AND candidate.relname <> '_prisma_migrations'
         AND NOT EXISTS (
@@ -115,7 +124,7 @@ BEGIN
   )
   INTO tables
   FROM pg_catalog.pg_tables
-  WHERE schemaname <> 'information_schema'
+  WHERE schemaname NOT IN ('information_schema', 'prisma_contract')
     AND schemaname !~ '^pg_'
     AND tablename <> '_prisma_migrations'
     AND NOT EXISTS (

package/dist/prisma-config.js

@@ -7,17 +7,20 @@ exports.loadPrismaDefaults = loadPrismaDefaults;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_module_1 = require("node:module");
 const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const prisma8_client_1 = require("./prisma8-client");
 const cleanup_options_1 = require("./cleanup-options");
 async function loadPrismaDefaults(configRoot, requireFromCwd, databaseUrlOverride) {
     const requireFromPrisma = (0, node_module_1.createRequire)(requireFromCwd.resolve('prisma/package.json'));
-    const { loadConfigFromFile } = requireFromPrisma('@prisma/config');
+    const version = requireFromPrisma('./package.json').version;
     const previousUrl = process.env.DATABASE_URL;
     if (databaseUrlOverride !== undefined) {
         process.env.DATABASE_URL = databaseUrlOverride;
     }
-    let loaded;
     try {
-        loaded = await loadConfigFromFile({ configRoot });
+        return version.startsWith('8.')
+            ? await loadPrisma8Defaults(configRoot, requireFromPrisma)
+            : await loadPrisma7Defaults(configRoot, requireFromPrisma, requireFromCwd);
     }
     finally {
         if (databaseUrlOverride !== undefined) {
@@ -27,6 +30,10 @@ async function loadPrismaDefaults(configRoot, requireFromCwd, databaseUrlOverrid
                 process.env.DATABASE_URL = previousUrl;
         }
     }
+}
+async function loadPrisma7Defaults(configRoot, requireFromPrisma, requireFromCwd) {
+    const { loadConfigFromFile } = requireFromPrisma('@prisma/config');
+    const loaded = await loadConfigFromFile({ configRoot });
     if (!loaded.resolvedPath || !loaded.config || loaded.error) {
         throw new Error('Prisma config could not be loaded');
     }
@@ -40,6 +47,20 @@ async function loadPrismaDefaults(configRoot, requireFromCwd, databaseUrlOverrid
         }).preserveTables ?? [],
     };
 }
+async function loadPrisma8Defaults(configRoot, requireFromPrisma) {
+    const { loadConfigForSections } = (await import((0, node_url_1.pathToFileURL)(requireFromPrisma.resolve('@prisma/orm-toolchain/config-loader')).href));
+    const loaded = await loadConfigForSections(node_path_1.default.join(configRoot, 'prisma.config.ts'), ['contract', 'db']);
+    const config = loaded.ok ? loaded.value : undefined;
+    const output = config?.contract?.output;
+    if (!output || config?.extensions?.length) {
+        throw new Error('Prisma 8 config requires an emitted contract and a supported runtime');
+    }
+    return {
+        module: output,
+        databaseUrl: config?.db?.connection,
+        preserveTables: (0, prisma8_client_1.contractPreservedTables)(JSON.parse(node_fs_1.default.readFileSync(output, 'utf8'))),
+    };
+}
 function defaultSchema(root) {
     for (const name of ['prisma/schema.prisma', 'schema.prisma']) {
         const file = node_path_1.default.join(root, name);

package/dist/prisma8-client.d.ts

@@ -0,0 +1,21 @@
+type Data = Record<string, unknown>;
+export declare const prisma8PreservedTables: WeakMap<object, string[]>;
+export declare function contractPreservedTables(value: unknown): string[];
+/** Bridge a native Prisma 8 PostgreSQL client to the fixture API. Requires PostgreSQL 17+. */
+export declare function createPrisma8FixtureClient(client: object): Record<string, {
+    create(args: {
+        data: Data;
+    }): Promise<unknown>;
+    update(args: {
+        where: Data;
+        data: Data;
+    }): Promise<unknown>;
+}> & {
+    $executeRawUnsafe(sql: string): Promise<unknown>;
+} & {
+    $disconnect: () => Promise<void>;
+    $transaction<T>(action: (tx: object) => Promise<T>, { timeout }?: {
+        timeout?: number | undefined;
+    }): Promise<T>;
+};
+export {};

package/dist/prisma8-client.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prisma8PreservedTables = void 0;
+exports.contractPreservedTables = contractPreservedTables;
+exports.createPrisma8FixtureClient = createPrisma8FixtureClient;
+const fixture_document_1 = require("./fixture-document");
+const cleanup_options_1 = require("./cleanup-options");
+// Internal cleanup metadata follows the adapted client and each transaction.
+exports.prisma8PreservedTables = new WeakMap();
+function contractPreservedTables(value) {
+    const contract = value;
+    const names = [];
+    for (const [namespace, entry] of Object.entries(contract.storage?.namespaces ?? {})) {
+        for (const [table, metadata] of Object.entries(entry.entries?.table ?? {})) {
+            if (metadata.control !== undefined && metadata.control !== 'managed')
+                names.push(`${namespace}.${table}`);
+        }
+    }
+    return (0, cleanup_options_1.normalizeCleanupOptions)({ preserveTables: names }).preserveTables ?? [];
+}
+/** Bridge a native Prisma 8 PostgreSQL client to the fixture API. Requires PostgreSQL 17+. */
+function createPrisma8FixtureClient(client) {
+    const db = client;
+    if (!db ||
+        !(0, fixture_document_1.isFixtureRecord)(db.contract?.domain?.namespaces) ||
+        !(0, fixture_document_1.isFixtureRecord)(db.orm) ||
+        typeof db.transaction !== 'function' ||
+        typeof db.close !== 'function' ||
+        typeof db.runtime !== 'function' ||
+        typeof db.raw?.sql !== 'function') {
+        throw new Error('Expected a Prisma 8 PostgreSQL client');
+    }
+    const namespaces = db.contract.domain.namespaces;
+    const preserveTables = contractPreservedTables(db.contract);
+    const aliases = new Map();
+    for (const [namespace, entry] of Object.entries(namespaces)) {
+        for (const name of Object.keys(entry.models)) {
+            for (const alias of new Set([
+                `${namespace}.${name}`,
+                name,
+                name[0].toLowerCase() + name.slice(1),
+            ])) {
+                aliases.set(alias, aliases.has(alias) ? null : { namespace, name });
+            }
+        }
+    }
+    const plan = (sql) => db.raw
+        .sql(Object.assign([sql], { raw: [sql] }))
+        .affectedCount()
+        .build();
+    function scalarValue(model, field, value) {
+        const metadata = model.fields?.[field];
+        const codecId = metadata?.type.codecId;
+        if (metadata?.type.kind !== 'scalar' ||
+            !codecId ||
+            !/^pg\/(?:int8|unboundedint|int8number|numeric|bytea|interval|(?:date|timestamp|timestamptz|time)-temporal|timestamptz-date)@1$/.test(codecId))
+            return value;
+        const decode = (item) => {
+            // Native objects returned by processors/references already have the runtime type.
+            if (typeof item !== 'string' && typeof item !== 'number')
+                return item;
+            if (typeof item === 'number') {
+                if (codecId === 'pg/int8number@1')
+                    return item;
+                if (!/^pg\/(?:int8|unboundedint|numeric)@1$/.test(codecId))
+                    return item;
+                if (!Number.isFinite(item) ||
+                    (codecId !== 'pg/numeric@1' && !Number.isSafeInteger(item)))
+                    throw new Error('Invalid numeric fixture value');
+                item = String(item);
+            }
+            const storage = model.storage;
+            const column = storage?.fields[field]?.column;
+            const codec = storage && column
+                ? db.context.contractCodecs.forColumn(storage.namespaceId, storage.table, column)
+                : undefined;
+            if (!codec)
+                throw new Error('Prisma 8 fixture column codec not found');
+            return codec.decodeJson(item);
+        };
+        return metadata.many && Array.isArray(value)
+            ? value.map(decode)
+            : decode(value);
+    }
+    function relationData(data, model) {
+        return Object.fromEntries(Object.entries(data).map(([field, value]) => {
+            const relation = model.relations[field];
+            if (!relation)
+                return [field, scalarValue(model, field, value)];
+            if (!(0, fixture_document_1.isFixtureRecord)(value) ||
+                Object.keys(value).length !== 1 ||
+                (!Object.hasOwn(value, 'connect') && !Object.hasOwn(value, 'create'))) {
+                throw new Error('Prisma 8 fixture relations require connect or create');
+            }
+            const target = namespaces[relation.to.namespace].models[relation.to.model];
+            const operation = Object.hasOwn(value, 'connect') ? 'connect' : 'create';
+            const map = (item) => {
+                if (!(0, fixture_document_1.isFixtureRecord)(item))
+                    throw new Error('Invalid fixture relation data');
+                return relationData(item, target);
+            };
+            const input = value[operation];
+            const mapped = Array.isArray(input) ? input.map(map) : map(input);
+            return [
+                field,
+                (mutator) => mutator[operation](mapped),
+            ];
+        }));
+    }
+    function adapt(orm, runtime, check = () => { }) {
+        const delegates = Object.create(null);
+        const byModel = new Map();
+        for (const [alias, model] of aliases) {
+            if (!model)
+                continue;
+            const { namespace, name } = model;
+            const qualified = `${namespace}.${name}`;
+            let delegate = byModel.get(qualified);
+            if (!delegate) {
+                const metadata = namespaces[namespace].models[name];
+                delegate = {
+                    async create({ data }) {
+                        check();
+                        return orm[namespace][name].create(relationData(data, metadata));
+                    },
+                    async update({ where, data }) {
+                        check();
+                        return orm[namespace][name]
+                            .where(relationData(where, metadata))
+                            .update(relationData(data, metadata));
+                    },
+                };
+                byModel.set(qualified, delegate);
+            }
+            delegates[alias] = delegate;
+        }
+        const adapted = Object.assign(delegates, {
+            async $executeRawUnsafe(sql) {
+                check();
+                return runtime.execute(plan(sql));
+            },
+        });
+        exports.prisma8PreservedTables.set(adapted, preserveTables);
+        return adapted;
+    }
+    return Object.assign(adapt(db.orm, db.runtime()), {
+        $disconnect: () => db.close(),
+        async $transaction(action, { timeout = 60_000 } = {}) {
+            if (!Number.isSafeInteger(timeout) ||
+                timeout <= 0 ||
+                timeout > 2_147_483_647)
+                throw new Error('Invalid transaction timeout');
+            return db.transaction(async (tx) => {
+                // PostgreSQL rejects this setting before any fixtures on versions older than 17.
+                // The database deadline also cancels in-flight queries and rolls back idle callbacks.
+                await tx.execute(plan(`SET LOCAL transaction_timeout = '${timeout}ms'`));
+                const deadline = Date.now() + timeout;
+                let closed = false;
+                let timer;
+                const check = () => {
+                    if (closed || Date.now() >= deadline)
+                        throw new Error('Fixture transaction closed or timed out');
+                };
+                try {
+                    const result = await Promise.race([
+                        Promise.resolve().then(() => action(adapt(tx.orm, tx, check))),
+                        new Promise((_, reject) => {
+                            timer = setTimeout(() => {
+                                closed = true;
+                                reject(new Error('Fixture transaction timed out'));
+                            }, timeout);
+                        }),
+                    ]);
+                    check();
+                    return result;
+                }
+                finally {
+                    closed = true;
+                    clearTimeout(timer);
+                }
+            });
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skmdev/prisma-fixtures",
-  "version": "0.1.1",
+  "version": "1.0.0-rc.1",
   "description": "YAML and JSON fixtures with references, templates and processors for Prisma.",
   "license": "MIT",
   "author": "skmdev <skmdev29@gmail.com>",
@@ -66,10 +66,12 @@
   "devDependencies": {
     "@prisma/adapter-pg": "7.10.0",
     "@prisma/client": "7.10.0",
+    "@prisma/orm-postgres": "8.0.0-rc.12",
+    "@prisma/prisma7": "7.10.0",
     "@types/ejs": "3.1.5",
     "@types/node": "22.19.15",
     "prettier": "3.8.3",
-    "prisma": "7.10.0",
+    "prisma": "8.0.0-rc.17",
     "typescript": "5.9.3"
   },
   "overrides": {

package/schema/fixture.schema.json

@@ -58,9 +58,9 @@
   },
   "definitions": {
     "entityName": {
-      "description": "Prisma model/delegate name.",
+      "description": "Prisma model/delegate name, optionally namespace-qualified for v8.",
       "type": "string",
-      "pattern": "^[A-Za-z][A-Za-z0-9_-]{0,127}$"
+      "pattern": "^(?:[A-Za-z][A-Za-z0-9_-]{0,127}\\.)?[A-Za-z][A-Za-z0-9_-]{0,127}$"
     },
     "fieldName": {
       "description": "Prisma relation field name.",