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

package/dist/config/config.resolver.js

@@ -1,6 +1,8 @@
-import { FrameworkConstructionError } from "../framework/framework-construction.error.js";
-import { entrypointRefusalDiagnostic } from "./config.validator.js";
+import { AvConstructionError } from "../framework/framework-construction.error.js";
+import { mountPathRefusalDiagnostic } from "./config.validator.js";
 import { normalizeEntrypoint } from "./entrypoint.normalizer.js";
+import { chainCompute, computeOfLayer, } from "./field-compute.resolver.js";
+import { resolvePipelineTree, } from "./pipeline-tree.resolver.js";
 const hasOwn = (value, key) => Object.hasOwn(value, key);
 function isPlainRecord(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
@@ -39,7 +41,7 @@ function resolveRecord(root, scoped) {
     }
     return result;
 }
-function resolveProperty(root, scoped, key) {
+function resolveOverride(root, scoped, key) {
     if (scoped === undefined || !hasOwn(scoped, key)) {
         return cloneConfigValue(root[key]);
     }
@@ -49,63 +51,125 @@ function resolveProperty(root, scoped, key) {
         ? resolveRecord(rootValue, scopedValue)
         : cloneConfigValue(scopedValue);
 }
-function resolvePipelines(root, scoped) {
+function resolveLayer(root, rootCompute, overlay, scoped) {
     return {
-        guards: [...(root?.guards ?? []), ...(scoped?.guards ?? [])],
-        pipes: [...(root?.pipes ?? []), ...(scoped?.pipes ?? [])],
-        hooks: {
-            before: [
-                ...(root?.hooks?.before ?? []),
-                ...(scoped?.hooks?.before ?? []),
-            ],
-            after: [...(root?.hooks?.after ?? []), ...(scoped?.hooks?.after ?? [])],
-        },
-        interceptors: [
-            ...(root?.interceptors ?? []),
-            ...(scoped?.interceptors ?? []),
-        ],
-        filters: [...(root?.filters ?? []), ...(scoped?.filters ?? [])],
+        compute: scoped === undefined
+            ? rootCompute
+            : chainCompute(rootCompute, computeOfLayer(scoped.resources)),
+        exposed: overlay
+            ? scoped?.exposed
+            : (root.exposed ?? true),
+        exemptions: overlay ? scoped?.exemptions : root.exemptions,
+        limits: resolveOverride(root, scoped, "limits"),
+        transactionsStyle: resolveOverride(root, scoped, "transactionsStyle"),
+        pipelines: scoped === undefined
+            ? resolvePipelineTree([root])
+            : resolvePipelineTree([root, scoped]),
     };
 }
-function resolveScope(root, scoped) {
+function resolveAgentLayer(root, parentName, parentOverlay, parent, agent, stated) {
+    const effective = {
+        limits: parent.limits,
+        transactionsStyle: parent.transactionsStyle,
+    };
+    const chain = [root];
+    if (parentName !== "root" && parentOverlay !== undefined) {
+        chain.push(parentOverlay);
+    }
+    if (agent !== undefined) {
+        chain.push(agent);
+    }
     return {
-        fields: resolveProperty(root, scoped, "fields"),
-        behaviors: resolveProperty(root, scoped, "behaviors"),
-        restrictions: resolveProperty(root, scoped, "restrictions"),
-        limits: resolveProperty(root, scoped, "limits"),
-        transactions: resolveProperty(root, scoped, "transactions"),
-        pipelines: resolvePipelines(root.pipelines, scoped?.pipelines),
+        parent: parentName,
+        stated,
+        compute: agent === undefined
+            ? parent.compute
+            : chainCompute(parent.compute, computeOfLayer(agent.resources)),
+        exposed: agent?.exposed,
+        exemptions: agent?.exemptions,
+        limits: resolveOverride(effective, agent, "limits"),
+        transactionsStyle: resolveOverride(effective, agent, "transactionsStyle"),
+        pipelines: resolvePipelineTree(chain),
     };
 }
-function resolveEntrypoint(entrypoint) {
-    const normalized = normalizeEntrypoint(entrypoint);
+function definitionsOf(resources) {
+    const result = {};
+    if (!isPlainRecord(resources)) {
+        return result;
+    }
+    for (const [resourceName, resource] of Object.entries(resources)) {
+        if (!isPlainRecord(resource) || !isPlainRecord(resource.fields)) {
+            continue;
+        }
+        for (const [fieldName, field] of Object.entries(resource.fields)) {
+            if (!isPlainRecord(field) || field.definition === undefined) {
+                continue;
+            }
+            result[resourceName] ??= {};
+            result[resourceName][fieldName] =
+                field.definition;
+        }
+    }
+    return result;
+}
+function resolveMountPath(value, path) {
+    const normalized = normalizeEntrypoint(value);
     if (!normalized.ok) {
-        throw new FrameworkConstructionError("configuration", [
-            entrypointRefusalDiagnostic(normalized.message),
+        throw new AvConstructionError("configuration", [
+            mountPathRefusalDiagnostic(path, normalized.message),
         ]);
     }
     return normalized.path;
 }
+function resolveMcp(mcp) {
+    if (mcp === undefined) {
+        return undefined;
+    }
+    if (typeof mcp === "string") {
+        return Object.freeze({ path: resolveMountPath(mcp, "mcp") });
+    }
+    const path = resolveMountPath(mcp.path, "mcp.path");
+    const authorization = mcp.authorization;
+    return Object.freeze(authorization === undefined
+        ? { path }
+        : {
+            path,
+            authorization: Object.freeze({
+                servers: Object.freeze([...authorization.servers]),
+                verify: authorization.verify,
+            }),
+        });
+}
 export function resolveFrameworkConfig(config) {
-    const root = {
-        ...(hasOwn(config, "fields") ? { fields: config.fields } : {}),
-        ...(hasOwn(config, "behaviors") ? { behaviors: config.behaviors } : {}),
-        ...(hasOwn(config, "restrictions")
-            ? { restrictions: config.restrictions }
-            : {}),
-        ...(hasOwn(config, "limits") ? { limits: config.limits } : {}),
-        ...(hasOwn(config, "pipelines") ? { pipelines: config.pipelines } : {}),
-        ...(hasOwn(config, "transactions")
-            ? { transactions: config.transactions }
-            : {}),
+    const root = config;
+    const application = config.application;
+    const client = config.client;
+    const agent = config.agent;
+    const rootCompute = computeOfLayer(root.resources);
+    const layers = {
+        root: resolveLayer(root, rootCompute, false),
+        application: resolveLayer(root, rootCompute, true, application),
+        client: resolveLayer(root, rootCompute, true, client),
     };
+    const parent = agent?.extends ?? "client";
     return {
-        entrypoint: resolveEntrypoint(config.entrypoint),
+        api: resolveMountPath(config.api, "api"),
+        mcp: resolveMcp(config.mcp),
         adapter: config.adapter,
         diagnostics: config.diagnostics,
         misuse: config.misuse,
-        root: resolveScope(root),
-        application: resolveScope(root, config.application),
-        client: resolveScope(root, config.client),
+        definitions: definitionsOf(root.resources),
+        trees: {
+            root: root.resources,
+            application: application?.resources,
+            client: client?.resources,
+            agent: agent?.resources,
+        },
+        ...layers,
+        agent: resolveAgentLayer(root, parent, parent === "application"
+            ? application
+            : parent === "client"
+                ? client
+                : undefined, layers[parent], agent, agent !== undefined || config.mcp !== undefined),
     };
 }

package/dist/config/config.validator.d.ts

@@ -1,12 +1,12 @@
-import type { ConfigDiagnostic } from "./config-diagnostic.js";
+import type { AvConfigDiagnostic } from "./config-diagnostic.js";
 /**
- * The refusal of an entrypoint whose mount path is not canonical, from the
- * normalizer's message: it names the defect and the rule — never the value, which may
- * carry credentials.
+ * The refusal of a mount path (`api`, `mcp`, `mcp.path`) that is not canonical,
+ * from the normalizer's message: it names the defect and the rule — never the
+ * value, which may carry credentials.
  */
-export declare function entrypointRefusalDiagnostic(message: string): ConfigDiagnostic;
+export declare function mountPathRefusalDiagnostic(path: string, message: string): AvConfigDiagnostic;
 /**
  * Checks the structure of a configuration object and reports each problem as
- * a {@link ConfigDiagnostic}.
+ * a {@link AvConfigDiagnostic}.
  */
-export declare function validateFrameworkConfig(value: unknown): readonly ConfigDiagnostic[];
+export declare function validateFrameworkConfig(value: unknown): readonly AvConfigDiagnostic[];