@aventara/prisma7-adapter 0.1.0-pilot.1 → 0.1.0-pilot.2

package/dist/prisma.adapter.js

@@ -1,17 +1,8 @@
 import { loadDiscoveryArtifact } from "./discovery/artifact.loader.js";
+import { assertClientMatchesArtifact } from "./discovery/client-shape.verifier.js";
 import { createPrismaOperationExecutor } from "./execution/operation.executor.js";
 import { createPrismaTransactionExecutor } from "./execution/transaction.executor.js";
 import { resolveProviderProfile, } from "./provider/provider-profile.js";
-/**
- * Each Prisma referential action as core's word for it (F-806). Keyed by the
- * closed {@link PrismaReferentialAction} union with `satisfies`, so a sixth
- * Prisma action is a compile error here rather than an edge core never follows,
- * and valued by core's own union, so a word core does not have is one too. The
- * mapping is one to one (the architect's five words, 2026-10-04): `no-action`
- * stays `noAction` although, measured on both engines (Phase 9 S0, U4), it is not
- * `DEFERRABLE` and answers one delete exactly as `restrict` does; `set-default`
- * stays `setDefault` although, like `setNull`, it keeps the rows.
- */
 const DELETE_EFFECTS = {
     cascade: "cascade",
     restrict: "restrict",
@@ -19,14 +10,6 @@ const DELETE_EFFECTS = {
     "set-null": "setNull",
     "set-default": "setDefault",
 };
-/**
- * The artifact's referential actions, translated into core's vocabulary.
- *
- * The direction is carried over unchanged, because it is the same sentence on
- * both sides of the seam: an edge listed under Resource `R` says **deleting a
- * `target` row does `onDelete` to rows of `R`**. Only owning edges exist in the
- * artifact, and `onUpdate` is not carried: core plans the delete closure only.
- */
 function translateReferentialActions(table) {
     return Object.fromEntries(Object.entries(table).map(([resource, { owningEdges }]) => [
         resource,
@@ -37,44 +20,19 @@ function translateReferentialActions(table) {
         })),
     ]));
 }
-/**
- * Construction is `async` because core's `Adapter.model` is a settled fact read
- * synchronously at framework construction, while *verifying* the artifact is
- * asynchronous: `computeModelHash` digests through `globalThis.crypto.subtle`,
- * which is a promise-returning API. The artifact itself is already a value in
- * hand (`options.discovery`); only its verification has to
- * await, so it happens here, once, before an adapter exists — every fence is
- * the same fence, moved from the first `discover()` call to construction.
- */
 export async function createPrismaAdapter(options) {
     const profile = resolveProviderProfile({
         provider: options.provider,
         driver: options.driver,
     });
-    // The loader is a *verifier*, and its return is deliberately discarded. It
-    // takes `unknown` because it guards the runtime boundary, so its answer is
-    // the general `PrismaAdapterModel`; the literal `M` is already in hand on
-    // `options.discovery.model`, which is the very object the loader would have
-    // handed back. Reading it from the argument keeps the literal without a
-    // cast, and keeps the loader honest about validating untrusted input.
     await loadDiscoveryArtifact({
         artifact: options.discovery,
         installedPrismaVersion: options.installedPrismaVersion ?? options.discovery.prismaVersion,
     });
+    assertClientMatchesArtifact(options.discovery.client, options.client);
     const model = options.discovery.model;
-    // Read once, like the model: a settled fact of the constructed adapter.
     const referentialActions = translateReferentialActions(options.discovery.referentialActions);
-    // Task 10: `execute` is real. The executor is built once, at construction, and
-    // closes over the client, the discovered model and the generate-time
-    // translation table — the three facts every call needs and none of which can
-    // change afterwards.
-    //
-    // `translation` is widened by one deliberate cast. `PrismaTranslationTable<M>`
-    // is a mapped type over `M`'s own resource keys, which is exactly what makes a
-    // missing Resource a compile error at the generate step; a mapped type over a
-    // literal union carries no index signature, so the executor — which looks a
-    // Resource up by a name core validated — takes the widened view. The narrow
-    // type has already done its work by the time this line runs.
+    const createRequirements = options.discovery.createRequirements;
     const { execute } = createPrismaOperationExecutor({
         client: options.client,
         model: options.discovery.model,
@@ -84,14 +42,8 @@ export async function createPrismaAdapter(options) {
             ? {}
             : { transactionOptions: options.transactionOptions }),
     });
-    // DA-12: `transaction` is mounted exactly when the declared driver supports
-    // an interactive one. For `@prisma/adapter-d1` the profile says `"none"`
-    // [PKG], so core never calls it and the `_transactions` route is never
-    // mounted. The declaration is Task 10's (D-805) and the body is Task 11's:
-    // one interactive transaction per plan, with the transaction-scoped executor
-    // as the only thing the callback hands core (C-803, C-804).
     if (profile.transactions === "none") {
-        return { model, referentialActions, execute };
+        return { model, referentialActions, createRequirements, execute };
     }
     const transaction = createPrismaTransactionExecutor({
         client: options.client,
@@ -101,5 +53,11 @@ export async function createPrismaAdapter(options) {
             ? {}
             : { transactionOptions: options.transactionOptions }),
     });
-    return { model, referentialActions, execute, transaction };
+    return {
+        model,
+        referentialActions,
+        createRequirements,
+        execute,
+        transaction,
+    };
 }

