@domino-sdk/relay 1.61.0 → 1.63.0

package/dist/chunk-GLH6MEI2.js

@@ -0,0 +1,193 @@
+// src/request-error.ts
+var requestErrorBrand = /* @__PURE__ */ (() => /* @__PURE__ */ Symbol.for("@domino-sdk/relay.RequestError"))();
+function isRequestError(value) {
+  return typeof value === "object" && value !== null && value[requestErrorBrand] === true;
+}
+var RequestError = class extends Error {
+  name = "RequestError";
+  [requestErrorBrand] = true;
+  kind;
+  uncertain;
+  status;
+  code;
+  operationId;
+  /** `replay` for a replay-safe operation ID, else `reconcile`; only when `uncertain`. */
+  recovery;
+  /**
+   * Milliseconds the server asked the client to wait before trying again, from the `Retry-After`
+   * header of an error answer such as a 429 or 503. The client's own retries never wait past the
+   * call's deadline, so a longer wait is left to the caller.
+   */
+  retryAfter;
+  constructor(message, details) {
+    super(message, details.cause === void 0 ? {} : { cause: details.cause });
+    this.kind = details.kind;
+    this.uncertain = details.uncertain ?? false;
+    this.status = details.status;
+    this.code = details.code;
+    this.operationId = details.operationId;
+    this.retryAfter = details.retryAfter;
+    this.recovery = this.uncertain ? details.operationId && (details.replaySafe ?? true) ? "replay" : "reconcile" : void 0;
+  }
+};
+
+// src/errors.ts
+import * as z from "zod";
+var RelayErrorCode = {
+  /** The call needs a signed-in member. */
+  NotSignedIn: "not-signed-in",
+  /** The session changed since the app read it (the `session` option). Reload before retrying. */
+  StaleSession: "stale-session",
+  /**
+   * A participant backend (`createParticipantBackend`) refused the call because the app's own
+   * sign-in ended. The SDK treats it like `not-signed-in`: the member is signed out.
+   */
+  Unauthenticated: "unauthenticated",
+  /** The input failed validation before it was sent. */
+  InvalidInput: "invalid-input",
+  /** Relay's answer was not JSON or not the expected shape (kind `invalid-response`). */
+  InvalidResponse: "invalid-response",
+  /** The transport failed, before a response or while reading its body (kind `network`). */
+  Network: "network",
+  /** The client's deadline elapsed (kind `timeout`). */
+  Timeout: "timeout",
+  /** The caller cancelled the request (kind `aborted`). */
+  Aborted: "aborted",
+  /** A quest or collection the call named is not in the member's experience. */
+  NotFound: "not-found",
+  /** The quest has no failed attempt the member can retry. */
+  RetryUnavailable: "retry-unavailable",
+  /**
+   * Durable submission storage is missing, blocked or unreadable. Nothing was lost: call the
+   * handle's `status()` or `resume()` again once storage is available.
+   */
+  SubmissionStorage: "submission-storage",
+  /** Browser storage is full, so submission progress was not saved. Free space, then resume. */
+  SubmissionStorageQuota: "submission-storage-quota",
+  /** The saved submission is in a state that does not allow this action. */
+  SubmissionConflict: "submission-conflict",
+  /**
+   * The saved submission's operation belongs to a retired contract and cannot continue. Show the
+   * current quest and let the member `discard()` it before submitting again.
+   */
+  OperationRetired: "operation-retired",
+  /** The quest changed since the member saw it; review it before submitting again. */
+  QuestUpdated: "quest-updated",
+  /** Wait for the deferred attempt before submitting another action. */
+  AttemptPending: "attempt-pending",
+  /**
+   * The member's last attempt was rejected and the quest's retry cooldown is running; `retryAt`
+   * says when they may submit again.
+   */
+  RetryCooldown: "retry-cooldown",
+  /**
+   * The member's last accepted completion of the quest is more recent than its completion
+   * cooldown; `retryAt` says when they may submit again.
+   */
+  CompletionCooldown: "completion-cooldown",
+  /** The quiz changed since the member answered it. */
+  StaleQuiz: "stale-quiz",
+  /** Relay refused the submitted evidence. */
+  InvalidSubmission: "invalid-submission",
+  /** A page cursor Relay cannot read; start again from the first page. */
+  InvalidCursor: "invalid-cursor",
+  /** No point ledger in the project has the key or ID the call named. */
+  PointLedgerNotFound: "point-ledger-not-found",
+  /** The member has not joined this project, so it holds no points here. */
+  NotJoined: "not-joined",
+  /** The quest or campaign is not open at this time. */
+  OutsideWindow: "outside-window",
+  /** The signed-in member must enroll in the campaign first. */
+  EnrollmentRequired: "enrollment-required",
+  /** The quest's current reward budget has no remaining capacity. */
+  BudgetExhausted: "budget-exhausted",
+  /** No published offer has the key or ID the call named. */
+  OfferNotFound: "offer-not-found",
+  /** The operator paused this offer. */
+  OfferPaused: "offer-paused",
+  /** This member has already used the offer's allowed number of redemptions. */
+  OfferLimitReached: "offer-limit-reached",
+  /** No declared units remain. */
+  OfferOutOfStock: "offer-out-of-stock",
+  /** The participant's available point balance is below the offer price. */
+  InsufficientPoints: "insufficient-points",
+  /** The client's `getToken` failed before anything was sent; `cause` is its own error. */
+  Credential: "credential",
+  /** A wallet signer failed or the member refused to sign; `cause` is the wallet's own error. */
+  WalletSigner: "wallet-signer",
+  /** The member has not met the quest's or offer's prerequisites; `missing` lists them. */
+  PrerequisitesIncomplete: "prerequisites-incomplete",
+  /** The quest is archived or retired: it takes no new participation. */
+  QuestClosed: "quest-closed",
+  /** An operator paused the quest. */
+  QuestPaused: "quest-paused",
+  /** An operator locked the member's profile; hiding it is still allowed. */
+  ProfileLocked: "profile-locked",
+  /** No member in the project has the invitation code the member accepted. */
+  InvitationNotFound: "invitation-not-found",
+  /** The email sign-in code is wrong; the member can type it again. */
+  InvalidCode: "invalid-code",
+  /** The email sign-in code expired, was used or had too many attempts; request another. */
+  CodeExpired: "code-expired",
+  /** The wallet sign-in challenge expired, was used or changed; start sign-in again. */
+  ChallengeExpired: "challenge-expired",
+  /** Too many requests; `retryAfter` says how long to wait when Relay knows. */
+  RateLimited: "rate-limited"
+};
+var relayErrorBrand = /* @__PURE__ */ (() => /* @__PURE__ */ Symbol.for("@domino-sdk/relay.RelayError"))();
+function isRelayError(value) {
+  return isRequestError(value) && value[relayErrorBrand] === true;
+}
+var RelayError = class extends RequestError {
+  name = "RelayError";
+  [relayErrorBrand] = true;
+  /** Which window refused admission when `code` is `outside-window`. */
+  window;
+  /** Prerequisites the member does not currently meet, when Relay refused for that reason. */
+  missing;
+  /**
+   * Unix milliseconds when the member may submit again, when `code` is `retry-cooldown` or
+   * `completion-cooldown`.
+   */
+  retryAt;
+  constructor(message, details) {
+    super(message, details);
+    this.window = details.window;
+    this.missing = details.missing ?? [];
+    this.retryAt = details.retryAt;
+  }
+};
+function asRelayError(cause, fallback = "Request failed") {
+  if (isRelayError(cause)) {
+    return cause;
+  }
+  return new RelayError(
+    cause instanceof Error && cause.message ? cause.message : fallback,
+    { kind: "client", cause }
+  );
+}
+function clientError(message, code, details = {}) {
+  return new RelayError(message, { ...details, kind: "client", code });
+}
+function parseInput(schema, value) {
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    throw clientError(
+      z.prettifyError(parsed.error),
+      RelayErrorCode.InvalidInput,
+      { cause: parsed.error }
+    );
+  }
+  return parsed.data;
+}
+
+export {
+  isRequestError,
+  RequestError,
+  RelayErrorCode,
+  isRelayError,
+  RelayError,
+  asRelayError,
+  clientError,
+  parseInput
+};

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
+};