@domino-sdk/relay 1.62.0 → 1.63.0

package/dist/chunk-ICXZZNPS.js

@@ -0,0 +1,199 @@
+import {
+  clientIdentity,
+  retryAfter
+} from "./chunk-3RFP6GT5.js";
+
+// src/http-exchange.ts
+var uncertainStatuses = /* @__PURE__ */ (() => /* @__PURE__ */ new Set([500, 502, 504]))();
+function withQuery(path, values) {
+  const query = new URLSearchParams(
+    Object.entries(values).flatMap(
+      ([key, value]) => value === void 0 ? [] : [[key, String(value)]]
+    )
+  ).toString();
+  return query ? path + "?" + query : path;
+}
+function untilAborted(step, signal) {
+  return new Promise((resolve, reject) => {
+    const stop = () => reject(signal.reason);
+    if (signal?.aborted) {
+      return stop();
+    }
+    signal?.addEventListener("abort", stop, { once: true });
+    step().then(resolve, reject).finally(() => signal?.removeEventListener("abort", stop));
+  });
+}
+function createHttpExchange(options, policy) {
+  const { messages, makeError } = policy;
+  const failure = (kind, code, message, cause, context) => makeError(message, { kind, code, uncertain: false, cause }, context);
+  try {
+    const headers = new Headers(options.headers);
+    if (options.token) {
+      headers.set("Authorization", `Bearer ${options.token}`);
+    }
+    headers.set("X-Relay-Organization", options.organization ?? "");
+    headers.set("X-Relay-Project", options.project ?? "");
+  } catch (error) {
+    throw failure("client", "invalid-input", messages.invalidOptions, error);
+  }
+  function interrupted(error, method, context, life, stage) {
+    const kind = life.ended() ?? "network";
+    return makeError(
+      kind === "aborted" ? messages.aborted : kind === "timeout" ? messages.timeout(life.timeout) : messages.network(stage.status),
+      {
+        kind,
+        code: kind,
+        uncertain: stage.sent && method !== "GET" && // An error status whose body broke off still refused the write, unless the status itself
+        // does not prove that.
+        (!stage.refused || uncertainStatuses.has(stage.status ?? 0)),
+        status: stage.status,
+        retryAfter: stage.headers ? retryAfter(stage.headers) : void 0,
+        cause: kind === "aborted" && policy.abortReason ? life.reason() : error
+      },
+      context
+    );
+  }
+  async function credential(method, context, life) {
+    const getToken = options.getToken;
+    if (!getToken) {
+      return options.token;
+    }
+    try {
+      return await untilAborted(getToken, life.signal);
+    } catch (error) {
+      throw life.signal.aborted ? interrupted(error, method, context, life, { sent: false }) : failure(
+        // A token source that could not reach its own service failed like a network call.
+        error instanceof TypeError ? "network" : "client",
+        "credential",
+        messages.credential,
+        error,
+        context
+      );
+    }
+  }
+  async function send(path, request, context, life) {
+    const { json } = request;
+    const method = (request.method ?? (json === void 0 ? "GET" : "POST")).toUpperCase();
+    if (life.signal.aborted) {
+      throw interrupted(life.reason(), method, context, life, { sent: false });
+    }
+    const last = policy.credentialLast;
+    let token = last ? void 0 : await credential(method, context, life);
+    const headers = new Headers();
+    let body = request.body;
+    let invalidToken;
+    const authorize = () => {
+      if (token) {
+        try {
+          headers.set("Authorization", `Bearer ${token}`);
+        } catch (error) {
+          throw invalidToken = failure(
+            "client",
+            "credential",
+            messages.invalidToken,
+            error,
+            context
+          );
+        }
+      } else if (options.getToken) {
+        headers.delete("Authorization");
+      }
+    };
+    try {
+      for (const source of [options.headers, request.headers]) {
+        new Headers(source).forEach((value, name) => headers.set(name, value));
+      }
+      headers.set("X-Domino-Client", policy.client ?? clientIdentity());
+      if (!last) {
+        authorize();
+      }
+      const scope = [
+        ["X-Relay-Organization", options.organization],
+        ["X-Relay-Project", options.project],
+        ["X-Relay-Environment", options.environment],
+        ["X-Relay-Session", policy.session?.(context)]
+      ];
+      for (const [name, value] of scope) {
+        if (value) {
+          headers.set(name, value);
+        }
+      }
+      if (json !== void 0) {
+        headers.set("Content-Type", "application/json");
+        body = JSON.stringify(json);
+      }
+      if (policy.csrf && method !== "GET") {
+        headers.set("X-Relay-CSRF", "1");
+      }
+    } catch (error) {
+      throw error === invalidToken || !messages.unsendable ? error : failure(
+        "client",
+        "invalid-input",
+        messages.unsendable,
+        error,
+        context
+      );
+    }
+    if (last) {
+      token = await credential(method, context, life);
+      authorize();
+    }
+    if (life.signal.aborted) {
+      throw interrupted(life.reason(), method, context, life, { sent: false });
+    }
+    let response;
+    try {
+      response = await (options.fetch ?? fetch)(options.baseUrl + path, {
+        ...request.init,
+        method: request.method ?? method,
+        headers,
+        body,
+        signal: life.signal
+      });
+    } catch (error) {
+      throw interrupted(error, method, context, life, {
+        sent: !policy.neverSent?.(error)
+      });
+    }
+    if (!response.ok) {
+      let text;
+      try {
+        text = await response.text();
+      } catch (error) {
+        throw interrupted(error, method, context, life, {
+          sent: true,
+          status: response.status,
+          headers: response.headers,
+          refused: true
+        });
+      }
+      let value = null;
+      try {
+        value = JSON.parse(text);
+      } catch {
+      }
+      const { status } = response;
+      const { message, ...refusal } = policy.parseRefusal(value);
+      throw makeError(
+        message ?? `Request failed (${status})`,
+        {
+          ...refusal,
+          kind: "http",
+          status,
+          retryAfter: retryAfter(response.headers),
+          uncertain: method !== "GET" && uncertainStatuses.has(status)
+        },
+        context
+      );
+    }
+    return response;
+  }
+  return { send, interrupted };
+}
+
+export {
+  uncertainStatuses,
+  withQuery,
+  untilAborted,
+  createHttpExchange
+};