@aventara/prisma7-adapter 0.1.0-pilot.4 → 1.0.0-rc.0

package/CHANGELOG.md

@@ -0,0 +1,190 @@
+# @aventara/prisma7-adapter
+
+## 1.0.0-rc.0
+
+### Major Changes
+
+- First release candidate of Aventara 1.0. The public API is now considered stable; changes before 1.0.0 are possible
+  based on feedback.
+
+### Minor Changes
+
+- 24ffbab: A nested `$update` or `$delete` through a to-many relation filters plain fields only on Prisma 7, and Aventara now says
+  so up front: a relation filter in its `where` — `{ posts: { $update: { where: { category: { name: "x" } }, … } } }`, at
+  any depth, under `AND`/`OR`/`NOT` too — is refused with `A2004` / `V1006` before the database is asked, and is a type
+  error in `framework.application`, `framework.client`, `appTx`/`clientTx` and the generated client. Before, it reached
+  Prisma and fail as `A3001`. A to-one relation's nested filter keeps relation filters. The limit is stated by the adapter
+  in the Contract (`nestedWriteFilter: "scalar"`), so the ClientContract hash changes: regenerate the client.
+
+### Patch Changes
+
+- 24ffbab: Each package ships its `CHANGELOG.md`, so the release notes are in the installed package beside the README.
+- a973e89: A write that sets an optional relation both ways — its reference field and the relation itself, such as `categoryId`
+  and `category: { $connect: … }` in the same record — is now refused before it reaches the database, exactly like a
+  required relation: `A2004` with a `V1012` issue at the relation, message `Set "categoryId" or "category", not both.`
+  Before, the database refused it and the caller received `A3001`. It applies to `create`, `update` and `upsert`, to
+  nested writes at any depth, and to each step of a transaction.
+
+  The discovery artifact now records, for each relation, the fields that hold its reference (`references` on each edge
+  of `referentialActions`), and a create requirement no longer repeats them. Regenerate your artifact with
+  `npm run aventara:prepare` (or `aventara-prisma7-generate`); an artifact from an earlier version is refused with a
+  message that says so. An adapter's `referentialActions` edges carry the same `references` member.
+
+- a973e89: With the Prisma adapter, a record that writes one relation through its reference field and another relation directly —
+  such as `authorId` beside `category: { $connect: … }` — is now refused before it reaches the database: `A2004` with a
+  `V1012` issue at the relation write, message
+  `Use relation fields only, or reference fields only, in one record: "authorId" is a reference field and "category" is a relation.`
+  Before, Prisma refused it and the caller received `A3001`. Write the record's relations all as relations
+  (`author: { $connect: … }, category: { $connect: … }`) or all through their fields (`authorId`, `categoryId`). A
+  reference field beside a relation that holds no reference on that side — `mentorId` beside `posts: { $create: … }` on
+  an author — is unchanged and still accepted. It applies to `create`, `update` and `upsert`, to nested writes at any
+  depth, and to each step of a transaction.
+
+  The limit is part of the Contract: a Contract whose data source has it carries `referenceWrites: "uniform"`, so the
+  Contract hash of every Prisma-backed application changes. Regenerate your discovery artifact
+  (`npm run aventara:prepare`) and your generated client (`avclient generate`). An adapter states the limit with
+  `referenceWrites: "uniform"` in its model; without it, nothing changes.
+
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [a973e89]
+- Updated dependencies [1e65e9a]
+- Updated dependencies
+- Updated dependencies [a973e89]
+- Updated dependencies [a973e89]
+- Updated dependencies [1e65e9a]
+- Updated dependencies [1e65e9a]
+- Updated dependencies [24ffbab]
+- Updated dependencies [2d00ad7]
+- Updated dependencies [384a50c]
+- Updated dependencies [d43d1cc]
+- Updated dependencies [3f98749]
+- Updated dependencies [032f792]
+- Updated dependencies [dbe6961]
+  - @aventara/core@1.0.0-rc.0
+
+## 0.1.0-pilot.4
+
+### Patch Changes
+
+- f37dcd6: A discovery artifact written by an older version of the adapter now fails the TypeScript build with an error that
+  says what to do: `Property 'regenerate_with_aventara_prepare' is missing`. Run `npm run aventara:prepare`
+  (or `aventara-prisma7-generate`) to regenerate it. Every newly generated artifact carries the property, and
+  `createPrismaAdapter` refuses an out-of-date artifact at startup with the same instruction.
+- f37dcd6: The documentation shipped with the package — the comments an editor shows on hover, and the README — now describes
+  what each export does, how to use it, what it returns and what it throws. Notes about how the package was built and
+  why are no longer part of what is published.
+
+  The generate step's error messages name "the generated client's types" in words instead of Prisma's emoji labels.
+
+- Updated dependencies [f37dcd6]
+  - @aventara/core@0.1.0-pilot.4
+
+## 0.1.0-pilot.3
+
+### Patch Changes
+
+- The manifest declares the adapter's CLI alias, `aventara.adapter.alias: "prisma7"`: the value `aventara new --orm` and `aventara init --orm` take.
+- @aventara/core@0.1.0-pilot.3
+
+## 0.1.0-pilot.2
+
+### Patch Changes
+
+- e69e88d: The published packages are written for the people who use them. The JavaScript ships without comments; the type
+  declarations keep their documentation, and it, the error messages, the protocol fixtures' labels and the comments in a
+  generated client no longer carry the project's internal development notes.
+- 06ed5d8: A relation write that would leave a child without the parent its required relation demands — `$set: []` or
+  `$disconnect` on a to-many whose children require the parent — now answers `A2008` (the same conflict a violated
+  reference constraint answers) instead of `A3001`. Nothing is written.
+- 23937f8: A create that lacks a value the database requires is refused as `A2004` with a `V1000` issue at the value's path,
+  instead of reaching the database and answering `A3001`. It covers `create.one`, every row of `create.many`, `upsert`'s
+  `create` branch, nested `$create` (and `$connectOrCreate`/`$upsert` creates) at any depth, and transaction steps
+  (`["operations", i, "args", …]`). A required relation is satisfied by writing it or every scalar that holds its
+  reference; a nested create never needs the relation it is created through. Defaults, `@updatedAt`, autoincrement,
+  optional and list columns are never required. The check runs after pipes and computed behaviours, so a value they
+  supply counts.
+
+  An adapter states the requirements through the new optional `Adapter.createRequirements`; the Prisma 7 adapter reads
+  them from the generated client's create inputs at generate time and records them in the discovery artifact, so the
+  artifact must be regenerated (`aventara:prepare`).
+
+- 287fc27: A discovery artifact older than the Prisma client is refused at startup. The artifact now records the client it was
+  generated from (each model and its field references), and `createPrismaAdapter` — which runs before the application
+  listens — compares that record with the client it is given: a model or field added, removed or renamed since the
+  artifact was generated stops the server with one sentence naming the difference and `aventara:prepare`. An artifact
+  generated by an earlier version carries no record and is refused with the same instruction; a project set up by
+  `aventara` regenerates it on install.
+- Updated dependencies [c2a3b7c]
+- Updated dependencies [e69e88d]
+- Updated dependencies [ab58424]
+- Updated dependencies [23937f8]
+  - @aventara/core@0.1.0-pilot.2
+
+## 0.1.0-pilot.1
+
+### Patch Changes
+
+- 799346e: The package READMEs (each package's npm page) are rewritten for the people who use the packages. The Prisma 7
+  adapter's README now states the actual behaviour of a to-many relation or `$count` projected on
+  `update.many`/`create.many`: a validation refusal, `A2004` with `V1008`, before any statement runs (it said `A3001`).
+  Every install or run command names the `@pilot` dist-tag.
+- Updated dependencies [a45f8a8]
+- Updated dependencies [799346e]
+  - @aventara/core@0.1.0-pilot.1
+
+## 0.1.0-pilot.0
+
+### Minor Changes
+
+- First pilot release of `@aventara/prisma7-adapter`, the Prisma 7 adapter. Peers: `@prisma/client`, `prisma` and the
+  driver adapters `^7.10.0`; `typescript` `>=5.5.0 <7` for the generate step. `typescript` and `prisma` are optional
+  peers used only by the generate step, so neither enters a deployed install.
+
+  - **`createPrismaAdapter({ client, discovery, provider, driver, transactionOptions? })`** is the entry point. Your
+    application owns the Prisma client, built with a driver adapter; the adapter never builds one, reads a connection
+    string or reads an environment variable. `provider` and `driver` are stated by you, and the driver decides whether
+    transactions are offered. It is `async` because it verifies the discovery artifact.
+  - **Discovery runs at generate time.** `aventara-prisma7-generate` (or the `@aventara/prisma7-adapter/generate`
+    export) reads `schema.prisma` and the generated client's types and writes one module, the discovery artifact: the
+    model, how each Resource is addressed, its referential actions, a `modelHash` and the Prisma version. At startup the
+    adapter checks that the artifact matches its `modelHash` and that the installed `@prisma/client` major is the one it
+    was generated against, and stops with an instruction to regenerate otherwise. The artifact is rewritten only when its
+    bytes change, and replaced atomically, so a reader never sees a half-written file.
+  - **The Contract says what Prisma serves.** `createMany`/`updateMany` results project fewer relations than a read
+    (the rule is which side holds the foreign key, not cardinality); the Contract advertises that per argument position,
+    and an out-of-position projection or nested write is refused with `A2004` (`V1008` / `V1006`) before any query.
+  - **Cascading deletes.** The schema's referential actions are stated to the Framework, so a transaction step that
+    depends on rows an earlier step's cascading delete removed is refused before the plan runs (`A2004`/`V1019`).
+  - **Conflicts are told apart:** `A2008 CONFLICT` for a uniqueness or reference constraint, `A2013
+CONCURRENT_MODIFICATION` when another operation changed the same state, `A2014 STALE_SELECTION` when the selected
+    record changed before the write.
+  - **Behaviours to know:**
+    - `delete.many` is not offered (Prisma 7 has no `deleteManyAndReturn`); use `delete.count`.
+    - `update.first` and `delete.first` are a read followed by a write narrowed to the record the read selected, and are
+      not atomic: the record written is one the read selected, or nothing is written and you are told (`A2014`). A
+      record that comes to sort first between the two statements is not seen. If firstness at the instant of the write
+      matters, select the record yourself and use `update.unique`/`delete.unique`.
+    - A serialization failure (`P2034`) is never retried automatically: a retry would re-run your pipeline callbacks.
+      Retrying is yours to decide.
+    - Whether transactions are offered depends on the driver and is part of the ClientContract hash, so generate the
+      client against the deployment's own driver.
+    - No raw SQL is ever issued.
+    - PostgreSQL and SQLite are supported.
+  - Every export has a `default` condition, so a CommonJS project can `require()` it. The manifest declares what the
+    adapter supports (providers, drivers, generators), which `@aventara/cli` reads.
+
+### Patch Changes
+
+- Updated dependencies
+  - @aventara/core@0.1.0-pilot.0

package/README.md

@@ -9,7 +9,7 @@ does, what it deliberately does **not** offer, and the two places where a correc
 has a weaker guarantee than its name suggests. Everything a consumer has to know is in the body of
 this file; nothing load-bearing is in a footnote.
 
-- **Status:** pilot. Two engines are proven — PostgreSQL and SQLite. Every other Prisma provider is
+- **Status:** release candidate. Two engines are proven — PostgreSQL and SQLite. Every other Prisma provider is
   unmeasured, and this file says so where it matters.
 - **Peer dependencies:** `@prisma/client` `^7.10.0` (required); `prisma`, `@prisma/adapter-better-sqlite3`
   and `@prisma/adapter-pg` `^7.10.0` and `typescript` `>=5.5.0 <7` (optional). 7.10.0 is the version the
@@ -127,14 +127,15 @@ project's `devDependencies` — if you are generating a Prisma client at all, yo
 The step reads two sources in the same instant — the `schema.prisma` text and the generated client's
 own public types — and cross-checks them against each other. What it emits is a TypeScript module
 exporting one `discovery` value with eight members: the canonical `AdapterModel` (scalars, enums,
-Resources with fields, identifiers and available operations, plus the `transactions` capability), the
+Resources with fields, identifiers and available operations, plus the `transactions` capability and the
+`referenceWrites` limit), the
 Prisma addressing each Resource is reached by, the resolved referential actions per Resource, a record
 of the generated client it was read from (each model and its field references), the create
 requirements per Resource, a `modelHash`, and the `prismaVersion` it was generated against.
 
 The create requirements are what a create cannot do without — a column with no default, or a required
