@domino-sdk/relay 1.11.1 → 1.14.0

package/dist/chunk-5TS3OAWS.js

@@ -0,0 +1,470 @@
+import {
+  MANAGEMENT_TIMEOUT,
+  lifetime,
+  retryAfter,
+  retrying,
+  validTimeout
+} from "./chunk-6QJ3LADK.js";
+import {
+  RequestError,
+  isRequestError
+} from "./chunk-NPGENI7K.js";
+import {
+  clientIdentity
+} from "./chunk-C3CB4WIQ.js";
+import {
+  authScopeSchema
+} from "./chunk-PT5STHFH.js";
+import {
+  appIdentityKindSchema,
+  knownResponse,
+  openIdentityKindSchema
+} from "./chunk-46C33ASD.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/identity-integration.ts
+import { z } from "zod";
+var identityIntegrationInputSchema = z.object({
+  name: z.string().trim().min(1).max(80),
+  origin: z.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: z.string().uuid().optional(),
+  /** Why the identities are adopted; required with `adoptIdentitiesFrom`. */
+  reason: z.string().trim().min(1).max(500).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 = z.object({
+  ...authScopeSchema.shape,
+  id: z.string().uuid(),
+  name: z.string(),
+  origin: z.string(),
+  expiresAt: z.number(),
+  /** The identity kind the integration owns; null when it only signs members in. */
+  identityKind: openIdentityKindSchema.nullable().default(null)
+});
+var identityIntegrationSecretSchema = identityIntegrationSchema.extend(
+  {
+    token: z.string()
+  }
+);
+var identityKindClaimSchema = z.object({
+  kind: openIdentityKindSchema,
+  /** The owning integration's ID; it stays after the integration is disconnected. */
+  integration: z.string(),
+  /** The owning integration's name when it claimed or adopted the kind. */
+  integrationName: z.string(),
+  /** Whether the owning integration is still connected. */
+  connected: z.boolean(),
+  /** Linked identities of the kind; adopting them is required to reuse the kind. */
+  linked: z.number().int().nonnegative(),
+  /** Identities an operator unlinked. */
+  unlinked: z.number().int().nonnegative(),
+  claimedAt: z.number().int().nonnegative()
+});
+var participantExchangeSchema = z.object({
+  subject: z.string().min(1).max(200),
+  previousToken: z.string().max(200).optional()
+}).strict();
+
+// src/server/errors.ts
+import { z as z2 } 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 = z2.looseObject({
+  error: z2.string(),
+  code: z2.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
+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(
+    error?.cause?.code ?? ""
+  );
+  return /^(ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ENETUNREACH|EHOSTUNREACH|UND_ERR_CONNECT_TIMEOUT)$|CERT|TLS|SSL/.test(
+    code
+  );
+}
+function redirected(error) {
+  const cause = error?.cause;
+  return /redirect/i.test(String(cause?.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;
+  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(fetchInit.headers);
+    headers.set("X-Domino-Client", options.client ?? clientIdentity());
+    const token = await credential(context, life);
+    if (token) {
+      headers.set("Authorization", `Bearer ${token}`);
+    }
+    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 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
+            );
+          }
+          if (schema === void 0) {
+            return body;
+          }
+          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();
+    }
+  }
+  return { raw, exchange };
+}
+
+// src/sequence-cursor.ts
+import { z as z3 } from "zod";
+var sequenceCursorSchema = z3.string().regex(/^[1-9][0-9]{0,15}$/, "Invalid cursor").transform(Number).pipe(z3.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,
+  identityIntegrationInputSchema,
+  identityIntegrationSchema,
+  identityIntegrationSecretSchema,
+  identityKindClaimSchema,
+  participantExchangeSchema,
+  ManagementErrorCode,
+  managementErrorSchema,
+  isManagementError,
+  ManagementError,
+  DEFAULT_MANAGEMENT_TIMEOUT,
+  actionIdOf,
+  managementTransport,
+  sequenceCursorSchema,
+  REFERRAL_INTEGRATION_REWARD_ERROR,
+  containsReferralIntegrationReward
+};

package/dist/{chunk-PUDL4JBY.js → chunk-6DD7DVNQ.js}

@@ -1,12 +1,12 @@
 import {
   createRelayClient
-} from "./chunk-XK5E4HAS.js";
+} from "./chunk-VBHFJH3P.js";
 import {
   RelayErrorCode,
   asRelayError,
   clientError,
   cosmosChain
-} from "./chunk-ZFABFKIY.js";
+} from "./chunk-2UAVZCMH.js";
 
 // src/base58.ts
 var alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

