@aventara/prisma7-adapter 1.0.0-rc.3 → 1.0.0-rc.8

package/CHANGELOG.md

@@ -1,5 +1,149 @@
 # @aventara/prisma7-adapter
 
+## 1.0.0-rc.8
+
+1.0.0-rc.5, rc.6 and rc.7 were tagged but never published; 1.0.0-rc.8 contains everything listed under them and the changes below.
+
+### Patch Changes
+
+- 1c8e4ee: The discovery artifact's referential actions say `referenceFields` where they said `references`: in
+  `referentialActions.<Resource>.owningEdges[]`, the fields of the Resource itself that hold the reference
+  (`@relation(fields: [...])`). The model's relation fields already use `references` for the target's fields
+  (`@relation(references: [...])`) and `referenceFields` for these, so the same word meant two different lists in one
+  file. The generated `discovery.artifact.ts` changes on the next `aventara:prepare` (it runs on install, build and
+  start), and only in those keys: `modelHash` is unchanged, since the referential actions are outside it, and so is the
+  prebuilt Contracts file `aventara-build` writes. Code that read `owningEdges[i].references` reads
+  `owningEdges[i].referenceFields`.
+- Updated dependencies [1c8e4ee]
+  - @aventara/core@1.0.0-rc.8
+
+## 1.0.0-rc.7
+
+1.0.0-rc.5 and 1.0.0-rc.6 were tagged but never published; 1.0.0-rc.7 contains everything listed under them and the changes below.
+
+### Patch Changes
+
+- Updated dependencies [f917c1c]
+  - @aventara/core@1.0.0-rc.7
+
+## 1.0.0-rc.6
+
+1.0.0-rc.5 was tagged but never published. 1.0.0-rc.6 contains everything listed under 1.0.0-rc.5 and the fix below.
+
+### Patch Changes
+
+- Updated dependencies [1cf72e0]
+  - @aventara/core@1.0.0-rc.6
+
+## 1.0.0-rc.5
+
+### Patch Changes
+
+- 4795ff1: Two additions for policy engines. A Framework without a policy, and every Contract a caller is served, are unchanged.
+
+  - A policy engine can check a create whose row reaches another Resource through a relation. Discovery now states, on the end of a relation that holds the reference, which of the target's fields its reference fields name, pair by pair (`Note.campaign`: `referenceFields: ["campaignId"]`, `references: ["id"]`). An engine reads them from the model it is built from (a Prisma discovery artifact's `model`) or from `framework.contracts.core`, and asks one `exists` about the row they name: "a player creates a note only in a campaign they play in". Only the adapter's model and the Core Contract carry them. The Application, Client and Agent Contracts, `/_contract`, the MCP tools and every ClientContract hash are unchanged. The discovery artifact's model hash, and so a prebuilt Contracts file's fingerprint, change: regenerate the artifact and rebuild the prebuilt file.
+  - `fieldsOf({ access: "write" })` also names the action that writes the record, `action: "create" | "update"` (an upsert's branches each their own, a nested record its directive's), so an engine can lock a field on update and still let a create write it. A read question names none. An engine that ignores it keeps working.
+
+- 9e178ca: Fixes for applications that check requests with a policy engine. A Framework without a policy behaves as before.
+
+  - A cursor on a row the caller cannot read is answered exactly as a cursor on a row that does not exist, at the root and in a to-many relation, whatever values the caller sends beside the identifier. Before, the page started at the hidden row, so it told that the row exists and where its values sort. The Prisma adapter reads the cursor's row under the read scope first: one statement more for a cursor on a readable row, and only that read for one on a row the caller cannot read.
+  - A unique update with a nested write (`$create`, `$connect`, …) on a row the caller can read but not change answers `A4002`, as the same update without one does. It answered `A2003`. A row the caller cannot read still answers `A2003`.
+  - The `exists` questions a policy asks select the Resource's primary identifier, never another unique field such as a governed `email`.
+  - `policy.principal` may answer with a promise. A synchronous principal works as before; a rejection answers `A3000`, as a throw does.
+  - `AvConstructionError.message` names the first problem and how many more there are, for example `Aventara framework configuration validation failed: CONFIG_INVALID_TYPE at adapter.execute: adapter.execute must be a function (+2 more)`. `stage` and `diagnostics` are unchanged.
+
+## 1.0.0-rc.4
+
+### Patch Changes
+
+- 7c3b65f: Build-time Contracts for serverless and edge cold starts.
+
+  - New package `@aventara/build`, bin `aventara-build`, a development dependency. It runs `src/aventara.config.ts` and
+    `src/aventara.adapter.ts` without a database client, compiles the Contracts with the project's `@aventara/core` and
+    writes `src/generated/aventara/contracts.generated.ts` (`aventaraContracts`), which a serverless or edge entry passes
+    to `createFramework` as `prebuilt`. A configuration that startup would refuse fails the build with the same
+    `CONFIG_…`/`COMPILER_…` diagnostics. `aventara-build --check` writes nothing and exits 1 when the file is missing or
+    stale, naming the Resources that changed.
+  - `@aventara/prisma7-adapter`: `describePrismaAdapter({ discovery, provider, driver })` states the adapter's passive
+    facts (the model, the driver's transaction capability, the referential actions, the computed fields) with no client.
+    `createPrismaAdapter({ ...description, client })` builds the adapter from the same facts, and still checks the client
+    against the discovery artifact.
+  - `@aventara/cli`: the scaffold's `src/aventara.config.ts` exports the configuration as a plain value
+    (`export const aventaraConfig = { … } as const`) with no `adapter`. A new `src/aventara.adapter.ts` default-exports
+    `describePrismaAdapter(…)`, and `app.module.ts` joins the two:
+    `config: { ...aventaraConfig, adapter: await createPrismaAdapter({ ...adapter, client: prisma }) }`. The Nest server
+    still compiles its Contracts at startup and passes no `prebuilt`. `aventara:prepare` ends with `&& aventara-build`,
+    and `@aventara/build` is an exact development dependency.
+
+- 2b1b17e: `aventara-build`'s files no longer land inside a Prisma client generated into `src/generated`.
+
+  When `aventara init` reuses a project whose Prisma client is generated into `src/generated`, it already puts the
+  discovery artifact in `src/aventara/`, because `prisma generate` deletes every file in its output directory that it did
+  not write. `aventara-build` still wrote its three files to `src/generated/aventara/`, so each `prisma generate` deleted
+  them and the project stopped compiling until the next `aventara:prepare`. Now all of Aventara's generated files are
+  in one place.
+
+  - `@aventara/build`: `aventara-build` writes `resources.generated.ts`, `computed-fields.generated.ts` and
+    `contracts.generated.ts` to the directory the configuration imports `aventaraResources` from, so the tree is always
+    written where the configuration reads it. A configuration that imports no tree keeps `src/generated/aventara/`.
+    The files of a project whose client is generated anywhere else are the same bytes, in the same place.
+  - `@aventara/prisma7-adapter`: with `--config`, the artifact imports the computed fields from its sibling,
+    `./computed-fields.generated`, wherever `--out` puts it. `--config` is still required for that import and the step
+    still checks that the file exists, but the step no longer uses its location. A scaffold's artifact is unchanged.
+  - `@aventara/cli`: in that project, `src/aventara.config.ts` imports the tree from `./aventara/resources.generated`,
+    and `.gitignore` gets the one `/src/aventara/` line that covers all four files (no separate
+    `/src/generated/aventara/contracts.generated.ts` line). The agent skill says where the generated files are in
+    both cases.
+
+- 3a0dfca: A write the policy checks costs fewer database round trips. What each check decides and refuses is unchanged.
+
+  - A single-row update or delete carries the caller's scopes inside its own `where` and runs as one statement, with no
+    read of its row before it. One that matches nothing still answers `A4002` when the caller can read the row and
+    `A2003` when it cannot, with one lookup on that miss only. The Prisma adapter sends it as
+    `update({ where: { id, AND: [scope] } })`.
+  - A create asks `can({ action: "create", row })` and its `exists` lookups before the insert, without a transaction. A
+    transaction around them never closed the race between the lookup and the insert at the database's default
+    isolation, and cost a BEGIN and a COMMIT.
+  - A transaction opens only when a check after the write may roll it back: an update's after check or move-out, a
+    created row held to a write grant, a nested write, or returned rows checked by `exists`. A plain checked create or
+    delete is one statement, its interceptors and hooks outside any transaction.
+  - The after check asks `can` about the row the update returned, so it reads nothing again. Only a move-out reads the
+    changed rows again. An `update.count` runs as the returning `update.many` when the Contract offers it.
+
+  Round trips per request on PostgreSQL: `create.one` 3 → 1, `delete.unique` 4 → 1, `update.unique` 5 → 3,
+  `update.many` 4 → 3, `update.count` 5 → 3. Reads, and a Framework without a policy, are unchanged.
+
+- 3813207: The Resource tree and the computed fields come from `aventara-build`.
+
+  - `@aventara/build`: before it compiles the Contracts, `aventara-build` writes two more files under
+    `src/generated/aventara/`. `resources.generated.ts` exports `aventaraResources`: every `defineResource(…)` result
+    that the files `src/resources/**/*.resource.ts` export, found by its type (never run), one `resources` tree per
+    layer, written as the plain spreads you wrote by hand (`root` always, `application`, `client` and `agent` when some
+    Resource has a block for them). Two definitions of one Resource stop the build, naming both. Imports are spelled as
+    the project spells its own. `computed-fields.generated.ts` exports `computedFields` and its type `AvComputedFields`:
+    which fields the configuration's write compute fills, read off its type after the tree exists, so a fresh install is
+    typed right on its first `aventara:prepare`. `--check` covers all three files. `typescript` (`>=5.7.0 <7`) is now a
+    peer dependency.
+  - `@aventara/prisma7-adapter`: the generate step no longer reads the configuration. With `--config`, the discovery
+    artifact imports `computedFields` and `AvComputedFields` from the file `aventara-build` writes beside the
+    configuration (`generated/aventara/computed-fields.generated.ts`); a `--config` file that does not exist is still
+    refused. `readConfigComputedFields`, `AvPrismaConfigReaderError` and `ConfigComputedFieldsReading` are removed from
+    `@aventara/prisma7-adapter/generate`, as are `PrismaGenerateToolchain.readComputedFields` and
+    `PrismaGenerateResult.computedFields`.
+  - `@aventara/cli`: the scaffold's `src/aventara.config.ts` takes its Resources from the tree,
+    `resources: aventaraResources.root`, so a new Resource file needs no configuration edit; the agent skill says so.
+
+- Updated dependencies [e3d03a7]
+- Updated dependencies [d10639a]
+- Updated dependencies [f67e68c]
+- Updated dependencies [708556c]
+- Updated dependencies [3a0dfca]
+- Updated dependencies [99169d2]
+- Updated dependencies [0fd2608]
+- Updated dependencies [154e440]
+- Updated dependencies [2fcffdb]
+  - @aventara/core@1.0.0-rc.4
+
 ## 1.0.0-rc.3
 
 ### Patch Changes
@@ -21,7 +165,7 @@
   `the artifact file /app/src/generated/aventara/discovery.artifact.ts (--out) cannot be written: permission denied (EACCES).`,
   and leaves no staged file behind. Before, every such failure except a directory printed a stack trace.
 
-- b38034d: On PostgreSQL, a `@unique` value too long for its index (an index row past the B-tree's 8191 bytes, SQLSTATE
+- b38034d: On PostgreSQL, a `@unique` value too long for its index (an index row past the B-tree's limit of about 2704 bytes, SQLSTATE
   `54000`) is answered `422 A2004`, not `500 A3001`: one `V1004` issue at `["arguments"]`, as a value too long for its
   column already was. The adapter reads the SQLSTATE, never the message. The issue's message for a value too long now
   reads `The database refused this value: it is longer than the database can hold for its column.`

package/README.md

@@ -55,6 +55,31 @@ than a declaration that is checked.
 `createPrismaAdapter` is `async`. Construction verifies the discovery artifact, and the digest it
 checks is a `crypto.subtle` promise, so every check runs once, here, before an adapter exists.
 
+### `describePrismaAdapter`: the same facts, with no client
+
+`describePrismaAdapter({ discovery, provider, driver })` returns the adapter's passive facts: the model,
+the driver's transaction capability, the referential actions in Aventara's words and the computed
+fields the generated types were written with. It constructs nothing and connects to nothing, so
+`aventara-build` (`@aventara/build`) compiles the Contracts from it at build time. Spread into
+`createPrismaAdapter` with the client, it is the adapter's options, and the adapter states exactly the
+facts the description does:
+
+```ts
+// src/aventara.adapter.ts
+export default describePrismaAdapter({
+  discovery,
+  provider: "postgresql",
+  driver: "@prisma/adapter-pg",
+});
+
+// where the framework is created
+import description from "./aventara.adapter.js";
+const adapter = await createPrismaAdapter({ ...description, client });
+```
+
+`createPrismaAdapter` still verifies the artifact and checks the client against it; the description
+does neither, because it has no client to check.
+
 ### `maxWait`, `timeout` and `isolationLevel` are adapter-owned
 
 They are provider concepts. Core's `Adapter.transaction(work)` interface carries no options and will
@@ -99,16 +124,18 @@ installed keeps `@prisma/prisma7` beside it. With neither usable, the step refus
 both. TypeScript 6 is supported; TypeScript 7, which has no classic compiler API, is refused in one
 sentence.
 
-`--config` is optional. It names your Aventara configuration module: its `aventaraConfig` export (a
-function, as the `aventara` scaffold writes it, or a value) or its default export. The step reads the
-configuration's TypeScript type, never runs it, and states in the artifact which fields its
-`compute.create` and `compute.update` stages fill, per layer (`computedFields`). A variant's guards,
-pipes and filters, which run before write compute, may then leave exactly those fields out of a create;
-every other required field stays required. Without `--config`, or when the configuration is not a
-literal where a compute stage is written (the step prints where), the artifact states nothing and those
-stages may leave any create field out. When the framework starts, it compares the statement with the
-configuration and warns (`AVENTARA_STALE_GENERATED_TYPES`) if you changed a compute stage without
-running the step again.
+`--config` is optional. It names your Aventara configuration module (`src/aventara.config.ts`). The step
+neither reads nor runs it: `aventara-build` (`@aventara/build`), which `aventara:prepare` runs right after
+this step, reads the configuration's TypeScript type and writes which fields its `compute.create` and
+`compute.update` stages fill, per layer, to `computed-fields.generated.ts` beside the artifact (the
+directory the configuration imports its Resource tree from). The artifact imports that sibling file: `computedFields` (also `discovery.computedFields`) and its type, which the
+model's type carries. A variant's guards, pipes and filters, which run before write compute, may then
+leave exactly those fields out of a create; every other required field stays required. On a fresh install
+the file is not there until `aventara-build` has run. Without `--config`, or when the configuration is not
+a literal where a compute stage is written (`aventara-build` prints where), the artifact states nothing and
+those stages may leave any create field out. When the framework starts, it compares the statement with
+the configuration and warns (`AVENTARA_STALE_GENERATED_TYPES`) if you changed a compute stage without
+running `aventara:prepare` again.
 
 `--out` must not be inside `--client`: Prisma's next `prisma generate` clears that directory and would
 delete the artifact. The step refuses such an `--out`, and one that names a directory, in one sentence
@@ -502,10 +529,10 @@ discovery.referentialActions;
 // {
 //   Shop:  { owningEdges: [] },
 //   Item:  { owningEdges: [{ field: "shop", target: "Shop",
-//                           cardinality: "one", references: ["shopId"],
+//                           cardinality: "one", referenceFields: ["shopId"],
 //                           onDelete: "cascade", onUpdate: "cascade" }] },
 //   Clerk: { owningEdges: [{ field: "shop", target: "Shop",
-//                           cardinality: "one", references: ["shopId"],
+//                           cardinality: "one", referenceFields: ["shopId"],
 //                           onDelete: "set-null", onUpdate: "cascade" }] },
 // }
 ```
@@ -517,7 +544,7 @@ read the enclosing Resource key: above, that is `Item` (cascade) and `Clerk` (se
 that sentence are Resource names and nothing in the shape tells them apart, so reading it backwards
 produces no error, only a plan that reasons backwards.
 
-`references` are the edge's `@relation(fields: […])`, the scalars that hold the reference. A record
+`referenceFields` are the edge's `@relation(fields: […])`, the scalars that hold the reference (the relation field's `referenceFields` in the model; its `references` are the target's fields). A record
 that writes both a relation and one of its reference fields (`shopId` and `shop: { $connect: … }`,
 whether the relation is required or optional) is refused before the database is reached: `A2004` with
 a `V1012` issue at the relation, message `Set "shopId" or "shop", not both.` The reference fields are
@@ -641,7 +668,9 @@ Resource or operation for one to wrap.
 - A record written through a relation cannot write that relation, or its reference fields, back: Prisma's nested
   input for it leaves them out (a post created in `author.posts` has no `author` or `authorId`; a category created in
   a post's `category` has no `posts`). The artifact states each relation's other end (`inverse`, paired by relation
-  name), the fields that hold its reference (`referenceFields`, from `@relation(fields: …)`) and no relation
+  name), the fields that hold its reference (`referenceFields`, from `@relation(fields: …)`) and the target's fields
+  they hold, pair by pair (`references`, from `@relation(references: …)`, which `@aventara/core` keeps in the Core
+  Contract only, for a policy engine), and no relation
   writable at the `"loopback"` position, so `@aventara/core` refuses such a write before any
   guard or SQL, `A2004` with a `V1012` issue at the field written back, and the types do not offer it. Where a layer
   hides the other end, Prisma's client refuses the write instead and the adapter answers that refusal the same way.

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

@@ -42,9 +42,11 @@ export type AvPrismaReferentialEdge = {
     readonly cardinality: "one" | "many";
     /**
      * The scalar fields of the enclosing resource that hold the reference: the
-     * relation's `@relation(fields: […])`, in schema order.
+     * relation's `@relation(fields: […])`, in schema order. Named as the relation
+     * field's `referenceFields` in the model: its `references` are the TARGET's
+     * fields (`@relation(references: […])`).
      */
-    readonly references: readonly string[];
+    readonly referenceFields: readonly string[];
     /** What deleting a `target` row does to rows of the enclosing resource. */
     readonly onDelete: AvPrismaReferentialAction;
     /** The same for an update of the referenced key. Read independently of `onDelete`. */
@@ -107,11 +109,13 @@ export type AvPrismaDiscoveryArtifact<M extends AvPrismaAdapterModel = AvPrismaA
      */
     readonly client: PrismaClientShape;
     /**
-     * Which fields the configuration's write compute fills, per layer, as the
-     * generate step read them off the configuration it was given (`--config`);
-     * `null` when it was given none. The model's type carries the same statement
-     * for the pipeline stages' types; this value is compared with the
-     * configuration when the framework starts. Not part of `modelHash`.
+     * Which fields the configuration's write compute fills, per layer, as
+     * `aventara-build` read them off the configuration's type (the artifact
+     * imports them when the step was given `--config`); `null` when it was
+     * given none, or the build could not read them. The model's type carries
+     * the same statement for the pipeline stages' types; this value is compared
+     * with the configuration when the framework starts. Not part of
+     * `modelHash`.
      */
     readonly computedFields: AvConfigComputedFields | null;
 };

package/dist/discovery/model.discoverer.js

@@ -245,10 +245,17 @@ function composeResource(input) {
                 const referenceFields = firstReference === undefined
                     ? undefined
                     : [firstReference, ...moreReferences];
+                const [firstTarget, ...moreTargets] = field.relation?.references ?? [];
+                const references = referenceFields === undefined ||
+                    firstTarget === undefined ||
+                    moreTargets.length + 1 !== referenceFields.length
+                    ? undefined
+                    : [firstTarget, ...moreTargets];
                 fields[projection.name] = {
                     ...projection.field,
                     ...(inverse === undefined ? {} : { inverse: inverse.relation }),
                     ...(referenceFields === undefined ? {} : { referenceFields }),
+                    ...(references === undefined ? {} : { references }),
                     capabilities: deriveRelationCapabilities({
                         surface: relationSurface,
                     }),
@@ -259,7 +266,7 @@ function composeResource(input) {
                         field: projection.edge.field,
                         target: projection.edge.target,
                         cardinality: projection.edge.cardinality,
-                        references: [...(referenceFields ?? [])],
+                        referenceFields: [...(referenceFields ?? [])],
                         onDelete: projection.edge.onDelete,
                         onUpdate: projection.edge.onUpdate,
                     });

package/dist/execution/operation.executor.js

@@ -2,9 +2,10 @@ import { locateBackReferenceWrite, } from "../errors/back-reference.locator.js";
 import { locateUnboundBigint } from "../errors/bigint-binding.locator.js";
 import { classifyPrismaError, prismaNestedWriteFailure, prismaOutcomeFailure, prismaValueFailure, } from "../errors/error.normalizer.js";
 import { prismaDelegates, } from "../prisma-client.interface.js";
-import { PRISMA_VARIANT_DISPATCH, translateOperation, } from "../translation/operation.translator.js";
+import { PRISMA_VARIANT_DISPATCH, translateOperation, translateScopedCursorLookup, } from "../translation/operation.translator.js";
 import { runFirstVariantEmulation } from "./first-variant.emulator.js";
 import { shapeCount, shapeRow, shapeRows, } from "./result.shaper.js";
+import { resolveScopedCursors } from "./scoped-cursor.resolver.js";
 export class AvPrismaExecutionError extends Error {
     name = "AvPrismaExecutionError";
 }
@@ -21,8 +22,9 @@ export function createPrismaOperationExecutor(dependencies) {
             : {}),
     });
     return {
-        async execute(operation) {
-            const result = resultKindOf(dispatchOf(operation));
+        async execute(sent) {
+            const result = resultKindOf(dispatchOf(sent));
+            const operation = await withScopedCursorsResolved(dependencies, sent, (call) => issueClassified(issue, call, sent, locatorFor(sent)));
             const translation = translateOperation({
                 model: dependencies.model,
                 translation: dependencies.translation,
@@ -53,6 +55,18 @@ export function createPrismaOperationExecutor(dependencies) {
         },
     };
 }
+async function withScopedCursorsResolved(dependencies, operation, issue) {
+    const args = operation.arguments;
+    const resolved = await resolveScopedCursors(dependencies.model, operation.resource, args, async (resource, cursor) => (await issue(translateScopedCursorLookup({
+        model: dependencies.model,
+        translation: dependencies.translation,
+        resource,
+        cursor,
+    }))) !== null);
+    return resolved === args
+        ? operation
+        : { ...operation, arguments: resolved };
+}
 async function withUnit(dependencies, work) {
     if (dependencies.scope === "transaction") {
         return work(dependencies.client);

package/dist/execution/scoped-cursor.resolver.d.ts

@@ -0,0 +1,11 @@
+import type { AvAdapterModel } from "@aventara/core";
+type Level = Readonly<Record<string, unknown>>;
+/** Whether the row `cursor` (with its `AND`) names on `resource` meets its conditions. */
+export type PrismaScopedCursorLookup = (resource: string, cursor: Level) => Promise<boolean>;
+/**
+ * The operation's arguments with every cursor that carries `AND` resolved: its
+ * address alone when the row meets the conditions, otherwise no cursor and
+ * `limit: 0`. The same object when no cursor carries `AND`.
+ */
+export declare function resolveScopedCursors(model: AvAdapterModel, resource: string, args: Level, lookup: PrismaScopedCursorLookup): Promise<Level>;
+export {};

package/dist/execution/scoped-cursor.resolver.js

@@ -0,0 +1,47 @@
+export async function resolveScopedCursors(model, resource, args, lookup) {
+    return (await resolveLevel(model, resource, args, lookup)) ?? args;
+}
+async function resolveLevel(model, resource, level, lookup) {
+    let resolved;
+    const cursor = level.cursor;
+    if (isRecord(cursor) && Object.hasOwn(cursor, "AND")) {
+        const { AND: _conditions, ...address } = cursor;
+        const { cursor: _cursor, ...rest } = level;
+        resolved = (await lookup(resource, cursor))
+            ? { ...rest, cursor: address }
+            : { ...rest, limit: 0 };
+    }
+    if (Array.isArray(level.select)) {
+        const select = await resolveSelect(model, resource, level.select, lookup);
+        if (select !== undefined) {
+            resolved = { ...(resolved ?? level), select };
+        }
+    }
+    return resolved;
+}
+async function resolveSelect(model, resource, select, lookup) {
+    let changed = false;
+    const entries = [];
+    for (const entry of select) {
+        if (!isRecord(entry)) {
+            entries.push(entry);
+            continue;
+        }
+        const rewritten = {};
+        for (const [name, value] of Object.entries(entry)) {
+            const field = model.resources[resource]?.fields[name];
+            const inner = field?.kind === "relation" && isRecord(value)
+                ? await resolveLevel(model, field.target, value, lookup)
+                : undefined;
+            if (inner !== undefined) {
+                changed = true;
+            }
+            rewritten[name] = inner ?? value;
+        }
+        entries.push(rewritten);
+    }
+    return changed ? entries : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/generate/artifact.emitter.d.ts

@@ -1,4 +1,3 @@
-import type { AvConfigComputedFields } from "@aventara/core";
 import { type AvPrismaAdapterModel, type AvPrismaReferentialActionTable, type PrismaClientShape, type PrismaTranslationTable } from "../discovery/discovery-artifact.interface.js";
 import type { AvPrismaProvider } from "../provider/provider-profile.js";
 export type PrismaArtifactEmission = {
@@ -12,9 +11,14 @@ export type PrismaArtifactEmission = {
     /** The generated client's models and field references — beside `model`, outside the hash. */
     readonly client: PrismaClientShape;
     /**
-     * What the configuration's write compute fills, read off its type; `null`
-     * when the step was given no configuration. Beside `model`, outside the hash.
+     * The specifier the module imports the configuration's computed fields by:
+     * the file `aventara-build` writes beside the configuration
+     * (`computed-fields.generated.ts`). `null` when the step was given no
+     * configuration: the module then states none. Beside `model`, outside the
+     * hash.
      */
-    readonly computedFields: AvConfigComputedFields | null;
+    readonly computedFields: {
+        readonly specifier: string;
+    } | null;
 };
 export declare function emitDiscoveryArtifactModule(emission: PrismaArtifactEmission): Promise<string>;

package/dist/generate/artifact.emitter.js

@@ -19,7 +19,7 @@ const REFERENTIAL_ACTIONS_DOC = [
     "/**",
     " * The schema's referential actions, per Resource: the relation fields that",
     " * declare `@relation(fields: …)`, each with the fields holding its reference",
-    " * (`references`) and its resolved `onDelete` and `onUpdate`. An edge under",
+    " * (`referenceFields`) and its resolved `onDelete` and `onUpdate`. An edge under",
     " * Resource `R` reads:",
     " *",
     " *   deleting a `target` row does `onDelete` to rows of `R`.",
@@ -60,8 +60,8 @@ const MODEL_TYPE_DOC = [
 const COMPUTED_FIELDS_DOC = [
     "/**",
     " * Which fields the configuration's write compute fills (`compute.create`,",
-    " * `compute.update`), per layer and Resource, read off the configuration's type",
-    " * by the generate step. A variant's guards, pipes and filters may leave a",
+    " * `compute.update`), per layer and Resource, as aventara-build read them off",
+    " * the configuration's type. A variant's guards, pipes and filters may leave a",
     " * create's computed fields out; every other required field stays required.",
     " * The framework warns at startup when the configuration says otherwise: run",
     " * `aventara:prepare` again. Not part of `modelHash`.",
@@ -90,10 +90,7 @@ function computedFieldsLines(computedFields) {
     }
     return [
         ...COMPUTED_FIELDS_DOC,
-        `export const computedFields = ${canonicalLiteral(computedFields)} as const satisfies AvConfigComputedFields;`,
-        "",
-        "/** The type of {@link computedFields}: what `AvModel` carries to the stages' types. */",
-        "export type AvComputedFields = typeof computedFields;",
+        "export { type AvComputedFields, computedFields };",
         "",
     ];
 }
@@ -102,9 +99,12 @@ export async function emitDiscoveryArtifactModule(emission) {
     return `${[
         ...BANNER,
         "",
-        emission.computedFields === null
-            ? 'import type { AvAdapterModel } from "@aventara/core";'
-            : 'import type { AvAdapterModel, AvConfigComputedFields } from "@aventara/core";',
+        'import type { AvAdapterModel } from "@aventara/core";',
+        ...(emission.computedFields === null
+            ? []
+            : [
+                `import { type AvComputedFields, computedFields } from ${JSON.stringify(emission.computedFields.specifier)};`,
+            ]),
         "",
         `const discoveredModel = ${canonicalLiteral(emission.model)} as const satisfies AvAdapterModel;`,
         "",

package/dist/generate/computed-fields.import.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The specifier the artifact at `artifactFile` imports the computed fields by:
+ * the sibling `computed-fields.generated` module.
+ */
+export declare function computedFieldsSpecifier(artifactFile: string): string;

package/dist/generate/computed-fields.import.js

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+function projectOptions(directory) {
+    const tsconfig = ts.findConfigFile(directory, ts.sys.fileExists);
+    if (tsconfig === undefined) {
+        return {};
+    }
+    const read = ts.readConfigFile(tsconfig, ts.sys.readFile);
+    return read.error !== undefined
+        ? {}
+        : ts.parseJsonConfigFileContent(read.config, ts.sys, path.dirname(tsconfig))
+            .options;
+}
+function packageType(directory) {
+    for (let current = path.resolve(directory);;) {
+        const manifest = path.join(current, "package.json");
+        if (existsSync(manifest)) {
+            try {
+                return JSON.parse(readFileSync(manifest, "utf8")).type;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}
+function importSuffix(directory) {
+    const options = projectOptions(directory);
+    if (options.allowImportingTsExtensions === true ||
+        options
+            .rewriteRelativeImportExtensions === true) {
+        return ".ts";
+    }
+    if (options.module === ts.ModuleKind.CommonJS ||
+        options.moduleResolution === ts.ModuleResolutionKind.Bundler) {
+        return "";
+    }
+    if (options.module === ts.ModuleKind.Node16 ||
+        options.module === ts.ModuleKind.NodeNext) {
+        return packageType(directory) === "module" ? ".js" : "";
+    }
+    return ".js";
+}
+export function computedFieldsSpecifier(artifactFile) {
+    return `./computed-fields.generated${importSuffix(path.dirname(path.resolve(artifactFile)))}`;
+}

package/dist/generate/discovery.cli.js

@@ -14,10 +14,13 @@ Options:
   --driver    <name>  ${PRISMA_DRIVERS.join(" | ")}
   --out       <file>  Where to write the emitted artifact module (a .ts file).
   --config    <file>  Optional: your Aventara configuration module, such as
-                      src/aventara.config.ts (its \`aventaraConfig\` export, or
-                      its default). The artifact states which fields it
-                      computes, so the stages that run before compute may leave
-                      exactly those out of a create.
+                      src/aventara.config.ts. aventara-build reads which fields
+                      it computes and writes them to
+                      computed-fields.generated.ts beside the artifact; the
+                      artifact imports them from there, so the stages that
+                      run before compute may leave exactly those out of a
+                      create. This step never reads the configuration; it
+                      only checks that it exists.
   -h, --help          Print this and exit 0.
 
 The artifact must NOT be written inside --client: the next \`prisma generate\`
@@ -94,12 +97,6 @@ async function main(argv) {
     for (const absence of result.excluded) {
         process.stdout.write(`excluded: ${absence.message}\n`);
     }
-    if (result.computedFields?.kind === "read") {
-        process.stdout.write(`computed fields: read from ${options.config ?? "the configuration"}\n`);
-    }
-    else if (result.computedFields?.kind === "unread") {
-        process.stdout.write(`computed fields: not read, ${result.computedFields.reason}; the stages before compute may leave any create field out. Write the configuration \`as const\` there.\n`);
-    }
     for (const exemption of result.exemptions) {
         process.stdout.write(`exempt (${exemption.kind}) ${exemption.entity}: ${exemption.reason}\n`);
     }
@@ -114,7 +111,6 @@ export async function runFromProcess() {
             (error instanceof Error &&
                 (error.name === "AvPrismaGenerateStepError" ||
                     error.name === "AvPrismaModelCompositionError" ||
-                    error.name === "AvPrismaConfigReaderError" ||
                     error.name === "AvPrismaSchemaReaderError"));
         process.stderr.write(named
             ? `aventara-prisma7-generate: ${error.message}\n`

package/dist/generate/index.d.ts

@@ -1,8 +1,6 @@
 import type { AvPrismaDriver, AvPrismaProvider } from "../provider/provider-profile.js";
 import type { PrismaGenerateResult, PrismaGenerateToolchain } from "./prisma.generate.js";
 export { AvPrismaModelCompositionError, createPrismaModelComposer, } from "../discovery/model.discoverer.js";
-export type { ConfigComputedFieldsReading } from "./computed-fields.reader.js";
-export { AvPrismaConfigReaderError, readConfigComputedFields, } from "./computed-fields.reader.js";
 export type { PrismaEntityAbsence } from "./existence.gate.js";
 export type { PrismaComposedArtifact, PrismaGenerateRequest, PrismaGenerateResult, PrismaGenerateToolchain, PrismaModelComposer, } from "./prisma.generate.js";
 export { AvPrismaGenerateStepError, createPrismaGenerateToolchain, PINNED_PRISMA_MAJOR, runPrismaGenerateStep, } from "./prisma.generate.js";
@@ -19,9 +17,9 @@ export type PrismaDiscoveryGenerateRequest = {
     /** Where the emitted TypeScript artifact module is written. */
     readonly artifactFile: string;
     /**
-     * The Aventara configuration module whose computed fields the artifact
-     * states (`src/aventara.config.ts` in a scaffolded project); left out, it
-     * states none.
+     * The Aventara configuration module (`src/aventara.config.ts` in a
+     * scaffolded project): the artifact imports the fields it computes from
+     * the file `aventara-build` writes beside it. Left out, it states none.
      */
     readonly config?: string;
     /** Replaces the step's external effects; omit it to use the installed Prisma and TypeScript. */

package/dist/generate/index.js

@@ -2,7 +2,6 @@ import { createPrismaModelComposer } from "../discovery/model.discoverer.js";
 import { resolveProviderProfile } from "../provider/provider-profile.js";
 import { runPrismaGenerateStep } from "./prisma.generate.js";
 export { AvPrismaModelCompositionError, createPrismaModelComposer, } from "../discovery/model.discoverer.js";
-export { AvPrismaConfigReaderError, readConfigComputedFields, } from "./computed-fields.reader.js";
 export { AvPrismaGenerateStepError, createPrismaGenerateToolchain, PINNED_PRISMA_MAJOR, runPrismaGenerateStep, } from "./prisma.generate.js";
 export async function generatePrismaDiscoveryArtifact(request) {
     const profile = resolveProviderProfile({