-relation, which may be written instead through the scalar fields that hold its reference — read off the
-question marks of the generated create inputs. The framework checks every create against them after
+relation, which may be written instead through the scalar fields that hold its reference (the edge's
+`references`, below) — read off the question marks of the generated create inputs. The framework checks every create against them after
 your pipes and computed behaviours have run, and answers a missing value as `A2004` with a `V1000`
 issue at its path (`["arguments", "data", "title"]`, or `["arguments", "data", "author"]` for a
 required relation) instead of letting the database refuse it. A nested create does not need the
@@ -477,10 +478,10 @@ discovery.referentialActions;
 // {
 //   Shop:  { owningEdges: [] },
 //   Item:  { owningEdges: [{ field: "shop", target: "Shop",
-//                           cardinality: "one",
+//                           cardinality: "one", references: ["shopId"],
 //                           onDelete: "cascade", onUpdate: "cascade" }] },
 //   Clerk: { owningEdges: [{ field: "shop", target: "Shop",
-//                           cardinality: "one",
+//                           cardinality: "one", references: ["shopId"],
 //                           onDelete: "set-null", onUpdate: "cascade" }] },
 // }
 ```
@@ -492,6 +493,20 @@ To answer *"what does deleting a `Shop` do?"*, scan every Resource's `owningEdge
 (set-null). Both ends of that sentence are Resource names and nothing in the shape tells them apart, so
 the inverted reading produces no error at all, only a plan that reasons backwards.
 
