@graphty/graph-io 0.3.47 → 0.3.49

package/dist/chunks/context-C3p0RQxR.js

@@ -0,0 +1,664 @@
+import { b as throwIfAborted } from "./input-CAxt_aV-.js";
+import { f as failOn, w as warnOn, o as originOf, a as applyCredential } from "./credentials-DXHx7nwR.js";
+const RETRY_STATUSES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([101, 204, 205, 304]);
+const REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+const MAX_REDIRECTS = 5;
+class LimitStop extends Error {
+  /**
+   * Create one.
+   * @param limit - the cap's option name
+   * @param value - the value that reached it
+   */
+  constructor(limit, value) {
+    super(`${limit} reached at ${String(value)}`);
+    this.limit = limit;
+    this.value = value;
+    this.name = "LimitStop";
+  }
+}
+function detectRuntime() {
+  const g = globalThis;
+  if (typeof g.process?.versions?.node === "string") {
+    return "node";
+  }
+  if (typeof g.importScripts === "function") {
+    return "worker";
+  }
+  return g.window !== void 0 && g.document !== void 0 ? "browser" : "other";
+}
+function originPath(url) {
+  return `${originOf(url)}${url.pathname}`;
+}
+function isLoopback(hostname) {
+  const host = hostname.replaceAll(/(?:^\[)|(?:\]$)/g, "").toLowerCase();
+  return host === "localhost" || host.endsWith(".localhost") || /^127(\.\d{1,3}){3}$/.test(host) || host === "::1";
+}
+function isLocalNetwork(hostname) {
+  const host = hostname.replaceAll(/(?:^\[)|(?:\]$)/g, "").toLowerCase();
+  return isLoopback(host) || host.endsWith(".local") || /^10(\.\d{1,3}){3}$/.test(host) || /^192\.168(\.\d{1,3}){2}$/.test(host) || /^169\.254(\.\d{1,3}){2}$/.test(host) || /^172\.(1[6-9]|2\d|3[01])(\.\d{1,3}){2}$/.test(host) || /^f[cd][0-9a-f]{2}:/.test(host) || host.startsWith("fe80:");
+}
+const PACERS = /* @__PURE__ */ new Map();
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function retryAfterMs(response) {
+  const value = response.headers.get("retry-after");
+  if (value === null) {
+    return null;
+  }
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) {
+    return Math.max(0, seconds * 1e3);
+  }
+  const date = Date.parse(value);
+  return Number.isNaN(date) ? null : Math.max(0, date - Date.now());
+}
+function boundOrigins(credential, endpoint) {
+  if (credential === void 0) {
+    return [];
+  }
+  if (credential.origins.length > 0) {
+    return credential.origins;
+  }
+  return endpoint === null ? [] : [originOf(endpoint)];
+}
+class SourceFetcher {
+  /**
+   * Set up one call.
+   * @param input - the source, options, report and counters
+   */
+  constructor(input) {
+    this.input = input;
+    this.state = { requests: 0, bytes: 0, finish: null };
+    this.controller = new AbortController();
+    this.warnedLimits = /* @__PURE__ */ new Set();
+    this.onCallerAbort = () => {
+      this.controller.abort(this.input.options.signal?.reason);
+    };
+    const { options, endpoint } = input;
+    this.runtime = input.runtime ?? detectRuntime();
+    this.fetchImpl = options.fetch ?? ((...args) => globalThis.fetch(...args));
+    this.limitOptions = options.limits ?? {};
+    const retry = options.retry === false ? { retries: 0 } : options.retry ?? {};
+    this.retry = {
+      retries: retry.retries ?? 3,
+      baseDelayMs: retry.baseDelayMs ?? 500,
+      maxDelayMs: retry.maxDelayMs ?? 3e4
+    };
+    this.credentialOrigins = boundOrigins(options.credential, endpoint);
+    const callerSignal = options.signal;
+    if (callerSignal?.aborted === true) {
+      this.controller.abort(callerSignal.reason);
+    } else {
+      callerSignal?.addEventListener("abort", this.onCallerAbort, { once: true });
+    }
+    const { timeoutMs } = this.limitOptions;
+    this.timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+      this.timeOut(timeoutMs);
+    }, timeoutMs);
+    this.signal = this.controller.signal;
+  }
+  /** Clear the timeout and detach from the caller's signal. */
+  dispose() {
+    clearTimeout(this.timer);
+    this.input.options.signal?.removeEventListener("abort", this.onCallerAbort);
+  }
+  /**
+   * Abort the load with E_SOURCE_TIMEOUT as the reason.
+   * @param timeoutMs - the limit that passed
+   */
+  timeOut(timeoutMs) {
+    try {
+      failOn(this.input.report, "E_SOURCE_TIMEOUT", `the load ran longer than ${String(timeoutMs)} ms`, {
+        timeoutMs,
+        serverSide: false
+      });
+    } catch (err) {
+      this.controller.abort(err);
+    }
+  }
+  /**
+   * A cap was reached: fail under "error", else warn once and stop.
+   * @param limit - the option name
+   * @param value - the value reached
+   */
+  limitHit(limit, value) {
+    const { report } = this.input;
+    if ((this.limitOptions.onLimit ?? "stop") === "error") {
+      failOn(report, "E_SOURCE_LIMIT", `${limit} of ${String(value)} reached`, { limit, value });
+    }
+    if (!this.warnedLimits.has(limit)) {
+      this.warnedLimits.add(limit);
+      warnOn(report, "W_SOURCE_LIMIT", `${limit} reached at ${String(value)}; what came first is kept`, {
+        limit,
+        value
+      });
+    }
+    throw new LimitStop(limit, value);
+  }
+  /**
+   * Whether a cap is reached; warns once under "stop", throws under "error".
+   * @returns true when the source should stop
+   */
+  reached() {
+    const { nodes, edges } = this.input.counts();
+    const caps = [
+      ["maxNodes", nodes, this.limitOptions.maxNodes],
+      ["maxEdges", edges, this.limitOptions.maxEdges],
+      ["maxBytes", this.state.bytes, this.limitOptions.maxBytes],
+      ["maxRequests", this.state.requests, this.limitOptions.maxRequests]
+    ];
+    const hit = caps.find(([, value, cap]) => cap !== void 0 && value >= cap);
+    if (hit === void 0) {
+      return false;
+    }
+    try {
+      this.limitHit(hit[0], hit[1]);
+    } catch (err) {
+      if (!(err instanceof LimitStop)) {
+        throw err;
+      }
+    }
+    return true;
+  }
+  /**
+   * Report progress.
+   * @param done - how much is done
+   * @param total - the total, when known
+   * @param unit - what is counted
+   */
+  progress(done, total, unit = "items") {
+    if (unit === "bytes") {
+      this.byteTotal = total;
+    }
+    this.input.options.onProgress?.(done, total, unit);
+  }
+  /**
+   * Resolve a request URL against the endpoint and refuse what must never be sent.
+   * @param target - the source's URL
+   * @returns the absolute URL
+   */
+  resolve(target) {
+    const { report, endpoint } = this.input;
+    let url;
+    try {
+      url = endpoint === null ? new URL(target) : new URL(target, endpoint);
+    } catch {
+      return failOn(report, "E_SOURCE_PARAM", "a relative URL needs an endpoint", {
+        name: "endpoint",
+        reason: "missing"
+      });
+    }
+    if (url.username !== "" || url.password !== "") {
+      failOn(report, "E_SOURCE_PARAM", "a URL may not carry a user name or password", {
+        name: "endpoint",
+        reason: "credentials-in-url"
+      });
+    }
+    const page = globalThis.location;
+    const plain = url.protocol === "http:" || url.protocol === "ws:";
+    if (this.runtime === "browser" && page?.protocol === "https:" && plain && !isLoopback(url.hostname)) {
+      failOn(report, "E_SOURCE_RUNTIME", "an https page cannot reach a plain http endpoint", {
+        runtime: this.runtime,
+        reason: "insecure-endpoint"
+      });
+    }
+    return url;
+  }
+  /**
+   * Wait for a slot under the descriptor's rate limit.
+   * @param url - the request URL
+   * @returns a release function
+   */
+  async pace(url) {
+    const rate = this.input.descriptor?.rateLimit;
+    if (rate === void 0) {
+      return () => void 0;
+    }
+    const key = `${this.input.id} ${originOf(url)}`;
+    const p = PACERS.get(key) ?? { active: 0, times: [], waiters: [] };
+    PACERS.set(key, p);
+    for (; ; ) {
+      const now = Date.now();
+      p.times = p.times.filter((t) => now - t < rate.perMs);
+      if (rate.concurrent !== void 0 && p.active >= rate.concurrent) {
+        await new Promise((r) => p.waiters.push(r));
+      } else if (p.times.length >= rate.requests) {
+        await sleep(Math.max(1, rate.perMs - (now - p.times[0])), this.signal);
+      } else {
+        p.times.push(now);
+        p.active++;
+        return () => {
+          p.active--;
+          p.waiters.shift()?.();
+        };
+      }
+    }
+  }
+  /**
+   * Count the decoded bytes of a body as it is read, against `maxBytes`.
+   * @param response - the response
+   * @returns the response, with a counted body
+   */
+  counted(response) {
+    if (response.body === null || NULL_BODY_STATUSES.has(response.status)) {
+      return response;
+    }
+    const counter = new TransformStream({
+      transform: (chunk, ctrl) => {
+        this.state.bytes += chunk.byteLength;
+        const cap = this.limitOptions.maxBytes;
+        if (cap !== void 0 && this.state.bytes > cap) {
+          this.limitHit("maxBytes", this.state.bytes);
+        }
+        if (this.input.unit === "bytes") {
+          this.input.options.onProgress?.(this.state.bytes, this.byteTotal, "bytes");
+        }
+        ctrl.enqueue(chunk);
+      }
+    });
+    return new Response(response.body.pipeThrough(counter), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+  /**
+   * Raise the coded issue of a status outside 200 to 299.
+   * @param response - the response
+   * @param url - the request URL
+   * @returns never; it throws
+   */
+  async statusFailure(response, url) {
+    await response.body?.cancel().catch(() => void 0);
+    const { report } = this.input;
+    const { status } = response;
+    const where = originPath(url);
+    switch (status) {
+      case 401:
+        return failOn(report, "E_SOURCE_AUTH", `${where} answered 401`, {
+          origin: originOf(url),
+          status,
+          scheme: response.headers.get("www-authenticate")?.split(/\s/)[0] ?? null,
+          serverCode: null
+        });
+      case 403:
+        return failOn(report, "E_SOURCE_FORBIDDEN", `${where} answered 403`, { status, serverCode: null });
+      case 404:
+        return failOn(report, "E_SOURCE_NOT_FOUND", `${where} answered 404`, { what: "url", value: where });
+      case 429:
+        return failOn(report, "E_SOURCE_QUOTA", `${where} answered 429`, {
+          retryAfterMs: retryAfterMs(response)
+        });
+      default:
+        return failOn(report, "E_FETCH", `${where} answered ${String(status)}`, { url: where, status });
+    }
+  }
+  /**
+   * Build one request, with the credential when the URL's origin is bound.
+   * @param url - the request URL
+   * @param init - the source's init
+   * @param attach - whether the credential goes with it
+   * @returns the request
+   */
+  async request(url, init, attach) {
+    const { options, report } = this.input;
+    const headers = new Headers(init.headers);
+    if (options.userAgent !== void 0 && this.runtime === "node") {
+      headers.set("User-Agent", options.userAgent);
+    }
+    const { retry: _retry, idempotent: _idempotent, allowStatus: _allowStatus, ...requestInit } = init;
+    const guarded = {
+      cache: "no-store",
+      credentials: "omit",
+      redirect: this.runtime === "browser" ? "error" : "manual"
+    };
+    const request = new Request(url, { ...requestInit, headers, signal: this.signal, ...attach ? guarded : {} });
+    if (!attach || options.credential === void 0) {
+      return request;
+    }
+    const signed = await applyCredential(options.credential, request);
+    const after = new URL(signed.url);
+    if (originOf(after) !== originOf(url)) {
+      failOn(report, "E_SOURCE_REDIRECT", "the credential changed the request's origin", {
+        from: originPath(url),
+        to: originPath(after)
+      });
+    }
+    return signed;
+  }
+  /**
+   * Send one request, following same-origin redirects by hand while a credential is attached.
+   * @param url - the request URL
+   * @param init - the source's init
+   * @param hops - redirects followed so far
+   * @returns the response
+   */
+  async send(url, init, hops) {
+    const { options, report } = this.input;
+    const attach = options.credential !== void 0 && this.credentialOrigins.includes(originOf(url));
+    const plain = url.protocol === "http:" || url.protocol === "ws:";
+    if (attach && plain && !isLoopback(url.hostname) && options.allowInsecure !== true) {
+      failOn(report, "E_SOURCE_PARAM", "a credential is never sent without TLS", {
+        name: "endpoint",
+        reason: "insecure-endpoint"
+      });
+    }
+    const request = await this.request(url, init, attach);
+    this.state.requests++;
+    const response = await this.fetchImpl(request);
+    if (!attach || !REDIRECT_STATUSES.has(response.status)) {
+      return response;
+    }
+    const location = response.headers.get("location");
+    await response.body?.cancel().catch(() => void 0);
+    const to = location === null ? null : new URL(location, url);
+    if (to === null || originOf(to) !== originOf(url) || hops >= MAX_REDIRECTS) {
+      return failOn(report, "E_SOURCE_REDIRECT", "a redirect while a credential was attached", {
+        from: originPath(url),
+        to: to === null ? null : originPath(to)
+      });
+    }
+    return this.send(to, response.status === 303 ? { ...init, method: "GET", body: null } : init, hops + 1);
+  }
+  /**
+   * Whether a browser refused a credentialed request because it was redirected (sent with
+   * `redirect: "error"`, which fails like a CORS refusal): the same URL once more, WITHOUT the
+   * credential, under `redirect: "manual"`, whose answer to a redirect is an opaque redirect.
+   * @param url - the refused URL
+   * @returns true when the URL answers with a redirect
+   */
+  async redirects(url) {
+    if (this.input.options.retry === false) {
+      return false;
+    }
+    try {
+      const response = await this.fetchImpl(url, {
+        method: "GET",
+        redirect: "manual",
+        credentials: "omit",
+        cache: "no-store",
+        signal: this.signal
+      });
+      await response.body?.cancel().catch(() => void 0);
+      return response.type === "opaqueredirect";
+    } catch {
+      throwIfAborted(this.signal);
+      return false;
+    }
+  }
+  /**
+   * Why the browser refused a request: one bodyless no-cors GET of the origin's root.
+   * @param url - the refused URL
+   * @returns the cause
+   */
+  async diagnose(url) {
+    const page = globalThis.location;
+    if (page?.hostname !== void 0 && !isLocalNetwork(page.hostname) && isLocalNetwork(url.hostname)) {
+      return "local-network";
+    }
+    if (this.input.options.retry === false) {
+      return "unknown";
+    }
+    try {
+      await this.fetchImpl(`${originOf(url)}/`, {
+        mode: "no-cors",
+        method: "GET",
+        credentials: "omit",
+        cache: "no-store",
+        signal: this.signal
+      });
+      return "cors";
+    } catch {
+      throwIfAborted(this.signal);
+      return "unreachable";
+    }
+  }
+  /**
+   * A full-jitter backoff delay.
+   * @param attempt - the attempt that failed, from 0
+   * @returns milliseconds
+   */
+  backoff(attempt) {
+    const jitter = Math.random();
+    return jitter * Math.min(this.retry.maxDelayMs, this.retry.baseDelayMs * 2 ** attempt);
+  }
+  /**
+   * What a network failure becomes: a retry (true), or the coded issue.
+   * @param err - what fetch threw
+   * @param url - the request URL
+   * @param attempt - the attempt, from 0
+   * @param tries - the retries allowed
+   * @param statuses - the statuses seen so far
+   * @param probeRedirect - whether a refused redirect may explain it (a credentialed GET or HEAD)
+   * @returns true to retry
+   */
+  async networkFailure(err, url, attempt, tries, statuses, probeRedirect) {
+    throwIfAborted(this.signal);
+    if (!(err instanceof TypeError)) {
+      throw err;
+    }
+    const { report } = this.input;
+    statuses.push(null);
+    if (this.runtime === "browser") {
+      if (probeRedirect && await this.redirects(url)) {
+        return failOn(report, "E_SOURCE_REDIRECT", "a redirect while a credential was attached", {
+          from: originPath(url),
+          to: null
+        });
+      }
+      const cause = await this.diagnose(url);
+      if (cause === "cors" && attempt === 0 && tries > 0) {
+        await sleep(this.backoff(0), this.signal);
+        return true;
+      }
+      return failOn(report, "E_SOURCE_BLOCKED", `the browser refused ${originPath(url)}`, {
+        url: originPath(url),
+        cause
+      });
+    }
+    if (attempt < tries) {
+      await sleep(this.backoff(attempt), this.signal);
+      return true;
+    }
+    return failOn(report, "E_FETCH", `${originPath(url)} could not be reached`, {
+      url: originPath(url),
+      status: null
+    });
+  }
+  /**
+   * Send one attempt under the request cap and the rate limit.
+   * @param url - the request URL
+   * @param init - the source's init
+   * @param attempt - the attempt, from 0
+   * @param tries - the retries allowed
+   * @param statuses - the statuses seen so far
+   * @returns the response, or null to try again
+   */
+  async attempt(url, init, attempt, tries, statuses) {
+    const cap = this.limitOptions.maxRequests;
+    if (cap !== void 0 && this.state.requests >= cap) {
+      this.limitHit("maxRequests", this.state.requests);
+    }
+    const release = await this.pace(url);
+    try {
+      return await this.send(url, init, 0);
+    } catch (err) {
+      const method = (init.method ?? "GET").toUpperCase();
+      const credentialed = this.input.options.credential !== void 0 && this.credentialOrigins.includes(originOf(url));
+      await this.networkFailure(
+        err,
+        url,
+        attempt,
+        tries,
+        statuses,
+        credentialed && (method === "GET" || method === "HEAD")
+      );
+      return null;
+    } finally {
+      release();
+    }
+  }
+  /**
+   * The guarded fetch handed to sources.
+   * @param target - the URL, relative to the endpoint or absolute
+   * @param init - fetch's init and the source options
+   * @returns the response
+   */
+  async fetch(target, init = {}) {
+    throwIfAborted(this.signal);
+    const url = this.resolve(target);
+    const method = (init.method ?? "GET").toUpperCase();
+    const idempotent = method === "GET" || method === "HEAD" || init.idempotent === true;
+    const tries = init.retry === false || !idempotent ? 0 : this.retry.retries;
+    const statuses = [];
+    for (let attempt = 0; ; attempt++) {
+      const response = await this.attempt(url, init, attempt, tries, statuses);
+      if (response === null) {
+        continue;
+      }
+      if (!RETRY_STATUSES.has(response.status) || attempt >= tries) {
+        return this.settle(response, url, init, attempt, statuses);
+      }
+      statuses.push(response.status);
+      const asked = retryAfterMs(response);
+      await response.body?.cancel().catch(() => void 0);
+      await sleep(asked === null ? this.backoff(attempt) : Math.min(asked, this.retry.maxDelayMs), this.signal);
+    }
+  }
+  /**
+   * What a fetch returns: a retried success warned, a failing status raised, the body counted.
+   * @param response - the response
+   * @param url - the request URL
+   * @param init - the source's init
+   * @param attempt - the attempt, from 0
+   * @param statuses - the statuses retried before it
+   * @returns the counted response
+   */
+  settle(response, url, init, attempt, statuses) {
+    if (statuses.length > 0 && response.ok) {
+      const attempts = attempt + 1;
+      warnOn(
+        this.input.report,
+        "W_SOURCE_RETRIED",
+        `${originPath(url)} answered after ${String(attempts)} attempts`,
+        {
+          attempts,
+          statuses
+        }
+      );
+    }
+    if (!response.ok && response.status !== 304 && !(init.allowStatus ?? []).includes(response.status)) {
+      return this.statusFailure(response, url);
+    }
+    return this.counted(response);
+  }
+  /**
+   * Fetch and parse JSON.
+   * @param target - the URL
+   * @param init - the request init
+   * @returns the parsed body
+   */
+  async fetchJson(target, init = {}) {
+    const headers = new Headers(init.headers);
+    if (!headers.has("accept")) {
+      headers.set("Accept", "application/json");
+    }
+    const response = await this.fetch(target, { ...init, headers });
+    let text;
+    try {
+      text = await response.text();
+    } catch (err) {
+      throwIfAborted(this.signal);
+      throw err;
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return failOn(this.input.report, "E_SOURCE_RESPONSE", "the response is not JSON", {
+        expected: "json",
+        contentType: response.headers.get("content-type")
+      });
+    }
+  }
+  /**
+   * The report's `source` member as it stands.
+   * @param next - where to resume
+   * @returns the info
+   */
+  info(next) {
+    const { finish } = this.state;
+    const { id, descriptor, endpoint } = this.input;
+    return Object.freeze({
+      id,
+      version: descriptor?.version ?? 1,
+      endpoint: endpoint === null ? null : originPath(endpoint),
+      requests: this.state.requests,
+      bytes: this.state.bytes,
+      next,
+      ...finish?.server === void 0 ? {} : { server: finish.server },
+      ...finish?.budget === void 0 ? {} : { budget: finish.budget },
+      ...finish?.validators === void 0 ? {} : { validators: finish.validators },
+      ...finish?.total === void 0 ? {} : { total: finish.total }
+    });
+  }
+}
+const CONTEXT_OPTIONS = /* @__PURE__ */ new WeakMap();
+function transportOptions(ctx) {
+  const options = CONTEXT_OPTIONS.get(ctx) ?? {};
+  return { credential: options.credential, allowInsecure: options.allowInsecure, userAgent: options.userAgent };
+}
+function createSourceContext(input) {
+  const f = new SourceFetcher(input);
+  const limits = Object.freeze({ ...input.options.limits, reached: () => f.reached() });
+  const ctx = Object.freeze({
+    fetch: (target, init) => f.fetch(target, init),
+    fetchJson: (target, init) => f.fetchJson(target, init),
+    endpoint: input.endpoint,
+    signal: f.signal,
+    report: input.report,
+    limits,
+    cursor: input.cursor,
+    runtime: f.runtime,
+    progress: (done, total, unit) => {
+      f.progress(done, total, unit);
+    },
+    finish: (result) => {
+      f.state.finish = result ?? {};
+      return Object.freeze({ ...input.report.finish(), source: f.info(result?.next ?? null) });
+    }
+  });
+  CONTEXT_OPTIONS.set(ctx, input.options);
+  return {
+    ctx,
+    state: f.state,
+    info: (next) => f.info(next),
+    dispose: () => {
+      f.dispose();
+    }
+  };
+}
+export {
+  LimitStop as L,
+  createSourceContext as c,
+  detectRuntime as d,
+  isLoopback as i,
+  sleep as s,
+  transportOptions as t
+};
+//# sourceMappingURL=context-C3p0RQxR.js.map