@aventara/core 1.0.0-rc.1 → 1.0.0-rc.11

package/dist/framework/operation-set.runner.js

@@ -0,0 +1,168 @@
+import { isThenable } from "../runtime/thenable.guard.js";
+const LAZY_CALLS = new WeakMap();
+const ignore = () => undefined;
+export function signalOptionOf(options) {
+    if (typeof options !== "object" || options === null) {
+        return undefined;
+    }
+    const signal = options.signal;
+    return typeof signal === "object" &&
+        signal !== null &&
+        typeof signal.aborted === "boolean" &&
+        typeof signal.addEventListener === "function"
+        ? signal
+        : undefined;
+}
+function start(run, signal) {
+    if (signal?.aborted === true) {
+        return { result: Promise.reject(signal.reason), done: Promise.resolve() };
+    }
+    let running;
+    try {
+        running = run();
+    }
+    catch (error) {
+        running = Promise.reject(error);
+    }
+    const done = running.then(ignore, ignore);
+    if (signal === undefined) {
+        return { result: running, done };
+    }
+    const result = new Promise((resolve, reject) => {
+        const aborted = () => reject(signal.reason);
+        signal.addEventListener("abort", aborted, { once: true });
+        running.then((value) => {
+            signal.removeEventListener("abort", aborted);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", aborted);
+            reject(error);
+        });
+    });
+    return { result, done };
+}
+export function runAbortable(run, signal) {
+    return start(run, signal).result;
+}
+export function avLazy(make) {
+    const run = () => Promise.resolve(make());
+    const record = {
+        begin: (signal) => start(run, signal),
+    };
+    const result = () => record.begin().result;
+    const lazy = Object.freeze({
+        then: (onFulfilled, onRejected) => result().then(onFulfilled, onRejected),
+        catch: (onRejected) => result().catch(onRejected),
+        finally: (onFinally) => result().finally(onFinally),
+        [Symbol.toStringTag]: "Promise",
+    });
+    LAZY_CALLS.set(lazy, record);
+    return lazy;
+}
+export function maxAllConcurrencyOf(limits) {
+    const limit = limits.maxAllConcurrency;
+    return typeof limit === "number" && Number.isSafeInteger(limit) && limit >= 1
+        ? limit
+        : 1;
+}
+export function runOperationSet(entries, options, limits) {
+    if (typeof entries !== "object" ||
+        entries === null ||
+        Array.isArray(entries)) {
+        return Promise.reject(new TypeError("all takes an object of calls: { key: avClient.Resource.find.many(…), … }."));
+    }
+    const keyed = [];
+    for (const key of Object.keys(entries)) {
+        const value = entries[key];
+        if (!isThenable(value)) {
+            return Promise.reject(new TypeError(`all's entry ${JSON.stringify(key)} is not a call.`));
+        }
+        keyed.push([key, value]);
+    }
+    const settle = typeof options === "object" &&
+        options !== null &&
+        options.settle === true;
+    const outer = signalOptionOf(options);
+    const group = new AbortController();
+    const forward = () => {
+        group.abort(outer?.reason);
+    };
+    if (outer?.aborted === true) {
+        forward();
+    }
+    else {
+        outer?.addEventListener("abort", forward, { once: true });
+    }
+    const list = keyed.map(([key, value]) => {
+        const record = LAZY_CALLS.get(value);
+        let resolve = ignore;
+        let reject = ignore;
+        const outcome = new Promise((onResolve, onReject) => {
+            resolve = onResolve;
+            reject = onReject;
+        });
+        return {
+            key,
+            value,
+            record,
+            outcome,
+            resolve,
+            reject,
+        };
+    });
+    const answer = (entry, result) => {
+        result.then((value) => entry.resolve(value), (reason) => {
+            entry.reject(reason);
+            if (!settle) {
+                group.abort();
+            }
+        });
+    };
+    const follow = (entry, result) => {
+        const aborted = () => entry.reject(group.signal.reason);
+        if (group.signal.aborted) {
+            aborted();
+        }
+        else {
+            group.signal.addEventListener("abort", aborted, { once: true });
+        }
+        answer(entry, result);
+    };
+    for (const entry of list) {
+        if (entry.record === undefined) {
+            follow(entry, entry.value);
+        }
+    }
+    const queued = list.filter((entry) => entry.record !== undefined);
+    const cap = maxAllConcurrencyOf(limits);
+    let next = 0;
+    let running = 0;
+    const launch = () => {
+        while (next < queued.length && (running < cap || group.signal.aborted)) {
+            const entry = queued[next];
+            const record = entry.record;
+            next += 1;
+            const call = record.begin(group.signal);
+            running += 1;
+            answer(entry, call.result);
+            void Promise.all([call.done, entry.outcome.then(ignore, ignore)]).then(() => {
+                running -= 1;
+                launch();
+            });
+        }
+    };
+    group.signal.addEventListener("abort", launch, { once: true });
+    launch();
+    const done = (result) => {
+        outer?.removeEventListener("abort", forward);
+        return result;
+    };
+    const byKey = (values) => Object.fromEntries(list.map(({ key }, index) => [key, values[index]]));
+    if (settle) {
+        return Promise.all(list.map(({ outcome }) => outcome.then((value) => ({ status: "fulfilled", value }), (reason) => ({ status: "rejected", reason })))).then((settled) => done(byKey(settled)));
+    }
+    return Promise.all(list.map(({ outcome }) => outcome)).then((values) => done(byKey(values)), (error) => {
+        group.abort();
+        throw done(error);
+    });
+}