package/dist/{chunk-AGFUDCNM.js → chunk-C3CB4WIQ.js}

@@ -1,6 +1,6 @@
 // package.json
 var name = "@domino-sdk/relay";
-var version = "1.11.1";
+var version = "1.14.0";
 
 // src/client-identity.ts
 function clientIdentity() {

package/dist/{chunk-T657WO56.js → chunk-LLMJ2SUT.js}

@@ -1,6 +1,6 @@
 import {
   pointLedgerReferenceSchema
-} from "./chunk-ZFABFKIY.js";
+} from "./chunk-UJACD6K2.js";
 import {
   authoringIdentityShape,
   entitlementSchema,
@@ -90,8 +90,12 @@ var relayEventSchema = z.union([
 ]);
 var participantActivityQuerySchema = z.object({
   cursor: pageCursorSchema.optional(),
+  /** `latest` answers no events and the cursor of the newest one, to follow only what comes next. */
+  start: z.literal("latest").optional(),
   limit: z.number().int().min(1).max(100).default(50)
-}).strict();
+}).strict().refine((query) => !(query.cursor && query.start), {
+  message: "Pass either cursor or start, not both"
+});
 var participantActivitySchema = z.object({
   member: z.string(),
   items: z.array(relayEventSchema),

package/dist/chunk-NIYCAW2I.js

@@ -0,0 +1,79 @@
+import {
+  capabilityFailureSchema
+} from "./chunk-MC6V6VMG.js";
+import {
+  contentPerformanceSnapshotSchema,
+  decisionSchema,
+  identifier,
+  rewardBundleSchema,
+  settingsValuesSchema,
+  trackerTriggerContextSchema
+} from "./chunk-46C33ASD.js";
+
+// src/server/attempt-captures.ts
+import { z } from "zod";
+var timestamp = z.number().int().nonnegative().safe();
+var capturedFactSchema = z.object({
+  /** The call's position in the run, from 0. */
+  sequence: z.number().int().nonnegative(),
+  /** The capability request quest code sent, after validation. */
+  request: z.record(z.string(), z.json()),
+  /**
+   * The answer every retry of the run receives: the result, or the failure quest code saw. Absent
+   * while the call has no answer, such as when the run stopped during it.
+   */
+  outcome: z.union([
+    z.object({ value: z.json() }),
+    z.object({ error: capabilityFailureSchema })
+  ]).optional(),
+  /**
+   * False when a retry of the run asks the provider again: a retryable failure Relay recorded but
+   * did not keep, or a call without an answer. A replay cannot answer such a call.
+   */
+  captured: z.boolean()
+});
+var attemptCaptureSchema = z.object({
+  format: z.literal(1),
+  attempt: identifier,
+  environment: z.literal("test"),
+  quest: z.object({
+    id: identifier,
+    /** The quest's authoring key; null for a quest created in Console. */
+    key: identifier.nullable()
+  }),
+  release: identifier,
+  evaluationRun: z.number().int().nonnegative(),
+  /** The evaluator protocol the release was built for. */
+  protocol: z.number().int().positive(),
+  /** The seed of the run's `Math.random()` and `crypto.randomUUID()` streams. */
+  seed: z.string().min(1),
+  /** The run's frozen start time, `ctx.now`. */
+  now: timestamp,
+  context: z.object({
+    settings: settingsValuesSchema,
+    rewards: rewardBundleSchema,
+    humanReview: z.boolean(),
+    integrations: z.array(z.string()),
+    member: identifier,
+    input: z.record(z.string(), z.json()),
+    tracker: trackerTriggerContextSchema.nullable(),
+    eligibleAt: timestamp,
+    calendar: z.object({
+      segments: z.array(
+        z.looseObject({ effectiveAt: timestamp, timeZone: z.string() })
+      )
+    }),
+    performance: contentPerformanceSnapshotSchema.nullable()
+  }),
+  facts: z.array(capturedFactSchema),
+  /**
+   * What quest code decided in the run, before Relay amended, claimed or reviewed it. Null while it
+   * has decided nothing, and for runs decided before Relay kept decisions.
+   */
+  recorded: decisionSchema.nullable()
+});
+
+export {
+  capturedFactSchema,
+  attemptCaptureSchema
+};