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

package/dist/transactions/transaction-stage.runtime.js

@@ -0,0 +1,126 @@
+import { AdapterBoundary, resolveOperationFailure, } from "../runtime/error-boundary.js";
+import { runLevelLifecycle, } from "../runtime/level-lifecycle.runtime.js";
+import { operationFailure } from "../runtime/operation-response.js";
+import { AvPipeOutputError, PIPE_OUTPUT_FAILURE_MESSAGE, } from "../runtime/pipe-output.validator.js";
+import { deepFreeze, frozenCopy } from "../runtime/readonly-value.js";
+import { AvTransactionIntegrityError } from "./transaction-integrity-error.js";
+export const TRANSACTION_ABORT = Object.freeze({ reason: "aventara-transaction-abort" });
+export const TRANSACTION_PIPES = "Transaction pipes";
+export function transactionFacts(contract, request, plan) {
+    return {
+        $contract: contract,
+        $origin: request.origin,
+        $args: frozenCopy(plan),
+        $requestId: request.requestId,
+        ...(request.origin !== "application" && request.transport !== undefined
+            ? { $transport: request.transport }
+            : {}),
+    };
+}
+export function touchedTransactionLevels(plan, levelsOf) {
+    const touched = new Set();
+    for (const step of plan) {
+        if (step.resource !== undefined) {
+            touched.add(step.resource);
+        }
+    }
+    return [...touched].flatMap((resource) => levelsOf(resource));
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function sameStructure(left, right) {
+    if (Object.is(left, right)) {
+        return true;
+    }
+    if (Array.isArray(left) && Array.isArray(right)) {
+        return (left.length === right.length &&
+            left.every((entry, index) => sameStructure(entry, right[index])));
+    }
+    if (isRecord(left) &&
+        isRecord(right) &&
+        Object.getPrototypeOf(left) === Object.prototype &&
+        Object.getPrototypeOf(right) === Object.prototype) {
+        const keys = Object.keys(left);
+        return (keys.length === Object.keys(right).length &&
+            keys.every((key) => Object.hasOwn(right, key) && sameStructure(left[key], right[key])));
+    }
+    return false;
+}
+function acceptPlan(original, returned, index) {
+    if (!Array.isArray(returned) || returned.length !== original.length) {
+        return `Transaction pipes[${index}] returned a plan that does not keep its ${original.length} step(s)`;
+    }
+    const accepted = [];
+    for (const [position, step] of original.entries()) {
+        const entry = returned[position];
+        if (step.sql !== undefined) {
+            if (!isRecord(entry) || !sameStructure(entry.sql, step.sql)) {
+                return `Transaction pipes[${index}] changed SQL step ${position}`;
+            }
+            accepted.push(step);
+            continue;
+        }
+        if (!isRecord(entry) ||
+            entry.resource !== step.resource ||
+            entry.family !== step.family ||
+            entry.variant !== step.variant) {
+            return `Transaction pipes[${index}] changed which operation step ${position} runs`;
+        }
+        accepted.push({ ...step, args: entry.args });
+    }
+    return accepted;
+}
+export async function runTransactionStages(levels, plan, contextOf, runSteps) {
+    let current = deepFreeze(plan);
+    const reuse = { refusal: undefined };
+    try {
+        for (const level of levels) {
+            for (const guard of level.guards) {
+                if ((await guard(contextOf(current))) === false) {
+                    return { kind: "denied" };
+                }
+            }
+        }
+        let piped = false;
+        let pipeIndex = 0;
+        for (const level of levels) {
+            for (const pipe of level.pipes) {
+                const told = frozenCopy(current);
+                const returned = await pipe(told, contextOf(current));
+                if (returned !== undefined &&
+                    returned !== told &&
+                    returned !== current) {
+                    const accepted = acceptPlan(current, returned, pipeIndex);
+                    if (typeof accepted === "string") {
+                        return {
+                            kind: "refused",
+                            refusal: {
+                                response: operationFailure("A3004", {
+                                    message: PIPE_OUTPUT_FAILURE_MESSAGE,
+                                }),
+                                error: new AvPipeOutputError(accepted, []),
+                            },
+                        };
+                    }
+                    current = deepFreeze(accepted);
+                    piped = true;
+                }
+                pipeIndex += 1;
+            }
+        }
+        const staged = { plan: current, piped };
+        await runLevelLifecycle(levels, () => contextOf(current), () => runSteps(staged), async (results) => results, reuse, () => new AvTransactionIntegrityError("next-called-twice"));
+        return reuse.refusal === undefined
+            ? { kind: "ran" }
+            : { kind: "broken", error: reuse.refusal };
+    }
+    catch (error) {
+        return reuse.refusal === undefined
+            ? { kind: "failed", error }
+            : { kind: "broken", error: reuse.refusal };
+    }
+}
+export function resolveTransactionStageFailure(error, levels, context, report, view) {
+    return resolveOperationFailure(error, levels.flatMap((level) => level.filters), context, new AdapterBoundary(), report, view);
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@aventara/core",
-  "version": "1.0.0-rc.0",
+  "version": "1.0.0-rc.10",
   "license": "SEE LICENSE IN LICENSE",
   "description": "Core runtime, contract compiler, and extension APIs for Aventara.",
   "type": "module",
   "engines": {
-    "node": "^22.18.0 || >=24.2.0"
+    "node": "^22.23.4 || >=24.22.1"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -25,27 +25,29 @@
       "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"
+    "./avz": {
+      "types": "./dist/avz/index.d.ts",
+      "import": "./dist/avz/index.js",
+      "default": "./dist/avz/index.js"
     }
   },
   "files": [
     "dist",
+    "src/runtime/field-check.evaluator.ts",
+    "ERRORS.md",
     "LICENSE-ADDITIONAL-PERMISSION.md",
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "zod": "^4.6.5"
+    "zod": "^4.6.7"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "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",
+    "build": "node ../../scripts/build/build-output.cleaner.ts dist && node scripts/core-version.generator.ts && tsc -p tsconfig.json --removeComments --declaration false && tsc -p tsconfig.json --emitDeclarationOnly && node ../../scripts/build/declaration-comments.sanitizer.ts dist && node scripts/errors-markdown.generator.ts",
     "typecheck": "tsc -p tsconfig.typecheck.json --noEmit",
     "test": "vitest run --typecheck --config ../../vitest.config.mts --root .",
-    "lint": "biome lint src"
+    "lint": "biome lint src scripts"
   }
 }