package/dist/provider/provider-profile.d.ts

@@ -1,38 +1,21 @@
 import type { TransactionCapability } from "@aventara/core";
 /**
- * T-2 / D-824 — the one closed table of provider and driver facts, carrying
- * **only** the facts no reader can supply.
+ * A stored copy of either class would be a second source of truth, which is
+ * dictionary invariant 6.
  *
- * What is deliberately absent: `supportsScalarLists`, `supportsOrderNulls`,
- * `supportsCreateManyAndReturn` and `supportsUpdateManyAndReturn` are
- * *discovered* from the generated client's own types at generate time and
- * recorded in `PrismaDiscoveryArtifact` (T-3, T-3.2); `supportsEmulatedFirst
- * Variants` is *derived* — it is exactly `transactions !== "none"` — and is
- * computed where the §8.3 gate lives. A stored copy of either class would be a
- * second source of truth, which is dictionary invariant 6.
- *
- * Nothing here is inferred at runtime, because nothing here is derived at
- * runtime at all.
- */
-/**
- * The two engines Phase 8 runs — a value, so the bin's `--provider` check and
- * the manifest's declaration drift guard (`declaration-drift.gate.spec.ts`)
- * read the same list the type is derived from.
+ * Nothing here is inferred at runtime, because nothing here is derived at runtime
+ * at all.
  */
 export declare const PRISMA_PROVIDERS: readonly ["sqlite", "postgresql"];
 export type PrismaProvider = (typeof PRISMA_PROVIDERS)[number];
 /**
- * The closed driver set. Neon-HTTP and PlanetScale-HTTP are **absent**, not
- * `false`: their interactive-transaction support is genuinely UNVERIFIED for
- * Prisma 7 (C-825 — no adapter package is installed, neither driver is in
- * Phase 8's engine split, and all three v7 driver-adapter documentation pages
- * returned HTTP 404), and an entry with no evidence is a guess.
+ * The closed driver set.
  */
 export declare const PRISMA_DRIVERS: readonly ["@prisma/adapter-better-sqlite3", "@prisma/adapter-pg", "@prisma/adapter-d1"];
 export type PrismaDriver = (typeof PRISMA_DRIVERS)[number];
 /** The five levels `Prisma.IsolationLevel` admits **[PKG, `runtime/client.d.ts`]**. */
 export type PrismaIsolationLevel = "ReadUncommitted" | "ReadCommitted" | "RepeatableRead" | "Snapshot" | "Serializable";
