@aventara/core 0.1.0-pilot.3 → 1.0.0-rc.0

package/dist/transactions/transaction-slot-writer.d.ts

@@ -1,18 +1,8 @@
 /**
  * The one owner of writing a value at a transaction slot path. Validation installs
- * framework-owned `$ref` control snapshots through it and execution installs
- * resolved final data through it, so both argument views are produced by the same
- * ancestor-cloning walker.
- *
- * Slot paths are collected once, from the validated semantic argument view.
- * Validation then writes them into two views: that semantic view, where the path
- * is known to name a member, and the raw wire view
- * (`operation.request.arguments`), where the same path is asserted rather than
- * established. It holds there because a slot names a scalar leaf key inside
- * top-level mutation data and Framework Validation Layer normalization preserves
- * that `data`-leaf key structure. A path that does not name a member of the view
- * being written is therefore a framework defect either way, and fails loudly
- * rather than being skipped.
+ * framework-owned `$ref` control snapshots through it and execution installs resolved
+ * final data through it, so both argument views are produced by the same ancestor-
+ * cloning walker.
  */
 type Path = readonly (string | number)[];
 /** One value to install at a full transaction slot path. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aventara/core",
-  "version": "0.1.0-pilot.3",
+  "version": "1.0.0-rc.0",
   "license": "SEE LICENSE IN LICENSE",
   "description": "Core runtime, contract compiler, and extension APIs for Aventara.",
   "type": "module",
@@ -19,17 +19,31 @@
       "types": "./dist/protocol/index.d.ts",
       "import": "./dist/protocol/index.js",
       "default": "./dist/protocol/index.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "import": "./dist/internal.js",
+      "default": "./dist/internal.js"
+    },
+    "./json": {
+      "types": "./dist/json/index.d.ts",
+      "import": "./dist/json/index.js",
+      "default": "./dist/json/index.js"
     }
   },
   "files": [
     "dist",
-    "LICENSE-ADDITIONAL-PERMISSION.md"
+    "LICENSE-ADDITIONAL-PERMISSION.md",
+    "CHANGELOG.md"
   ],
+  "dependencies": {
+    "zod": "^4.6.5"
+  },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json --removeComments --declaration false && tsc -p tsconfig.json --emitDeclarationOnly && node ../../scripts/build/declaration-comments.sanitizer.ts dist",
+    "build": "node ../../scripts/build/build-output.cleaner.ts dist && tsc -p tsconfig.json --removeComments --declaration false && tsc -p tsconfig.json --emitDeclarationOnly && node ../../scripts/build/declaration-comments.sanitizer.ts dist",
     "typecheck": "tsc -p tsconfig.typecheck.json --noEmit",
     "test": "vitest run --typecheck --config ../../vitest.config.mts --root .",
     "lint": "biome lint src"

package/dist/operations/operation-boolean-nodes.d.ts

@@ -1,11 +0,0 @@
-import type { Contract } from "../contracts/contract.js";
-import type { OperationIdentity } from "./operation-identity.js";
-import type { ValidationIssue } from "./validation-code.js";
-/**
- * Enforces maxBooleanNodes across every general where tree in one semantic
- * operation, including root filters, returned-relation filters, and nested
- * relation mutation filters. Unique selectors are intentionally excluded.
- */
-export declare function findOperationBooleanNodeIssue(contract: Contract, request: OperationIdentity & {
-    readonly resource: string;
-}, args: Readonly<Record<string, unknown>>): ValidationIssue | undefined;

package/dist/operations/operation-boolean-nodes.js

