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

package/dist/errors/back-reference.locator.js

@@ -0,0 +1,100 @@
+export function derivePrismaBackReferences(model) {
+    const table = {};
+    for (const [source, resource] of Object.entries(model.resources)) {
+        const entries = {};
+        for (const [field, shape] of Object.entries(resource.fields)) {
+            if (shape.kind !== "relation" || typeof shape.inverse !== "string") {
+                continue;
+            }
+            const relation = shape.inverse;
+            const other = model.resources[shape.target]?.fields[relation];
+            entries[field] = {
+                relation,
+                references: other?.kind === "relation" ? (other.referenceFields ?? []) : [],
+            };
+        }
+        table[source] = entries;
+    }
+    return table;
+}
+const DATA_KEYS = {
+    $create: null,
+    $connectOrCreate: ["create"],
+    $update: ["data"],
+    $upsert: ["create", "update"],
+};
+const TOP_DATA_KEYS = ["data", "create", "update"];
+export function locateBackReferenceWrite(table, model, resource, args) {
+    if (!isRecord(args)) {
+        return undefined;
+    }
+    for (const key of TOP_DATA_KEYS) {
+        const found = eachRecord(args[key], [key], (data, path) => inRecord(table, model, resource, data, path, undefined));
+        if (found !== undefined) {
+            return found;
+        }
+    }
+    return undefined;
+}
+function inRecord(table, model, resource, data, path, via) {
+    const fields = model.resources[resource]?.fields;
+    for (const [key, value] of Object.entries(data)) {
+        if (via !== undefined &&
+            (key === via.relation || via.references.includes(key))) {
+            return [...path, key];
+        }
+        const shape = fields?.[key];
+        if (shape?.kind !== "relation" || !isRecord(value)) {
+            continue;
+        }
+        const back = table[resource]?.[key];
+        for (const [directive, operand] of Object.entries(value)) {
+            const dataKeys = DATA_KEYS[directive];
+            if (dataKeys === undefined) {
+                continue;
+            }
+            const found = eachRecord(operand, [...path, key, directive], (item, itemPath) => dataKeys === null
+                ? inRecord(table, model, shape.target, item, itemPath, back)
+                : firstOf(dataKeys, (dataKey) => {
+                    const nested = item[dataKey];
+                    return isRecord(nested)
+                        ? inRecord(table, model, shape.target, nested, [...itemPath, dataKey], back)
+                        : undefined;
+                }));
+            if (found !== undefined) {
+                return found;
+            }
+        }
+    }
+    return undefined;
+}
+function eachRecord(value, path, visit) {
+    if (Array.isArray(value)) {
+        for (const [index, entry] of value.entries()) {
+            const found = isRecord(entry)
+                ? visit(entry, [...path, index])
+                : undefined;
+            if (found !== undefined) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    return isRecord(value) ? visit(value, path) : undefined;
+}
+function firstOf(keys, find) {
+    for (const key of keys) {
+        const found = find(key);
+        if (found !== undefined) {
+            return found;
+        }
+    }
+    return undefined;
+}
+function isRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/errors/bigint-binding.locator.d.ts

@@ -0,0 +1,7 @@
+import type { PrismaArgumentPath } from "./back-reference.locator.js";
+/**
+ * Where the caller's arguments hold a `bigint` beyond ±(2^53 − 1), as a path in
+ * the arguments; `undefined` when they hold none. The first such value, in key
+ * order.
+ */
+export declare function locateUnboundBigint(args: unknown): PrismaArgumentPath | undefined;

package/dist/errors/bigint-binding.locator.js

@@ -0,0 +1,27 @@
+export function locateUnboundBigint(args) {
+    return isRecord(args) ? inValue(args, []) : undefined;
+}
+function inValue(value, path) {
+    if (typeof value === "bigint") {
+        return Number.isSafeInteger(Number(value)) ? undefined : path;
+    }
+    const entries = Array.isArray(value)
+        ? [...value.entries()]
+        : isRecord(value)
+            ? Object.entries(value)
+            : [];
+    for (const [key, member] of entries) {
+        const found = inValue(member, [...path, key]);
+        if (found !== undefined) {
+            return found;
+        }
+    }
+    return undefined;
+}
+function isRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/errors/error.normalizer.d.ts

@@ -1,11 +1,32 @@
 import { AvError, type AvOperationErrorCode, type AvOperationIdentity } from "@aventara/core";
+import { type AvDatabaseRefusal } from "@aventara/core/internal";
+import type { PrismaArgumentPath } from "./back-reference.locator.js";
 import { type PrismaConstraintSubject } from "./prisma-error.reader.js";
-/** The three answers a Prisma failure can get. */
+/**
+ * Where in the caller's arguments a refused call's cause stands, read only after
+ * the refusal; each answers `undefined` when the arguments do not explain it.
+ */
+export type PrismaArgumentLocators = {
+    /** A write that writes its relation back: for a validation error. */
+    readonly backReference?: () => PrismaArgumentPath | undefined;
+    /** A bigint the driver cannot bind: given only for a driver that binds a safe integer. */
+    readonly unboundBigint?: () => PrismaArgumentPath | undefined;
+};
+/** A value the database refused: every refusal but the ORM's nested-write one. */
+export type PrismaValueRefusal = Exclude<AvDatabaseRefusal, "backReference">;
+/** The five answers a Prisma failure can get. */
 export type PrismaErrorClassification = {
     readonly kind: "absence";
 } | {
     readonly kind: "outcome";
     readonly code: AvOperationErrorCode;
+} | {
+    readonly kind: "value";
+    readonly refusal: PrismaValueRefusal;
+    readonly path: PrismaArgumentPath;
+} | {
+    readonly kind: "nested-write";
+    readonly path: PrismaArgumentPath;
 } | {
     readonly kind: "unclassified";
 };
@@ -23,8 +44,15 @@ export type PrismaErrorTable = Readonly<Record<string, PrismaErrorRule>>;
 export declare const PRISMA_ERROR_TABLE_MAJOR = "7";
 /** Every code here was induced above. */
 export declare const PRISMA_ERROR_TABLE: PrismaErrorTable;
+/** Every P-code here was induced above: a value the database refused, by what it refused. */
+export declare const PRISMA_VALUE_TABLE: Readonly<Record<string, PrismaValueRefusal>>;
+/**
+ * `P2039` with the driver adapter's `kind: "postgres"`, by PostgreSQL's SQLSTATE:
+ * each one induced above by a caller's value.
+ */
+export declare const PRISMA_DATABASE_VALUE_TABLE: Readonly<Record<string, PrismaValueRefusal>>;
 /** Classifies one failed Prisma call. */
-export declare function classifyPrismaError(error: unknown, operation: Pick<AvOperationIdentity, "family" | "variant">): PrismaErrorClassification;
+export declare function classifyPrismaError(error: unknown, operation: Pick<AvOperationIdentity, "family" | "variant">, locators?: PrismaArgumentLocators): PrismaErrorClassification;
 /**
  * Classifies one failed `appTx.$sql` statement: a `P2010` by its driver-adapter
  * kind, any other P-code by the table, never forgiven as an absence (a statement
@@ -33,6 +61,10 @@ export declare function classifyPrismaError(error: unknown, operation: Pick<AvOp
 export declare function classifyPrismaStatementError(error: unknown): PrismaErrorClassification;
 /** The deliberate failure an `outcome` classification stands for. */
 export declare function prismaOutcomeFailure(code: AvOperationErrorCode): AvError;
+/** The `A2004` a value the database refused answers: one issue at the arguments (or the value in them) saying what was refused. */
+export declare function prismaValueFailure(refusal: PrismaValueRefusal, path?: PrismaArgumentPath): AvError;
+/** The `A2004` a nested write that writes its relation back answers: `V1012` at `path`. */
+export declare function prismaNestedWriteFailure(path: PrismaArgumentPath): AvError;
 export type PrismaConflictSubject = {
     readonly code: string;
     readonly model: string | undefined;

package/dist/errors/error.normalizer.js

@@ -1,4 +1,5 @@
 import { AvError, } from "@aventara/core";
+import { DATABASE_REFUSALS, } from "@aventara/core/internal";
 import { readPrismaError, } from "./prisma-error.reader.js";
 export const PRISMA_ERROR_TABLE_MAJOR = "7";
 export const PRISMA_ERROR_TABLE = {
@@ -14,11 +15,40 @@ export const PRISMA_ERROR_TABLE = {
             subject: "root-record",
         },
     },
+    P2028: { outcome: "A3002" },
 };
+export const PRISMA_VALUE_TABLE = {
+    P2000: "tooLong",
+    P2020: "outOfRange",
+    P2007: "invalidInput",
+    P2011: "computedNull",
+};
+export const PRISMA_DATABASE_VALUE_TABLE = {
+    "22021": "nulInText",
+    "22P05": "nulInJson",
+    "22025": "trailingEscape",
+    "22009": "datetimeOutOfRange",
+    "22012": "divisionByZero",
+};
+function refusedValue(facts) {
+    if (facts.code === undefined) {
+        return undefined;
+    }
+    if (Object.hasOwn(PRISMA_VALUE_TABLE, facts.code)) {
+        return PRISMA_VALUE_TABLE[facts.code];
+    }
+    return facts.code === "P2039" &&
+        facts.driverAdapterKind === "postgres" &&
+        facts.databaseCode !== undefined &&
+        Object.hasOwn(PRISMA_DATABASE_VALUE_TABLE, facts.databaseCode)
+        ? PRISMA_DATABASE_VALUE_TABLE[facts.databaseCode]
+        : undefined;
+}
 const OUTCOME_MESSAGES = {
     A2008: "The operation conflicts with the current state of the resource.",
     A2013: "Another operation modified the same state concurrently, so this operation was not applied and nothing was written.",
     A2003: "The operation's arguments referenced a record that does not exist.",
+    A3002: "The transaction was no longer open when this call ran: it had expired or been closed.",
 };
 function matchesAbsenceSubject(subject, facts) {
     switch (subject) {
@@ -26,10 +56,25 @@ function matchesAbsenceSubject(subject, facts) {
             return facts.relation === undefined;
     }
 }
-export function classifyPrismaError(error, operation) {
+export function classifyPrismaError(error, operation, locators = {}) {
     const facts = readPrismaError(error);
     if (facts.code === undefined) {
-        return { kind: "unclassified" };
+        const path = facts.errorClass === PRISMA_VALIDATION_ERROR_CLASS
+            ? locators.backReference?.()
+            : undefined;
+        return path === undefined
+            ? { kind: "unclassified" }
+            : { kind: "nested-write", path };
+    }
+    const refusal = refusedValue(facts);
+    if (refusal !== undefined) {
+        return { kind: "value", refusal, path: [] };
+    }
+    if (isDriverRefusalWithoutDatabaseCode(facts)) {
+        const path = locators.unboundBigint?.();
+        if (path !== undefined) {
+            return { kind: "value", refusal: "outOfRange", path };
+        }
     }
     const rule = Object.hasOwn(PRISMA_ERROR_TABLE, facts.code)
         ? PRISMA_ERROR_TABLE[facts.code]
@@ -74,6 +119,28 @@ export function prismaOutcomeFailure(code) {
         message: OUTCOME_MESSAGES[code] ?? "The operation could not be completed.",
     });
 }
+export function prismaValueFailure(refusal, path = []) {
+    const { code, message } = DATABASE_REFUSALS[refusal];
+    return new AvError("A2004", {
+        message: VALUE_REFUSED_MESSAGE,
+        issues: [{ path: ["arguments", ...path], code, message }],
+    });
+}
+const VALUE_REFUSED_MESSAGE = "The database refused a value in the arguments: it cannot store or compare it as written.";
+function isDriverRefusalWithoutDatabaseCode(facts) {
+    return (facts.code === "P2039" &&
+        facts.driverAdapterKind === "sqlite" &&
+        facts.databaseCode === undefined);
+}
+const PRISMA_VALIDATION_ERROR_CLASS = "PrismaClientValidationError";
+export function prismaNestedWriteFailure(path) {
+    const { code, message } = DATABASE_REFUSALS.backReference;
+    return new AvError("A2004", {
+        message: NESTED_WRITE_REFUSED_MESSAGE,
+        issues: [{ path: ["arguments", ...path], code, message }],
+    });
+}
+const NESTED_WRITE_REFUSED_MESSAGE = "The data source refused a nested write in the arguments.";
 export function describePrismaConflict(error) {
     const facts = readPrismaError(error);
     if (facts.code === undefined) {

package/dist/errors/prisma-error.reader.d.ts

@@ -26,7 +26,11 @@ export type PrismaErrorFacts = {
     readonly constraint: PrismaConstraintSubject | undefined;
     /** `meta.driverAdapterError.cause.kind`, e.g. `"UniqueConstraintViolation"`. */
     readonly driverAdapterKind: string | undefined;
+    /** `meta.driverAdapterError.cause.originalCode`, e.g. `"22021"`. */
+    readonly databaseCode: string | undefined;
     readonly legacyTarget: readonly string[] | undefined;
+    /** The error's own `name`, e.g. `"PrismaClientValidationError"`. */
+    readonly errorClass: string | undefined;
 };
 /**
  * Reads one hostile value into the facts a classification may use.

package/dist/errors/prisma-error.reader.js

@@ -72,6 +72,8 @@ export function readPrismaError(error) {
         relatedModel: ownString(meta, "model"),
         constraint: readConstraint(meta),
         driverAdapterKind: ownString(ownValue(ownValue(meta, "driverAdapterError"), "cause"), "kind"),
+        databaseCode: ownString(ownValue(ownValue(meta, "driverAdapterError"), "cause"), "originalCode"),
         legacyTarget: ownStringList(meta, "target"),
+        errorClass: ownString(error, "name"),
     };
 }

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

@@ -1,7 +1,9 @@
 import type { AvAdapterModel } from "@aventara/core";
 import type { AvAdapterOperationExecutor } from "@aventara/core/internal";
 import type { PrismaResourceTranslation } from "../discovery/discovery-artifact.interface.js";
+import { type PrismaBackReferenceTable } from "../errors/back-reference.locator.js";
 import { type AvPrismaDelegateHost, type AvPrismaTransactionOptions } from "../prisma-client.interface.js";
+import type { PrismaBigintBinding } from "../provider/provider-profile.js";
 /** A call the executor cannot issue against the client it was given. */
 export declare class AvPrismaExecutionError extends Error {
     readonly name = "AvPrismaExecutionError";
@@ -12,6 +14,10 @@ export type PrismaOperationExecutorDependencies = {
     readonly model: AvAdapterModel;
     /** The generate-time translation table (Prisma addressing per Resource). */
     readonly translation: Readonly<Record<string, PrismaResourceTranslation>>;
+    /** Each relation field's back-reference (`errors/back-reference.locator.ts`). */
+    readonly backReferences: PrismaBackReferenceTable;
+    /** How the driver binds a `bigint` (`provider/provider-profile.ts`). */
+    readonly bigintBinding: PrismaBigintBinding;
     readonly scope: PrismaExecutionScope;
     readonly transactionOptions?: AvPrismaTransactionOptions;
 };

package/dist/execution/operation.executor.js

@@ -1,4 +1,6 @@
-import { classifyPrismaError, prismaOutcomeFailure, } from "../errors/error.normalizer.js";
+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 { runFirstVariantEmulation } from "./first-variant.emulator.js";
@@ -12,6 +14,12 @@ export function delegateKeyOf(model) {
 }
 export function createPrismaOperationExecutor(dependencies) {
     const issue = async (call) => resolveDelegateCall(dependencies.client, call)(call.args);
+    const locatorFor = (operation) => ({
+        backReference: () => locateBackReferenceWrite(dependencies.backReferences, dependencies.model, operation.resource, operation.arguments),
+        ...(dependencies.bigintBinding === "safe-integer"
+            ? { unboundBigint: () => locateUnboundBigint(operation.arguments) }
+            : {}),
+    });
     return {
         async execute(operation) {
             const result = resultKindOf(dispatchOf(operation));
@@ -27,16 +35,17 @@ export function createPrismaOperationExecutor(dependencies) {
             };
             if (translation.plan.kind === "single") {
                 const call = translation.plan.call;
-                return shape(result, await issueClassified(issue, call, operation), shaping);
+                return shape(result, await issueClassified(issue, call, operation, locatorFor(operation)), shaping);
             }
             const { steps } = translation.plan;
-            const emulated = await classifyFailure(operation, () => runFirstVariantEmulation({
+            const locate = locatorFor(operation);
+            const emulated = await classifyFailure(operation, locate, () => runFirstVariantEmulation({
                 steps,
                 identifiers: identifiersOf(dependencies, operation.resource),
                 inUnit: (work) => withUnit(dependencies, (client) => work((call, step) => {
                     const send = (one) => resolveDelegateCall(client, one)(one.args);
                     return step === "read"
-                        ? issueClassified(send, call, operation)
+                        ? issueClassified(send, call, operation, locate)
                         : send(call);
                 })),
             }));
@@ -86,20 +95,24 @@ function resolveDelegateCall(client, call) {
     }
     return (args) => Promise.resolve(method.call(delegate, args));
 }
-function issueClassified(issue, call, operation) {
-    return classifyFailure(operation, () => issue(call));
+function issueClassified(issue, call, operation, locate) {
+    return classifyFailure(operation, locate, () => issue(call));
 }
-async function classifyFailure(operation, work) {
+async function classifyFailure(operation, locate, work) {
     try {
         return await work();
     }
     catch (error) {
-        const classification = classifyPrismaError(error, operation);
+        const classification = classifyPrismaError(error, operation, locate);
         switch (classification.kind) {
             case "absence":
                 return null;
             case "outcome":
                 throw prismaOutcomeFailure(classification.code);
+            case "value":
+                throw prismaValueFailure(classification.refusal, classification.path);
+            case "nested-write":
+                throw prismaNestedWriteFailure(classification.path);
             case "unclassified":
                 throw error;
         }

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

@@ -1,12 +1,16 @@
 import type { AvAdapterModel } from "@aventara/core";
 import type { AvAdapterTransactionExecutor } from "@aventara/core/internal";
 import type { PrismaResourceTranslation } from "../discovery/discovery-artifact.interface.js";
+import type { PrismaBackReferenceTable } from "../errors/back-reference.locator.js";
 import type { AvPrismaDelegateHost, AvPrismaTransactionOptions } from "../prisma-client.interface.js";
+import type { PrismaBigintBinding } from "../provider/provider-profile.js";
 export type PrismaTransactionExecutorDependencies = {
     readonly client: AvPrismaDelegateHost;
     readonly model: AvAdapterModel;
     /** The generate-time translation table (Prisma addressing per Resource). */
     readonly translation: Readonly<Record<string, PrismaResourceTranslation>>;
+    readonly backReferences: PrismaBackReferenceTable;
+    readonly bigintBinding: PrismaBigintBinding;
     readonly transactionOptions?: AvPrismaTransactionOptions;
 };
 export type PrismaTransactionRunner<M extends AvAdapterModel> = <T>(work: (executor: AvAdapterTransactionExecutor<M>) => Promise<T>) => Promise<T>;

package/dist/execution/transaction.executor.js

@@ -7,6 +7,8 @@ export function createPrismaTransactionExecutor(dependencies) {
             client: transactional,
             model: dependencies.model,
             translation: dependencies.translation,
+            backReferences: dependencies.backReferences,
+            bigintBinding: dependencies.bigintBinding,
             scope: "transaction",
         }),
         executeSql: createPrismaSqlStatementExecutor(transactional),

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

@@ -1,3 +1,4 @@
+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 = {
@@ -10,5 +11,10 @@ export type PrismaArtifactEmission = {
     readonly referentialActions: AvPrismaReferentialActionTable;
     /** 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.
+     */
+    readonly computedFields: AvConfigComputedFields | null;
 };
 export declare function emitDiscoveryArtifactModule(emission: PrismaArtifactEmission): Promise<string>;

package/dist/generate/artifact.emitter.js

@@ -50,21 +50,74 @@ const MODEL_DOC = [
     " * one is answered `A2004`/`V1000` at its path before the database is reached.",
     " */",
 ];
+const MODEL_TYPE_DOC = [
+    "/**",
+    " * The model's type, by name: a declaration that holds the model (an exported",
+    " * configuration, an `AppFramework` alias) writes `AvModel` rather",
+    " * than the whole model. `typeof model` is this type.",
+    " */",
+];
+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",
+    " * 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`.",
+    " */",
+];
+const NO_COMPUTED_FIELDS_DOC = [
+    "/**",
+    " * `null`: the generate step was given no configuration (`--config`), so the",
+    " * stages before write compute may leave any create field out. Not part of",
+    " * `modelHash`.",
+    " */",
+];
 const DISCOVERY_DOC = [
     "/** Pass this to `createPrismaAdapter({ discovery })`. */",
 ];
 function canonicalLiteral(value) {
     return JSON.stringify(JSON.parse(canonicalizeJson(value)), null, "\t");
 }
+function computedFieldsLines(computedFields) {
+    if (computedFields === null) {
+        return [
+            ...NO_COMPUTED_FIELDS_DOC,
+            "export const computedFields = null;",
+            "",
+        ];
+    }
+    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 async function emitDiscoveryArtifactModule(emission) {
     const modelHash = await computeModelHash(emission.model);
     return `${[
         ...BANNER,
         "",
-        'import type { AvAdapterModel } from "@aventara/core";',
+        emission.computedFields === null
+            ? 'import type { AvAdapterModel } from "@aventara/core";'
+            : 'import type { AvAdapterModel, AvConfigComputedFields } from "@aventara/core";',
+        "",
+        `const discoveredModel = ${canonicalLiteral(emission.model)} as const satisfies AvAdapterModel;`,
+        "",
+        ...computedFieldsLines(emission.computedFields),
+        ...MODEL_TYPE_DOC,
+        "export type AvModel = {",
+        "\treadonly [K in keyof typeof discoveredModel]: (typeof discoveredModel)[K];",
+        emission.computedFields === null
+            ? "};"
+            : '} & { readonly "~computedFields"?: AvComputedFields };',
         "",
         ...MODEL_DOC,
-        `export const model = ${canonicalLiteral(emission.model)} as const satisfies AvAdapterModel;`,
+        "export const model: AvModel = discoveredModel;",
         "",
         ...TRANSLATION_DOC,
         `export const translation = ${canonicalLiteral(emission.translation)} as const;`,
@@ -89,6 +142,7 @@ export async function emitDiscoveryArtifactModule(emission) {
         "\ttranslation,",
         "\treferentialActions,",
         "\tclient,",
+        "\tcomputedFields,",
         "} as const;",
     ].join("\n")}\n`;
 }

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

@@ -0,0 +1,19 @@
+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;