package/dist/index.d.ts

@@ -3,6 +3,8 @@ export type { AvAdapterDiscoveryDiagnostic, AvAdapterDiscoveryDiagnosticCode, }
 export type { AvAdapterModel } from "./adapters/adapter-model.js";
 export type { AvContracts } from "./compiler/contract.compiler.js";
 export type { AvContractCompilerDiagnostic, AvContractCompilerDiagnosticCode, } from "./compiler/contract-compiler-diagnostic.js";
+export { cache } from "./config/cache-stage.factory.js";
+export type { AvConfigComputedFields } from "./config/computed-fields.js";
 export type { AvMcpEndpoint } from "./config/config.resolver.js";
 export type { AvConfigDiagnostic, AvConfigDiagnosticCode, } from "./config/config-diagnostic.js";
 export type { AvConfigLayerName, AvRequestOrigin, } from "./config/config-layer.js";
@@ -12,12 +14,13 @@ export type { AvConfigExact } from "./config/exact-framework-config.js";
 export type { AvConfig, AvConfigAddedFieldDefinition, AvConfigAgentLayer, AvConfigAny, AvConfigExemptions, AvConfigFamily, AvConfigFieldDefinition, AvConfigFieldLifecycleTrait, AvConfigKnownFieldDefinition, AvConfigLayer, AvConfigLayerAny, AvConfigLayerKind, AvConfigLimits, AvConfigMcp, AvConfigOperations, AvConfigOperationsExemption, AvConfigOverlayField, AvConfigRelationFieldExemption, AvConfigResource, AvConfigResourceExemption, AvConfigResourceFields, AvConfigResourceKey, AvConfigResources, AvConfigResourcesAny, AvConfigResourceTransactions, AvConfigRootField, AvConfigScalarFieldExemption, AvConfigScalarTypeRef, AvConfigVariant, AvFieldCompute, AvRelationFieldCapabilityName, AvRelationFieldPipeline, AvScalarFieldCapabilityName, AvScalarFieldPipeline, AvZCheck, AvZFormat, } from "./config/framework-config.js";
 export type { AvPipeline, AvTransactionPipeline, } from "./config/pipeline-config.js";
 export type { AvPaginationCapability, AvProjectionScope, AvRelationFilterCapability, AvRelationMutationDirective, AvRelationReducer, AvScalarFilterOperator, AvScalarMutationDirective, AvWriteScope, } from "./contracts/capability.js";
