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

package/dist/runtime/caller-data.copier.js

@@ -1,13 +1,13 @@
-import { Decimal } from "./decimal.js";
+import { AvDecimal, decimalDigitsOf, isAvDecimal } from "./decimal.js";
 const FAILURE_MESSAGES = {
     "unreadable-value": "Value could not be read.",
     "non-plain-value": "Value must be plain data.",
 };
-export class CallerDataError extends Error {
+export class AvCallerDataError extends Error {
     kind;
     path;
     within;
-    name = "CallerDataError";
+    name = "AvCallerDataError";
     constructor(kind, path, within) {
         super(FAILURE_MESSAGES[kind]);
         this.kind = kind;
@@ -19,7 +19,6 @@ const NO_POLICY = {};
 const OBJECT_PROTOTYPE = Object.prototype;
 const DATE_PROTOTYPE = Date.prototype;
 const dateValueOf = Date.prototype.getTime;
-const decimalValueOf = Decimal.prototype.toString;
 const FAST_WALK_DEPTH = 256;
 const SLOW_WALK = Symbol("slow walk");
 class FastWalkFailure {
@@ -33,8 +32,8 @@ function copyValueType(value, prototype) {
     if (prototype === DATE_PROTOTYPE || value instanceof Date) {
         return new Date(dateValueOf.call(value));
     }
-    if (value instanceof Decimal) {
-        return new Decimal(decimalValueOf.call(value));
+    if (isAvDecimal(value)) {
+        return new AvDecimal(decimalDigitsOf(value));
     }
     if (value instanceof Uint8Array) {
         return new Uint8Array(value);
@@ -134,7 +133,7 @@ function readAt(link, read) {
         return read();
     }
     catch {
-        throw new CallerDataError("unreadable-value", pathOf(link));
+        throw new AvCallerDataError("unreadable-value", pathOf(link));
     }
 }
 function copySlow(value, policy, failedAt) {
@@ -154,7 +153,7 @@ function copySlow(value, policy, failedAt) {
         const task = stack.pop();
         if (task.kind === "leave") {
             if (task.refuse !== false) {
-                throw new CallerDataError("unreadable-value", pathOf(task.refuse));
+                throw new AvCallerDataError("unreadable-value", pathOf(task.refuse));
             }
             ancestors.delete(task.container);
             continue;
@@ -172,7 +171,7 @@ function copySlow(value, policy, failedAt) {
         const refuse = current === failedAt ? link : false;
         const settle = (copy) => {
             if (refuse !== false) {
-                throw new CallerDataError("unreadable-value", pathOf(refuse));
+                throw new AvCallerDataError("unreadable-value", pathOf(refuse));
             }
             task.assign(copy);
         };
@@ -209,7 +208,7 @@ function copySlow(value, policy, failedAt) {
         if (!isPlainPrototype(prototype)) {
             const copied = readAt(link, () => copyValueType(current, prototype));
             if (copied === undefined) {
-                throw new CallerDataError("non-plain-value", pathOf(link));
+                throw new AvCallerDataError("non-plain-value", pathOf(link));
             }
             settle(copied);
             continue;
@@ -268,14 +267,14 @@ function pathSegment(array, key) {
     }
     return key;
 }
-function mirrorControlData(value) {
+function mirrorControlData(value, members) {
     const shape = reflectNode(value);
     if (shape === undefined) {
-        throw new CallerDataError("unreadable-value", []);
+        throw new AvCallerDataError("unreadable-value", []);
     }
     let root;
     const refuse = (kind, path) => {
-        throw new CallerDataError(kind, path, root);
+        throw new AvCallerDataError(kind, path, root);
     };
     const mirrors = new Map();
     const stack = [
@@ -375,6 +374,20 @@ function mirrorControlData(value) {
                 continue;
             }
             const memberLink = childLink(link, pathSegment(shape.array, key));
+            const byValue = members?.copyAt(pathOf(memberLink));
+            if (byValue !== undefined) {
+                try {
+                    store(copyCallerData(member, byValue));
+                }
+                catch (error) {
+                    if (!(error instanceof AvCallerDataError)) {
+                        throw error;
+                    }
+                    members?.refused(pathOf(memberLink), error);
+                    store(undefined);
+                }
+                continue;
+            }
             const memberShape = reflectNode(member);
             if (memberShape === undefined) {
                 store(UNREADABLE);
@@ -408,6 +421,9 @@ function mirrorControlData(value) {
     }
     return root;
 }
+export function mirrorCallerData(value, members) {
+    return mirrorControlData(value, members);
+}
 export function locateCallerDataError(error, copy) {
     const within = error.within;
     if (within === undefined) {
@@ -416,7 +432,7 @@ export function locateCallerDataError(error, copy) {
     const at = pathTo(copy, within);
     return at === undefined
         ? error
-        : new CallerDataError(error.kind, [...at, ...error.path]);
+        : new AvCallerDataError(error.kind, [...at, ...error.path]);
 }
 function pathTo(copy, target) {
     const seen = new Set();
@@ -465,6 +481,3 @@ export function copyCallerData(value, policy = NO_POLICY) {
     }
     return guardNative(() => copyFast(value, 0, policy), (failure) => copySlow(value, policy, failure instanceof FastWalkFailure ? failure.at : undefined));
 }
-export function callerDataFailureMessage(kind) {
-    return FAILURE_MESSAGES[kind];
-}

package/dist/runtime/caller-data.door.d.ts

@@ -1,20 +1,26 @@
-import type { ValidationIssue } from "../operations/validation-code.js";
-import { CallerDataError, type CallerDataPath, type CallerDataPolicy } from "./caller-data.copier.js";
-import type { FrameworkMisuseEvent, MisuseReporter } from "./misuse-reporter.js";
+import type { AvValidationIssue } from "../operations/validation-code.js";
+import { AvCallerDataError, type CallerDataPath, type CallerDataPolicy } from "./caller-data.copier.js";
+import type { AvMisuseEvent, MisuseReporter } from "./misuse-reporter.js";
 /**
  * Where the arguments an execution entry receives came from.
  *
  * - `"caller"`: a server-side caller's own objects — copied at the door.
  * - `"owned"`: data no caller holds a reference to — a body the protocol decoder
- *   parsed with `JSON.parse` for this request alone, or a plan the typed runner
- *   assembled from copies its builders took. It is never copied again.
+ *   parsed with `JSON.parse` for this request alone, a host's parsed body the
+ *   protocol's shortcut copied at the call, or a plan the typed runner assembled
+ *   from copies its builders took. It is never copied again.
  *
- * Only core's own modules choose `"owned"`: the public `framework.execute` and
- * `executeTransaction` always pass `"caller"`.
+ * - `{ refused }`: a body the protocol's shortcut copied at the call, whose copy
+ *   failed — answered at the door as `"caller"` would answer it, never read again.
+ *
+ * Only core's own modules choose anything but `"caller"`: the public
+ * `framework.execute` and `executeTransaction` always pass `"caller"`.
  */
-export type ArgumentsSource = "caller" | "owned";
+export type ArgumentsSource = "caller" | "owned" | {
+    readonly refused: AvCallerDataError;
+};
 /** The operation identity a misuse event may name, as far as it could be read. */
-export type MisuseIdentity = Omit<FrameworkMisuseEvent, "kind" | "path">;
+type MisuseIdentity = Omit<AvMisuseEvent, "kind" | "path">;
 /**
  * The identity of a request the framework holds a copy of, keeping only what is
  * identity: an origin, a Resource name and a standard operation, each present only
@@ -30,7 +36,7 @@ export declare function misuseIdentityOf(request: {
  * The caller's `V1001` for a refused value at `address` (the door's own spelling of
  * where the copied value stands), reported once to the misuse hook.
  */
-export declare function refuseCallerData(error: CallerDataError, address: CallerDataPath, identity: MisuseIdentity, misuse: MisuseReporter): ValidationIssue;
+export declare function refuseCallerData(error: AvCallerDataError, address: CallerDataPath, identity: MisuseIdentity, misuse: MisuseReporter): AvValidationIssue;
 /**
  * A door's copy of one caller value, or the failure it met. The door holds it until
  * its answer is due — a plan answers its steps in order — so the failure is a value
@@ -41,7 +47,7 @@ export type CallerDataCopy = {
     readonly value: unknown;
 } | {
     readonly ok: false;
-    readonly error: CallerDataError;
+    readonly error: AvCallerDataError;
 };
 /** Copies `value` at a door, keeping {@link copyCallerData}'s refusal as a value. */
 export declare function copyAtDoor(value: unknown, policy?: CallerDataPolicy): CallerDataCopy;
@@ -54,3 +60,4 @@ export declare function copyAtDoor(value: unknown, policy?: CallerDataPolicy): C
  * plan validator inspects and copies step by step.
  */
 export declare function copyEnvelopeAtDoor(request: unknown, members: readonly string[]): CallerDataCopy;
+export {};

package/dist/runtime/caller-data.door.js

@@ -1,8 +1,10 @@
 import { parseOperationIdentity } from "../operations/operation-identity.js";
 import { validationIssue } from "../operations/validation-code.js";
-import { CallerDataError, copyCallerData, } from "./caller-data.copier.js";
+import { AvCallerDataError, copyCallerData, } from "./caller-data.copier.js";
 export function misuseIdentityOf(request) {
-    const origin = request.origin === "application" || request.origin === "client"
+    const origin = request.origin === "application" ||
+        request.origin === "client" ||
+        request.origin === "agent"
         ? request.origin
         : undefined;
     const identity = typeof request.family === "string" && typeof request.variant === "string"
@@ -28,7 +30,7 @@ export function copyAtDoor(value, policy) {
         return { ok: true, value: copyCallerData(value, policy) };
     }
     catch (error) {
-        if (error instanceof CallerDataError) {
+        if (error instanceof AvCallerDataError) {
             return { ok: false, error };
         }
         throw error;
@@ -53,7 +55,7 @@ export function copyEnvelopeAtDoor(request, members) {
         if (!copy.ok) {
             return {
                 ok: false,
-                error: new CallerDataError(copy.error.kind, [
+                error: new AvCallerDataError(copy.error.kind, [
                     member,
                     ...copy.error.path,
                 ]),

package/dist/runtime/computed-read-runtime.d.ts

@@ -1,8 +1,9 @@
-import type { FrameworkBehaviorsConfig } from "../config/framework-behaviors-config.js";
-import type { Contract, CoreContract } from "../contracts/contract.js";
+import type { AvAdapterModel } from "../adapters/adapter-model.js";
+import type { ResolvedComputeConfig } from "../config/field-compute.resolver.js";
+import type { AvContract, AvContractCore } from "../contracts/contract.js";
+import type { AvComputeContext } from "./field-compute.js";
 import type { OperationExecutionRequest } from "./operation-request.js";
-import type { PipelineContext } from "./pipeline.js";
-type ContextFactory = () => PipelineContext;
+type ContextFactory = () => AvComputeContext;
 export type RelationReadPlan = {
     readonly field: string;
     readonly cardinality: "one" | "many";
@@ -20,6 +21,11 @@ export type PlannedReadOperation = {
     readonly projection: ReadProjectionPlan | undefined;
     readonly materialize: boolean;
 };
+/**
+ * The fields a level returns when it states no projection: every scalar of the
+ * active Contract whose `select` is `true` and that is not governed.
+ */
+export declare function defaultProjectionFields(active: AvContract, resourceName: string): readonly string[];
 /**
  * Clone the caller projection into the internal Adapter projection: the read
  * set the Adapter is asked for, always explicit for a projecting variant, plus
@@ -27,10 +33,10 @@ export type PlannedReadOperation = {
  * are never mutated and hidden dependencies are resolved through the Core
  * Contract.
  */
-export declare function planReadOperation(core: CoreContract, active: Contract, behaviors: FrameworkBehaviorsConfig | undefined, request: OperationExecutionRequest, args: unknown): PlannedReadOperation;
+export declare function planReadOperation(core: AvContractCore, model: AvAdapterModel, active: AvContract, compute: ResolvedComputeConfig | undefined, request: OperationExecutionRequest, args: unknown): PlannedReadOperation;
 /**
  * Materialize computed scalar reads and remove internal dependency fields,
  * against `active` — the Contract `planReadOperation` was given as `active`.
  */
-export declare function materializeReadOperation(active: Contract, behaviors: FrameworkBehaviorsConfig | undefined, request: OperationExecutionRequest, plan: PlannedReadOperation, value: unknown, contextFactory: ContextFactory): Promise<unknown>;
+export declare function materializeReadOperation(active: AvContract, compute: ResolvedComputeConfig | undefined, _request: OperationExecutionRequest, plan: PlannedReadOperation, value: unknown, contextFactory: ContextFactory): Promise<unknown>;
 export {};