@adcp/sdk 16.0.0-beta.2 → 16.0.0-beta.4

package/dist/lib/reporting/ledger/managed-router.mjs

@@ -1,258 +0,0 @@
-import {
-  REPORTING_ADAPTER_PROBE_DEADLINE_MILLISECONDS_V1,
-  REPORTING_DESTINATION_PATTERNS_V1,
-  REPORTING_DESTINATION_TRANSPORT_PATTERN_V1
-} from "./managed.mjs";
-const ROUTE_ID_PATTERN = /^[a-z][a-z0-9_.-]{0,63}$/;
-const DEFAULT_ROUTE_PROBE_TIMEOUT_MILLISECONDS = 1e4;
-class ReportingManagedDeliveryRoutingErrorV1 extends Error {
-  code;
-  operation;
-  pattern;
-  transport;
-  verificationProfile;
-  constructor(code, operation, detail, message) {
-    super(message);
-    this.name = "ReportingManagedDeliveryRoutingErrorV1";
-    this.code = code;
-    this.operation = operation;
-    this.pattern = detail.pattern;
-    this.transport = detail.transport;
-    this.verificationProfile = detail.verificationProfile;
-  }
-}
-class ReportingManagedDeliveryProbeErrorV1 extends Error {
-  failedRouteIds;
-  constructor(failedRouteIds, errors) {
-    super(`Managed Delivery route probe failed for ${failedRouteIds.map((id) => JSON.stringify(id)).join(", ")}`, {
-      cause: new AggregateError(errors, "Managed Delivery route probes failed")
-    });
-    this.name = "ReportingManagedDeliveryProbeErrorV1";
-    this.failedRouteIds = Object.freeze([...failedRouteIds]);
-  }
-}
-const routeKey = (pattern, transport) => `${pattern}:${transport}`;
-const hasText = (value) => typeof value === "string" && value !== "";
-function createReportingManagedDeliveryAdapterRouterV1(options) {
-  if (!options || !Array.isArray(options.routes) || options.routes.length === 0) {
-    throw new TypeError("A Managed Delivery router requires at least one route");
-  }
-  const probeTimeout = options.probeTimeoutMilliseconds ?? DEFAULT_ROUTE_PROBE_TIMEOUT_MILLISECONDS;
-  if (!Number.isSafeInteger(probeTimeout) || probeTimeout <= 0) {
-    throw new RangeError("probeTimeoutMilliseconds must be a positive safe integer");
-  }
-  if (probeTimeout >= REPORTING_ADAPTER_PROBE_DEADLINE_MILLISECONDS_V1) {
-    throw new RangeError(
-      `probeTimeoutMilliseconds must be below the runtime's ${REPORTING_ADAPTER_PROBE_DEADLINE_MILLISECONDS_V1} ms probe deadline`
-    );
-  }
-  const routes = [];
-  const byId = /* @__PURE__ */ new Map();
-  const byMatch = /* @__PURE__ */ new Map();
-  for (const candidate of options.routes) {
-    const id = candidate?.id;
-    if (typeof id !== "string" || !ROUTE_ID_PATTERN.test(id)) {
-      throw new TypeError("A Managed Delivery route id must match ^[a-z][a-z0-9_.-]{0,63}$");
-    }
-    if (byId.has(id)) throw new TypeError(`Managed Delivery route id ${JSON.stringify(id)} is duplicated`);
-    const pattern = candidate.match?.pattern;
-    const transport = candidate.match?.transport;
-    if (!REPORTING_DESTINATION_PATTERNS_V1.includes(pattern)) {
-      throw new TypeError(
-        `Managed Delivery route ${JSON.stringify(id)} must match file_transfer, dataset_share, or warehouse_materialization`
-      );
-    }
-    if (typeof transport !== "string" || !REPORTING_DESTINATION_TRANSPORT_PATTERN_V1.test(transport)) {
-      throw new TypeError(`Managed Delivery route ${JSON.stringify(id)} has an invalid transport`);
-    }
-    const adapter = candidate.adapter;
-    if (!adapter || typeof adapter.deliver !== "function" || typeof adapter.read !== "function" || typeof adapter.revoke !== "function") {
-      throw new TypeError(`Managed Delivery route ${JSON.stringify(id)} requires deliver, read, and revoke`);
-    }
-    if (adapter.revocationFencesDeliveryGenerations !== true) {
-      throw new TypeError(
-        `Managed Delivery route ${JSON.stringify(id)} does not fence delivery generations on revocation`
-      );
-    }
-    if (!Array.isArray(adapter.verificationProfiles) || adapter.verificationProfiles.length === 0) {
-      throw new TypeError(`Managed Delivery route ${JSON.stringify(id)} declares no verification profile`);
-    }
-    const key = routeKey(pattern, transport);
-    const clash = byMatch.get(key);
-    if (clash) {
-      throw new TypeError(
-        `Managed Delivery routes ${JSON.stringify(clash.id)} and ${JSON.stringify(id)} both match ${pattern}/${transport}`
-      );
-    }
-    const route = Object.freeze({
-      id,
-      pattern,
-      transport,
-      adapter,
-      verificationProfiles: Object.freeze([...new Set(adapter.verificationProfiles)])
-    });
-    routes.push(route);
-    byId.set(id, route);
-    byMatch.set(key, route);
-  }
-  let legacy;
-  if (options.legacyDefault !== void 0) {
-    legacy = byId.get(options.legacyDefault);
-    if (!legacy) {
-      throw new TypeError(`Managed Delivery legacyDefault ${JSON.stringify(options.legacyDefault)} is not a route id`);
-    }
-  }
-  const exact = (pattern, transport) => typeof pattern === "string" && typeof transport === "string" ? byMatch.get(routeKey(pattern, transport)) : void 0;
-  const forBinding = (binding, operation) => {
-    const pattern = binding?.method;
-    const transport = binding?.transport;
-    if (!hasText(transport)) {
-      if (legacy && legacy.pattern === pattern) return legacy;
-      throw new ReportingManagedDeliveryRoutingErrorV1(
-        "REPORTING_ROUTE_TRANSPORT_REQUIRED",
-        operation,
-        { pattern },
-        "Managed Delivery binding names no transport and no legacy route serves its pattern"
-      );
-    }
-    const route = exact(pattern, transport);
-    if (route) return route;
-    throw new ReportingManagedDeliveryRoutingErrorV1(
-      "REPORTING_ROUTE_NOT_FOUND",
-      operation,
-      { pattern, transport },
-      `No Managed Delivery route serves ${String(pattern)}/${transport}`
-    );
-  };
-  const forAuthorization = (authorization) => {
-    const { pattern, transport } = authorization ?? {};
-    if (hasText(pattern) && hasText(transport)) {
-      const route = exact(pattern, transport);
-      if (route) return route;
-      throw new ReportingManagedDeliveryRoutingErrorV1(
-        "REPORTING_ROUTE_NOT_FOUND",
-        "revoke",
-        { pattern, transport },
-        `No Managed Delivery route serves ${pattern}/${transport}`
-      );
-    }
-    if (legacy && (!hasText(pattern) || legacy.pattern === pattern)) return legacy;
-    throw new ReportingManagedDeliveryRoutingErrorV1(
-      "REPORTING_ROUTE_CONTRACT_UNRECORDED",
-      "revoke",
-      { pattern, transport },
-      "Managed Delivery destination authorization recorded no pattern and transport, and no legacy route serves it"
-    );
-  };
-  const assertProfile = (route, binding, operation) => {
-    if (!route.verificationProfiles.includes(binding.verification_profile)) {
-      throw new ReportingManagedDeliveryRoutingErrorV1(
-        "REPORTING_ROUTE_VERIFICATION_UNSUPPORTED",
-        operation,
-        { pattern: route.pattern, transport: route.transport, verificationProfile: binding.verification_profile },
-        `Managed Delivery route ${JSON.stringify(route.id)} cannot verify ${String(binding.verification_profile)}`
-      );
-    }
-  };
-  const union = Object.freeze([...new Set(routes.flatMap((route) => route.verificationProfiles))]);
-  const descriptions = Object.freeze(
-    routes.map(
-      (route) => Object.freeze({
-        id: route.id,
-        match: Object.freeze({ pattern: route.pattern, transport: route.transport }),
-        verificationProfiles: route.verificationProfiles
-      })
-    )
-  );
-  const router = {
-    routes: descriptions,
-    legacyDefault: legacy?.id,
-    // Compatibility only: nothing here ever admits a binding. A route's own
-    // profiles do, in `admitBinding` and again before delivery.
-    verificationProfiles: union,
-    revocationFencesDeliveryGenerations: true,
-    async deliver(input, context) {
-      const route = forBinding(input.binding, "deliver");
-      assertProfile(route, input.binding, "deliver");
-      return route.adapter.deliver(input, context);
-    },
-    async read(input, context) {
-      return forBinding(input.binding, "read").adapter.read(input, context);
-    },
-    async revoke(input, context) {
-      return forAuthorization(input.authorization).adapter.revoke(input, context);
-    },
-    admitBinding(binding) {
-      assertProfile(forBinding(binding, "admit_binding"), binding, "admit_binding");
-    },
-    admitOffering(offering) {
-      const { pattern, transport } = offering.method;
-      const route = exact(pattern, transport);
-      if (!route) {
-        throw new ReportingManagedDeliveryRoutingErrorV1(
-          "REPORTING_ROUTE_NOT_FOUND",
-          "admit_offering",
-          { pattern, transport },
-          `No Managed Delivery route serves the advertised offering ${pattern}/${transport}`
-        );
-      }
-      if (offering.reconciliation_mode === "consumer_receipt" && !route.verificationProfiles.includes("canonical_digest")) {
-        throw new ReportingManagedDeliveryRoutingErrorV1(
-          "REPORTING_ROUTE_VERIFICATION_UNSUPPORTED",
-          "admit_offering",
-          { pattern, transport, verificationProfile: "canonical_digest" },
-          `Managed Delivery route ${JSON.stringify(route.id)} cannot verify canonical_digest for a consumer-receipt offering`
-        );
-      }
-    },
-    routeIdFor(target) {
-      try {
-        if ("binding" in target) return forBinding(target.binding, "deliver").id;
-        return forAuthorization(target.authorization).id;
-      } catch {
-        return void 0;
-      }
-    },
-    async probe(context) {
-      const probing = routes.filter((route) => typeof route.adapter.probe === "function");
-      const settled = await Promise.allSettled(probing.map((route) => probeRoute(route, context.signal, probeTimeout)));
-      const failedIds = [];
-      const errors = [];
-      settled.forEach((result, index) => {
-        if (result.status === "rejected") {
-          failedIds.push(probing[index].id);
-          errors.push(result.reason);
-        }
-      });
-      if (failedIds.length) throw new ReportingManagedDeliveryProbeErrorV1(failedIds, errors);
-    }
-  };
-  return Object.freeze(router);
-}
-async function probeRoute(route, outer, timeoutMilliseconds) {
-  const controller = new AbortController();
-  const signal = AbortSignal.any([outer, controller.signal]);
-  let timer;
-  try {
-    await Promise.race([
-      Promise.resolve().then(() => route.adapter.probe({ signal })),
-      new Promise((_resolve, reject) => {
-        const abandon = (reason) => reject(reason ?? new Error("Route probe aborted"));
-        if (signal.aborted) return abandon(signal.reason);
-        signal.addEventListener("abort", () => abandon(signal.reason), { once: true });
-        timer = setTimeout(() => {
-          const error = new Error("Route probe deadline elapsed");
-          controller.abort(error);
-          abandon(error);
-        }, timeoutMilliseconds);
-      })
-    ]);
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
-export {
-  ReportingManagedDeliveryProbeErrorV1,
-  ReportingManagedDeliveryRoutingErrorV1,
-  createReportingManagedDeliveryAdapterRouterV1
-};