@domino-sdk/relay 1.61.0 → 1.63.0

package/dist/chunk-NQDEWJWE.js

@@ -0,0 +1,554 @@
+import {
+  createHttpExchange,
+  uncertainStatuses
+} from "./chunk-ICXZZNPS.js";
+import {
+  MANAGEMENT_TIMEOUT,
+  lifetime,
+  retrying,
+  validTimeout
+} from "./chunk-3RFP6GT5.js";
+import {
+  knownResponse,
+  lifecycleReasonSchema,
+  limits
+} from "./chunk-ID3BZXFZ.js";
+import {
+  RequestError,
+  isRequestError
+} from "./chunk-GLH6MEI2.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/server/errors.ts
+import * as z 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 = /* @__PURE__ */ (() => z.looseObject({
+  error: z.string(),
+  code: z.string().optional()
+}))();
+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__ */ (() => /* @__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 z2 from "zod";
+var ManagementUploadBody = class {
+  constructor(body, headers, actionId) {
+    this.body = body;
+    this.headers = headers;
+    this.actionId = actionId;
+  }
+  body;
+  headers;
+  actionId;
+};
+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) {
+  if (input instanceof ManagementUploadBody) {
+    return input.actionId;
+  }
+  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;
+  const redirect = options.redirect ? { redirect: options.redirect } : {};
+  const http = createHttpExchange(
+    {
+      baseUrl: `${options.baseUrl}/management/v1`,
+      headers: options.headers,
+      getToken: options.getToken,
+      fetch: options.fetch,
+      organization: options.organization,
+      project: options.project,
+      environment: options.environment
+    },
+    {
+      client: options.client,
+      credentialLast: true,
+      // A redirect fetch refused to follow was answered without being applied. The participant
+      // client has no such rule, so there a write that failed to connect stays uncertain.
+      neverSent: (error) => unsent(error) || redirected(error),
+      abortReason: true,
+      messages: {
+        aborted: "The management request was cancelled",
+        timeout: (milliseconds) => `The management request did not finish within ${milliseconds} ms`,
+        network: () => "The management request failed before Domino answered",
+        credential: "Could not get a management credential",
+        invalidToken: "getToken returned a value that is not a token",
+        invalidOptions: "Management headers, organization and project must be valid HTTP header values"
+        // No `unsendable`: a header or body that cannot be sent rejects with the platform's error.
+      },
+      makeError: (message, error, context) => new ManagementError({ ...context, ...error, message }),
+      // A body that is not the server's error JSON still rejects with the status.
+      parseRefusal: (body) => {
+        const parsed = managementErrorSchema.safeParse(body);
+        if (!parsed.success) {
+          return {};
+        }
+        const { error, code, ...details } = parsed.data;
+        return { message: error, code, details };
+      }
+    }
+  );
+  function callLifetime(call) {
+    return lifetime(
+      checkedTimeout(call?.timeout) ?? clientTimeout,
+      call?.signal ?? void 0
+    );
+  }
+  async function raw(path, init) {
+    const { timeout, signal, ...fetchInit } = init ?? {};
+    const life = callLifetime({ timeout, signal: signal ?? void 0 });
+    try {
+      return await http.send(
+        path,
+        {
+          method: fetchInit.method,
+          headers: fetchInit.headers,
+          body: fetchInit.body,
+          init: { ...fetchInit, ...redirect }
+        },
+        {
+          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 tolerance = tolerant ? { "X-Domino-Response": "tolerant-v1" } : {};
+    const request = input instanceof ManagementUploadBody ? {
+      method,
+      headers: {
+        "Content-Type": input.body.type,
+        ...input.headers,
+        ...tolerance
+      },
+      body: input.body,
+      init: redirect
+    } : { method, headers: tolerance, json: input, init: redirect };
+    const life = callLifetime(call);
+    try {
+      return await retrying(
+        life,
+        { replaySafe: method === "GET" || replaySafe },
+        async () => {
+          const response = await http.send(path, request, 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 http.interrupted(error, method, context, life, {
+              sent: true,
+              status: response.status,
+              headers: 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,
+    z2.unknown(),
+    body,
+    method,
+    void 0,
+    method === "GET" || replaySafe
+  );
+  return { raw, exchange, json };
+}
+
+// src/sequence-cursor.ts
+import * as z3 from "zod";
+var sequenceCursorSchema = /* @__PURE__ */ (() => 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)
+  );
+}
+
+// src/server/schedules.ts
+import * as z4 from "zod";
+import { Cron } from "croner";
+var APP_SCHEDULE_LIMIT = 10;
+var APP_SCHEDULE_MIN_INTERVAL = 3e5;
+var APP_SCHEDULE_TIMEOUT = 3e4;
+var appScheduleNameSchema = /* @__PURE__ */ (() => z4.string().regex(/^[a-z][a-z0-9-]{0,63}$/))();
+var appSchedulePathSchema = /* @__PURE__ */ (() => z4.string().min(2).max(512).refine((path) => {
+  if (!/^\/[a-zA-Z0-9_/-]+$/.test(path) || path.startsWith("//")) {
+    return false;
+  }
+  return path.split("/").slice(1).every((part) => part.length > 0) && new URL(path, "https://app.invalid").pathname === path;
+}, "Expected an absolute route path without a query or hidden segments"))();
+function interval(value) {
+  const amount = Number(value.slice(0, -1));
+  const unit = value.slice(-1);
+  return amount * (unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5);
+}
+var everySchema = /* @__PURE__ */ (() => z4.string().regex(/^[1-9]\d{0,3}[mhd]$/).refine(
+  (value) => interval(value) >= limits.apps.scheduleMinIntervalMs && interval(value) <= 365 * 864e5,
+  "Use an interval from 5 minutes to 365 days, such as 5m, 1h or 1d"
+))();
+var cronSchema = /* @__PURE__ */ (() => z4.string().max(120).refine((value) => {
+  const fields = value.trim().split(/\s+/);
+  if (fields.length !== 5 || fields.some((field) => !/^[\d*,/-]+$/.test(field))) {
+    return false;
+  }
+  try {
+    const job = new Cron(value, { paused: true, timezone: "UTC" });
+    if (!job.nextRun()) {
+      return false;
+    }
+    const minutes = new Cron(`${fields[0]} * * * *`, {
+      paused: true,
+      timezone: "UTC"
+    });
+    const times = minutes.nextRuns(13, /* @__PURE__ */ new Date("2024-01-01T00:00:00Z"));
+    return times.every(
+      (time, i) => i === 0 || time.getTime() - times[i - 1].getTime() >= limits.apps.scheduleMinIntervalMs
+    );
+  } catch {
+    return false;
+  }
+}, "Expected a five-field UTC cron expression with minute slots at least five minutes apart"))();
+var declaration = /* @__PURE__ */ (() => ({
+  name: appScheduleNameSchema,
+  path: appSchedulePathSchema,
+  description: z4.string().min(1).max(500)
+}))();
+var everySchedule = /* @__PURE__ */ (() => z4.object({ ...declaration, every: everySchema }))();
+var cronSchedule = /* @__PURE__ */ (() => z4.object({ ...declaration, cron: cronSchema }))();
+var appScheduleSchema = /* @__PURE__ */ (() => z4.union([
+  everySchedule.strict(),
+  cronSchedule.strict()
+]))();
+var appSchedulesSchema = /* @__PURE__ */ (() => z4.array(appScheduleSchema).max(limits.apps.schedules).refine(
+  (items) => new Set(items.map((item) => item.name)).size === items.length,
+  "Schedule names must be unique"
+))();
+function nextScheduleRun(schedule, after) {
+  if ("every" in schedule) {
+    return after + interval(schedule.every);
+  }
+  const next = new Cron(schedule.cron, {
+    paused: true,
+    timezone: "UTC"
+  }).nextRun(new Date(after));
+  if (!next) {
+    throw new Error("Schedule has no next occurrence");
+  }
+  return next.getTime();
+}
+var appScheduleStateSchema = /* @__PURE__ */ (() => z4.enum(["active", "paused", "archived"]))();
+var appScheduleStateInputSchema = /* @__PURE__ */ (() => z4.object({
+  state: appScheduleStateSchema,
+  reason: lifecycleReasonSchema.optional()
+}).strict())();
+var APP_SCHEDULE_RESULT_BYTES = 16384;
+var appScheduleDiagnosticSchema = /* @__PURE__ */ (() => z4.object({
+  level: z4.enum(["error", "warning", "info"]),
+  message: z4.string().min(1).max(500),
+  /** What the line is about, such as a member, record or tracker ID. */
+  subject: z4.string().min(1).max(200).optional(),
+  /** A stable code the app chooses, such as `ingest-timeout`. */
+  code: z4.string().min(1).max(100).optional()
+}))();
+var appScheduleResultSchema = /* @__PURE__ */ (() => z4.object({
+  outcome: z4.enum(["succeeded", "partial", "failed"]),
+  summary: z4.string().min(1).max(500).optional(),
+  /** Counts and gauges, such as processed and failed members. */
+  metrics: z4.record(z4.string().regex(/^[A-Za-z][\w.-]{0,63}$/), z4.number()).refine(
+    (metrics) => Object.keys(metrics).length <= 50,
+    "Report at most 50 metrics"
+  ).optional(),
+  diagnostics: z4.array(appScheduleDiagnosticSchema).max(50).optional()
+}))();
+function scheduleResult(result) {
+  const body = JSON.stringify(appScheduleResultSchema.parse(result));
+  if (new TextEncoder().encode(body).byteLength > limits.apps.scheduleResultBytes) {
+    throw new Error(
+      `A schedule result must be at most ${limits.apps.scheduleResultBytes.toLocaleString("en-US")} bytes of JSON: send fewer or shorter diagnostics`
+    );
+  }
+  return new Response(body, {
+    headers: { "Content-Type": "application/json" }
+  });
+}
+var appScheduleRunSchema = /* @__PURE__ */ (() => z4.object({
+  id: z4.string().uuid(),
+  build: z4.string().uuid(),
+  startedAt: z4.number(),
+  scheduledAt: z4.number(),
+  manual: z4.boolean(),
+  status: z4.enum(["queued", "running", "succeeded", "failed", "uncertain"]),
+  duration: z4.number().nullable(),
+  /** Why the run failed or is uncertain, or why Relay ignored the app's result. */
+  error: z4.string().nullable(),
+  /** The app's JSON answer when it sent a valid result. Absent on runs from before results. */
+  result: appScheduleResultSchema.nullable().optional()
+}))();
+var appScheduleRunsSchema = /* @__PURE__ */ (() => z4.object({
+  /** Newest first: the latest twenty runs of one schedule, including a queued or running one. */
+  runs: z4.array(appScheduleRunSchema)
+}))();
+var appScheduleListSchema = /* @__PURE__ */ (() => z4.object({
+  state: appScheduleStateSchema,
+  schedules: z4.array(
+    z4.object({
+      declaration: z4.union([everySchedule, cronSchedule]),
+      nextRun: z4.number().nullable(),
+      blocked: z4.boolean(),
+      lastRun: appScheduleRunSchema.nullable()
+    })
+  )
+}))();
+var scheduledInvocationSchema = /* @__PURE__ */ (() => z4.object({
+  id: z4.string().uuid(),
+  build: z4.string().uuid(),
+  name: appScheduleNameSchema,
+  scheduledAt: z4.number().int(),
+  startedAt: z4.number().int(),
+  manual: z4.boolean()
+}).strict())();
+async function verifyScheduledRequest(request, key) {
+  const signature = request.headers.get("X-Domino-Schedule-Signature");
+  const url = new URL(request.url);
+  if (request.method !== "POST" || url.search !== "" || url.hash !== "" || !key || !signature || !/^[a-f0-9]{64}$/.test(signature)) {
+    return null;
+  }
+  const reader = request.clone().body?.getReader();
+  if (!reader) {
+    return null;
+  }
+  let body = "";
+  let size = 0;
+  const decoder = new TextDecoder();
+  try {
+    for (; ; ) {
+      const chunk = await reader.read();
+      if (chunk.done) {
+        break;
+      }
+      size += chunk.value.byteLength;
+      if (size > 4096) {
+        void reader.cancel().catch(() => {
+        });
+        return null;
+      }
+      body += decoder.decode(chunk.value, { stream: true });
+    }
+    body += decoder.decode();
+  } catch {
+    return null;
+  }
+  const secret = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(key),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["verify"]
+  );
+  const bytes = Uint8Array.from(
+    signature.match(/../g) ?? [],
+    (byte) => Number.parseInt(byte, 16)
+  );
+  const valid = await crypto.subtle.verify(
+    "HMAC",
+    secret,
+    bytes,
+    new TextEncoder().encode(`POST
+${url.pathname}
+${body}`)
+  );
+  if (!valid) {
+    return null;
+  }
+  const parsed = scheduledInvocationSchema.safeParse(
+    await new Response(body).json().catch(() => null)
+  );
+  if (!parsed.success || Math.abs(Date.now() - parsed.data.startedAt) > 6e4) {
+    return null;
+  }
+  return parsed.data;
+}
+
+export {
+  questConfiguration,
+  ManagementErrorCode,
+  managementErrorSchema,
+  isManagementError,
+  ManagementError,
+  DEFAULT_MANAGEMENT_TIMEOUT,
+  ManagementUploadBody,
+  actionIdOf,
+  managementTransport,
+  sequenceCursorSchema,
+  REFERRAL_INTEGRATION_REWARD_ERROR,
+  containsReferralIntegrationReward,
+  APP_SCHEDULE_LIMIT,
+  APP_SCHEDULE_MIN_INTERVAL,
+  APP_SCHEDULE_TIMEOUT,
+  appScheduleNameSchema,
+  appSchedulePathSchema,
+  appScheduleSchema,
+  appSchedulesSchema,
+  nextScheduleRun,
+  appScheduleStateSchema,
+  appScheduleStateInputSchema,
+  APP_SCHEDULE_RESULT_BYTES,
+  appScheduleDiagnosticSchema,
+  appScheduleResultSchema,
+  scheduleResult,
+  appScheduleRunSchema,
+  appScheduleRunsSchema,
+  appScheduleListSchema,
+  scheduledInvocationSchema,
+  verifyScheduledRequest
+};