@domino-sdk/relay 1.63.0 → 1.66.0

package/dist/chunk-7MQCQYEE.js

@@ -0,0 +1,405 @@
+import {
+  authoringIdentityShape,
+  badgeSchema,
+  entitlementSchema,
+  identifier,
+  limits,
+  mediaUrlSchema,
+  memberProgressSchema,
+  pageCursorSchema,
+  pointLedgerReferenceSchema,
+  prerequisiteSchema,
+  publishedReleaseSchema,
+  questPresentationContentSchema,
+  responseShape,
+  retryCooldownMsSchema,
+  reviewModeSchema,
+  sdkRuntimeReferenceSchema,
+  settingsValuesSchema,
+  storedQuestDescriptionSchema,
+  storedReviewModeSchema,
+  tieredRewardReferenceSchema
+} from "./chunk-XCEGNKGH.js";
+
+// src/participant-activity.ts
+import * as z from "zod";
+var base = /* @__PURE__ */ (() => ({ id: z.string(), at: z.number() }))();
+var attempt = /* @__PURE__ */ (() => ({
+  ...base,
+  quest: z.string(),
+  attempt: z.string(),
+  completion: z.string().nullable()
+}))();
+var kinds = [
+  "attempt.accepted",
+  "attempt.rejected",
+  "attempt.review",
+  "points.awarded",
+  "entitlement.granted",
+  "entitlement.collected",
+  "delivery.updated",
+  "referral.qualified"
+];
+var knownRelayEventSchema = /* @__PURE__ */ (() => z.discriminatedUnion("kind", [
+  z.object({ ...attempt, kind: z.literal("attempt.accepted") }),
+  z.object({ ...attempt, kind: z.literal("attempt.rejected") }),
+  z.object({ ...attempt, kind: z.literal("attempt.review") }),
+  z.object({
+    ...base,
+    kind: z.literal("points.awarded"),
+    entry: z.string(),
+    ledger: z.string(),
+    amount: z.number(),
+    quest: z.string().nullable(),
+    completion: z.string().nullable()
+  }),
+  z.object({
+    ...base,
+    kind: z.literal("entitlement.granted"),
+    entitlement: z.string(),
+    tier: z.string(),
+    status: z.string()
+  }),
+  z.object({
+    ...base,
+    kind: z.literal("entitlement.collected"),
+    entitlement: z.string()
+  }),
+  z.object({
+    ...base,
+    kind: z.literal("delivery.updated"),
+    delivery: z.string(),
+    quest: z.string(),
+    completion: z.string(),
+    status: z.string()
+  }),
+  z.object({
+    ...base,
+    kind: z.literal("referral.qualified"),
+    program: z.string()
+  })
+]))();
+var relayEventSchema = /* @__PURE__ */ (() => z.union([
+  knownRelayEventSchema,
+  z.object({
+    ...base,
+    kind: z.string().refine((kind) => !kinds.includes(kind))
+  }).catchall(z.json()).transform(({ kind, ...event }) => ({
+    ...event,
+    kind: "unknown",
+    reportedKind: kind
+  }))
+]))();
+var participantActivityQuerySchema = /* @__PURE__ */ (() => 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().refine((query) => !(query.cursor && query.start), {
+  message: "Pass either cursor or start, not both"
+}))();
+var participantActivitySchema = /* @__PURE__ */ (() => z.object({
+  member: z.string(),
+  items: z.array(relayEventSchema),
+  /**
+   * Never null: the feed has no last page, so an empty page still answers the cursor to read
+   * from next. A loop over it, such as `paginate`, stops on its own condition, such as an empty
+   * page or a count.
+   */
+  nextCursor: pageCursorSchema
+}))();
+
+// src/auth.ts
+import * as z2 from "zod";
+var authScopeSchema = /* @__PURE__ */ (() => z2.object({
+  organization: identifier,
+  project: identifier,
+  environment: z2.enum(["test", "live"])
+}).strict())();
+var principalSchema = /* @__PURE__ */ (() => z2.discriminatedUnion("kind", [
+  z2.object({ kind: z2.literal("member"), member: identifier }),
+  z2.object({ kind: z2.literal("staff"), subject: identifier }),
+  z2.object({ kind: z2.literal("operator"), subject: identifier })
+]))();
+var sessionSchema = /* @__PURE__ */ (() => z2.object({
+  ...authScopeSchema.shape,
+  id: identifier,
+  principal: principalSchema,
+  expiresAt: z2.number()
+}))();
+var knownPrincipalKinds = /* @__PURE__ */ (() => principalSchema.options.map(
+  (option) => option.shape.kind.value
+))();
+var participantPrincipalSchema = /* @__PURE__ */ (() => z2.union([
+  principalSchema,
+  z2.object({ kind: z2.string().min(1) }).refine((principal) => !knownPrincipalKinds.includes(principal.kind))
+]))();
+var participantSessionSchema = /* @__PURE__ */ (() => z2.object({
+  ...authScopeSchema.shape,
+  id: identifier,
+  principal: participantPrincipalSchema,
+  expiresAt: z2.number()
+}))();
+function sessionMember(session) {
+  const principal = session?.principal;
+  return principal?.kind === "member" && "member" in principal ? principal.member : null;
+}
+var memberSummarySchema = /* @__PURE__ */ (() => z2.object({
+  member: identifier,
+  avatarSeed: z2.string().min(1).max(100),
+  /**
+   * The member's own email address for "signed in as": the first of `emails`, or null when they
+   * have none, such as after wallet-only sign-in. Only the member reads it. Relay always sends
+   * it; the SDK reads one older than this field as null.
+   */
+  email: z2.string().min(1).nullable().default(null),
+  /**
+   * The verified email addresses that sign the member in: each email-code sign-in address, then
+   * the verified email of each Google or Apple account enabled for sign-in. Accounts connected
+   * only for activity are left out. Empty when there are none, and read as empty from a Relay
+   * older than this field.
+   */
+  emails: z2.array(z2.string().min(1)).default([]),
+  /**
+   * Whether the member may take part in the project: false while an operator has banned them,
+   * when their attempts, completions and invitations are refused with `member-banned`. Relay
+   * gives the member no reason. Read as true from a Relay older than this field.
+   */
+  eligible: z2.boolean().default(true),
+  /**
+   * The member's clock, which Relay judges their activity on. `now` is their current time in epoch
+   * milliseconds and `offsetMs` how far it runs ahead of real time: a test member's clock moves
+   * when the staging toolbar or `domino test-members advance` moves it, and every other member's
+   * offset is 0. `memberTime()` keeps it ticking. Absent from a Relay older than this field;
+   * `relay.me.get()` then answers real time.
+   */
+  clock: z2.object({
+    now: z2.number().int().nonnegative(),
+    offsetMs: z2.number().int()
+  }).optional()
+}))();
+var exchangeSchema = /* @__PURE__ */ (() => authScopeSchema.extend({
+  identity: z2.object({ issuer: identifier, subject: z2.string().min(1).max(200) }).strict(),
+  role: z2.enum(["member", "staff", "operator"])
+}).strict())();
+var exchangeResultSchema = /* @__PURE__ */ (() => z2.object({
+  token: z2.string(),
+  session: sessionSchema
+}))();
+
+// src/catalog.ts
+import * as z3 from "zod";
+var interactionSchema = /* @__PURE__ */ (() => z3.enum([
+  "photo",
+  "text",
+  "url",
+  "quiz",
+  "claim",
+  "staff",
+  "automatic"
+]))();
+function questInteraction(trigger) {
+  return trigger.kind === "automatic" ? "automatic" : trigger.actor === "staff" ? "staff" : trigger.input === "none" ? "claim" : trigger.input;
+}
+var questTypeVersionSchema = /* @__PURE__ */ (() => z3.object({
+  archivedAt: z3.number().int().nonnegative().nullable().optional(),
+  key: identifier.optional(),
+  id: identifier,
+  version: identifier,
+  code: z3.string(),
+  /** The SDK runtime `code` imports. Absent, the code bundles its own SDK. */
+  runtime: sdkRuntimeReferenceSchema.optional(),
+  definition: storedQuestDescriptionSchema,
+  provider: storedReviewModeSchema,
+  createdAt: z3.number()
+}))();
+var collectionSlotSchema = /* @__PURE__ */ (() => z3.object({
+  archivedAt: z3.number().int().nonnegative().nullable().optional(),
+  id: identifier,
+  key: identifier.optional(),
+  title: z3.string().trim().min(1).max(120),
+  description: z3.string().max(4e3).optional(),
+  image: mediaUrlSchema.optional(),
+  imageAlt: z3.string().max(500).optional()
+}))();
+var collectionSlotDeclarationSchema = /* @__PURE__ */ (() => collectionSlotSchema.omit({ id: true, archivedAt: true }).extend(authoringIdentityShape).strict())();
+var questCollectionSchema = /* @__PURE__ */ (() => collectionSlotSchema.extend({
+  quests: z3.array(identifier).max(100).refine(
+    (v) => new Set(v).size === v.length,
+    "A collection can contain a quest only once"
+  )
+}))();
+var questInstanceSchema = /* @__PURE__ */ (() => z3.object({
+  badges: z3.array(identifier).max(10).refine(
+    (items) => new Set(items).size === items.length,
+    "Choose each badge once"
+  ).optional(),
+  id: identifier,
+  title: z3.string().trim().min(1).max(120),
+  typeVersion: identifier,
+  presentation: questPresentationContentSchema.optional(),
+  settings: settingsValuesSchema,
+  requires: z3.array(prerequisiteSchema).max(30),
+  /**
+   * Milliseconds a member waits after a rejected attempt before submitting again, or `null` for
+   * no cooldown. Omitted: the quest type's own `retryCooldownMs`.
+   */
+  retryCooldownMs: retryCooldownMsSchema.nullable().optional(),
+  /**
+   * Milliseconds a member waits after an accepted completion before submitting again, or `null`
+   * for no cooldown. Omitted: the quest type's own `completionCooldownMs`.
+   */
+  completionCooldownMs: retryCooldownMsSchema.nullable().optional(),
+  status: z3.enum(["active", "paused", "archived"])
+}).strict())();
+var questDraftChangesSchema = /* @__PURE__ */ (() => z3.object({
+  quests: z3.array(
+    questInstanceSchema.extend({ expectedRelease: identifier.nullable() })
+  ).max(limits.quests),
+  collections: z3.array(questCollectionSchema.omit({ archivedAt: true }).strict()).max(limits.collections)
+}).strict())();
+var draftBase = /* @__PURE__ */ (() => z3.object({
+  id: identifier,
+  revision: z3.number().int().positive(),
+  baseRevision: z3.number().int().nonnegative(),
+  changes: questDraftChangesSchema
+}))();
+var questDraftSchema = /* @__PURE__ */ (() => responseShape(
+  z3.discriminatedUnion("status", [
+    draftBase.extend({ status: z3.literal("draft") }),
+    draftBase.extend({
+      status: z3.literal("published"),
+      releaseIds: z3.array(identifier)
+    })
+  ])
+))();
+var questCatalogSchema = /* @__PURE__ */ (() => responseShape(
+  z3.object({
+    revision: z3.number().int().nonnegative(),
+    types: z3.array(questTypeVersionSchema),
+    collections: z3.array(questCollectionSchema),
+    quests: z3.array(questInstanceSchema),
+    drafts: z3.array(questDraftSchema),
+    releases: z3.array(publishedReleaseSchema).default([]),
+    supportedInteractions: z3.array(interactionSchema)
+  })
+))();
+var catalogDeploymentSchema = /* @__PURE__ */ (() => z3.object({
+  expectedRevision: z3.number().int().nonnegative(),
+  types: z3.array(
+    z3.object({
+      code: z3.string().min(1).max(1e6),
+      runtime: sdkRuntimeReferenceSchema.optional(),
+      provider: reviewModeSchema
+    })
+  ).max(limits.questTypes).default([]),
+  collections: z3.array(collectionSlotDeclarationSchema).max(limits.collections).default([]),
+  supportedInteractions: z3.array(interactionSchema).min(1).optional()
+}).strict())();
+var catalogDeploymentPreviewSchema = /* @__PURE__ */ (() => responseShape(
+  z3.object({
+    revision: z3.number().int().nonnegative(),
+    types: z3.array(questTypeVersionSchema),
+    collections: z3.array(collectionSlotSchema),
+    supportedInteractions: z3.array(interactionSchema)
+  })
+))();
+var saveQuestDraftSchema = /* @__PURE__ */ (() => z3.object({
+  id: identifier.optional(),
+  actionId: identifier,
+  expectedRevision: z3.number().int().nonnegative(),
+  baseRevision: z3.number().int().nonnegative(),
+  changes: questDraftChangesSchema
+}).strict())();
+var publishQuestDraftSchema = /* @__PURE__ */ (() => z3.object({ id: identifier, expectedRevision: z3.number().int().positive() }).strict())();
+var questRewardViewSchema = /* @__PURE__ */ (() => z3.discriminatedUnion("kind", [
+  z3.object({
+    kind: z3.literal("points"),
+    label: z3.string(),
+    amount: z3.number().int().nonnegative(),
+    ledger: pointLedgerReferenceSchema
+  }),
+  z3.object({
+    kind: z3.literal("tier"),
+    label: z3.string(),
+    reward: tieredRewardReferenceSchema.extend({
+      title: z3.string(),
+      badge: badgeSchema.optional(),
+      /** The group the reward adds the member to: its key and the title the quest names it by. */
+      group: z3.object({ key: identifier, title: z3.string() }).optional()
+    }),
+    tier: identifier
+  }),
+  z3.object({ kind: z3.literal("integration"), label: z3.string() })
+]))();
+var questViewSchema = /* @__PURE__ */ (() => responseShape(
+  memberProgressSchema.shape.quests.element.extend({
+    release: identifier,
+    interaction: interactionSchema,
+    lifecycle: z3.enum(["active", "paused", "archived"]),
+    rewards: z3.array(questRewardViewSchema)
+  })
+))();
+var collectionViewSchema = /* @__PURE__ */ (() => z3.object({
+  key: identifier.optional(),
+  id: identifier,
+  title: z3.string(),
+  description: z3.string().optional(),
+  image: mediaUrlSchema.optional(),
+  imageAlt: z3.string().optional(),
+  quests: z3.array(questViewSchema)
+}))();
+var questExperienceSchema = /* @__PURE__ */ (() => responseShape(
+  z3.object({
+    entitlements: z3.array(entitlementSchema).default([]),
+    member: identifier,
+    quests: z3.array(questViewSchema),
+    collections: z3.array(collectionViewSchema)
+  })
+))();
+var questPublicationPreviewSchema = /* @__PURE__ */ (() => responseShape(
+  z3.object({
+    draft: questDraftSchema,
+    releases: z3.array(publishedReleaseSchema),
+    affectedCollections: z3.array(questCollectionSchema)
+  })
+))();
+var allocateQuestSchema = /* @__PURE__ */ (() => z3.object({ actionId: identifier }).strict())();
+var allocatedQuestSchema = /* @__PURE__ */ (() => z3.object({ id: identifier }))();
+
+export {
+  knownRelayEventSchema,
+  relayEventSchema,
+  participantActivityQuerySchema,
+  participantActivitySchema,
+  authScopeSchema,
+  principalSchema,
+  sessionSchema,
+  participantPrincipalSchema,
+  participantSessionSchema,
+  sessionMember,
+  memberSummarySchema,
+  exchangeSchema,
+  exchangeResultSchema,
+  interactionSchema,
+  questInteraction,
+  questTypeVersionSchema,
+  collectionSlotSchema,
+  collectionSlotDeclarationSchema,
+  questCollectionSchema,
+  questInstanceSchema,
+  questDraftChangesSchema,
+  questDraftSchema,
+  questCatalogSchema,
+  catalogDeploymentSchema,
+  catalogDeploymentPreviewSchema,
+  saveQuestDraftSchema,
+  publishQuestDraftSchema,
+  questRewardViewSchema,
+  questViewSchema,
+  collectionViewSchema,
+  questExperienceSchema,
+  questPublicationPreviewSchema,
+  allocateQuestSchema,
+  allocatedQuestSchema
+};

