@domino-sdk/relay 1.61.0 → 1.63.0

package/dist/chunk-DHXDBAJF.js

@@ -1,544 +0,0 @@
-import {
-  MANAGEMENT_TIMEOUT,
-  lifetime,
-  retryAfter,
-  retrying,
-  validTimeout
-} from "./chunk-XBV2CK2H.js";
-import {
-  clientIdentity
-} from "./chunk-EN3M5Z4J.js";
-import {
-  authScopeSchema
-} from "./chunk-PPB7HALD.js";
-import {
-  RequestError,
-  appIdentityKindSchema,
-  isRequestError,
-  knownResponse,
-  openIdentityKindSchema
-} from "./chunk-ZDJLPN4L.js";
-
-// src/configuration.ts
-function questConfiguration(release) {
-  return release.configuration ?? {
-    defaults: Object.fromEntries(
-      Object.entries(release.fields).map(([key, field]) => [
-        key,
-        field.default
-      ])
-    ),
-    overrides: { ...release.values },
-    preserved: Object.keys(release.values)
-  };
-}
-
-// src/credential-secrets.ts
-import * as z from "zod";
-var credentialSecretSchema = z.object({
-  id: z.string().uuid(),
-  /** The secret's last four characters, to tell secrets apart; null for one issued before hints. */
-  hint: z.string().nullable(),
-  createdAt: z.number(),
-  /** When the secret stops working; null when it never expires. */
-  expiresAt: z.number().nullable(),
-  /** When the secret last authenticated a request; null when it never has. */
-  lastUsedAt: z.number().nullable()
-});
-var credentialSecretInputSchema = z.object({
-  expiresInDays: z.number().int().min(1).max(3650).optional()
-}).strict();
-
-// src/identity-integration.ts
-import * as z2 from "zod";
-var identityIntegrationInputSchema = z2.object({
-  name: z2.string().trim().min(1).max(80),
-  origin: z2.string().url().refine((value) => {
-    const url = new URL(value);
-    return url.protocol === "https:" && url.origin === value;
-  }, "Use an exact HTTPS application origin"),
-  /**
-   * The identity kind this integration owns in the project and environment, such as
-   * `app:telegram`. Each member it signs in gets the exchanged subject as an identity of this
-   * kind, which tracker attribution and `ctx.member.identities()` read. Its kind cannot change.
-   * Omit it for an integration that only signs members in.
-   *
-   * A kind belongs to the integration that first claimed it, also after that integration is
-   * disconnected. A new integration takes a kind that already has identities only by adopting
-   * them with `adoptIdentitiesFrom`.
-   */
-  identityKind: appIdentityKindSchema.optional(),
-  /**
-   * Adopt the identities of a disconnected integration's `identityKind`: its ID, as
-   * `identityIntegrations.kinds()` lists it. Adopt only when this app's user IDs mean the same
-   * users as that integration's, because each one then signs in as the member that ID is linked
-   * to. Needs `reason`, which the audit log keeps.
-   */
-  adoptIdentitiesFrom: z2.string().uuid().optional(),
-  /** Why the identities are adopted; required with `adoptIdentitiesFrom`. */
-  reason: z2.string().trim().min(1).max(500).optional(),
-  /** Days until the first secret expires. Omit it for a key that never expires. */
-  expiresInDays: z2.number().int().min(1).max(3650).optional()
-}).strict().refine(
-  (input) => !input.adoptIdentitiesFrom || input.identityKind,
-  "Adopting identities needs the identityKind they have"
-).refine(
-  (input) => !input.adoptIdentitiesFrom === !input.reason,
-  "Give a reason when adopting identities, and only then"
-);
-var identityIntegrationSchema = z2.object({
-  ...authScopeSchema.shape,
-  id: z2.string().uuid(),
-  name: z2.string(),
-  origin: z2.string(),
-  /**
-   * When the integration's last working secret expires: 8640000000000000 (the latest date
-   * JavaScript represents) when one never does.
-   *
-   * @deprecated Read `secrets`, which gives each secret's own expiry.
-   */
-  expiresAt: z2.number(),
-  /** The integration's working secrets, oldest first. Any of them authenticates it. */
-  secrets: z2.array(credentialSecretSchema).default([]),
-  /** The latest use of any of its secrets, revoked ones included; null when none was used. */
-  lastUsedAt: z2.number().nullable().default(null),
-  /** The identity kind the integration owns; null when it only signs members in. */
-  identityKind: openIdentityKindSchema.nullable().default(null)
-});
-var identityIntegrationSecretSchema = identityIntegrationSchema.extend(
-  {
-    token: z2.string()
-  }
-);
-var identityKindClaimSchema = z2.object({
-  kind: openIdentityKindSchema,
-  /** The owning integration's ID; it stays after the integration is disconnected. */
-  integration: z2.string(),
-  /** The owning integration's name when it claimed or adopted the kind. */
-  integrationName: z2.string(),
-  /** Whether the owning integration is still connected. */
-  connected: z2.boolean(),
-  /** Linked identities of the kind; adopting them is required to reuse the kind. */
-  linked: z2.number().int().nonnegative(),
-  /** Identities an operator unlinked. */
-  unlinked: z2.number().int().nonnegative(),
-  claimedAt: z2.number().int().nonnegative()
-});
-var participantExchangeSchema = z2.object({
-  subject: z2.string().min(1).max(200),
-  previousToken: z2.string().max(200).optional()
-}).strict();
-
-// src/server/errors.ts
-import * as z3 from "zod";
-var ManagementErrorCode = {
-  /** The input or an option failed validation before anything was sent (kind `client`). */
-  InvalidInput: "invalid-input",
-  /** The client's `getToken` failed before anything was sent (kind `client` or `network`). */
-  Credential: "credential",
-  Network: "network",
-  Timeout: "timeout",
-  Aborted: "aborted",
-  InvalidResponse: "invalid-response"
-};
-var managementErrorSchema = z3.looseObject({
-  error: z3.string(),
-  code: z3.string().optional()
-});
-var uncertainStatuses = /* @__PURE__ */ new Set([500, 502, 504]);
-function uncertainOutcome(init) {
-  if (init.method === void 0 || init.method === "GET") {
-    return false;
-  }
-  switch (init.kind) {
-    case "network":
-    case "timeout":
-    case "aborted":
-      return true;
-    case "http":
-      return uncertainStatuses.has(init.status ?? 0);
-    case "invalid-response":
-      return (init.status ?? 0) >= 200 && (init.status ?? 0) < 300;
-    default:
-      return false;
-  }
-}
-var managementErrorBrand = /* @__PURE__ */ Symbol.for("@domino-sdk/relay.ManagementError");
-function isManagementError(value) {
-  return isRequestError(value) && value[managementErrorBrand] === true;
-}
-var ManagementError = class extends RequestError {
-  name = "ManagementError";
-  [managementErrorBrand] = true;
-  /** The rest of the server's error body besides `error` and `code`, such as `moved`; absent when there is none. */
-  details;
-  /** The request's method; absent when the call failed before forming a request. */
-  method;
-  /** The management API path, below `/management/v1`, without its query; absent like `method`. */
-  path;
-  constructor(init) {
-    super(init.message, {
-      kind: init.kind,
-      uncertain: init.uncertain ?? uncertainOutcome(init),
-      status: init.status,
-      code: init.code,
-      operationId: init.actionId,
-      replaySafe: init.replaySafe,
-      retryAfter: init.retryAfter,
-      cause: init.cause
-    });
-    this.details = init.details && Object.keys(init.details).length ? init.details : void 0;
-    this.method = init.method;
-    this.path = init.path;
-  }
-};
-var DEFAULT_MANAGEMENT_TIMEOUT = MANAGEMENT_TIMEOUT;
-
-// src/server/transport.ts
-import * as z4 from "zod";
-function failureCause(error) {
-  if (typeof error !== "object" || error === null || !("cause" in error)) {
-    return {};
-  }
-  const { cause } = error;
-  return typeof cause === "object" && cause !== null ? cause : {};
-}
-function actionIdOf(input) {
-  return typeof input === "object" && input !== null && "actionId" in input && typeof input.actionId === "string" ? input.actionId : void 0;
-}
-function unsent(error) {
-  const code = String(failureCause(error).code ?? "");
-  return /^(ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ENETUNREACH|EHOSTUNREACH|UND_ERR_CONNECT_TIMEOUT)$|CERT|TLS|SSL/.test(
-    code
-  );
-}
-function redirected(error) {
-  return /redirect/i.test(String(failureCause(error).message ?? ""));
-}
-function checkedTimeout(timeout) {
-  if (timeout !== void 0 && !validTimeout(timeout)) {
-    throw new ManagementError({
-      kind: "client",
-      code: ManagementErrorCode.InvalidInput,
-      message: "Management timeout must be a positive, finite number of milliseconds"
-    });
-  }
-  return timeout;
-}
-function managementTransport(options) {
-  const clientTimeout = checkedTimeout(options.timeout) ?? DEFAULT_MANAGEMENT_TIMEOUT;
-  try {
-    const headers = new Headers(options.headers);
-    headers.set("X-Relay-Organization", options.organization ?? "");
-    headers.set("X-Relay-Project", options.project ?? "");
-  } catch (error) {
-    throw new ManagementError({
-      kind: "client",
-      code: ManagementErrorCode.InvalidInput,
-      message: "Management headers, organization and project must be valid HTTP header values",
-      cause: error
-    });
-  }
-  function callLifetime(call) {
-    return lifetime(
-      checkedTimeout(call?.timeout) ?? clientTimeout,
-      call?.signal ?? void 0
-    );
-  }
-  function transportFailure(error, context, life, sent, status, refused = false, headers) {
-    if (error instanceof ManagementError) {
-      return error;
-    }
-    const unsent2 = {
-      retryAfter: headers ? retryAfter(headers) : void 0,
-      // A redirect fetch refused to follow was answered without being applied.
-      ...!sent || redirected(error) ? { uncertain: false } : refused ? {
-        uncertain: context.method !== "GET" && [500, 502, 504].includes(status ?? 0)
-      } : {},
-      ...status === void 0 ? {} : { status }
-    };
-    const ended = life.ended();
-    if (ended === "aborted") {
-      return new ManagementError({
-        ...context,
-        ...unsent2,
-        kind: "aborted",
-        code: ManagementErrorCode.Aborted,
-        message: "The management request was cancelled",
-        cause: life.reason()
-      });
-    }
-    if (ended === "timeout") {
-      return new ManagementError({
-        ...context,
-        ...unsent2,
-        kind: "timeout",
-        code: ManagementErrorCode.Timeout,
-        message: `The management request did not finish within ${life.timeout} ms`,
-        cause: error
-      });
-    }
-    return new ManagementError({
-      ...context,
-      ...unsent2,
-      kind: "network",
-      code: ManagementErrorCode.Network,
-      message: "The management request failed before Domino answered",
-      cause: error
-    });
-  }
-  async function credential(context, life) {
-    if (!options.getToken) {
-      return null;
-    }
-    const getToken = options.getToken;
-    try {
-      return await new Promise((resolve, reject) => {
-        const stop = () => reject(life.signal.reason);
-        life.signal.addEventListener("abort", stop, { once: true });
-        getToken().then(resolve, reject).finally(() => life.signal.removeEventListener("abort", stop));
-      });
-    } catch (error) {
-      if (life.signal.aborted) {
-        throw transportFailure(error, context, life, false);
-      }
-      throw new ManagementError({
-        ...context,
-        // A token source that could not reach its own service failed like a network call.
-        kind: error instanceof TypeError ? "network" : "client",
-        code: ManagementErrorCode.Credential,
-        uncertain: false,
-        message: "Could not get a management credential",
-        cause: error
-      });
-    }
-  }
-  async function send(path, fetchInit, context, life) {
-    if (life.signal.aborted) {
-      throw transportFailure(life.reason(), context, life, false);
-    }
-    const headers = new Headers(options.headers);
-    new Headers(fetchInit.headers).forEach(
-      (value, name) => headers.set(name, value)
-    );
-    headers.set("X-Domino-Client", options.client ?? clientIdentity());
-    const token = await credential(context, life);
-    if (token) {
-      try {
-        headers.set("Authorization", `Bearer ${token}`);
-      } catch (error) {
-        throw new ManagementError({
-          ...context,
-          kind: "client",
-          code: ManagementErrorCode.Credential,
-          uncertain: false,
-          message: "getToken returned a value that is not a token",
-          cause: error
-        });
-      }
-    } else if (options.getToken) {
-      headers.delete("Authorization");
-    }
-    if (options.organization) {
-      headers.set("X-Relay-Organization", options.organization);
-    }
-    if (options.project) {
-      headers.set("X-Relay-Project", options.project);
-    }
-    if (options.environment) {
-      headers.set("X-Relay-Environment", options.environment);
-    }
-    let response;
-    try {
-      response = await (options.fetch ?? fetch)(
-        `${options.baseUrl}/management/v1${path}`,
-        {
-          ...fetchInit,
-          headers,
-          signal: life.signal,
-          ...options.redirect ? { redirect: options.redirect } : {}
-        }
-      );
-    } catch (error) {
-      throw transportFailure(error, context, life, !unsent(error));
-    }
-    if (!response.ok) {
-      let text;
-      try {
-        text = await response.text();
-      } catch (error2) {
-        throw transportFailure(
-          error2,
-          context,
-          life,
-          true,
-          response.status,
-          true,
-          response.headers
-        );
-      }
-      let body = null;
-      try {
-        body = JSON.parse(text);
-      } catch {
-      }
-      const parsed = managementErrorSchema.safeParse(body);
-      const { error, code, ...details } = parsed.success ? parsed.data : { error: `Request failed (${response.status})`, code: void 0 };
-      throw new ManagementError({
-        ...context,
-        kind: "http",
-        status: response.status,
-        message: error,
-        ...code === void 0 ? {} : { code },
-        details,
-        retryAfter: retryAfter(response.headers)
-      });
-    }
-    return response;
-  }
-  async function raw(path, init) {
-    const { timeout, signal, ...fetchInit } = init ?? {};
-    const life = callLifetime({ timeout, signal: signal ?? void 0 });
-    try {
-      return await send(
-        path,
-        fetchInit,
-        {
-          method: (fetchInit.method ?? "GET").toUpperCase(),
-          path: path.split("?")[0],
-          replaySafe: false
-        },
-        life
-      );
-    } finally {
-      life.end();
-    }
-  }
-  async function exchange(path, schema, input, method, call, replaySafe, tolerant = false) {
-    const actionId = actionIdOf(input);
-    const context = {
-      method,
-      replaySafe,
-      path: path.split("?")[0],
-      ...actionId ? { actionId } : {}
-    };
-    const fetchInit = {
-      method,
-      headers: tolerant ? { "X-Domino-Response": "tolerant-v1" } : void 0,
-      ...input === void 0 ? {} : {
-        headers: {
-          "Content-Type": "application/json",
-          ...tolerant ? { "X-Domino-Response": "tolerant-v1" } : {}
-        },
-        body: JSON.stringify(input)
-      }
-    };
-    const life = callLifetime(call);
-    try {
-      return await retrying(
-        life,
-        { replaySafe: method === "GET" || replaySafe },
-        async () => {
-          const response = await send(path, fetchInit, context, life);
-          let body;
-          try {
-            body = response.status === 204 ? null : await response.json();
-          } catch (error) {
-            if (error instanceof SyntaxError && !life.signal.aborted) {
-              throw new ManagementError({
-                ...context,
-                kind: "invalid-response",
-                code: ManagementErrorCode.InvalidResponse,
-                status: response.status,
-                message: "Domino answered with a body that is not JSON",
-                cause: error
-              });
-            }
-            throw transportFailure(
-              error,
-              context,
-              life,
-              true,
-              response.status,
-              false,
-              response.headers
-            );
-          }
-          const parsed = knownResponse(schema).safeParse(
-            tolerant ? { status: response.status, operationId: actionId, result: body } : body
-          );
-          if (!parsed.success) {
-            throw new ManagementError({
-              ...context,
-              kind: "invalid-response",
-              code: ManagementErrorCode.InvalidResponse,
-              status: response.status,
-              message: "Domino answered with a response this client does not recognize",
-              cause: parsed.error
-            });
-          }
-          return parsed.data;
-        }
-      );
-    } finally {
-      life.end();
-    }
-  }
-  const json = ({
-    path,
-    method,
-    body,
-    replaySafe
-  }) => exchange(
-    path,
-    z4.unknown(),
-    body,
-    method,
-    void 0,
-    method === "GET" || replaySafe
-  );
-  return { raw, exchange, json };
-}
-
-// src/sequence-cursor.ts
-import * as z5 from "zod";
-var sequenceCursorSchema = z5.string().regex(/^[1-9][0-9]{0,15}$/, "Invalid cursor").transform(Number).pipe(z5.number().int().positive().safe());
-
-// src/referral-reward-kinds.ts
-var REFERRAL_INTEGRATION_REWARD_ERROR = "Referral programs can grant points and tiered rewards; Discord roles need a quest";
-var isRecord = (value) => typeof value === "object" && value !== null;
-function containsReferralIntegrationReward(value) {
-  if (Array.isArray(value)) {
-    return value.some(
-      (reward) => isRecord(reward) && reward.kind === "integration"
-    );
-  }
-  if (!isRecord(value)) {
-    return false;
-  }
-  const definition = isRecord(value.definition) ? value.definition : value;
-  return isRecord(definition.rewards) && (containsReferralIntegrationReward(definition.rewards.inviter) || containsReferralIntegrationReward(definition.rewards.invitee)) || Array.isArray(definition.milestones) && definition.milestones.some(
-    (milestone) => isRecord(milestone) && containsReferralIntegrationReward(milestone.rewards)
-  );
-}
-
-export {
-  questConfiguration,
-  credentialSecretSchema,
-  credentialSecretInputSchema,
-  identityIntegrationInputSchema,
-  identityIntegrationSchema,
-  identityIntegrationSecretSchema,
-  identityKindClaimSchema,
-  participantExchangeSchema,
-  ManagementErrorCode,
-  managementErrorSchema,
-  isManagementError,
-  ManagementError,
-  DEFAULT_MANAGEMENT_TIMEOUT,
-  actionIdOf,
-  managementTransport,
-  sequenceCursorSchema,
-  REFERRAL_INTEGRATION_REWARD_ERROR,
-  containsReferralIntegrationReward
-};

package/dist/chunk-EN3M5Z4J.js

@@ -1,13 +0,0 @@
-// package.json
-var name = "@domino-sdk/relay";
-var version = "1.61.0";
-
-// src/client-identity.ts
-function clientIdentity() {
-  const runtime = typeof document === "undefined" ? "server" : "browser";
-  return `${name}/${version} (${runtime})`;
-}
-
-export {
-  clientIdentity
-};