@@ -1,283 +0,0 @@
-import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
-import { advertisedDirectives, holdsAt, } from "../contracts/field.js";
-import { NESTED_PROJECTION_SCOPE, resolveProjectionScope, } from "./projection-scope.resolver.js";
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function booleanNodeIssue(contract, path) {
-    return {
-        path,
-        code: "V1015",
-        message: `Boolean/filter node count exceeds maxBooleanNodes (${contract.limits.maxBooleanNodes}).`,
-    };
-}
-function countNode(state, path) {
-    state.count += 1;
-    return state.count > state.contract.limits.maxBooleanNodes
-        ? booleanNodeIssue(state.contract, path)
-        : undefined;
-}
-function walkWhere(state, resourceName, value, path) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    const resource = lookupResource(state.contract, resourceName);
-    if (resource === undefined) {
-        return undefined;
-    }
-    for (const [key, child] of Object.entries(value)) {
-        const exceeded = countNode(state, [...path, key]);
-        if (exceeded !== undefined) {
-            return exceeded;
-        }
-        if (key === "AND" || key === "OR") {
-            if (!Array.isArray(child)) {
-                continue;
-            }
-            for (let index = 0; index < child.length; index += 1) {
-                const issue = walkWhere(state, resourceName, child[index], [
-                    ...path,
-                    key,
-                    index,
-                ]);
-                if (issue !== undefined) {
-                    return issue;
-                }
-            }
-            continue;
-        }
-        if (key === "NOT") {
-            const issue = walkWhere(state, resourceName, child, [...path, key]);
-            if (issue !== undefined) {
-                return issue;
-            }
-            continue;
-        }
-        const field = lookupField(resource, key);
-        if (field?.kind !== "relation") {
-            continue;
-        }
-        if (field.cardinality === "one") {
-            if (child === null || !isRecord(child)) {
-                continue;
-            }
-            const issue = walkWhere(state, field.target, child, [...path, key]);
-            if (issue !== undefined) {
-                return issue;
-            }
-            continue;
-        }
-        if (!isRecord(child)) {
-            continue;
-        }
-        for (const relationOperator of ["some", "every", "none"]) {
-            if (!(relationOperator in child)) {
-                continue;
-            }
-            const issue = walkWhere(state, field.target, child[relationOperator], [
-                ...path,
-                key,
-                relationOperator,
-            ]);
-            if (issue !== undefined) {
-                return issue;
-            }
-        }
-    }
-    return undefined;
-}
-function projectionRelation(contract, resourceName, entry, mode, scope) {
-    if (Object.keys(entry).length !== 1) {
-        return undefined;
-    }
-    const name = Object.keys(entry)[0];
-    const field = lookupField(lookupResource(contract, resourceName), name);
-    if (field?.kind !== "relation") {
-        return undefined;
-    }
-    if (mode === "select" && !holdsAt(field.capabilities.select, scope)) {
-        return undefined;
-    }
-    if (mode === "include" && !holdsAt(field.capabilities.include, scope)) {
-        return undefined;
-    }
-    return { name, edge: field, value: entry[name] };
-}
-function walkProjection(state, resourceName, value, mode, scope, path) {
-    if (!Array.isArray(value)) {
-        return undefined;
-    }
-    for (let index = 0; index < value.length; index += 1) {
-        const entry = value[index];
-        if (!isRecord(entry)) {
-            continue;
-        }
-        const relation = projectionRelation(state.contract, resourceName, entry, mode, scope);
-        if (relation === undefined || !isRecord(relation.value)) {
-            continue;
-        }
-        const relationPath = [...path, index, relation.name];
-        if ("where" in relation.value &&
-            relation.edge.capabilities.filter?.includes("nested") === true) {
-            const issue = walkWhere(state, relation.edge.target, relation.value.where, [...relationPath, "where"]);
-            if (issue !== undefined) {
-                return issue;
-            }
-        }
-        for (const nestedMode of ["select", "include"]) {
-            if (!(nestedMode in relation.value)) {
-                continue;
-            }
-            const issue = walkProjection(state, relation.edge.target, relation.value[nestedMode], nestedMode, NESTED_PROJECTION_SCOPE, [...relationPath, nestedMode]);
-            if (issue !== undefined) {
-                return issue;
-            }
-        }
-    }
-    return undefined;
-}
-function relationEntries(value) {
-    return Array.isArray(value) ? value : [value];
-}
-function walkMutationData(state, resourceName, value, stage, path) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    const resource = lookupResource(state.contract, resourceName);
-    if (resource === undefined) {
-        return undefined;
-    }
-    for (const [fieldName, fieldValue] of Object.entries(value)) {
-        const edge = lookupField(resource, fieldName);
-        if (edge?.kind !== "relation" || !isRecord(fieldValue)) {
-            continue;
-        }
-        const supported = advertisedDirectives(edge.capabilities[stage]);
-        for (const [directive, directiveValue] of Object.entries(fieldValue)) {
-            if (supported?.includes(directive) !== true) {
-                continue;
-            }
-            const entries = relationEntries(directiveValue);
-            for (let index = 0; index < entries.length; index += 1) {
-                const entry = entries[index];
-                const indexPath = Array.isArray(directiveValue) ? [index] : [];
-                const directivePath = [...path, fieldName, directive, ...indexPath];
-                if (directive === "$create") {
-                    const issue = walkMutationData(state, edge.target, entry, "create", directivePath);
-                    if (issue !== undefined) {
-                        return issue;
-                    }
-                    continue;
-                }
-                if (!isRecord(entry)) {
-                    continue;
-                }
-                if (directive === "$connectOrCreate" && "create" in entry) {
-                    const issue = walkMutationData(state, edge.target, entry.create, "create", [...directivePath, "create"]);
-                    if (issue !== undefined) {
-                        return issue;
-                    }
-                    continue;
-                }
-                if (directive === "$update") {
-                    if ("where" in entry) {
-                        const issue = walkWhere(state, edge.target, entry.where, [
-                            ...directivePath,
-                            "where",
-                        ]);
-                        if (issue !== undefined) {
-                            return issue;
-                        }
-                    }
-                    if ("data" in entry) {
-                        const issue = walkMutationData(state, edge.target, entry.data, "update", [...directivePath, "data"]);
-                        if (issue !== undefined) {
-                            return issue;
-                        }
-                    }
-                    continue;
-                }
-                if (directive === "$delete" && "where" in entry) {
-                    const issue = walkWhere(state, edge.target, entry.where, [
-                        ...directivePath,
-                        "where",
-                    ]);
-                    if (issue !== undefined) {
-                        return issue;
-                    }
-                    continue;
-                }
-                if (directive === "$upsert") {
-                    for (const branch of ["create", "update"]) {
-                        if (!(branch in entry)) {
-                            continue;
-                        }
-                        const issue = walkMutationData(state, edge.target, entry[branch], branch, [...directivePath, branch]);
-                        if (issue !== undefined) {
-                            return issue;
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return undefined;
-}
-function isUniqueOperation(request) {
-    return (request.variant === "unique" &&
-        (request.family === "find" ||
-            request.family === "update" ||
-            request.family === "delete" ||
-            request.family === "upsert"));
-}
-export function findOperationBooleanNodeIssue(contract, request, args) {
-    const state = { contract, count: 0 };
-    const projectionScope = resolveProjectionScope(lookupResource(contract, request.resource), request);
-    if ("where" in args && !isUniqueOperation(request)) {
-        const issue = walkWhere(state, request.resource, args.where, [
-            "arguments",
-            "where",
-        ]);
-        if (issue !== undefined) {
-            return issue;
-        }
-    }
-    for (const mode of ["select", "include"]) {
-        if (!(mode in args)) {
-            continue;
-        }
-        const issue = walkProjection(state, request.resource, args[mode], mode, projectionScope, ["arguments", mode]);
-        if (issue !== undefined) {
-            return issue;
-        }
-    }
-    if (request.family === "create" && "data" in args) {
-        const entries = Array.isArray(args.data) ? args.data : [args.data];
-        for (let index = 0; index < entries.length; index += 1) {
-            const issue = walkMutationData(state, request.resource, entries[index], "create", Array.isArray(args.data)
-                ? ["arguments", "data", index]
-                : ["arguments", "data"]);
-            if (issue !== undefined) {
-                return issue;
-            }
-        }
-    }
-    if (request.family === "update" && "data" in args) {
-        const issue = walkMutationData(state, request.resource, args.data, "update", ["arguments", "data"]);
-        if (issue !== undefined) {
-            return issue;
-        }
-    }
-    if (request.family === "upsert") {
-        for (const branch of ["create", "update"]) {
-            if (!(branch in args)) {
-                continue;
-            }
-            const issue = walkMutationData(state, request.resource, args[branch], branch, ["arguments", branch]);
-            if (issue !== undefined) {
-                return issue;
-            }
-        }
-    }
-    return undefined;
-}

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

@@ -1,8 +0,0 @@
-import type { Contract } from "../contracts/contract.js";
-import type { ValidationIssue } from "./validation-code.js";
-/**
- * Enforces the Contract's semantic nesting limit across where, projection,
- * orderBy, mutation data, and relation traversal before deeper argument
- * validation.
- */
-export declare function findOperationNestingIssue(contract: Contract, resourceName: string, args: Readonly<Record<string, unknown>>): ValidationIssue | undefined;

package/dist/operations/operation-nesting.js

@@ -1,307 +0,0 @@
-import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function nestingIssue(context) {
-    return {
-        path: context.rootPath,
-        code: "V1013",
-        message: `Request nesting exceeds maxNestingDepth (${context.limit}).`,
-    };
-}
-function checkDepth(context, depth) {
-    return depth > context.limit ? nestingIssue(context) : undefined;
-}
-function createContext(contract, rootPath) {
-    return {
-        contract,
-        limit: contract.limits.maxNestingDepth,
-        rootPath,
-    };
-}
-function relationEntries(value) {
-    return Array.isArray(value) ? value : [value];
-}
-function walkWhere(context, resourceName, value, depth, path) {
-    const exceeded = checkDepth(context, depth);
-    if (exceeded !== undefined || !isRecord(value)) {
-        return exceeded;
-    }
-    const resource = lookupResource(context.contract, resourceName);
-    if (resource === undefined) {
-        return undefined;
-    }
-    for (const [key, child] of Object.entries(value)) {
-        if (key === "AND" || key === "OR") {
-            if (!Array.isArray(child)) {
-                continue;
-            }
-            for (let index = 0; index < child.length; index += 1) {
-                const issue = walkWhere(context, resourceName, child[index], depth + 1, [...path, key, index]);
-                if (issue !== undefined) {
-                    return issue;
-                }
-            }
-            continue;
-        }
-        if (key === "NOT") {
-            const issue = walkWhere(context, resourceName, child, depth + 1, [
-                ...path,
-                key,
-            ]);
-            if (issue !== undefined) {
-                return issue;
-            }
-            continue;
-        }
-        const field = lookupField(resource, key);
-        if (field?.kind !== "relation") {
-            continue;
-        }
-        if (field.cardinality === "one") {
-            const issue = walkWhere(context, field.target, child, depth + 1, [
-                ...path,
-                key,
-            ]);
-            if (issue !== undefined) {
-                return issue;
-            }
-            continue;
-        }
-        if (!isRecord(child)) {
-            continue;
-        }
-        for (const relationOperator of ["some", "every", "none"]) {
-            if (!(relationOperator in child)) {
-                continue;
-            }
-            const issue = walkWhere(context, field.target, child[relationOperator], depth + 1, [...path, key, relationOperator]);
-            if (issue !== undefined) {
-                return issue;
-            }
-        }
-    }
-    return undefined;
-}
-function walkOrderBy(context, resourceName, value, depth, path) {
-    const entries = Array.isArray(value) ? value : [value];
-    const resource = lookupResource(context.contract, resourceName);
-    if (resource === undefined) {
-        return undefined;
-    }
-    for (let index = 0; index < entries.length; index += 1) {
-        const entry = entries[index];
-        if (!isRecord(entry)) {
-            continue;
-        }
-        const entryPath = Array.isArray(value) ? [...path, index] : path;
-        for (const [fieldName, child] of Object.entries(entry)) {
-            const field = lookupField(resource, fieldName);
-            if (field?.kind !== "relation" || field.cardinality === "many") {
-                continue;
-            }
-            const relationDepth = depth + 1;
-            const exceeded = checkDepth(context, relationDepth);
-            if (exceeded !== undefined) {
-                return exceeded;
-            }
-            const issue = walkOrderBy(context, field.target, child, relationDepth, [
-                ...entryPath,
-                fieldName,
-            ]);
-            if (issue !== undefined) {
-                return issue;
-            }
-        }
-    }
-    return undefined;
-}
-function walkProjection(context, resourceName, value, depth, path) {
-    if (!Array.isArray(value)) {
-        return undefined;
-    }
-    const resource = lookupResource(context.contract, resourceName);
-    if (resource === undefined) {
-        return undefined;
-    }
-    for (let index = 0; index < value.length; index += 1) {
-        const entry = value[index];
-        if (!isRecord(entry) || Object.keys(entry).length !== 1) {
-            continue;
-        }
-        const relationName = Object.keys(entry)[0];
-        const edge = lookupField(resource, relationName);
-        if (edge?.kind !== "relation") {
-            continue;
-        }
-        const relationPath = [...path, index, relationName];
-        const relationDepth = depth + 1;
-        const exceeded = checkDepth(context, relationDepth);
-        if (exceeded !== undefined) {
-            return exceeded;
-        }
-        const projection = entry[relationName];
-        if (!isRecord(projection)) {
-            continue;
-        }
-        if ("where" in projection) {
-            const issue = walkWhere(context, edge.target, projection.where, relationDepth, [...relationPath, "where"]);
-            if (issue !== undefined) {
-                return issue;
-            }
-        }
-        if ("orderBy" in projection) {
-            const issue = walkOrderBy(context, edge.target, projection.orderBy, relationDepth, [...relationPath, "orderBy"]);
-            if (issue !== undefined) {
-                return issue;
-            }
-        }
-        for (const mode of ["select", "include"]) {
-            if (!(mode in projection)) {
-                continue;
-            }
-            const issue = walkProjection(context, edge.target, projection[mode], relationDepth, [...relationPath, mode]);
-            if (issue !== undefined) {
-                return issue;
-            }
-        }
-    }
-    return undefined;
-}
-function nestedMutationPayloads(directive, value) {
-    const values = relationEntries(value);
-    const payloads = [];
-    for (let index = 0; index < values.length; index += 1) {
-        const entry = values[index];
-        const indexPath = Array.isArray(value) ? [index] : [];
-        if (directive === "$create") {
-            payloads.push({ data: entry, suffix: indexPath });
-            continue;
-        }
-        if (!isRecord(entry)) {
-            continue;
-        }
-        if (directive === "$connectOrCreate" && "create" in entry) {
-            payloads.push({ data: entry.create, suffix: [...indexPath, "create"] });
-            continue;
-        }
-        if (directive === "$update" && "data" in entry) {
-            payloads.push({ data: entry.data, suffix: [...indexPath, "data"] });
-            continue;
-        }
-        if (directive === "$upsert") {
-            if ("create" in entry) {
-                payloads.push({ data: entry.create, suffix: [...indexPath, "create"] });
-            }
-            if ("update" in entry) {
-                payloads.push({ data: entry.update, suffix: [...indexPath, "update"] });
-            }
-        }
-    }
-    return payloads;
-}
-function walkMutationDirectiveWheres(context, resourceName, directive, value, depth, path) {
-    if (directive !== "$update" && directive !== "$delete") {
-        return undefined;
-    }
-    const entries = relationEntries(value);
-    for (let index = 0; index < entries.length; index += 1) {
-        const entry = entries[index];
-        if (!isRecord(entry) || !("where" in entry)) {
-            continue;
-        }
-        const indexPath = Array.isArray(value) ? [index] : [];
-        const issue = walkWhere(context, resourceName, entry.where, depth, [
-            ...path,
-            ...indexPath,
-            "where",
-        ]);
-        if (issue !== undefined) {
-            return issue;
-        }
-    }
-    return undefined;
-}
-function walkMutationData(context, resourceName, value, depth, path) {
-    const exceeded = checkDepth(context, depth);
-    if (exceeded !== undefined || !isRecord(value)) {
-        return exceeded;
-    }
-    const resource = lookupResource(context.contract, resourceName);
-    if (resource === undefined) {
-        return undefined;
-    }
-    for (const [fieldName, fieldValue] of Object.entries(value)) {
-        const edge = lookupField(resource, fieldName);
-        if (edge?.kind !== "relation" || !isRecord(fieldValue)) {
-            continue;
-        }
-        for (const [directive, directiveValue] of Object.entries(fieldValue)) {
-            const relationDepth = depth + 1;
-            const relationPath = [...path, fieldName, directive];
-            const relationExceeded = checkDepth(context, relationDepth);
-            if (relationExceeded !== undefined) {
-                return relationExceeded;
-            }
-            const whereIssue = walkMutationDirectiveWheres(context, edge.target, directive, directiveValue, relationDepth, relationPath);
-            if (whereIssue !== undefined) {
-                return whereIssue;
-            }
-            for (const payload of nestedMutationPayloads(directive, directiveValue)) {
-                const issue = walkMutationData(context, edge.target, payload.data, relationDepth, [...relationPath, ...payload.suffix]);
-                if (issue !== undefined) {
-                    return issue;
-                }
-            }
-        }
-    }
-    return undefined;
-}
-export function findOperationNestingIssue(contract, resourceName, args) {
-    if ("where" in args) {
-        const rootPath = ["arguments", "where"];
-        const issue = walkWhere(createContext(contract, rootPath), resourceName, args.where, 1, rootPath);
-        if (issue !== undefined) {
-            return issue;
-        }
-    }
-    if ("orderBy" in args) {
-        const rootPath = ["arguments", "orderBy"];
-        const issue = walkOrderBy(createContext(contract, rootPath), resourceName, args.orderBy, 0, rootPath);
-        if (issue !== undefined) {
-            return issue;
-        }
-    }
-    for (const mode of ["select", "include"]) {
-        if (!(mode in args)) {
-            continue;
-        }
-        const rootPath = ["arguments", mode];
-        const issue = walkProjection(createContext(contract, rootPath), resourceName, args[mode], 0, rootPath);
-        if (issue !== undefined) {
-            return issue;
-        }
-    }
-    if ("data" in args) {
-        const rootPath = ["arguments", "data"];
-        const context = createContext(contract, rootPath);
-        const dataEntries = Array.isArray(args.data) ? args.data : [args.data];
-        for (let index = 0; index < dataEntries.length; index += 1) {
-            const issue = walkMutationData(context, resourceName, dataEntries[index], 0, Array.isArray(args.data) ? [...rootPath, index] : rootPath);
-            if (issue !== undefined) {
-                return issue;
-            }
-        }
-    }
-    for (const branch of ["create", "update"]) {
-        if (!(branch in args)) {
-            continue;
-        }
-        const rootPath = ["arguments", branch];
-        const issue = walkMutationData(createContext(contract, rootPath), resourceName, args[branch], 0, rootPath);
-        if (issue !== undefined) {
-            return issue;
-        }
-    }
-    return undefined;
-}