package/dist/{chunk-7X67QLPB.js → chunk-ANVAUOJP.js}

@@ -2,7 +2,7 @@ import {
   identifier,
   responseShape,
   xTweetSchema
-} from "./chunk-ID3BZXFZ.js";
+} from "./chunk-XCEGNKGH.js";
 
 // src/x.ts
 import * as z from "zod";

package/dist/{chunk-AQOL3SK5.js → chunk-BQXRCJ3N.js}

@@ -2,7 +2,7 @@ import {
   RelayErrorCode,
   clientError,
   isRequestError
-} from "./chunk-GLH6MEI2.js";
+} from "./chunk-FGXLXENM.js";
 
 // src/action.ts
 function withActionId(value) {

package/dist/{chunk-EHUSD3O2.js → chunk-CGUL4MRE.js}

@@ -1,6 +1,3 @@
-import {
-  pointLedgerReferenceSchema
-} from "./chunk-W7YSMSGC.js";
 import {
   authProviderSchema,
   entitlementSchema,
@@ -8,11 +5,12 @@ import {
   pageCursorSchema,
   pickupAvailabilitySchema,
   pickupSelectionSchema,
+  pointLedgerReferenceSchema,
   signInProviderOptionSchema,
   skipEnrollmentSchema,
   telegramSignInMethodsSchema,
   walletSignInNetworksSchema
-} from "./chunk-ID3BZXFZ.js";
+} from "./chunk-XCEGNKGH.js";
 
 // src/sign-in-providers.ts
 import * as z from "zod";