-/** The caller's explicit declaration; never sniffed from client internals (D-804). */
+/** The caller's explicit declaration; never sniffed from client internals. */
 export type PrismaProviderDeclaration = {
     readonly provider: PrismaProvider;
     readonly driver: PrismaDriver;

package/dist/provider/provider-profile.js

@@ -1,74 +1,14 @@
-/**
- * T-2 / D-824 — the one closed table of provider and driver facts, carrying
- * **only** the facts no reader can supply.
- *
- * What is deliberately absent: `supportsScalarLists`, `supportsOrderNulls`,
- * `supportsCreateManyAndReturn` and `supportsUpdateManyAndReturn` are
- * *discovered* from the generated client's own types at generate time and
- * recorded in `PrismaDiscoveryArtifact` (T-3, T-3.2); `supportsEmulatedFirst
- * Variants` is *derived* — it is exactly `transactions !== "none"` — and is
- * computed where the §8.3 gate lives. A stored copy of either class would be a
- * second source of truth, which is dictionary invariant 6.
- *
- * Nothing here is inferred at runtime, because nothing here is derived at
- * runtime at all.
- */
-/**
- * The two engines Phase 8 runs — a value, so the bin's `--provider` check and
- * the manifest's declaration drift guard (`declaration-drift.gate.spec.ts`)
- * read the same list the type is derived from.
- */
 export const PRISMA_PROVIDERS = ["sqlite", "postgresql"];
-/**
- * The closed driver set. Neon-HTTP and PlanetScale-HTTP are **absent**, not
- * `false`: their interactive-transaction support is genuinely UNVERIFIED for
- * Prisma 7 (C-825 — no adapter package is installed, neither driver is in
- * Phase 8's engine split, and all three v7 driver-adapter documentation pages
- * returned HTTP 404), and an entry with no evidence is a guess.
- */
 export const PRISMA_DRIVERS = [
     "@prisma/adapter-better-sqlite3",
     "@prisma/adapter-pg",
     "@prisma/adapter-d1",
 ];
-/**
- * `transactions` is a **DRIVER** fact, and each row carries its evidence.
- *
- * - `@prisma/adapter-d1` → `"none"` **[PKG]**: `runtime/client.js` of
- *   `@prisma/client` 7.10.0 branches on
- *   `this._engineConfig.adapter?.adapterName === "@prisma/adapter-d1"` and
- *   throws `"Cloudflare D1 does not support interactive transactions. …"`.
- *   Read from the installed package on 2026-09-23 (C-824, F-703).
- * - `@prisma/adapter-better-sqlite3` and `@prisma/adapter-pg` →
- *   `"interactive"` **[RUN8]**: observed, not assumed. D-805 conditions this
- *   value on an interactive transaction having been *proved to run* on each
- *   driver, and `src/provider/interactive-transaction.spec.ts` runs one — a
- *   write and a read issued through the callback's `tx`, with the write
- *   visible afterwards — on both. Produced by
- *   `AVENTARA_TEST_POSTGRES_URL=postgresql://aventara:aventara_dev@127.0.0.1:5432/aventara
- *    npx vitest run --config ../../vitest.config.mts --root .
- *    src/provider/interactive-transaction.spec.ts --reporter=verbose`
- *   from `packages/prisma7-adapter`, which is what the relative `--config` path
- *   and `--root .` are relative to. Run on 2026-09-23 against `@prisma/client`
- *   7.10.0, Node v24.20.0, SQLite through better-sqlite3 12.11.1 and
- *   PostgreSQL 18.6: 4 passed, and 2 of those 4 skip when the URL is absent, so
- *   the PostgreSQL half is not a silent pass. Re-run as written on 2026-10-02
- *   after the config's `.mts` rename (`aba66a2`): 4 passed, and 2 passed with
- *   2 skipped without the URL.
- */
 const DRIVER_TRANSACTIONS = {
     "@prisma/adapter-better-sqlite3": "interactive",
     "@prisma/adapter-pg": "interactive",
     "@prisma/adapter-d1": "none",
 };
-/**
- * `isolationLevels` is a **PROVIDER** fact **[DOC7]**, fetched 2026-09-23 from
- * the version-pinned `prisma.io/docs/orm/v7/…/queries/transactions` page:
- * PostgreSQL supports ReadUncommitted, ReadCommitted, RepeatableRead and
- * Serializable; SQLite supports Serializable only. `Snapshot` is a SQL Server
- * level and belongs to neither Phase 8 engine, so it appears in the level
- * union (it is one of the five Prisma admits) and in no row.
- */
 const PROVIDER_ISOLATION_LEVELS = {
     sqlite: ["Serializable"],
     postgresql: [
@@ -78,10 +18,6 @@ const PROVIDER_ISOLATION_LEVELS = {
         "Serializable",
     ],
 };
-/**
- * Resolves the profile for a declaration. Pure, total over the closed sets,
- * and the only place provider truth is read.
- */
 export function resolveProviderProfile(declaration) {
     return {
         provider: declaration.provider,

package/dist/translation/identifier.addressing.d.ts

@@ -7,17 +7,13 @@ import type { PrismaIdentifierAddress } from "../discovery/discovery-artifact.in
  *
  * The rule is three facts, every one of them measured at 7.10.0 and recorded in
  * {@link PrismaIdentifierAddress}: the generate-time `key` is matched and never
- * re-derived (`members.join("_")` is wrong for every `name:`-renamed criterion),
- * a key wraps its members iff `members.length > 1`, and the identifier chosen is
- * the first recorded criterion the caller's values complete.
+ * re-derived (`members.join("_")` is wrong for every `name:`-renamed criterion), a
+ * key wraps its members iff `members.length > 1`, and the identifier chosen is the
+ * first recorded criterion the caller's values complete.
  *
- * Task 9 flagged that the rule had landed twice — `addressCursor` in
- * `order-pagination.translator.ts` and `addressUnique` in
- * `mutation.translator.ts` — and Task 10 needed it a third time, for the
- * top-level where-unique of `find.unique`, `update.unique`, `delete.unique` and
- * `upsert.unique`. Three copies of a measured rule is three places a later
- * maintainer can fix two of, so the rule moved here and the three call sites
- * became three *configurations* of it.
+ * Three copies of a measured rule is three places a later maintainer can fix two
+ * of, so the rule moved here and the three call sites became three
+ * *configurations* of it.
  *
  * # What the call sites still own, and why that is not a leak
  *
@@ -26,23 +22,20 @@ import type { PrismaIdentifierAddress } from "../discovery/discovery-artifact.in
  * - **How complete the values must be.** A unique selector is `"exact"`: core's
  *   selector carries one identifier and nothing else, so a selector with a spare
  *   key is not that identifier. A cursor is `"subset"`: `validateCursor` requires
- *   the cursor's keys to equal the *active ordered scalar fields*, which include
- *   a complete identifier **plus** every other ordered key, so the identifier is
- *   a proper subset of what arrives.
- * - **How a member's value is emitted.** `mutation.translator.ts` runs each
- *   member through C-834's outbound scalar conversion (a core `Decimal` must
- *   leave as a base-10 string); a cursor's values are already Prisma-shaped.
- *   Passing the conversion in as `emit` keeps the scalar table in the module that
+ *   the cursor's keys to equal the *active ordered scalar fields*, which include a
+ *   complete identifier **plus** every other ordered key, so the identifier is a
+ *   proper subset of what arrives.
+ * - Passing the conversion in as `emit` keeps the scalar table in the module that
  *   owns it rather than importing it here.
  *
  * # No spec file of its own, deliberately
  *
  * Every branch is exercised through its three callers' specs —
- * `order-pagination.translator.spec.ts` (subset, compound wrapping, the
- * "addresses no row" refusal), `mutation.translator.spec.ts` (exact, renamed
- * keys, Decimal members) and `operation.translator.spec.ts` (exact, at the top
- * level). A fourth spec restating them would test this module's three lines
- * twice and the measured facts not at all.
+ * `order-pagination.translator.spec.ts` (subset, compound wrapping, the "addresses
+ * no row" refusal), `mutation.translator.spec.ts` (exact, renamed keys, Decimal
+ * members) and `operation.translator.spec.ts` (exact, at the top level). A fourth
+ * spec restating them would test this module's three lines twice and the measured
+ * facts not at all.
  */
 /**
  * How completely the supplied values must cover a criterion.

package/dist/translation/identifier.addressing.js

@@ -1,10 +1,3 @@
-/**
- * Addresses one row by the first recorded criterion the values complete.
- *
- * @returns the addressing, or `undefined` when no criterion is complete — which
- * is a caller-specific refusal (each call site raises its own error type with
- * its own path), never a silently unaddressed write.
- */
 export function addressIdentifier(input) {
     const keyCount = Object.keys(input.values).length;
     for (const address of input.addresses) {
@@ -16,9 +9,6 @@ export function addressIdentifier(input) {
         }
         const members = address.members.map((member) => [member, input.emit(member, input.values[member])]);
         const [single] = members;
-        // A single-column criterion does NOT wrap, and a compound one does. The
-        // difference is `members.length`, read off the recorded criterion rather
-        // than guessed from the shape of the value.
         return {
             address,
             where: members.length === 1 && single !== undefined

package/dist/translation/mutation.translator.d.ts

@@ -1,58 +1,40 @@
 import { type AdapterModel, type OperationIdentity } from "@aventara/core";
 import type { PrismaIdentifierAddress } from "../discovery/discovery-artifact.interface.js";
 /**
- * T-7's mutation half — one validated Aventara `data` in, one Prisma write
- * argument out.
- *
  * # Pure, and the tables are the module
  *
- * No client, no database, no provider name. Three tables carry everything this
- * module knows, each one TOTAL over a core union by `satisfies`, so a member
- * added to core with no row here is a compile error rather than a silently
- * dropped argument (C-855's emission half, C-837's translator table — the one
- * `vocabulary.dictionary.ts` explicitly left to this task):
+ * No client, no database, no provider name.
  *
  * - {@link SCALAR_DIRECTIVE_TOKENS} over `ScalarMutationDirective`;
  * - {@link RELATION_DIRECTIVE_EMISSIONS} over `RelationMutationDirective`;
- * - {@link MUTATION_DATA_SITES} over every standard operation key, which is
- *   C-818's enforcement point.
  *
- * C-834's own table is NOT one of them any more: the scalar value conversion was
- * born here, and `where.translator.ts` and `execution/result.shaper.ts` need the
- * same answers, so it moved to `scalar.conversion.ts` and all three read it
- * (Task 10's `identifier.addressing.ts` is the precedent). This module's
- * emission site is {@link emitValue}, which is now a call rather than a copy.
+ * This module's emission site is {@link emitValue}, which is now a call rather
+ * than a copy.
  *
- * Phase 7's `RELATION_MUTATION_RECORD_SITES` is the pattern
- * (`packages/core/src/runtime/mutation-planner.ts`): `as const satisfies
- * Readonly<Record<Union, …>>` keeps every cell a literal while making the union
- * coverage a compile-time obligation. Two of core's passes are already keyed
- * that way; this is the third, and the only one that names Prisma.
+ * Two of core's passes are already keyed that way; this is the third, and the only
+ * one that names Prisma.
  *
  * # Refusing is part of honouring (the `where.translator.ts` stance)
  *
- * The adapter assumes validated input (C-845). It still refuses to EMIT a
- * directive the discovered model does not advertise for that field and stage,
- * and refuses one for which Prisma's nested input at that stage and cardinality
- * has no key at all. Both refusals are C-855 seen from the emission side: an
- * argument is honoured or it is not sent. A directive quietly dropped here would
- * surface as a write that silently did less than it was asked to.
- *
- * # C-818 cannot reach the Contract, so it is enforced here
+ * The adapter assumes validated input. It still refuses to EMIT a directive the
+ * discovered model does not advertise for that field and stage, and refuses one
+ * for which Prisma's nested input at that stage and cardinality has no key at all.
+ * A directive quietly dropped here would surface as a write that silently did less
+ * than it was asked to.
  *
  * `RelationFieldCapabilities` is one record per field with a single `create`
- * member **[CORE, adapters/adapter-field.ts]**, so "relation create directives
- * for `create.one` and none for `create.many`" is unrepresentable in the model;
+ * member **[CORE, adapters/adapter-field.ts]**, so "relation create directives for
+ * `create.one` and none for `create.many`" is unrepresentable in the model;
  * `model.discoverer.ts` composes the permissive `create.one` answer and says so.
  * The restriction therefore lives in {@link MUTATION_DATA_SITES}, which is keyed
  * by the operation the data belongs to. Measured at 7.10.0 on both engines
  * (2026-10-02), a nested relation key in a bulk write is a hard failure, not a
  * no-op:
  *
- * - `post.createMany({ data: [{ title, author: { connect: … } }] })` →
- *   *"Argument `authorId` is missing."*
- * - `post.updateMany({ where, data: { category: { connect: … } } })` →
- *   *"Unknown argument `category`. Available options are marked with ?."*
+ * - `post.createMany({ data: [{ title, author: { connect: … } }] })` → *"Argument
+ *   `authorId` is missing."*
+ * - `post.updateMany({ where, data: { category: { connect: … } } })` → *"Unknown
+ *   argument `category`. Available options are marked with ?."*
  *
  * # Nothing in the caller's arguments is touched
  *
@@ -73,11 +55,6 @@ export declare class PrismaMutationTranslationError extends Error {
 export type PrismaMutationData = Readonly<Record<string, unknown>>;
 /** The two write stages core distinguishes. */
 export type PrismaWriteStage = "create" | "update";
-/**
- * Task 7's `where` translator, injected rather than imported so this module
- * stays a pure function of its inputs and the filter grammar keeps one owner
- * (the same shape `projection.translator.ts` uses for the same reason).
- */
 export type PrismaNestedWhereTranslator = (resource: string, where: unknown, path: string) => Readonly<Record<string, unknown>>;
 export type PrismaMutationDependencies = {
     readonly translateWhere: PrismaNestedWhereTranslator;
@@ -97,7 +74,6 @@ export type MutationTranslation = {
     readonly model: AdapterModel;
     /** The Aventara Resource key the data is written against. */
     readonly resource: string;
-    /** The operation whose argument this data becomes; it decides C-818 admission. */
     readonly operation: OperationIdentity;
     /** Which of that operation's write stages this data is (`upsert.unique` has two). */
     readonly stage: PrismaWriteStage;
@@ -105,11 +81,11 @@ export type MutationTranslation = {
     readonly data: unknown;
 };
 /**
- * Translates one validated Aventara mutation `data` into the Prisma write
- * argument for the named operation and stage.
+ * Translates one validated Aventara mutation `data` into the Prisma write argument
+ * for the named operation and stage.
  *
  * @throws {PrismaMutationTranslationError} rather than emitting a directive the
  * model does not advertise, one Prisma has no key for at this stage and
- * cardinality, or a nested relation write inside a bulk argument (C-818).
+ * cardinality, or a nested relation write inside a bulk argument.
  */
 export declare function translateMutationData(input: MutationTranslation, dependencies: PrismaMutationDependencies): PrismaMutationData;