+`references` are the edge's `@relation(fields: […])` — the scalars that hold the reference. A record
+that writes a relation and one of its reference fields both (`shopId` and `shop: { $connect: … }`,
+required relation or optional) is refused before the database is reached: `A2004` with a `V1012` issue
+at the relation, message `Set "shopId" or "shop", not both.` They are also what a required relation may
+be written through instead of the relation itself.
+
+Prisma takes one record's relations either all as relation writes or all through their reference
+fields — its checked and unchecked inputs — so every artifact's model states `referenceWrites: "uniform"`,
+and every Contract compiled from it carries the same member. A record that writes `shopId` beside
+another relation's write (`supplier: { $connect: … }`) is refused before the database is reached:
+`A2004` with a `V1012` issue at the relation write. A reference field beside a back-reference (a
+relation that holds no reference on that side, such as a shop's `items`) mixes nothing and is
+accepted.
+
 Only **owning** edges appear: PSL forbids the non-owning side of a relation from declaring an action,
 so a back-reference's answer is its partner's and carries no entry of its own. Both actions are
 *resolved* — an absent PSL argument is not a third state but Prisma's effective default (`set-null`
@@ -499,7 +514,7 @@ where every foreign-key scalar is optional, `restrict` otherwise, `cascade` on u
 PostgreSQL and SQLite. An action spelling the reader cannot name stops the generate step rather than reaching
 the artifact.
 
-Neither the model nor the compiled Contracts carry a referential action — the actions are beside the
+Neither the model nor the compiled Contracts carry a referential action or a reference field — the edges are beside the
 model and outside `modelHash`, so they move no Contract value and no hash. `createPrismaAdapter` states
 them to core through the adapter's optional `referentialActions` member, translated one to one into core's
 five words (mirroring Prisma's and SQL's actions; direction unchanged):

package/dist/discovery/artifact.loader.js

@@ -1,4 +1,4 @@
-import { canonicalizeJson } from "@aventara/core";
+import { canonicalizeJson } from "@aventara/core/internal";
 import { DISCOVERY_ARTIFACT_FORMAT, } from "./discovery-artifact.interface.js";
 const HASH_PREFIX = "sha256:";
 const REGENERATION_INSTRUCTION = "Regenerate the discovery artifact — `npm run aventara:prepare` in a project " +
@@ -63,6 +63,9 @@ function assertArtifactShape(artifact) {
         artifact.model.transactions !== "interactive") {
         throw new PrismaDiscoveryArtifactError("The discovery artifact's `model.transactions` is not a transaction capability.");
     }
+    if (artifact.model.referenceWrites !== "uniform") {
+        throw new PrismaDiscoveryArtifactError("The discovery artifact's `model.referenceWrites` is not `uniform`, which every Prisma model is.");
+    }
 }
 export async function loadDiscoveryArtifact(load) {
     const { artifact, installedPrismaVersion } = load;

package/dist/discovery/capability-surface.interface.d.ts

@@ -76,6 +76,13 @@ export type PrismaRelationSurface = {
      */
     readonly createRequired: boolean;
     readonly updateMutations: readonly string[];
+    /**
+     * Whether the update stage's `deleteMany` takes a `<T>ScalarWhereInput` — a filter of
+     * the target's scalar fields only, which `updateMany`'s `where` shares. Read off the
+     * nested input's own member type; `false` where the input has no `deleteMany` (a
+     * to-one edge, whose `update`/`delete` take a full `<T>WhereInput`).
+     */
+    readonly scalarNestedWriteFilter: boolean;
     readonly edgeArguments: readonly string[];
     readonly pagination: readonly string[];
     /** The edge is admitted by `<M>OrderByWithRelationInput`. */

package/dist/discovery/capability.deriver.js

@@ -157,6 +157,9 @@ export function deriveRelationCapabilities(input) {
             : {}),
         create: writableIn(directives(surface.createMutations), surface.bulkCreatable),
         update: writableIn(directives(surface.updateMutations), surface.bulkUpdatable),
+        ...(surface.scalarNestedWriteFilter
+            ? { nestedWriteFilter: "scalar" }
+            : {}),
     };
 }
 function look(table, key, what) {

package/dist/discovery/discovery-artifact.interface.d.ts

@@ -1,4 +1,5 @@
-import type { Adapter, AdapterResource, EnumDefinition, ScalarRegistry, TransactionCapability } from "@aventara/core";
+import type { Adapter, AdapterModel, EnumDefinition, ScalarRegistry, TransactionCapability } from "@aventara/core";
+import type { AdapterResource } from "@aventara/core/internal";
 import type { PrismaProvider } from "../provider/provider-profile.js";
 /** The adapter model a discovery artifact carries, in Aventara's vocabulary. */
 export type PrismaAdapterModel = {
@@ -10,6 +11,11 @@ export type PrismaAdapterModel = {
     readonly resources: Readonly<Record<string, AdapterResource<PrismaAdapterModel>>>;
     /** Whether the driver supports interactive transactions. */
     readonly transactions: TransactionCapability;
+    /**
+     * Prisma takes one record's references one way at a time (its checked and
+     * unchecked write inputs), so every artifact states `"uniform"`.
+     */
+    readonly referenceWrites: NonNullable<AdapterModel["referenceWrites"]>;
 };
 /** One identifier, and the **Prisma addressing key** that reaches it. */
 export type PrismaIdentifierAddress = {
@@ -34,6 +40,11 @@ export type PrismaReferentialEdge = {
     readonly target: string;
     /** Whether the edge holds one related row or many. */
     readonly cardinality: "one" | "many";
+    /**
+     * The scalar fields of the ENCLOSING resource that hold the reference — the
+     * relation's `@relation(fields: […])`, in schema order.
+     */
+    readonly references: readonly string[];
     /** What deleting a `target` row does to rows of the ENCLOSING resource. */
     readonly onDelete: PrismaReferentialAction;
     /** The same for an update of the referenced key. Read independently of `onDelete`. */
@@ -64,9 +75,10 @@ export type PrismaClientShape = Readonly<Record<string, readonly string[]>>;
 /**
  * What a create of each Resource cannot do without, already in core's words
  * (`Adapter["createRequirements"]`): a column the client must write, or a
- * required relation that may instead be written through the scalar fields that
- * hold its reference — and the relation's other end, through which a nested
- * create supplies it.
+ * required relation — which may instead be written through the scalar fields
+ * that hold its reference, read off the relation's referential edge
+ * (`references`), never restated here — and the relation's other end, through
+ * which a nested create supplies it.
  *
  * Read at generate time from the generated client's create inputs — the
  * question marks on `<M>UncheckedCreateInput` and `<M>CreateInput` — and from the
@@ -76,7 +88,7 @@ export type PrismaClientShape = Readonly<Record<string, readonly string[]>>;
  */
 export type PrismaCreateRequirementTable = NonNullable<Adapter["createRequirements"]>;
 /** The current discovery artifact format. */
-export declare const DISCOVERY_ARTIFACT_FORMAT = 1;
+export declare const DISCOVERY_ARTIFACT_FORMAT = 2;
 /**
  * The discovery artifact: the module `aventara-prisma7-generate` writes from
  * your schema and generated client. Import its `discovery` export and pass it

package/dist/discovery/discovery-artifact.interface.js

@@ -1 +1 @@
-export const DISCOVERY_ARTIFACT_FORMAT = 1;
+export const DISCOVERY_ARTIFACT_FORMAT = 2;

package/dist/discovery/field.mapper.d.ts

@@ -1,4 +1,4 @@
-import { type AdapterLifecycleTrait, type AdapterRelationField, type AdapterScalarField } from "@aventara/core";
+import { type AdapterLifecycleTrait, type AdapterRelationField, type AdapterScalarField } from "@aventara/core/internal";
 import type { PrismaResourceSurface } from "./capability-surface.interface.js";
 import type { PrismaAdapterModel, PrismaReferentialAction } from "./discovery-artifact.interface.js";
 import type { PrismaSchemaField, PrismaSchemaUnknown } from "./schema-facts.interface.js";

package/dist/discovery/field.mapper.js

@@ -1,4 +1,4 @@
-import { LIFECYCLE_TRAITS, } from "@aventara/core";
+import { LIFECYCLE_TRAITS, } from "@aventara/core/internal";
 import { projectEnumBackedColumn } from "./enum.mapper.js";
 import { mapPrismaScalarField } from "./scalar.mapper.js";
 import { PRISMA_DEFAULT_TABLE, PRISMA_UNMATCHED_DEFAULT_TRAITS, } from "./vocabulary.dictionary.js";

package/dist/discovery/model.discoverer.d.ts

@@ -1,4 +1,4 @@
-import { type TransactionCapability } from "@aventara/core";
+import type { TransactionCapability } from "@aventara/core";
 import type { PrismaComposedArtifact, PrismaModelComposer } from "../generate/prisma.generate.js";
 import type { PrismaCapabilitySurface } from "./capability-surface.interface.js";
 import type { PrismaSchemaFacts } from "./schema-facts.interface.js";

package/dist/discovery/model.discoverer.js

@@ -1,4 +1,4 @@
-import { BUILT_IN_SCALARS, } from "@aventara/core";
+import { BUILT_IN_SCALARS, } from "@aventara/core/internal";
 import { deriveRelationCapabilities, deriveScalarCapabilities, } from "./capability.deriver.js";
 import { mapPrismaEnum } from "./enum.mapper.js";
 import { crossCheckCreateOptional, projectPrismaField, } from "./field.mapper.js";
@@ -58,12 +58,14 @@ export function discoverPrismaModel(input) {
             enums,
             resources,
             transactions: input.transactions,
+            referenceWrites: PRISMA_REFERENCE_WRITES,
         },
         translation,
         referentialActions,
         createRequirements: composeCreateRequirements(declared, input.surface, resources),
     };
 }
+const PRISMA_REFERENCE_WRITES = "uniform";
 function composeCreateRequirements(declared, surface, resources) {
     const table = {};
     for (const [name, resource] of Object.entries(resources)) {
@@ -95,15 +97,13 @@ function composeCreateRequirements(declared, surface, resources) {
             if (exposed.relationFields[field.name]?.createRequired !== true) {
                 continue;
             }
-            const orFields = owned.filter((scalar) => requiredScalars.has(scalar));
-            if (orFields.length === 0) {
+            if (!owned.some((scalar) => requiredScalars.has(scalar))) {
                 continue;
             }
             const inverse = inverseOf(declared, name, field);
             requirements.push({
                 kind: "relation",
                 relation: field.name,
-                orFields,
                 ...(inverse === undefined ? {} : { inverse }),
             });
         }
@@ -217,6 +217,7 @@ function composeResource(input) {
                         field: projection.edge.field,
                         target: projection.edge.target,
                         cardinality: projection.edge.cardinality,
+                        references: [...(field.relation?.fields ?? [])],
                         onDelete: projection.edge.onDelete,
                         onUpdate: projection.edge.onUpdate,
                     });

package/dist/discovery/operations.deriver.d.ts

@@ -1,4 +1,5 @@
-import type { AdapterResource, ResourceOperations, TransactionCapability } from "@aventara/core";
+import type { ResourceOperations, TransactionCapability } from "@aventara/core";
+import type { AdapterResource } from "@aventara/core/internal";
 import type { PrismaAdapterModel } from "./discovery-artifact.interface.js";
 type DiscoveredIdentifiers = AdapterResource<PrismaAdapterModel>["identifiers"];
 export type ResourceOperationsInput = {

package/dist/discovery/types.reader.js

@@ -201,6 +201,16 @@ function keysOfReferenced(index, node, accept) {
     }
     return memberNames(members);
 }
+function deleteManyTakesScalarWhere(index, node) {
+    const input = findReference(node, (n) => n.endsWith("NestedInput"));
+    if (input === null) {
+        return false;
+    }
+    const deleteMany = (membersOf(index, referencedName(input)) ?? []).find((member) => memberName(member) === "deleteMany");
+    return (deleteMany !== undefined &&
+        findReference(deleteMany.type, (n) => n.endsWith("ScalarWhereInput")) !==
+            null);
+}
 function readEnums(program, root) {
     const source = program.getSourceFile(path.join(root, "enums.ts"));
     if (source === undefined) {
@@ -386,6 +396,7 @@ function readRelationFields(checker, index, payload, where, create, update, incl
             createRequired: create.get(name) !== undefined &&
                 create.get(name)?.questionToken === undefined,
             updateMutations: keysOfReferenced(index, update.get(name)?.type, (n) => n.endsWith("NestedInput")),
+            scalarNestedWriteFilter: deleteManyTakesScalarWhere(index, update.get(name)?.type),
             edgeArguments,
             pagination: edgeArguments.filter((argument) => !NON_PAGINATION_EDGE_ARGUMENTS.has(argument)),
             orderable: orderBy.has(name),

package/dist/discovery/vocabulary.dictionary.d.ts

@@ -1,4 +1,5 @@
-import type { AdapterLifecycleTrait, BuiltInScalar, PaginationCapability, RelationFilterCapability, RelationMutationDirective, ScalarFilterOperator, ScalarFormat, ScalarMutationDirective } from "@aventara/core";
+import type { BuiltInScalar, PaginationCapability, RelationFilterCapability, RelationMutationDirective, ScalarFilterOperator, ScalarFormat, ScalarMutationDirective } from "@aventara/core";
+import type { AdapterLifecycleTrait } from "@aventara/core/internal";
 export type VocabularySource = "PSL" | "TYPE" | "RUN" | "DRIVER" | "CFG";
 export type VocabularyEntry = {
     readonly fact: string;

package/dist/execution/operation.executor.d.ts

@@ -1,4 +1,5 @@
-import type { AdapterModel, AdapterOperationExecutor } from "@aventara/core";
+import type { AdapterModel } from "@aventara/core";
+import type { AdapterOperationExecutor } from "@aventara/core/internal";
 import type { PrismaResourceTranslation } from "../discovery/discovery-artifact.interface.js";
 import { type PrismaDelegateHost, type PrismaTransactionOptions } from "../prisma-client.interface.js";
 /** A call the executor cannot issue against the client it was given. */

package/dist/execution/transaction.executor.d.ts

@@ -1,4 +1,5 @@
-import type { AdapterModel, AdapterOperationExecutor } from "@aventara/core";
+import type { AdapterModel } from "@aventara/core";
+import type { AdapterOperationExecutor } from "@aventara/core/internal";
 import type { PrismaResourceTranslation } from "../discovery/discovery-artifact.interface.js";
 import type { PrismaDelegateHost, PrismaTransactionOptions } from "../prisma-client.interface.js";
 export type PrismaTransactionExecutorDependencies = {

package/dist/generate/artifact.emitter.js

@@ -1,4 +1,4 @@
-import { canonicalizeJson } from "@aventara/core";
+import { canonicalizeJson } from "@aventara/core/internal";
 import { computeModelHash } from "../discovery/artifact.loader.js";
 import { DISCOVERY_ARTIFACT_FORMAT, } from "../discovery/discovery-artifact.interface.js";
 const BANNER = [
@@ -18,8 +18,9 @@ const TRANSLATION_DOC = [
 const REFERENTIAL_ACTIONS_DOC = [
     "/**",
     " * The schema's referential actions, per Resource: the relation fields that",
-    " * declare `@relation(fields: …)`, each with its resolved `onDelete` and",
-    " * `onUpdate`. An edge under Resource `R` reads:",
+    " * declare `@relation(fields: …)`, each with the fields holding its reference",
+    " * (`references`) and its resolved `onDelete` and `onUpdate`. An edge under",
+    " * Resource `R` reads:",
     " *",
     " *   deleting a `target` row does `onDelete` to rows of `R`.",
     " *",
@@ -42,9 +43,9 @@ const CLIENT_DOC = [
 const CREATE_REQUIREMENTS_DOC = [
     "/**",
     " * What a create of each Resource cannot do without: a field with no default,",
-    " * or a required relation, which may instead be written through `orFields` —",
-    " * the scalar fields holding its reference — and which a nested create",
-    " * reached through its `inverse` gets from the parent.",
+    " * or a required relation, which may instead be written through the fields",
+    " * holding its reference (its edge's `references` above) and which a nested",
+    " * create reached through its `inverse` gets from the parent.",
     " *",
     " * Every create is checked against it and a missing value is answered as",
     " * `A2004`/`V1000` at its path, before the database is reached. Not part of",

package/dist/prisma.adapter.js

@@ -16,6 +16,7 @@ function translateReferentialActions(table) {
         owningEdges.map((edge) => ({
             field: edge.field,
             target: edge.target,
+            references: edge.references,
             onDelete: DELETE_EFFECTS[edge.onDelete],
         })),
     ]));

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

@@ -1,4 +1,4 @@
-import { type AdapterModel, type OperationIdentity } from "@aventara/core";
+import type { AdapterModel, OperationIdentity } from "@aventara/core";
 import type { PrismaIdentifierAddress } from "../discovery/discovery-artifact.interface.js";
 /** A mutation the model, the stage or the active operation does not license. */
 export declare class PrismaMutationTranslationError extends Error {

package/dist/translation/mutation.translator.js

@@ -1,4 +1,4 @@
-import { advertisedDirectives, } from "@aventara/core";
+import { advertisedDirectives, } from "@aventara/core/internal";
 import { addressIdentifier } from "./identifier.addressing.js";
 import { emitScalarValue } from "./scalar.conversion.js";
 export class PrismaMutationTranslationError extends Error {

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

@@ -1,4 +1,5 @@
-import type { AdapterModel, AdapterOperation } from "@aventara/core";
+import type { AdapterModel } from "@aventara/core";
+import type { AdapterOperation } from "@aventara/core/internal";
 import type { PrismaResourceTranslation } from "../discovery/discovery-artifact.interface.js";
 import { type PrismaProjectionPlan } from "./projection.translator.js";
 /** The `ModelAction` subset this adapter uses. See the header for the exclusions. */

package/dist/translation/order-pagination.translator.d.ts

@@ -1,4 +1,4 @@
-import { type AdapterModel } from "@aventara/core";
+import type { AdapterModel } from "@aventara/core";
 import type { PrismaIdentifierAddress } from "../discovery/discovery-artifact.interface.js";
 /** An order or cursor the discovered model does not license. */
 export declare class PrismaOrderTranslationError extends Error {

package/dist/translation/order-pagination.translator.js

@@ -1,4 +1,4 @@
-import { advertisedReducers, } from "@aventara/core";
+import { advertisedReducers } from "@aventara/core/internal";
 import { addressIdentifier } from "./identifier.addressing.js";
 export class PrismaOrderTranslationError extends Error {
     name = "PrismaOrderTranslationError";

package/dist/translation/scalar.conversion.d.ts

@@ -1,4 +1,5 @@
-import { type AdapterField, type AdapterModel } from "@aventara/core";
+import { type AdapterModel } from "@aventara/core";
+import type { AdapterField } from "@aventara/core/internal";
 /** A value this adapter will not convert rather than misrepresent. */
 export declare class PrismaScalarConversionError extends Error {
     readonly name = "PrismaScalarConversionError";

package/dist/translation/scalar.conversion.js

@@ -1,4 +1,4 @@
-import { Decimal, } from "@aventara/core";
+import { Decimal } from "@aventara/core";
 export class PrismaScalarConversionError extends Error {
     name = "PrismaScalarConversionError";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aventara/prisma7-adapter",
-  "version": "0.1.0-pilot.4",
+  "version": "1.0.0-rc.0",
   "license": "SEE LICENSE IN LICENSE",
   "description": "The Prisma 7 adapter for Aventara.",
   "type": "module",
@@ -26,10 +26,11 @@
   },
   "files": [
     "dist",
-    "LICENSE-ADDITIONAL-PERMISSION.md"
+    "LICENSE-ADDITIONAL-PERMISSION.md",
+    "CHANGELOG.md"
   ],
   "dependencies": {
-    "@aventara/core": "0.1.0-pilot.4"
+    "@aventara/core": "1.0.0-rc.0"
   },
   "peerDependencies": {
     "@prisma/adapter-better-sqlite3": "^7.10.0",
@@ -91,7 +92,7 @@
     "typescript-6": "npm:typescript@6.0.3"
   },
   "scripts": {
-    "build": "node node_modules/typescript/bin/tsc -p tsconfig.json --removeComments --declaration false && node node_modules/typescript/bin/tsc -p tsconfig.json --emitDeclarationOnly && node ../../scripts/build/declaration-comments.sanitizer.ts dist",
+    "build": "node ../../scripts/build/build-output.cleaner.ts dist && node node_modules/typescript/bin/tsc -p tsconfig.json --removeComments --declaration false && node node_modules/typescript/bin/tsc -p tsconfig.json --emitDeclarationOnly && node ../../scripts/build/declaration-comments.sanitizer.ts dist",
     "typecheck": "node node_modules/typescript/bin/tsc -p tsconfig.typecheck.json --noEmit",
     "generate": "node node_modules/typescript/bin/tsc -p tsconfig.generate.json && node .generate/generate/discovery.generate.js && prisma generate --schema src/discovery/__fixtures__/ignore.prisma",
     "db:push": "prisma db push --config prisma.config.sqlite.ts && sh -c 'if [ -n \"$AVENTARA_TEST_POSTGRES_URL\" ]; then prisma db push --config prisma.config.postgres.ts; else echo \"AVENTARA_TEST_POSTGRES_URL is unset: skipping the PostgreSQL schema push\"; fi'",