@aventara/core 1.0.0-rc.0 → 1.0.0-rc.10

package/dist/operations/operation-validator-core.js

@@ -1,10 +1,11 @@
+import { FILTER_MODES, toOneRelinkWithRewrite, } from "../contracts/capability.js";
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
 import { advertisedDirectivesAt, advertisedReducers, advertisedReducersAt, holdsAt, } from "../contracts/field.js";
-import { isPlainRecord } from "../runtime/scalar-runtime.js";
+import { isPlainRecord, unsentReadValueIssue, } from "../runtime/scalar-runtime.js";
 import { routeTransactionReferenceCandidate } from "../transactions/transaction-reference.js";
 import { isOperationFamily, } from "./operation-identity.js";
 import { NESTED_PROJECTION_SCOPE, resolveProjectionScope, } from "./projection-scope.resolver.js";
-import { NESTED_WRITE_SCOPE, resolveWriteScope, } from "./write-scope.resolver.js";
+import { NESTED_WRITE_SCOPE, resolveWriteScope, TO_MANY_UPDATE_WRITE_SCOPE, } from "./write-scope.resolver.js";
 const OPERATION_ARGUMENT_RULES = {
     "find.first": {
         allowed: ["where", "orderBy", "select", "include"],
@@ -153,12 +154,15 @@ function checkDepth(contract, state, depth) {
     }
     return false;
 }
-function validateScalarFilter(fieldName, field, value, path, state) {
+function validateScalarFilter(contract, fieldName, field, value, path, state, depth) {
     const supported = field.capabilities.filter;
     if (supported === undefined) {
         addIssue(state.issues, "V1006", path, `Filtering is not available on field "${fieldName}".`);
         return;
     }
+    validateScalarCondition(contract, fieldName, field, supported, value, path, state, depth);
+}
+function validateScalarCondition(contract, fieldName, field, supported, value, path, state, depth) {
     if (value === null) {
         if (!field.nullable) {
             addIssue(state.issues, "V1001", path, `Field "${fieldName}" is not nullable.`);
@@ -187,18 +191,74 @@ function validateScalarFilter(fieldName, field, value, path, state) {
         addIssue(state.issues, "V1001", path, `Filter object for field "${fieldName}" must contain an operator.`);
         return;
     }
+    refuseDanglingQualifiers(fieldName, value, path, state);
     for (const operator of operators) {
         if (!includes(supported, operator)) {
             addIssue(state.issues, "V1006", [...path, operator], `Filter operator "${operator}" is not available on field "${fieldName}".`);
+            continue;
+        }
+        if (operator === "mode") {
+            refuseUnavailableMode(field, fieldName, value, path, state);
+            continue;
+        }
+        if (operator === "not") {
+            const operand = value[operator];
+            if (isPlainRecord(operand) && !checkDepth(contract, state, depth + 1)) {
+                continue;
+            }
+            validateScalarCondition(contract, fieldName, field, supported, operand, [...path, operator], state, isPlainRecord(operand) ? depth + 1 : depth);
         }
     }
 }
+function refuseDanglingQualifiers(fieldName, level, path, state) {
+    const qualifiers = DANGLING_QUALIFIERS.filter((key) => Object.hasOwn(level, key));
+    if (qualifiers.length === 0) {
+        return;
+    }
+    const compares = Object.entries(level).some(([operator, operand]) => !includes(DANGLING_QUALIFIERS, operator) &&
+        !(operator === "not" && isNegatedOperatorObject(operand, state)));
+    if (compares) {
+        return;
+    }
+    for (const qualifier of qualifiers) {
+        addIssue(state.issues, "V1001", [...path, qualifier], `${qualifier} on field "${fieldName}" qualifies no operator: write it next to the operator it applies to (inside "not" to apply to a negated one).`);
+    }
+}
+const DANGLING_QUALIFIERS = ["mode", "path"];
+function isNegatedOperatorObject(operand, state) {
+    return (isPlainRecord(operand) &&
+        !(state.transactionReferences === true &&
+            routeTransactionReferenceCandidate(operand).kind !== "ordinary"));
+}
+function refuseUnavailableMode(field, fieldName, level, path, state) {
+    const mode = level.mode;
+    if (mode === "default" ||
+        typeof mode !== "string" ||
+        !includes(FILTER_MODES, mode)) {
+        return;
+    }
+    const { filterModes = [], pathFilterModes } = field.capabilities;
+    const atPath = Object.hasOwn(level, "path") && pathFilterModes !== undefined;
+    if (includes(atPath ? pathFilterModes : filterModes, mode)) {
+        return;
+    }
+    const where = atPath
+        ? " at a path"
+        : pathFilterModes !== undefined && includes(pathFilterModes, mode)
+            ? " without a path"
+            : "";
+    addIssue(state.issues, "V1006", [...path, "mode"], `Filter mode "${mode}" is not available on field "${fieldName}"${where}.`);
+}
 function validateRelationFilter(contract, fieldName, field, value, path, state, depth) {
     const supported = field.capabilities.filter;
     if (supported === undefined) {
         addIssue(state.issues, "V1006", path, `Filtering is not available on relation "${fieldName}".`);
         return;
     }
+    if (value === undefined) {
+        state.issues.push(unsentReadValueIssue(path));
+        return;
+    }
     if (field.cardinality === "one") {
         if (value === null) {
             if (!field.nullable || !includes(supported, "null")) {
@@ -238,10 +298,26 @@ function validateRelationFilter(contract, fieldName, field, value, path, state,
         validateWhere(contract, field.target, value[operator], [...path, operator], state, depth + 1);
     }
 }
+const UNDEFINED_ARGUMENT_MESSAGES = {
+    where: "where must not be undefined: leave the key out to mean no filter.",
+    limit: "limit must not be undefined: leave the key out to mean no limit.",
+    offset: "offset must not be undefined: leave the key out to mean no offset.",
+    cursor: "cursor must not be undefined: leave the key out to mean no cursor.",
+};
+const EMPTY_BOOLEAN_NODE_MESSAGE = "A boolean node must hold a condition here: an empty one matches every row, and the write would reach more rows.";
+function isEmptyBooleanNode(value) {
+    return Array.isArray(value)
+        ? value.length === 0
+        : isRecord(value) && Object.keys(value).length === 0;
+}
 function validateWhere(contract, resourceName, where, path, state, depth) {
     if (!checkDepth(contract, state, depth)) {
         return;
     }
+    if (where === undefined) {
+        state.issues.push(unsentReadValueIssue(path));
+        return;
+    }
     if (!isRecord(where)) {
         addIssue(state.issues, "V1001", path, "where must be an object.");
         return;
@@ -252,6 +328,13 @@ function validateWhere(contract, resourceName, where, path, state, depth) {
         return;
     }
     for (const [key, value] of Object.entries(where)) {
+        if (state.refuseEmptyNodes === true &&
+            (key === "AND" || key === "OR" || key === "NOT") &&
+            isEmptyBooleanNode(value)) {
+            countFilterNode(contract, state);
+            addIssue(state.issues, "V1001", [...path, key], EMPTY_BOOLEAN_NODE_MESSAGE);
+            continue;
+        }
         if (key === "AND" || key === "OR") {
             countFilterNode(contract, state);
             if (!Array.isArray(value)) {
@@ -259,6 +342,10 @@ function validateWhere(contract, resourceName, where, path, state, depth) {
                 continue;
             }
             value.forEach((entry, index) => {
+                if (state.refuseEmptyNodes === true && isEmptyBooleanNode(entry)) {
+                    addIssue(state.issues, "V1001", [...path, key, index], EMPTY_BOOLEAN_NODE_MESSAGE);
+                    return;
+                }
                 validateWhere(contract, resourceName, entry, [...path, key, index], state, depth + 1);
             });
             continue;
@@ -276,7 +363,7 @@ function validateWhere(contract, resourceName, where, path, state, depth) {
         }
         const fieldPath = [...path, key];
         if (field.kind === "scalar") {
-            validateScalarFilter(key, field, value, fieldPath, state);
+            validateScalarFilter(contract, key, field, value, fieldPath, state, depth);
         }
         else if (state.scalarOnly === true) {
             addIssue(state.issues, "V1006", fieldPath, `Relation filter "${key}" is not available here: a nested $update or $delete filter on this relation takes scalar fields only.`);
@@ -355,7 +442,9 @@ function validateOrderBy(contract, resourceName, orderBy, path, issues) {
                 valueKeys[1] !== "sort" ||
                 (value.sort !== "asc" && value.sort !== "desc") ||
                 (value.nulls !== "first" && value.nulls !== "last")) {
-                addIssue(issues, "V1001", fieldPath, `Extended null ordering for "${fieldName}" must contain sort and nulls.`);
+                addIssue(issues, "V1001", fieldPath, Object.hasOwn(value, "$ref")
+                    ? `A transaction reference cannot stand in orderBy: order "${fieldName}" by "asc", "desc" or { sort, nulls }.`
+                    : `Null ordering for "${fieldName}" must be exactly { sort: "asc" | "desc", nulls: "first" | "last" }.`);
                 continue;
             }
             if (!field.nullable || field.capabilities.orderNulls !== true) {
@@ -382,6 +471,10 @@ function validateOrderBy(contract, resourceName, orderBy, path, issues) {
     return analysis;
 }
 function validatePaginationValue(contract, name, value, path, issues) {
+    if (value === undefined) {
+        addIssue(issues, "V1001", path, UNDEFINED_ARGUMENT_MESSAGES[name]);
+        return;
+    }
     if (!Number.isInteger(value) || typeof value !== "number" || value < 0) {
         addIssue(issues, "V1001", path, `${name} must be a non-negative integer.`);
         return;
@@ -391,6 +484,10 @@ function validatePaginationValue(contract, name, value, path, issues) {
     }
 }
 function validateCursor(contract, resourceName, cursor, orderBy, path, issues) {
+    if (cursor === undefined) {
+        addIssue(issues, "V1009", path, UNDEFINED_ARGUMENT_MESSAGES.cursor);
+        return;
+    }
     if (!isRecord(cursor) || orderBy === undefined) {
         addIssue(issues, "V1009", path, "Cursor pagination requires an object cursor and explicit deterministic orderBy.");
         return;
@@ -427,6 +524,12 @@ function validateProjection(contract, resourceName, mode, value, scope, path, is
     }
     value.forEach((entry, index) => {
         const entryPath = [...path, index];
+        if (entry === "$defaults") {
+            if (mode !== "select") {
+                addIssue(issues, "V1008", entryPath, "$defaults is a select entry: include already returns the default fields.");
+            }
+            return;
+        }
         if (entry === "$count") {
             if (mode !== "select" ||
                 reducerOwner?.edge.cardinality !== "many" ||
@@ -502,6 +605,9 @@ function validateRelationProjection(contract, edge, scope, value, path, issues)
         if (!includes(edge.capabilities.filter, "nested")) {
             addIssue(issues, "V1006", [...path, "where"], "Nested returned-relation filtering is not available on this edge.");
         }
+        else if (value.where === undefined) {
+            addIssue(issues, "V1001", [...path, "where"], UNDEFINED_ARGUMENT_MESSAGES.where);
+        }
         else {
             const state = {
                 issues,
@@ -575,11 +681,16 @@ function validateScalarMutation(fieldName, field, value, stage, path, issues, tr
         addIssue(issues, "V1001", path, "Scalar mutation action objects may contain only $-prefixed directive keys.");
         return;
     }
+    let unavailable = false;
     for (const directive of directiveKeys) {
         if (!includes(directives, directive)) {
+            unavailable = true;
             addIssue(issues, "V1006", [...path, directive], `Mutation directive "${directive}" is not available on field "${fieldName}".`);
         }
     }
+    if (!unavailable && directiveKeys.length > 1) {
+        addIssue(issues, "V1001", path, "Scalar mutation action objects may contain only one directive.");
+    }
 }
 function validateRelationMutationEntry(contract, edge, directive, value, path, issues, transactionReferences) {
     const target = edge.target;
@@ -599,8 +710,8 @@ function validateRelationMutationEntry(contract, edge, directive, value, path, i
             addIssue(issues, "V1012", path, "To-many $disconnect requires one or more unique identifiers.");
             return;
         }
-        for (const selector of selectors) {
-            validateUniqueSelector(contract, target, selector, path, issues);
+        for (const { entry: selector, at } of entriesOf(edge, value, path)) {
+            validateUniqueSelector(contract, target, selector, at, issues);
         }
         return;
     }
@@ -615,82 +726,81 @@ function validateRelationMutationEntry(contract, edge, directive, value, path, i
             addIssue(issues, "V1012", path, "To-many $set requires an identifier array.");
             return;
         }
-        for (const selector of value) {
-            validateUniqueSelector(contract, target, selector, path, issues);
+        for (const { entry: selector, at } of entriesOf(edge, value, path)) {
+            validateUniqueSelector(contract, target, selector, at, issues);
         }
         return;
     }
     if (directive === "$connect") {
-        const selectors = edge.cardinality === "many" && Array.isArray(value) ? value : [value];
-        for (const selector of selectors) {
-            validateUniqueSelector(contract, target, selector, path, issues);
+        for (const { entry: selector, at } of entriesOf(edge, value, path)) {
+            validateUniqueSelector(contract, target, selector, at, issues);
         }
         return;
     }
     if (directive === "$create") {
-        const entries = edge.cardinality === "many" && Array.isArray(value) ? value : [value];
-        for (const entry of entries) {
-            validateMutationData(contract, target, entry, "create", NESTED_WRITE_SCOPE, path, issues, transactionReferences);
+        for (const { entry, at } of entriesOf(edge, value, path)) {
+            validateMutationData(contract, target, entry, "create", NESTED_WRITE_SCOPE, at, issues, transactionReferences);
         }
         return;
     }
     if (directive === "$connectOrCreate") {
-        const entries = edge.cardinality === "many" && Array.isArray(value) ? value : [value];
-        for (const entry of entries) {
+        for (const { entry, at } of entriesOf(edge, value, path)) {
             if (!isRecord(entry) || !("where" in entry) || !("create" in entry)) {
-                addIssue(issues, "V1012", path, "$connectOrCreate requires where and create.");
+                addIssue(issues, "V1012", at, "$connectOrCreate requires where and create.");
                 continue;
             }
-            validateUniqueSelector(contract, target, entry.where, [...path, "where"], issues);
-            validateMutationData(contract, target, entry.create, "create", NESTED_WRITE_SCOPE, [...path, "create"], issues, transactionReferences);
+            validateUniqueSelector(contract, target, entry.where, [...at, "where"], issues);
+            validateMutationData(contract, target, entry.create, "create", NESTED_WRITE_SCOPE, [...at, "create"], issues, transactionReferences);
         }
         return;
     }
     if (directive === "$update") {
-        const entries = edge.cardinality === "many" && Array.isArray(value) ? value : [value];
-        for (const entry of entries) {
+        for (const { entry, at } of entriesOf(edge, value, path)) {
             if (!isRecord(entry) || !("data" in entry)) {
-                addIssue(issues, "V1012", path, "$update requires a data object.");
+                addIssue(issues, "V1012", at, "$update requires a data object.");
                 continue;
             }
             if (edge.cardinality === "many" && !("where" in entry)) {
-                addIssue(issues, "V1012", path, "To-many $update requires where.");
+                addIssue(issues, "V1012", at, "To-many $update requires where.");
                 continue;
             }
             if ("where" in entry) {
                 const state = {
                     issues,
-                    structuralRoot: [...path, "where"],
+                    structuralRoot: [...at, "where"],
                     transactionReferences,
                     scalarOnly: edge.capabilities.nestedWriteFilter === "scalar",
+                    ...(edge.cardinality === "many" ? { refuseEmptyNodes: true } : {}),
                     booleanFilterNodes: 0,
                     nestingExceeded: false,
                     booleanNodesExceeded: false,
                 };
-                validateWhere(contract, target, entry.where, [...path, "where"], state, 1);
+                validateWhere(contract, target, entry.where, [...at, "where"], state, 1);
             }
-            validateMutationData(contract, target, entry.data, "update", NESTED_WRITE_SCOPE, [...path, "data"], issues, transactionReferences);
+            validateMutationData(contract, target, entry.data, "update", edge.cardinality === "many"
+                ? TO_MANY_UPDATE_WRITE_SCOPE
+                : NESTED_WRITE_SCOPE, [...at, "data"], issues, transactionReferences);
         }
         return;
     }
     if (directive === "$delete") {
-        const entries = edge.cardinality === "many" && Array.isArray(value) ? value : [value];
-        for (const entry of entries) {
+        for (const { entry, at } of entriesOf(edge, value, path)) {
             if (edge.cardinality === "many") {
                 if (!isRecord(entry) || !("where" in entry)) {
-                    addIssue(issues, "V1012", path, "To-many $delete requires where.");
+                    addIssue(issues, "V1012", at, "To-many $delete requires where.");
                     continue;
                 }
                 const state = {
                     issues,
-                    structuralRoot: [...path, "where"],
+                    structuralRoot: [...at, "where"],
                     transactionReferences,
                     scalarOnly: edge.capabilities.nestedWriteFilter === "scalar",
+                    refuseEmptyNodes: true,
                     booleanFilterNodes: 0,
                     nestingExceeded: false,
                     booleanNodesExceeded: false,
                 };
-                validateWhere(contract, target, entry.where, [...path, "where"], state, 1);
+                validateWhere(contract, target, entry.where, [...at, "where"], state, 1);
             }
             else if (entry !== true &&
                 (!isRecord(entry) || Object.keys(entry).some((key) => key !== "where"))) {
@@ -712,23 +822,34 @@ function validateRelationMutationEntry(contract, edge, directive, value, path, i
         return;
     }
     if (directive === "$upsert") {
-        const entries = edge.cardinality === "many" && Array.isArray(value) ? value : [value];
-        for (const entry of entries) {
+        for (const { entry, at } of entriesOf(edge, value, path)) {
             if (!isRecord(entry) ||
                 !("create" in entry) ||
                 !("update" in entry) ||
                 (edge.cardinality === "many" && !("where" in entry))) {
-                addIssue(issues, "V1012", path, "$upsert requires create/update and requires where on to-many relations.");
+                addIssue(issues, "V1012", at, "$upsert requires create/update and requires where on to-many relations.");
                 continue;
             }
             if ("where" in entry) {
-                validateUniqueSelector(contract, target, entry.where, [...path, "where"], issues);
+                validateUniqueSelector(contract, target, entry.where, [...at, "where"], issues);
             }
-            validateMutationData(contract, target, entry.create, "create", NESTED_WRITE_SCOPE, [...path, "create"], issues, transactionReferences);
-            validateMutationData(contract, target, entry.update, "update", NESTED_WRITE_SCOPE, [...path, "update"], issues, transactionReferences);
+            validateMutationData(contract, target, entry.create, "create", NESTED_WRITE_SCOPE, [...at, "create"], issues, transactionReferences);
+            validateMutationData(contract, target, entry.update, "update", NESTED_WRITE_SCOPE, [...at, "update"], issues, transactionReferences);
         }
     }
 }
+function entriesOf(edge, value, path) {
+    return edge.cardinality === "many" && Array.isArray(value)
+        ? value.map((entry, index) => ({ entry, at: [...path, index] }))
+        : [{ entry: value, at: path }];
+}
+function refuseToOneRelinkWithRewrite(fieldName, field, value, path, issues) {
+    const paired = field.cardinality === "one" ? toOneRelinkWithRewrite(value) : undefined;
+    if (paired === undefined) {
+        return;
+    }
+    addIssue(issues, "V1012", path, `To-one relation "${fieldName}" cannot combine ${paired.rewrite.join("/")} with ${paired.relink.join("/")} in one write: the row it would update is the newly linked one. Relink in one write and update in another.`);
+}
 function validateRelationMutation(contract, fieldName, field, value, stage, scope, path, issues, transactionReferences) {
     const directives = advertisedDirectivesAt(field.capabilities[stage], scope);
     if (directives === undefined) {
@@ -739,6 +860,7 @@ function validateRelationMutation(contract, fieldName, field, value, stage, scop
         addIssue(issues, "V1012", path, `Relation "${fieldName}" mutation value must be a directive object.`);
         return;
     }
+    refuseToOneRelinkWithRewrite(fieldName, field, value, path, issues);
     for (const [directive, directiveValue] of Object.entries(value)) {
         const directivePath = [...path, directive];
         if (!directive.startsWith("$") || !includes(directives, directive)) {
@@ -806,6 +928,14 @@ function validateMutationArguments(contract, resourceName, request, args, issues
         }
     }
 }
+function emptyNodeRefusalOf(request) {
+    return (request.family === "update" || request.family === "delete") &&
+        (request.variant === "many" ||
+            request.variant === "count" ||
+            request.variant === "first")
+        ? { refuseEmptyNodes: true }
+        : {};
+}
 function isUniqueOperation(request) {
     return (request.variant === "unique" &&
         (request.family === "find" ||
@@ -843,11 +973,15 @@ export function validateOperationArguments(contract, request, options) {
         if (isUniqueOperation(request)) {
             validateUniqueSelector(contract, request.resource, request.arguments.where, ["arguments", "where"], issues);
         }
+        else if (request.arguments.where === undefined) {
+            addIssue(issues, "V1001", ["arguments", "where"], UNDEFINED_ARGUMENT_MESSAGES.where);
+        }
         else {
             const state = {
                 issues,
                 structuralRoot: ["arguments", "where"],
                 transactionReferences: options?.transactionReferences === true,
+                ...emptyNodeRefusalOf(request),
                 booleanFilterNodes: 0,
                 nestingExceeded: false,
                 booleanNodesExceeded: false,

package/dist/operations/operation-validator.d.ts

@@ -1,10 +1,10 @@
-import type { Contract } from "../contracts/contract.js";
-import { type OperationIdentity } from "./operation-identity.js";
+import type { AvContract } from "../contracts/contract.js";
+import { type AvOperationIdentity } from "./operation-identity.js";
 import { type OperationValidationOptions, type OperationValidationResult } from "./operation-validator-core.js";
-import type { ValidationIssue } from "./validation-code.js";
-export type { OperationValidationOptions, OperationValidationResult, SemanticOperationArguments, } from "./operation-validator-core.js";
+import type { AvValidationIssue } from "./validation-code.js";
+export type { OperationValidationOptions, SemanticOperationArguments, } from "./operation-validator-core.js";
 /** The key of a request's operation identity that makes it unavailable. */
-export declare function unavailableOperationKey(contract: Contract, request: {
+export declare function unavailableOperationKey(contract: AvContract, request: {
     readonly resource: string;
     readonly family: string;
 }): "family" | "variant";
@@ -15,25 +15,25 @@ export declare function unavailableOperationKey(contract: Contract, request: {
  * {@link unavailableOperationKey}). The one spelling — the protocol's absence
  * answers build theirs with it, so a caller cannot tell which layer answered.
  */
-export declare function operationUnavailableIssue(contract: Contract, request: {
+export declare function operationUnavailableIssue(contract: AvContract, request: {
     readonly resource: string;
     readonly family: string;
     readonly variant: string;
-}): ValidationIssue;
+}): AvValidationIssue;
 /**
  * The availability answer alone — `V1006` when the active Contract does not advertise
  * the operation on a Resource it has — read from the request's identity, never its
  * arguments. A door that refuses unreadable arguments asks this first, so an
  * unadvertised operation answers `A2002` whatever its arguments hold.
  */
-export declare function findOperationAvailabilityIssue(contract: Contract, request: OperationIdentity & {
+export declare function findOperationAvailabilityIssue(contract: AvContract, request: AvOperationIdentity & {
     readonly resource: string;
-}): ValidationIssue | undefined;
+}): AvValidationIssue | undefined;
 /**
  * Validates one standard operation's arguments against a Contract. Operation
  * availability and request limits are checked before the arguments' grammar.
  */
-export declare function validateOperationArguments(contract: Contract, request: OperationIdentity & {
+export declare function validateOperationArguments(contract: AvContract, request: AvOperationIdentity & {
     readonly resource: string;
     readonly arguments: unknown;
 }, options?: OperationValidationOptions): OperationValidationResult;

package/dist/operations/projection-scope.resolver.d.ts

@@ -1,7 +1,7 @@
-import type { ProjectionScope } from "../contracts/capability.js";
-import type { Contract } from "../contracts/contract.js";
-import type { Resource } from "../contracts/resource.js";
-import type { OperationIdentity } from "./operation-identity.js";
+import type { AvProjectionScope } from "../contracts/capability.js";
+import type { AvContract } from "../contracts/contract.js";
+import type { AvResource } from "../contracts/resource.js";
+import type { AvOperationIdentity } from "./operation-identity.js";
 /**
  * Which projection position one request's **top-level** projection arguments sit
  * in, read off the variant the Resource advertises.
@@ -21,9 +21,9 @@ import type { OperationIdentity } from "./operation-identity.js";
  * answering `"record"` for one keeps this function a projection question rather
  * than a second, weaker copy of the availability gate.
  */
-export declare function resolveProjectionScope(resource: Resource<Contract> | undefined, request: OperationIdentity): ProjectionScope;
+export declare function resolveProjectionScope(resource: AvResource<AvContract> | undefined, request: AvOperationIdentity): AvProjectionScope;
 /**
  * The position a projection NESTED beneath an admitted relation sits in: the
  * unrestricted one, at every depth, under every top-level scope.
  */
-export declare const NESTED_PROJECTION_SCOPE: ProjectionScope;
+export declare const NESTED_PROJECTION_SCOPE: AvProjectionScope;

package/dist/operations/structural-limits.walker.d.ts

@@ -1,19 +1,19 @@
-import type { Contract } from "../contracts/contract.js";
-import type { OperationIdentity } from "./operation-identity.js";
-import type { ValidationIssue } from "./validation-code.js";
+import type { AvContract } from "../contracts/contract.js";
+import type { AvOperationIdentity } from "./operation-identity.js";
+import type { AvValidationIssue } from "./validation-code.js";
 type Readable = Readonly<Record<string, unknown>>;
 /** What one walk of an operation's arguments found. */
-export type StructuralLimitsFinding = {
+type StructuralLimitsFinding = {
     /** The nesting issue, which wins over any boolean-node issue. */
-    readonly nesting: ValidationIssue | undefined;
+    readonly nesting: AvValidationIssue | undefined;
     /** The boolean-node issue, when there is no nesting issue. */
-    readonly booleanNodes: ValidationIssue | undefined;
+    readonly booleanNodes: AvValidationIssue | undefined;
 };
 /**
  * Enforces the structural limits on one operation's argument object: the nesting
  * issue if there is one, otherwise the boolean-node issue if there is one.
  */
-export declare function findStructuralLimitIssues(contract: Contract, request: OperationIdentity & {
+export declare function findStructuralLimitIssues(contract: AvContract, request: AvOperationIdentity & {
     readonly resource: string;
 }, args: Readable): StructuralLimitsFinding;
 export {};