-export type { AvContract, AvContractAgent, AvContractApplication, AvContractClient, AvContractCore, } from "./contracts/contract.js";
+export type { AvContract, AvContractAgent, AvContractApplication, AvContractClient, AvContractCore, AvCoreResource, } from "./contracts/contract.js";
+export type { AvContractClientAccess } from "./contracts/contract-access.js";
 export type { AvContractLimits } from "./contracts/contract-limits.js";
 export type { AvContractClientProtocol, AvContractHash, AvContractProtocol, } from "./contracts/contract-protocol.js";
 export type { AvCreateRequirementGroup, AvCreateRequirements, } from "./contracts/create-requirements.js";
 export type { AvEnumDefinition } from "./contracts/enum-definition.js";
-export type { AvField, AvProjectionScopes, AvRelationField, AvRelationFieldCapabilities, AvRelationMutationCapability, AvRelationProjectionCapability, AvRelationReducerCapability, AvScalarField, AvScalarFieldCapabilities, AvScalarFormat, AvScopedRelationMutations, AvScopedRelationReducers, AvWriteScopes, } from "./contracts/field.js";
+export type { AvCoreField, AvCoreRelationField, AvField, AvProjectionScopes, AvRelationField, AvRelationFieldCapabilities, AvRelationMutationCapability, AvRelationProjectionCapability, AvRelationReducerCapability, AvScalarField, AvScalarFieldCapabilities, AvScalarFormat, AvScopedRelationMutations, AvScopedRelationReducers, AvWriteScopes, } from "./contracts/field.js";
 export type { AvFieldCheck } from "./contracts/field-check.js";
 export type { AvIdentifier, AvScalarFieldKey } from "./contracts/identifier.js";
 export type { AvLifecycleTrait } from "./contracts/lifecycle-trait.js";
