@aventara/prisma7-adapter 1.0.0-rc.2 → 1.0.0-rc.4

package/CHANGELOG.md

@@ -1,5 +1,131 @@
 # @aventara/prisma7-adapter
 
+## 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
+
+- b38034d: `aventara-prisma7-generate` refuses a `--provider` that the schema's `datasource` block contradicts, or a block naming
+  a provider the adapter does not support, before `prisma generate` runs, so neither the Prisma client nor the artifact
+  is written:
+
+  ```text
+  aventara-prisma7-generate: --provider postgresql contradicts the schema's datasource `db` (prisma/schema.prisma:12), which names provider "sqlite"; pass --provider sqlite.
+  ```
+
+  PSL's `postgres` spelling counts as `postgresql`, and a provider that is not a string literal is not compared.
+  Before, the flag was taken on trust, and a wrong one wrote the wrong provider into the artifact and the wrong filter
+  modes into the Contract.
+
+  When the file system refuses the artifact file (`--out`), the step says so in one sentence naming the file and why,
+  such as
+  `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 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.`
+  (it said `longer than its column can hold`, which an index refusal is not).
+- Updated dependencies [b38034d]
+- Updated dependencies [b38034d]
+- Updated dependencies [b38034d]
+- Updated dependencies [b38034d]
+- Updated dependencies [b38034d]
+- Updated dependencies [b38034d]
+  - @aventara/core@1.0.0-rc.3
+
 ## 1.0.0-rc.2
 
 ### Patch Changes

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
@@ -86,8 +111,9 @@ npx aventara-prisma7-generate \
   --config   src/aventara.config.ts
 ```
 
-`--provider` and `--driver` are declared, never sniffed. The provider is recorded in the artifact. The
-driver decides `AvAdapterModel.transactions`, a driver fact the schema cannot state. Declare the driver
+`--provider` and `--driver` are declared, never sniffed. The provider is recorded in the artifact, and the
+step refuses a `--provider` that the schema's `datasource` block contradicts (`provider = "sqlite"` with
+`--provider postgresql`), naming the flag to pass. The driver decides `AvAdapterModel.transactions`, a driver fact the schema cannot state. Declare the driver
 the application will actually construct the adapter with. The two cannot drift silently, but they can
 disagree, and core refuses construction when they do.
 
@@ -98,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

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

@@ -107,11 +107,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/schema-facts.interface.d.ts

@@ -26,8 +26,16 @@ export type PrismaSchemaUnknownKind =
  | "block"
 /** A line the reader could not classify at all. */
  | "line";
+/** A `datasource` block: the provider it names. */
+export type PrismaSchemaDatasource = {
+    readonly name: string;
+    readonly provider: string | null;
+    readonly site: PrismaSchemaSite;
+};
 export type PrismaSchemaFacts = {
     readonly enums: readonly PrismaSchemaEnum[];
+    /** Every `datasource` block, in reading order (Prisma admits one). */
+    readonly datasources: readonly PrismaSchemaDatasource[];
     readonly models: readonly PrismaSchemaModel[];
     /**
      * Attributes and blocks the reader does not recognise at all (a `type`/`view`

package/dist/discovery/schema.reader.js

@@ -63,12 +63,15 @@ export function readPrismaSchemaSources(sources) {
     const enums = [];
     const models = [];
     const unhandled = [];
+    const datasources = [];
     for (const source of sources) {
-        readOneSource(source, enums, models, unhandled);
+        readOneSource(source, enums, models, unhandled, datasources);
     }
-    return { enums, models, unhandled };
+    return { enums, datasources, models, unhandled };
 }
-function readOneSource(source, enums, models, unhandled) {
+const DATASOURCE_PROVIDER = /^provider\s*=\s*(.*)$/;
+const STRING_LITERAL = /^"([^"\\]*)"$/;
+function readOneSource(source, enums, models, unhandled, datasources) {
     let open = null;
     const lines = source.text.split("\n");
     const unreadableActions = new Set();
@@ -105,12 +108,26 @@ function readOneSource(source, enums, models, unhandled) {
                     site: open.site,
                 });
             }
+            else if (open.kind === "datasource") {
+                datasources.push({
+                    name: open.name,
+                    provider: open.provider,
+                    site: open.site,
+                });
+            }
             open = null;
             continue;
         }
         if (open.kind === "skip") {
             continue;
         }
+        if (open.kind === "datasource") {
+            const assigned = DATASOURCE_PROVIDER.exec(line)?.[1]?.trim();
+            if (assigned !== undefined) {
+                open.provider = STRING_LITERAL.exec(assigned)?.[1] ?? null;
+            }
+            continue;
+        }
         if (open.kind === "enum") {
             if (line.startsWith("@@")) {
                 for (const attribute of splitAttributes(line)) {
@@ -175,6 +192,9 @@ function openBlock(line, site, record) {
     if (keyword === "enum") {
         return { kind: "enum", name, site, values: [] };
     }
+    if (keyword === "datasource") {
+        return { kind: "datasource", name, site, provider: null };
+    }
     if (keyword === "type" || keyword === "view") {
         record("block", keyword, line);
     }

package/dist/errors/error.normalizer.js

@@ -29,6 +29,7 @@ export const PRISMA_DATABASE_VALUE_TABLE = {
     "22025": "trailingEscape",
     "22009": "datetimeOutOfRange",
     "22012": "divisionByZero",
+    "54000": "tooLong",
 };
 function refusedValue(facts) {
     if (facts.code === undefined) {

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

@@ -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({

package/dist/generate/prisma.generate.d.ts

@@ -2,7 +2,6 @@ import type { PrismaCapabilitySurface } from "../discovery/capability-surface.in
 import type { AvPrismaAdapterModel, AvPrismaReferentialActionTable, PrismaTranslationTable } from "../discovery/discovery-artifact.interface.js";
 import type { PrismaSchemaFacts } from "../discovery/schema-facts.interface.js";
 import type { AvPrismaProvider } from "../provider/provider-profile.js";
-import { type ConfigComputedFieldsReading } from "./computed-fields.reader.js";
 import type { PrismaEntityAbsence } from "./existence.gate.js";
 import { type PrismaCli } from "./prisma-cli.resolver.js";
 import type { PrismaReaderExemption } from "./reader-crosscheck.js";
@@ -38,11 +37,6 @@ export type PrismaGenerateToolchain = {
     readonly readSchema: (location: string) => Promise<PrismaSchemaFacts>;
     readonly readSurface: (clientDirectory: string) => PrismaCapabilitySurface;
     readonly writeArtifact: (file: string, source: string) => Promise<void>;
-    /**
-     * Reads which fields a configuration computes off its type. Optional: the
-     * TypeScript reader is used when it is left out.
-     */
-    readonly readComputedFields?: (configFile: string) => ConfigComputedFieldsReading;
 };
 /** What {@link runPrismaGenerateStep} needs. */
 export type PrismaGenerateRequest = {
@@ -55,8 +49,11 @@ export type PrismaGenerateRequest = {
     readonly composeModel: PrismaModelComposer;
     /**
      * The application's Aventara configuration module (`src/aventara.config.ts`
-     * in a scaffolded project), whose computed fields the artifact states. Left
-     * out, the artifact states none (`computedFields: null`).
+     * in a scaffolded project). The artifact imports the fields it computes
+     * from the file `aventara-build` writes beside the artifact
+     * (`computed-fields.generated.ts`, a sibling); the step never reads the
+     * configuration, and only checks it exists. Left out, the artifact states
+     * none (`computedFields: null`).
      */
     readonly config?: string;
     readonly toolchain?: PrismaGenerateToolchain;
@@ -71,11 +68,6 @@ export type PrismaGenerateResult = {
     /** PSL-only entities the schema itself explained away. */
     readonly excluded: readonly PrismaEntityAbsence[];
     readonly exemptions: readonly PrismaReaderExemption[];
-    /**
-     * What the step made of the configuration's computed fields: read, or why
-     * not. Absent when it was given no configuration.
-     */
-    readonly computedFields?: ConfigComputedFieldsReading;
 };
 export declare function resolveInstalledPrismaCli(): PrismaCli;
 /**

package/dist/generate/prisma.generate.js

@@ -4,11 +4,10 @@ import path from "node:path";
 import { promisify } from "node:util";
 import ts from "typescript";
 import { computeModelHash } from "../discovery/artifact.loader.js";
-import { DISCOVERY_ARTIFACT_FORMAT } from "../discovery/discovery-artifact.interface.js";
-import { readPrismaSchema } from "../discovery/schema.reader.js";
+import { AvPrismaSchemaReaderError, readPrismaSchema, } from "../discovery/schema.reader.js";
 import { readPrismaCapabilitySurface } from "../discovery/types.reader.js";
 import { emitDiscoveryArtifactModule } from "./artifact.emitter.js";
-import { readConfigComputedFields, } from "./computed-fields.reader.js";
+import { computedFieldsSpecifier } from "./computed-fields.import.js";
 import { readDeclaredSupport } from "./declared-support.reader.js";
 import { applyExistenceGate } from "./existence.gate.js";
 import { resolvePrismaCli } from "./prisma-cli.resolver.js";
@@ -76,21 +75,38 @@ async function writeArtifactAtomically(file, source) {
     if (current === source) {
         return;
     }
-    await mkdir(path.dirname(file), { recursive: true });
     const staged = `${file}.${process.pid}.${Date.now()}.tmp`;
     try {
+        await mkdir(path.dirname(file), { recursive: true });
         await writeFile(staged, source, "utf8");
         await rename(staged, file);
     }
     catch (error) {
-        await rm(staged, { force: true });
-        throw error;
+        await rm(staged, { force: true }).catch(() => undefined);
+        throw unwritableArtifact(file, error);
     }
 }
-async function describesModel(file, modelHash) {
-    const current = await readFile(file, "utf8").catch(() => undefined);
-    return (current?.includes(`\tregenerate_with_aventara_prepare: ${DISCOVERY_ARTIFACT_FORMAT},\n`) === true &&
-        current.includes(`\tmodelHash: ${JSON.stringify(modelHash)},\n`));
+const UNWRITABLE_BECAUSE = {
+    EACCES: "permission denied",
+    EPERM: "permission denied",
+    ENOTDIR: "a part of its path is a file, not a directory",
+    EEXIST: "a part of its path is a file, not a directory",
+    ENOSPC: "no space is left on the device",
+    EROFS: "the file system is read-only",
+    EISDIR: "it is a directory",
+    ENAMETOOLONG: "its path is too long",
+};
+function unwritableArtifact(file, error) {
+    const code = error instanceof Error && "code" in error && typeof error.code === "string"
+        ? error.code
+        : undefined;
+    if (code === undefined) {
+        return error;
+    }
+    const because = Object.hasOwn(UNWRITABLE_BECAUSE, code)
+        ? `${UNWRITABLE_BECAUSE[code]} (${code})`
+        : code;
+    return new AvPrismaGenerateStepError(`the artifact file ${path.resolve(file)} (--out) cannot be written: ${because}.`);
 }
 function majorOf(version) {
     const major = /^(\d+)\./.exec(version)?.[1];
@@ -126,6 +142,28 @@ async function assertArtifactPlacement(artifactFile, clientDirectory) {
         throw new AvPrismaGenerateStepError(`the artifact file ${file} (--out) is a directory; name the .ts file to write, such as ${path.join(file, "discovery.artifact.ts")}.`);
     }
 }
+const PSL_PROVIDERS = {
+    sqlite: "sqlite",
+    postgresql: "postgresql",
+    postgres: "postgresql",
+};
+function assertDatasourceProvider(facts, provider) {
+    for (const datasource of facts.datasources) {
+        if (datasource.provider === null) {
+            continue;
+        }
+        const named = Object.hasOwn(PSL_PROVIDERS, datasource.provider)
+            ? PSL_PROVIDERS[datasource.provider]
+            : undefined;
+        if (named === provider) {
+            continue;
+        }
+        const where = `${datasource.site.file}:${datasource.site.line}`;
+        throw new AvPrismaGenerateStepError(named === undefined
+            ? `the schema's datasource \`${datasource.name}\` (${where}) names provider "${datasource.provider}", which this adapter does not support (${Object.keys(PSL_PROVIDERS).join(", ")}).`
+            : `--provider ${provider} contradicts the schema's datasource \`${datasource.name}\` (${where}), which names provider "${datasource.provider}"; pass --provider ${named}.`);
+    }
+}
 function assertNothingUnhandled(facts) {
     if (facts.unhandled.length === 0) {
         return;
@@ -141,6 +179,17 @@ export async function runPrismaGenerateStep(request) {
     const prismaVersion = await toolchain.installedPrismaVersion();
     assertPinnedMajor(prismaVersion);
     assertClientRuntimeResolves(toolchain, request.clientDirectory);
+    const declared = await toolchain
+        .readSchema(request.schema)
+        .catch((error) => {
+        if (error instanceof AvPrismaSchemaReaderError) {
+            return undefined;
+        }
+        throw error;
+    });
+    if (declared !== undefined) {
+        assertDatasourceProvider(declared, request.provider);
+    }
     await toolchain.runPrismaGenerate(request.schema);
     const facts = await toolchain.readSchema(request.schema);
     assertNothingUnhandled(facts);
@@ -170,19 +219,17 @@ export async function runPrismaGenerateStep(request) {
         client: clientShapeOf(surface),
     };
     const modelHash = await computeModelHash(model);
-    let computedFields;
-    if (request.config !== undefined) {
-        if (!(await describesModel(request.artifactFile, modelHash))) {
-            await toolchain.writeArtifact(request.artifactFile, await emitDiscoveryArtifactModule({
-                ...emission,
-                computedFields: null,
-            }));
-        }
-        computedFields = (toolchain.readComputedFields ?? readConfigComputedFields)(request.config);
+    if (request.config !== undefined &&
+        (await stat(request.config).catch(() => undefined))?.isFile() !== true) {
+        throw new AvPrismaGenerateStepError(`the configuration \`${request.config}\` does not exist (--config).`);
     }
     const source = await emitDiscoveryArtifactModule({
         ...emission,
-        computedFields: computedFields?.kind === "read" ? computedFields.computedFields : null,
+        computedFields: request.config === undefined
+            ? null
+            : {
+                specifier: computedFieldsSpecifier(request.artifactFile),
+            },
     });
     await toolchain.writeArtifact(request.artifactFile, source);
     return {
@@ -192,7 +239,6 @@ export async function runPrismaGenerateStep(request) {
         admitted,
         excluded,
         exemptions,
-        ...(computedFields === undefined ? {} : { computedFields }),
     };
 }
 function clientShapeOf(surface) {

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export type { AvPrismaAdapterModel, AvPrismaDiscoveryArtifact, AvPrismaReferentialAction, AvPrismaReferentialActionTable, AvPrismaReferentialEdge, AvPrismaResourceReferentialActions, } from "./discovery/discovery-artifact.interface.js";
 export type { AvPrismaAdapterOptions } from "./prisma.adapter.js";
 export { createPrismaAdapter } from "./prisma.adapter.js";
+export { describePrismaAdapter } from "./prisma-adapter.description.js";
 export type { AvPrismaDelegate, AvPrismaDelegateHost, AvPrismaDelegateIndex, AvPrismaTransactionOptions, } from "./prisma-client.interface.js";
 export type { AvPrismaDriver, AvPrismaIsolationLevel, AvPrismaProvider, AvPrismaProviderProfile, } from "./provider/provider-profile.js";

package/dist/index.js

@@ -1 +1,2 @@
 export { createPrismaAdapter } from "./prisma.adapter.js";
+export { describePrismaAdapter } from "./prisma-adapter.description.js";

package/dist/prisma-adapter.description.d.ts

@@ -0,0 +1,42 @@
+import type { AvAdapter, AvTransactionCapability } from "@aventara/core";
+import type { AvPrismaAdapterModel, AvPrismaDiscoveryArtifact } from "./discovery/discovery-artifact.interface.js";
+import { type AvPrismaDriver, type AvPrismaProvider } from "./provider/provider-profile.js";
+/** What {@link describePrismaAdapter} takes: the artifact and the declared provider and driver. */
+type PrismaAdapterDescriptionInput<M extends AvPrismaAdapterModel> = {
+    /** The `discovery` export of the generated discovery artifact. */
+    readonly discovery: AvPrismaDiscoveryArtifact<M>;
+    /** The database provider the client was generated for. */
+    readonly provider: AvPrismaProvider;
+    /** The Prisma driver adapter the client is constructed with. */
+    readonly driver: AvPrismaDriver;
+};
+/** The adapter's passive facts, as {@link describePrismaAdapter} states them. */
+type PrismaAdapterDescription<M extends AvPrismaAdapterModel> = PrismaAdapterDescriptionInput<M> & Required<Pick<AvAdapter<M>, "model" | "referentialActions">> & Pick<AvAdapter<M>, "computedFields"> & {
+    /**
+     * The driver's transaction capability: `"interactive"` when the
+     * constructed Adapter runs transactions, `"none"` when it carries no
+     * `transaction` (`@prisma/adapter-d1`).
+     */
+    readonly transactions: AvTransactionCapability;
+    /** Every Prisma driver runs developer SQL statements. */
+    readonly sqlStatements: true;
+};
+/**
+ * The Prisma 7 adapter's passive description: the model, the driver's
+ * transaction capability, the referential actions and the computed fields, read
+ * from the discovery artifact with no client. `aventara-build` compiles the
+ * Contracts from it; `createPrismaAdapter({ ...description, client })` builds
+ * the adapter from it.
+ *
+ * @example
+ * ```ts
+ * // src/aventara.adapter.ts
+ * export default describePrismaAdapter({
+ *   discovery,
+ *   provider: "postgresql",
+ *   driver: "@prisma/adapter-pg",
+ * });
+ * ```
+ */
+export declare function describePrismaAdapter<M extends AvPrismaAdapterModel>(input: PrismaAdapterDescriptionInput<M>): PrismaAdapterDescription<M>;
+export {};

package/dist/prisma-adapter.description.js

@@ -0,0 +1,36 @@
+import { resolveProviderProfile, } from "./provider/provider-profile.js";
+const DELETE_EFFECTS = {
+    cascade: "cascade",
+    restrict: "restrict",
+    "no-action": "noAction",
+    "set-null": "setNull",
+    "set-default": "setDefault",
+};
+function translateReferentialActions(table) {
+    return Object.fromEntries(Object.entries(table).map(([resource, { owningEdges }]) => [
+        resource,
+        owningEdges.map((edge) => ({
+            field: edge.field,
+            target: edge.target,
+            references: edge.references,
+            onDelete: DELETE_EFFECTS[edge.onDelete],
+        })),
+    ]));
+}
+export function describePrismaAdapter(input) {
+    const profile = resolveProviderProfile({
+        provider: input.provider,
+        driver: input.driver,
+    });
+    const computedFields = input.discovery.computedFields;
+    return Object.freeze({
+        discovery: input.discovery,
+        provider: input.provider,
+        driver: input.driver,
+        model: input.discovery.model,
+        transactions: profile.transactions,
+        referentialActions: translateReferentialActions(input.discovery.referentialActions),
+        ...(computedFields === null ? {} : { computedFields }),
+        sqlStatements: true,
+    });
+}

package/dist/prisma.adapter.js

@@ -5,25 +5,8 @@ import { derivePrismaBackReferences } from "./errors/back-reference.locator.js";
 import { createPrismaOperationExecutor } from "./execution/operation.executor.js";
 import { createPrismaSqlStatementExecutor } from "./execution/sql-statement.executor.js";
 import { createPrismaTransactionExecutor } from "./execution/transaction.executor.js";
-import { resolveBigintBinding, resolveProviderProfile, } from "./provider/provider-profile.js";
-const DELETE_EFFECTS = {
-    cascade: "cascade",
-    restrict: "restrict",
-    "no-action": "noAction",
-    "set-null": "setNull",
-    "set-default": "setDefault",
-};
-function translateReferentialActions(table) {
-    return Object.fromEntries(Object.entries(table).map(([resource, { owningEdges }]) => [
-        resource,
-        owningEdges.map((edge) => ({
-            field: edge.field,
-            target: edge.target,
-            references: edge.references,
-            onDelete: DELETE_EFFECTS[edge.onDelete],
-        })),
-    ]));
-}
+import { describePrismaAdapter } from "./prisma-adapter.description.js";
+import { resolveBigintBinding, } from "./provider/provider-profile.js";
 const PRISMA_VERSION_UNCHECKED_WARNING = "AVENTARA_PRISMA_VERSION_UNCHECKED";
 function installedClientVersion(discovery, override) {
     if (override !== undefined) {
@@ -47,22 +30,19 @@ function installedClientVersion(discovery, override) {
     return undefined;
 }
 export async function createPrismaAdapter(options) {
-    const profile = resolveProviderProfile({
-        provider: options.provider,
-        driver: options.driver,
-    });
+    const description = describePrismaAdapter(options);
     await loadDiscoveryArtifact({
         artifact: options.discovery,
         installedPrismaVersion: installedClientVersion(options.discovery, options.installedPrismaVersion),
     });
     assertClientMatchesArtifact(options.discovery.client, options.client);
-    const model = options.discovery.model;
-    const referentialActions = translateReferentialActions(options.discovery.referentialActions);
+    const model = description.model;
+    const referentialActions = description.referentialActions;
     const backReferences = derivePrismaBackReferences(options.discovery.model);
     const bigintBinding = resolveBigintBinding(options.driver);
-    const computedFields = options.discovery.computedFields === null
+    const computedFields = description.computedFields === undefined
         ? {}
-        : { computedFields: options.discovery.computedFields };
+        : { computedFields: description.computedFields };
     const { execute } = createPrismaOperationExecutor({
         client: options.client,
         model: options.discovery.model,
@@ -75,13 +55,13 @@ export async function createPrismaAdapter(options) {
             : { transactionOptions: options.transactionOptions }),
     });
     const executeSql = createPrismaSqlStatementExecutor(options.client);
-    if (profile.transactions === "none") {
+    if (description.transactions === "none") {
         return {
             model,
             referentialActions,
             ...computedFields,
             execute,
-            sqlStatements: true,
+            sqlStatements: description.sqlStatements,
             executeSql,
         };
     }
@@ -101,7 +81,7 @@ export async function createPrismaAdapter(options) {
         ...computedFields,
         execute,
         transaction,
-        sqlStatements: true,
+        sqlStatements: description.sqlStatements,
         executeSql,
     };
 }

package/dist/translation/operation.translator.js

@@ -131,7 +131,7 @@ function isUniqueSelectorVariant(key) {
 function singleCallArguments(context, key, predicate, projectionArgs) {
     const unique = isUniqueSelectorVariant(key);
     const where = unique
-        ? { where: uniqueWhere(context) }
+        ? { where: uniqueWhere(context, key) }
         : predicate === undefined
             ? {}
             : { where: predicate };
@@ -189,11 +189,18 @@ function singleCallArguments(context, key, predicate, projectionArgs) {
             throw new AvPrismaOperationTranslationError(`"${key}" has a dispatch entry and no argument shape, which is a translator defect`);
     }
 }
-function uniqueWhere(context) {
-    const selector = context.args.where;
-    if (!isRecord(selector)) {
+const SCOPED_UNIQUE_VARIANTS = new Set([
+    "update.unique",
+    "delete.unique",
+]);
+function uniqueWhere(context, key) {
+    const where = context.args.where;
+    if (!isRecord(where)) {
         throw new AvPrismaOperationTranslationError("where must be a unique identifier object for a unique variant");
     }
+    const { AND: conditions, ...rest } = where;
+    const scoped = conditions !== undefined && SCOPED_UNIQUE_VARIANTS.has(key);
+    const selector = scoped ? rest : where;
     const addressed = addressIdentifier({
         addresses: identifiersOf(context, context.resource),
         values: selector,
@@ -203,7 +210,17 @@ function uniqueWhere(context) {
     if (addressed === undefined) {
         throw new AvPrismaOperationTranslationError(`where: { ${Object.keys(selector).join(", ")} } is no identifier of Resource "${context.resource}", so it addresses no row`);
     }
-    return addressed.where;
+    if (!scoped) {
+        return addressed.where;
+    }
+    return {
+        ...addressed.where,
+        ...translateWhere({
+            model: context.model,
+            resource: context.resource,
+            where: { AND: conditions },
+        }),
+    };
 }
 function identifierSelect(context) {
     const [address] = identifiersOf(context, context.resource);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aventara/prisma7-adapter",
-  "version": "1.0.0-rc.2",
+  "version": "1.0.0-rc.4",
   "license": "SEE LICENSE IN LICENSE",
   "description": "The Prisma 7 adapter for Aventara.",
   "type": "module",
@@ -30,7 +30,7 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@aventara/core": "1.0.0-rc.2"
+    "@aventara/core": "1.0.0-rc.4"
   },
   "peerDependencies": {
     "@prisma/adapter-better-sqlite3": "^7.10.0",

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

@@ -1,19 +0,0 @@
-import type { AvConfigComputedFields } from "@aventara/core";
-/** What the reader made of a configuration: its computed fields, or why it could not tell. */
-export type ConfigComputedFieldsReading = {
-    readonly kind: "read";
-    readonly computedFields: AvConfigComputedFields;
-} | {
-    readonly kind: "unread";
-    readonly reason: string;
-};
-/** Thrown when the configuration the step was told to read cannot be found. */
-export declare class AvPrismaConfigReaderError extends Error {
-    readonly name = "AvPrismaConfigReaderError";
-}
-/**
- * Reads which fields the configuration in `configFile` computes, from the type
- * of its `aventaraConfig` export (a function's awaited return, or a value), or
- * of its default export.
- */
-export declare function readConfigComputedFields(configFile: string): ConfigComputedFieldsReading;

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

@@ -1,210 +0,0 @@
-import { existsSync } from "node:fs";
-import path from "node:path";
-import ts from "typescript";
-export class AvPrismaConfigReaderError extends Error {
-    name = "AvPrismaConfigReaderError";
-}
-const CONFIG_EXPORTS = ["aventaraConfig", "default"];
-const LAYERS = ["application", "client", "agent"];
-const AGENT_PARENTS = ["root", "application", "client"];
-const PHASES = ["create", "update"];
-class NotExact extends Error {
-}
-function defaultOptions() {
-    return {
-        target: ts.ScriptTarget.ES2022,
-        module: ts.ModuleKind.NodeNext,
-        moduleResolution: ts.ModuleResolutionKind.NodeNext,
-        strict: true,
-    };
-}
-function compilerOptionsFor(configFile) {
-    const tsconfig = ts.findConfigFile(path.dirname(configFile), ts.sys.fileExists, "tsconfig.json");
-    if (tsconfig === undefined) {
-        return defaultOptions();
-    }
-    const read = ts.readConfigFile(tsconfig, ts.sys.readFile);
-    if (read.error !== undefined) {
-        return defaultOptions();
-    }
-    return ts.parseJsonConfigFileContent(read.config, ts.sys, path.dirname(tsconfig)).options;
-}
-export function readConfigComputedFields(configFile) {
-    const file = path.resolve(configFile);
-    if (!existsSync(file)) {
-        throw new AvPrismaConfigReaderError(`the configuration \`${configFile}\` does not exist (--config).`);
-    }
-    const program = ts.createProgram({
-        rootNames: [file],
-        options: {
-            ...compilerOptionsFor(file),
-            noEmit: true,
-            skipLibCheck: true,
-        },
-    });
-    const checker = program.getTypeChecker();
-    const source = program.getSourceFile(file);
-    const module = source === undefined ? undefined : checker.getSymbolAtLocation(source);
-    if (module === undefined) {
-        throw new AvPrismaConfigReaderError(`the configuration \`${configFile}\` is not a module: it exports nothing to read.`);
-    }
-    const exports = checker.getExportsOfModule(module);
-    const exported = CONFIG_EXPORTS.map((name) => exports.find((symbol) => symbol.escapedName === name)).find((symbol) => symbol !== undefined);
-    if (exported === undefined) {
-        throw new AvPrismaConfigReaderError(`the configuration \`${configFile}\` exports neither \`aventaraConfig\` nor a default.`);
-    }
-    const target = exported.flags & ts.SymbolFlags.Alias
-        ? checker.getAliasedSymbol(exported)
-        : exported;
-    const declared = checker.getTypeOfSymbol(target);
-    const [signature] = declared.getCallSignatures();
-    const config = signature === undefined
-        ? declared
-        : (checker.getAwaitedType(signature.getReturnType()) ??
-            signature.getReturnType());
-    try {
-        return {
-            kind: "read",
-            computedFields: computedFieldsOfType(checker, config),
-        };
-    }
-    catch (error) {
-        if (error instanceof NotExact) {
-            return { kind: "unread", reason: error.message };
-        }
-        throw error;
-    }
-}
-function computedFieldsOfType(checker, config) {
-    assertExact(checker, config, "the configuration");
-    const overlays = Object.fromEntries(LAYERS.map((layer) => {
-        const overlay = stated(checker, config, layer, "the configuration");
-        return [
-            layer,
-            overlay === undefined
-                ? {}
-                : layerComputedFields(checker, overlay, layer),
-        ];
-    }));
-    return {
-        agent: overlays.agent,
-        agentExtends: agentParent(checker, config),
-        application: overlays.application,
-        client: overlays.client,
-        root: layerComputedFields(checker, config, "the root"),
-    };
-}
-function agentParent(checker, config) {
-    const agent = stated(checker, config, "agent", "the configuration");
-    const property = agent?.getProperty("extends");
-    if (property !== undefined && property.flags & ts.SymbolFlags.Optional) {
-        throw new NotExact("`extends` in agent may be absent");
-    }
-    const parent = property === undefined ? undefined : checker.getTypeOfSymbol(property);
-    if (parent === undefined) {
-        return "client";
-    }
-    const named = AGENT_PARENTS.find((candidate) => parent.isStringLiteral() && parent.value === candidate);
-    if (named === undefined) {
-        throw new NotExact(`\`agent.extends\` is \`${checker.typeToString(parent)}\`, not one layer`);
-    }
-    return named;
-}
-function layerComputedFields(checker, layer, where) {
-    const resources = stated(checker, layer, "resources", where);
-    if (resources === undefined) {
-        return {};
-    }
-    const result = {};
-    for (const [resource, block] of members(checker, resources, `${where}'s resources`)) {
-        const fields = stated(checker, block, "fields", `resources.${resource}`);
-        if (fields === undefined) {
-            continue;
-        }
-        const phases = {
-            create: [],
-            update: [],
-        };
-        for (const [field, entry] of members(checker, fields, `resources.${resource}.fields`)) {
-            const at = `resources.${resource}.fields.${field}`;
-            const pipelines = stated(checker, entry, "pipelines", at);
-            const compute = pipelines === undefined
-                ? undefined
-                : stated(checker, pipelines, "compute", `${at}.pipelines`);
-            if (compute === undefined) {
-                continue;
-            }
-            for (const phase of PHASES) {
-                if (stagePresent(checker, compute, phase, `${at}.pipelines.compute`)) {
-                    phases[phase].push(field);
-                }
-            }
-        }
-        const create = phases.create.sort();
-        const update = phases.update.sort();
-        if (create.length > 0 || update.length > 0) {
-            result[resource] = {
-                ...(create.length === 0 ? {} : { create }),
-                ...(update.length === 0 ? {} : { update }),
-            };
-        }
-    }
-    return Object.fromEntries(Object.entries(result).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0));
-}
-function assertExact(checker, type, where) {
-    if (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
-        throw new NotExact(`${where} has no type (\`${checker.typeToString(type)}\`)`);
-    }
-    if (type.isUnion()) {
-        throw new NotExact(`${where} is one of several shapes (\`${checker.typeToString(type)}\`)`);
-    }
-    if (checker.getIndexInfosOfType(type).length > 0) {
-        throw new NotExact(`${where} is not a literal: it has an index signature`);
-    }
-}
-function stated(checker, type, name, where) {
-    const property = type.getProperty(name);
-    if (property === undefined) {
-        return undefined;
-    }
-    if (property.flags & ts.SymbolFlags.Optional) {
-        throw new NotExact(`\`${name}\` in ${where} may be absent`);
-    }
-    const value = checker.getTypeOfSymbol(property);
-    if (value.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Never)) {
-        return undefined;
-    }
-    assertExact(checker, value, `\`${name}\` in ${where}`);
-    return value;
-}
-function stagePresent(checker, compute, phase, where) {
-    const property = compute.getProperty(phase);
-    if (property === undefined) {
-        return false;
-    }
-    if (property.flags & ts.SymbolFlags.Optional) {
-        throw new NotExact(`\`${phase}\` in ${where} may be absent`);
-    }
-    const stage = checker.getTypeOfSymbol(property);
-    if (stage.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Never)) {
-        return false;
-    }
-    const undefinedMember = (candidate) => (candidate.flags & ts.TypeFlags.Undefined) !== 0;
-    if (stage.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown) ||
-        (stage.isUnion() && stage.types.some(undefinedMember))) {
-        throw new NotExact(`\`${phase}\` in ${where} may be undefined (\`${checker.typeToString(stage)}\`)`);
-    }
-    return true;
-}
-function members(checker, type, where) {
-    return type
-        .getProperties()
-        .map((property) => {
-        const name = property.getName();
-        const value = stated(checker, type, name, where);
-        return value === undefined
-            ? undefined
-            : [name, value];
-    })
-        .filter((entry) => entry !== undefined);
-}