@@ -26,31 +29,42 @@ export type { AvOperationAvailability, AvOperationVariantScopes, AvResourceOpera
 export type { AvBuiltInScalar, AvScalarDefinition, AvScalarRegistry, } from "./contracts/scalar.js";
 export type { AvApplicationScalarForms, AvScalarValueType, AvWireScalarForms, } from "./contracts/scalar-value-type.js";
 export type { AvTransactionCapability } from "./contracts/transaction-capability.js";
+export type { AvContractView, AvManagedContractView, } from "./framework/contract-view.js";
 export { createFramework } from "./framework/framework.factory.js";
 export type { AvFramework } from "./framework/framework.js";
 export type { AvConstructionDiagnostic, AvConstructionStage, } from "./framework/framework-construction.error.js";
 export { AvConstructionError } from "./framework/framework-construction.error.js";
-export type { AvApplicationFacade, AvApplicationFamilyFacade, AvApplicationResourceFacade, AvAppTxFacade, AvAppTxFamilyFacade, AvAppTxResourceFacade, AvClientFacade, AvClientFamilyFacade, AvClientResourceFacade, AvClientTxFacade, AvClientTxFamilyFacade, AvClientTxResourceFacade, } from "./framework/operation-facade.js";
-export type { AvCreateDataInput, AvCursorInput, AvFieldKey, AvIncludeInput, AvNullsOrder, AvOperationArgumentMap, AvOperationArgumentsFor, AvOrderByEntry, AvOrderByInput, AvProjectionEntry, AvRelationProjectionInput, AvResourceKey, AvScalarOrderInput, AvSelectInput, AvSortDirection, AvUniqueWhereInput, AvUpdateDataInput, AvWhereInput, } from "./operations/operation-arguments.js";
+export type { AvApplicationFacade, AvApplicationFamilyFacade, AvApplicationPlainCall, AvApplicationProjectingCall, AvApplicationResourceFacade, AvAppTxFacade, AvAppTxFamilyFacade, AvAppTxPlainCall, AvAppTxProjectingCall, AvAppTxResourceFacade, AvClientFacade, AvClientFamilyFacade, AvClientPlainCall, AvClientProjectingCall, AvClientResourceFacade, AvClientTxFacade, AvClientTxFamilyFacade, AvClientTxPlainCall, AvClientTxProjectingCall, AvClientTxResourceFacade, AvServerClientFacade, AvServerClientFamilyFacade, AvServerClientPlainCall, AvServerClientProjectingCall, AvServerClientResourceFacade, AvServerClientTxFacade, AvServerClientTxFamilyFacade, AvServerClientTxPlainCall, AvServerClientTxProjectingCall, AvServerClientTxResourceFacade, } from "./framework/operation-facade.js";
+export { avLazy } from "./framework/operation-set.runner.js";
+export type { AvCreateDataInput, AvCursorInput, AvFieldKey, AvIncludeInput, AvNoAdvertisedMember, AvNullsOrder, AvOperationArgumentMap, AvOperationArgumentsFor, AvOrderByEntry, AvOrderByInput, AvProjectionEntry, AvRelationProjectionInput, AvResourceKey, AvScalarFilterOperands, AvScalarOrderInput, AvScalarWhereInput, AvSelectInput, AvSortDirection, AvUniqueWhereInput, AvUpdateDataInput, AvWhereInput, } from "./operations/operation-arguments.js";
 export type { AvDeferredOperationCall, AvOperationCall, AvOperationGrammar, AvOperationSlot, } from "./operations/operation-call.js";
 export type { AvOperationFamily, AvOperationIdentity, AvOperationVariant, } from "./operations/operation-identity.js";
 export type { AvOperationResultFor } from "./operations/operation-result.js";
 export type { AvValidationCode, AvValidationIssue, } from "./operations/validation-code.js";
+export type { AvAccessProvider } from "./policy/access-provider.interface.js";
+export type { AvAccessQuestion } from "./policy/access-question.js";
+export type { AvAccessVerbs } from "./policy/access-verbs.js";
+export type { AvPolicyEngine, AvPolicyWhere, } from "./policy/policy-engine.js";
+export type { AvPrebuiltContracts } from "./prebuilt/prebuilt-contracts.js";
 export { AvDecimal } from "./runtime/decimal.js";
-export type { AvDiagnostic, AvDiagnosticsSink, AvMcpDiagnostic, AvOperationDiagnostic, AvTransactionDiagnostic, } from "./runtime/diagnostics-reporter.js";
+export type { AvCanDiagnostic, AvDiagnostic, AvDiagnosticsSink, AvMcpDiagnostic, AvOperationDiagnostic, AvTransactionDiagnostic, } from "./runtime/diagnostics-reporter.js";
+export { AvErrorCatalog, type AvErrorCatalogCode, type AvErrorCatalogEntry, type AvErrorKind, } from "./runtime/error.catalog.js";
 export type { AvExecutionOptions } from "./runtime/execution-options.js";
 export type { AvComputeContext, AvComputeCreate, AvComputeRead, AvComputeUpdate, } from "./runtime/field-compute.js";
 export { AvAuthError, AvConflictError, AvContractMismatchError, AvError, AvInternalError, AvNotFoundError, AvProtocolError, AvValidationError, } from "./runtime/framework-error.js";
 export type { AvJsonValue } from "./runtime/json-value.js";
 export type { AvMisuseEvent, AvMisuseSink, } from "./runtime/misuse-reporter.js";
+export type { AvAgentOperationRequest, AvApplicationOperationRequest, AvClientOperationRequest, AvOperationRequest, AvRequestProtocol, } from "./runtime/operation-request.js";
 export type { AvCause, AvOperationCode, AvOperationErrorCode, AvOperationFailureResponse, AvOperationNoMatchResponse, AvOperationResponse, AvOperationSuccessCode, AvOperationSuccessDataCode, AvOperationSuccessResponse, } from "./runtime/operation-response.js";
 export type { AvAfterHook, AvBeforeHook, AvContext, AvFieldGuard, AvFieldPipe, AvFilter, AvGuard, AvInterceptor, AvPipe, AvTransactionAfterHook, AvTransactionBeforeHook, AvTransactionContext, AvTransactionFilter, AvTransactionGuard, AvTransactionInterceptor, AvTransactionPipe, AvTransactionStep, AvTransportContext, } from "./runtime/pipeline.js";
 export type { AvDeepReadonly } from "./runtime/readonly-value.js";
 export type { AvState } from "./runtime/request-state.js";
 export type { AvOperation, AvOperationHandle, AvOperationReferenceSurface, AvReferenceableField, AvReferenceBuilder, AvSingleRowResult, AvTransactionResults, AvTransactionRunner, } from "./transactions/deferred-operation.js";
+export type { AvSqlStatementBuilder, AvSqlStatementValue, } from "./transactions/sql-statement.js";
 export type { AvTransactionIntegrityViolation } from "./transactions/transaction-integrity-error.js";
 export { AvTransactionIntegrityError } from "./transactions/transaction-integrity-error.js";
 export type { AvTransactionReference } from "./transactions/transaction-reference.js";
+export type { AvAgentTransactionRequest, AvApplicationTransactionRequest, AvClientTransactionRequest, AvTransactionRequest, } from "./transactions/transaction-request.js";
 export type { AvTransactionCommittedResponse, AvTransactionResponse, } from "./transactions/transaction-response.js";
 export type { AvTransactionSlotPathViolation } from "./transactions/transaction-slot-path-error.js";
 export { AvTransactionSlotPathError } from "./transactions/transaction-slot-path-error.js";

package/dist/index.js

@@ -1,7 +1,10 @@
+export { cache } from "./config/cache-stage.factory.js";
 export { defineResource, } from "./config/define-resource.js";
 export { createFramework } from "./framework/framework.factory.js";
 export { AvConstructionError } from "./framework/framework-construction.error.js";
+export { avLazy } from "./framework/operation-set.runner.js";
 export { AvDecimal } from "./runtime/decimal.js";
+export { AvErrorCatalog, } from "./runtime/error.catalog.js";
 export { AvAuthError, AvConflictError, AvContractMismatchError, AvError, AvInternalError, AvNotFoundError, AvProtocolError, AvValidationError, } from "./runtime/framework-error.js";
 export { AvTransactionIntegrityError } from "./transactions/transaction-integrity-error.js";
 export { AvTransactionSlotPathError } from "./transactions/transaction-slot-path-error.js";

package/dist/internal.d.ts

@@ -15,6 +15,7 @@ export type { AvAdapterSqlStatement, AvAdapterSqlValue, } from "./adapters/adapt
 export type { AvAdapterTransactionExecutor } from "./adapters/adapter-transaction-executor.interface.js";
 export { compileContracts } from "./compiler/contract.compiler.js";
 export { resolveFrameworkConfig } from "./config/config.resolver.js";
+export { canonicalJson } from "./contracts/canonical-json.writer.js";
 export { PROJECTION_SCOPES, WRITE_SCOPES } from "./contracts/capability.js";
 export { validateClientContractStructure } from "./contracts/client-contract-structure.validator.js";
 export { AvCanonicalJsonError, canonicalizeContract, canonicalizeJson, } from "./contracts/contract-canonicalizer.js";
@@ -23,18 +24,24 @@ export { computeClientContractHash, verifyClientContractHash, } from "./contract
 export { DEFAULT_CONTRACT_LIMITS } from "./contracts/contract-limits.js";
 export { AVENTARA_PROTOCOL_VERSION } from "./contracts/contract-protocol.js";
 export { advertisedDirectives, advertisedReducers } from "./contracts/field.js";
+export { projectJsonValue } from "./contracts/json-schema.projector.js";
 export { LIFECYCLE_TRAITS } from "./contracts/lifecycle-trait.js";
 export { isOperationVariantAvailable, projectionScopeOf, writeScopeOf, } from "./contracts/resource-operations.js";
 export { BUILT_IN_SCALARS } from "./contracts/scalar.js";
 export { TRANSACTION_CAPABILITIES } from "./contracts/transaction-capability.js";
 export type { AvContractApplicationView } from "./framework/contract-view.js";
+export type { AvDatabaseRefusal } from "./operations/database-refusal.js";
+export { DATABASE_REFUSALS } from "./operations/database-refusal.js";
 export type { SemanticOperationArguments } from "./operations/operation-validator.js";
 export { VALIDATION_CODES } from "./operations/validation-code.js";
+export { accessProviderOf } from "./policy/access-provider.registry.js";
+export { ACCESS_VERB_NAMES, ACCESS_VERBS, providerVerb, } from "./policy/access-verb.table.js";
+export { holdRequestPrincipal } from "./policy/policy-request.js";
+export { prebuiltFileChanges } from "./prebuilt/prebuilt-changes.js";
+export { emitPrebuiltContracts, prebuiltContractsOf, } from "./prebuilt/prebuilt-contracts.emitter.js";
 export { mcpFailureReporterOf } from "./runtime/diagnostics-reporter.js";
 export type { AvErrorClassName } from "./runtime/framework-error-class.table.js";
 export { FRAMEWORK_ERROR_CLASS_OF } from "./runtime/framework-error-class.table.js";
-export type { AgentOperationRequest, ApplicationOperationRequest, ClientOperationRequest, ClientProtocolIdentity, FrameworkOperationRequest, } from "./runtime/operation-request.js";
 export { OPERATION_CODES } from "./runtime/operation-response.js";
 export type { BuiltinNonRow, OperationFingerprint, } from "./transactions/deferred-operation.js";
 export { computeOperationFingerprint } from "./transactions/operation-fingerprint.js";
-export type { AgentTransactionRequest, ApplicationTransactionRequest, ClientTransactionRequest, FrameworkTransactionRequest, } from "./transactions/transaction-request.js";

package/dist/internal.js

@@ -1,5 +1,6 @@
 export { compileContracts } from "./compiler/contract.compiler.js";
 export { resolveFrameworkConfig } from "./config/config.resolver.js";
+export { canonicalJson } from "./contracts/canonical-json.writer.js";
 export { PROJECTION_SCOPES, WRITE_SCOPES } from "./contracts/capability.js";
 export { validateClientContractStructure } from "./contracts/client-contract-structure.validator.js";
 export { AvCanonicalJsonError, canonicalizeContract, canonicalizeJson, } from "./contracts/contract-canonicalizer.js";
@@ -7,11 +8,18 @@ export { computeClientContractHash, verifyClientContractHash, } from "./contract
 export { DEFAULT_CONTRACT_LIMITS } from "./contracts/contract-limits.js";
 export { AVENTARA_PROTOCOL_VERSION } from "./contracts/contract-protocol.js";
 export { advertisedDirectives, advertisedReducers } from "./contracts/field.js";
+export { projectJsonValue } from "./contracts/json-schema.projector.js";
 export { LIFECYCLE_TRAITS } from "./contracts/lifecycle-trait.js";
 export { isOperationVariantAvailable, projectionScopeOf, writeScopeOf, } from "./contracts/resource-operations.js";
 export { BUILT_IN_SCALARS } from "./contracts/scalar.js";
 export { TRANSACTION_CAPABILITIES } from "./contracts/transaction-capability.js";
+export { DATABASE_REFUSALS } from "./operations/database-refusal.js";
 export { VALIDATION_CODES } from "./operations/validation-code.js";
+export { accessProviderOf } from "./policy/access-provider.registry.js";
+export { ACCESS_VERB_NAMES, ACCESS_VERBS, providerVerb, } from "./policy/access-verb.table.js";
+export { holdRequestPrincipal } from "./policy/policy-request.js";
+export { prebuiltFileChanges } from "./prebuilt/prebuilt-changes.js";
+export { emitPrebuiltContracts, prebuiltContractsOf, } from "./prebuilt/prebuilt-contracts.emitter.js";
 export { mcpFailureReporterOf } from "./runtime/diagnostics-reporter.js";
 export { FRAMEWORK_ERROR_CLASS_OF } from "./runtime/framework-error-class.table.js";
 export { OPERATION_CODES } from "./runtime/operation-response.js";

package/dist/operations/database-refusal.d.ts

@@ -0,0 +1,51 @@
+import type { AvValidationCode } from "./validation-code.js";
+/**
+ * Why the database refused a caller's value, each with the validation code and the
+ * issue message an adapter answers it with.
+ */
+export declare const DATABASE_REFUSALS: {
+    readonly tooLong: {
+        readonly code: "V1004";
+        readonly message: "The database refused this value: it is longer than the database can hold for its column.";
+    };
+    readonly outOfRange: {
+        readonly code: "V1004";
+        readonly message: "The database refused this value: it is outside the range its column can hold.";
+    };
+    readonly datetimeOutOfRange: {
+        readonly code: "V1004";
+        readonly message: "The database refused this value: the date and time is outside the range the database can hold.";
+    };
+    readonly divisionByZero: {
+        readonly code: "V1004";
+        readonly message: "The database refused this value: it divides by zero.";
+    };
+    readonly computedNull: {
+        readonly code: "V1004";
+        readonly message: "The database refused this value: the write computes no value for a column that requires one, as a division by zero does.";
+    };
+    readonly invalidInput: {
+        readonly code: "V1001";
+        readonly message: "The database refused this value: it is not valid input for its column's type.";
+    };
+    readonly nulInText: {
+        readonly code: "V1001";
+        readonly message: "The database refused this value: its text cannot contain the NUL character (U+0000).";
+    };
+    readonly nulInJson: {
+        readonly code: "V1001";
+        readonly message: "The database refused this value: its JSON cannot contain the NUL character (U+0000).";
+    };
+    readonly trailingEscape: {
+        readonly code: "V1001";
+        readonly message: "The database refused this value: a text match cannot end with the escape character \\.";
+    };
+    readonly backReference: {
+        readonly code: "V1012";
+        readonly message: "The data source refused this nested write: a record written through a relation cannot write that relation or its reference fields back.";
+    };
+};
+/** A reason the database refused a caller's value: a key of {@link DATABASE_REFUSALS}. */
+export type AvDatabaseRefusal = keyof typeof DATABASE_REFUSALS;
+/** Whether `message` is the message of a database refusal answered under `code`. */
+export declare function isDatabaseRefusalMessage(code: AvValidationCode, message: string): boolean;

package/dist/operations/database-refusal.js

@@ -0,0 +1,45 @@
+export const DATABASE_REFUSALS = {
+    tooLong: {
+        code: "V1004",
+        message: "The database refused this value: it is longer than the database can hold for its column.",
+    },
+    outOfRange: {
+        code: "V1004",
+        message: "The database refused this value: it is outside the range its column can hold.",
+    },
+    datetimeOutOfRange: {
+        code: "V1004",
+        message: "The database refused this value: the date and time is outside the range the database can hold.",
+    },
+    divisionByZero: {
+        code: "V1004",
+        message: "The database refused this value: it divides by zero.",
+    },
+    computedNull: {
+        code: "V1004",
+        message: "The database refused this value: the write computes no value for a column that requires one, as a division by zero does.",
+    },
+    invalidInput: {
+        code: "V1001",
+        message: "The database refused this value: it is not valid input for its column's type.",
+    },
+    nulInText: {
+        code: "V1001",
+        message: "The database refused this value: its text cannot contain the NUL character (U+0000).",
+    },
+    nulInJson: {
+        code: "V1001",
+        message: "The database refused this value: its JSON cannot contain the NUL character (U+0000).",
+    },
+    trailingEscape: {
+        code: "V1001",
+        message: "The database refused this value: a text match cannot end with the escape character \\.",
+    },
+    backReference: {
+        code: "V1012",
+        message: "The data source refused this nested write: a record written through a relation cannot write that relation or its reference fields back.",
+    },
+};
+export function isDatabaseRefusalMessage(code, message) {
+    return Object.values(DATABASE_REFUSALS).some((refusal) => refusal.code === code && refusal.message === message);
+}