@domino-sdk/relay 0.3.0 → 0.5.0

package/dist/{chunk-L757OYXZ.js → chunk-LUCL63DS.js}

@@ -1,10 +1,25 @@
+import {
+  leaderboardArtifactSchema,
+  leaderboardDefinitionSchema,
+  leaderboardPageSchema,
+  leaderboardPreviewSchema,
+  leaderboardQuerySchema,
+  publishedReferralSchema,
+  referralAcceptSchema,
+  referralArtifactSchema,
+  referralDefinitionSchema,
+  referralHistorySchema,
+  referralSummarySchema
+} from "./chunk-TXL43HL3.js";
 import {
   authScopeSchema,
   exchangeResultSchema,
   sessionSchema
-} from "./chunk-6IXQRMGW.js";
+} from "./chunk-QWRSUSNB.js";
 import {
+  accountConnectionSchema,
   attemptSchema,
+  authProviderSchema,
   entitlementSchema,
   errorSchema,
   evidenceSchema,
@@ -24,7 +39,20 @@ import {
   settingsValuesSchema,
   snapshotSchema,
   templateSchema
-} from "./chunk-C2KOMNLG.js";
+} from "./chunk-3IQ4KUKF.js";
+
+// src/resource-id.ts
+var alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function resourceId(prefix) {
+  let suffix = "";
+  while (suffix.length < 22) {
+    for (const byte of crypto.getRandomValues(new Uint8Array(32))) {
+      if (byte < 248) suffix += alphabet[byte % 62];
+      if (suffix.length === 22) break;
+    }
+  }
+  return `${prefix}_${suffix}`;
+}
 
 // src/catalog.ts
 import { z } from "zod";
@@ -327,6 +355,23 @@ function submissions(transport, configuredStore, namespace) {
       });
     }
     const handle = {
+      async discard() {
+        return store.exclusive(key, async () => {
+          await currentSession();
+          const record = await read();
+          if (!record) return;
+          if (record.stage !== "submitted")
+            throw new Error(
+              "Resume the unfinished submission before starting over."
+            );
+          const attempt = await claim(record);
+          if (attempt.status !== "failed" && attempt.status !== "rejected")
+            throw new Error(
+              "Only a failed or rejected submission can be discarded."
+            );
+          await store.write(key, null);
+        });
+      },
       async status() {
         await currentSession();
         const record = await read();
@@ -447,6 +492,7 @@ function questActions(submission, latest) {
         kind: "status",
         view,
         status: handle.status,
+        discard: handle.discard,
         resume: () => run(handle.resume)
       };
     }
@@ -461,6 +507,7 @@ function questActions(submission, latest) {
           kind: "photo",
           view,
           status: handle.status,
+          discard: handle.discard,
           resume: () => run(handle.resume),
           submit: (file) => run(() => handle.submit(file))
         };
@@ -475,6 +522,7 @@ function questActions(submission, latest) {
           kind: "quiz",
           view,
           status: handle.status,
+          discard: handle.discard,
           resume: () => run(handle.resume),
           submit: (answers) => run(() => handle.submit(answers, { release: view.release }))
         };
@@ -489,6 +537,7 @@ function questActions(submission, latest) {
           kind: "claim",
           view,
           status: handle.status,
+          discard: handle.discard,
           resume: () => run(handle.resume),
           submit: () => run(handle.submit)
         };
@@ -643,11 +692,13 @@ function questConfiguration(release) {
 
 // src/deployments.ts
 import { z as z5 } from "zod";
-var projectDeploymentSchema = catalogDeploymentSchema.omit({ expectedRevision: true }).extend({
-  releases: z5.array(releaseSchema).max(50).default([])
-}).refine(
-  (value) => value.releases.length > 0 || value.types.length > 0 || value.collections.length > 0 || value.supportedInteractions !== void 0,
-  "No resources configured. Add quests, questTypes, collections, or supportedInteractions to relay.json."
+var projectCatalogArtifactSchema = catalogDeploymentSchema.omit({ expectedRevision: true }).extend({
+  referrals: z5.array(referralArtifactSchema).max(50).default([]),
+  leaderboards: z5.array(leaderboardArtifactSchema).max(50).default([])
+});
+var projectDeploymentSchema = projectCatalogArtifactSchema.extend({ releases: z5.array(releaseSchema).max(50).default([]) }).refine(
+  (value) => value.releases.length > 0 || value.leaderboards.length > 0 || value.referrals.length > 0 || value.types.length > 0 || value.collections.length > 0 || value.supportedInteractions !== void 0,
+  "No resources configured. Add quests, questTypes, leaderboards, collections, or supportedInteractions to relay.json."
 );
 var deploymentPreviewSchema = z5.object({
   id: identifier,
@@ -655,7 +706,9 @@ var deploymentPreviewSchema = z5.object({
   releases: z5.array(publishedReleaseSchema),
   types: z5.array(questTypeVersionSchema),
   collections: z5.array(questCollectionSchema),
-  supportedInteractions: z5.array(interactionSchema)
+  supportedInteractions: z5.array(interactionSchema),
+  referrals: z5.array(publishedReferralSchema).default([]),
+  leaderboards: z5.array(leaderboardPreviewSchema).default([])
 });
 var publishDeploymentSchema = z5.object({ id: identifier }).strict();
 var deploymentResultSchema = deploymentPreviewSchema.extend({
@@ -796,6 +849,28 @@ function createRelayClient(options) {
     return quest;
   }
   return {
+    referrals: {
+      list: () => request("/v1/referrals", z7.array(referralDefinitionSchema)),
+      summary: () => request("/v1/referrals/me", referralSummarySchema),
+      history: (before) => request(
+        query("/v1/referrals/history", { before }),
+        referralHistorySchema
+      ),
+      accept: (input) => request("/v1/referrals/accept", z7.object({ ok: z7.literal(true) }), {
+        method: "POST",
+        body: JSON.stringify(referralAcceptSchema.parse(input))
+      })
+    },
+    leaderboards: {
+      list: () => request("/v1/leaderboards", z7.array(leaderboardDefinitionSchema)),
+      standings: (board, options2 = {}) => {
+        const parsed = leaderboardQuerySchema.parse(options2);
+        return request(
+          query(`/v1/leaderboards/${identifier.parse(board)}`, parsed),
+          leaderboardPageSchema
+        );
+      }
+    },
     quests: {
       get: getQuest,
       retry: async (view) => {
@@ -866,7 +941,7 @@ function createRelayClient(options) {
         z7.object({
           providers: z7.array(
             z7.object({
-              provider: z7.enum(["google", "apple", "x", "discord"]),
+              provider: authProviderSchema,
               configured: z7.boolean()
             })
           ),
@@ -891,6 +966,12 @@ function createRelayClient(options) {
           json({ challenge, code })
         )
       ),
+      accounts: () => request("/v1/auth/accounts", z7.array(accountConnectionSchema)),
+      disconnect: (provider) => request(
+        "/v1/auth/accounts/disconnect",
+        z7.object({ ok: z7.boolean() }),
+        json({ provider })
+      ),
       connections: () => request(
         "/v1/auth/connections",
         z7.array(
@@ -902,9 +983,6 @@ function createRelayClient(options) {
         )
       ),
       session: () => request("/v1/auth/session", sessionSchema.nullable()),
-      demoSignIn: (code) => changeSession(
-        () => request("/v1/auth/demo", sessionSchema, json({ code }))
-      ),
       signOut: () => changeSession(
         () => request("/v1/auth/logout", z7.object({ ok: z7.boolean() }), json({}))
       ),
@@ -1015,6 +1093,7 @@ function createRelayClient(options) {
 }
 
 export {
+  resourceId,
   interactionSchema,
   questInteraction,
   questTypeVersionSchema,
@@ -1048,6 +1127,7 @@ export {
   collectionBeginSchema,
   collectionPreviewSchema,
   questConfiguration,
+  projectCatalogArtifactSchema,
   projectDeploymentSchema,
   deploymentPreviewSchema,
   publishDeploymentSchema,

package/dist/{chunk-6IXQRMGW.js → chunk-QWRSUSNB.js}

@@ -1,6 +1,6 @@
 import {
   identifier
-} from "./chunk-C2KOMNLG.js";
+} from "./chunk-3IQ4KUKF.js";
 
 // src/auth.ts
 import { z } from "zod";

package/dist/chunk-TXL43HL3.js

@@ -0,0 +1,335 @@
+import {
+  identifier,
+  rewardSchema
+} from "./chunk-3IQ4KUKF.js";
+
+// src/referrals.ts
+import { z } from "zod";
+var amount = z.number().int().safe().nonnegative();
+var reason = z.string().trim().min(1).max(1e3);
+var referralDefinitionSchema = z.object({
+  id: identifier,
+  title: z.string().trim().min(1).max(120),
+  enabled: z.boolean().default(true),
+  qualification: z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("signup") }).strict(),
+    z.object({ kind: z.literal("quest"), quest: identifier }).strict(),
+    z.object({ kind: z.literal("external") }).strict()
+  ]),
+  inviterGroup: identifier.optional(),
+  rewards: z.object({
+    inviter: z.array(rewardSchema).max(10).default([]),
+    invitee: z.array(rewardSchema).max(10).default([])
+  }).strict().default({ inviter: [], invitee: [] }),
+  milestones: z.array(
+    z.object({
+      id: identifier,
+      count: amount.min(1),
+      rewards: z.array(rewardSchema).min(1).max(10)
+    }).strict()
+  ).max(30).default([]),
+  bonuses: z.array(
+    z.object({
+      id: identifier,
+      balance: identifier,
+      basisPoints: amount.min(1).max(1e4),
+      quests: z.array(identifier).min(1).max(100).optional(),
+      external: z.boolean().default(false),
+      durationDays: amount.min(1).max(36500).optional(),
+      maxPoints: amount.min(1).optional()
+    }).strict()
+  ).max(20).default([])
+}).strict().superRefine((value, ctx) => {
+  for (const entries of [value.milestones, value.bonuses])
+    if (new Set(entries.map((e) => e.id)).size !== entries.length)
+      ctx.addIssue({ code: "custom", message: "Rule IDs must be unique" });
+});
+function defineReferral(input) {
+  return referralDefinitionSchema.parse(input);
+}
+var referralArtifactSchema = z.union([
+  referralDefinitionSchema,
+  z.object({ code: z.string().min(1).max(2e6) }).strict()
+]);
+var publishedReferralSchema = z.object({
+  version: identifier,
+  definition: referralDefinitionSchema,
+  publishedAt: amount,
+  actor: z.string().nullable()
+});
+var referralAcceptSchema = z.object({ actionId: identifier, code: identifier }).strict();
+var referralControlSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("suspend"),
+    actionId: identifier,
+    member: identifier,
+    suspended: z.boolean(),
+    reason
+  }).strict(),
+  z.object({
+    kind: z.literal("qualify"),
+    actionId: identifier,
+    member: identifier,
+    program: identifier,
+    qualified: z.boolean(),
+    reason
+  }).strict(),
+  z.object({
+    kind: z.literal("resolve-reward"),
+    actionId: identifier,
+    entitlement: identifier,
+    reason
+  }).strict()
+]);
+var referralRelationshipSchema = z.object({
+  member: identifier,
+  inviter: identifier,
+  acceptedAt: amount,
+  suspended: z.boolean()
+});
+var referralAccountSchema = z.object({
+  id: identifier,
+  program: identifier,
+  kind: z.enum(["bonus", "fixed", "milestone"]),
+  balance: identifier,
+  earned: amount,
+  settled: amount,
+  outstanding: amount
+});
+var referralSummarySchema = z.object({
+  code: identifier,
+  attributed: amount,
+  programs: z.array(
+    z.object({
+      definition: referralDefinitionSchema,
+      qualified: amount,
+      milestones: z.array(
+        z.object({ id: identifier, count: amount, reached: z.boolean() })
+      )
+    })
+  ),
+  accounts: z.array(referralAccountSchema)
+});
+var referralHistorySchema = z.object({
+  items: z.array(
+    z.object({
+      id: amount,
+      program: identifier,
+      balance: identifier,
+      amount: z.number().int().safe(),
+      at: amount,
+      reason: z.string()
+    })
+  ),
+  next: amount.nullable()
+});
+var referralManagementSchema = z.object({
+  relationships: z.array(referralRelationshipSchema),
+  qualifications: z.array(
+    z.object({
+      member: identifier,
+      program: identifier,
+      qualified: z.boolean(),
+      qualifiedAt: amount
+    })
+  ),
+  accounts: z.array(
+    referralAccountSchema.extend({ member: identifier, invitee: z.string() })
+  ),
+  reviews: z.array(
+    z.object({
+      entitlement: identifier,
+      member: identifier,
+      program: identifier,
+      reason: z.string()
+    })
+  ),
+  next: amount.nullable()
+});
+
+// src/leaderboards.ts
+import { z as z2 } from "zod";
+var integer = z2.number().int().safe();
+var timestamp = integer.nonnegative().max(864e13);
+var leaderboardWindowSchema = z2.discriminatedUnion("kind", [
+  z2.object({ kind: z2.literal("all-time") }).strict(),
+  z2.object({ kind: z2.literal("fixed"), start: timestamp, end: timestamp }).strict().refine((w) => w.end > w.start, "Window end must follow its start"),
+  z2.object({ kind: z2.literal("rolling"), days: integer.min(1).max(3660) }).strict(),
+  z2.object({
+    kind: z2.literal("calendar"),
+    period: z2.enum(["day", "week", "month"]),
+    timeZone: z2.string().min(1).max(100).refine((zone) => {
+      try {
+        new Intl.DateTimeFormat("en", { timeZone: zone });
+        return true;
+      } catch {
+        return false;
+      }
+    }, "Use an IANA timezone")
+  }).strict()
+]);
+var periodScore = {
+  window: leaderboardWindowSchema.default({ kind: "all-time" }),
+  quests: z2.array(identifier).min(1).max(100).optional()
+};
+var leaderboardDefinitionSchema = z2.object({
+  id: identifier,
+  title: z2.string().trim().min(1).max(120),
+  balance: identifier,
+  score: z2.discriminatedUnion("kind", [
+    z2.object({ kind: z2.literal("balance") }).strict(),
+    z2.object({ kind: z2.literal("earned"), ...periodScore }).strict(),
+    z2.object({
+      kind: z2.literal("net"),
+      window: leaderboardWindowSchema.default({ kind: "all-time" })
+    }).strict()
+  ]).default({ kind: "balance" }),
+  access: z2.enum(["participants", "public"]).default("participants"),
+  group: identifier.optional()
+}).strict();
+function defineLeaderboard(input) {
+  return leaderboardDefinitionSchema.parse(input);
+}
+var leaderboardArtifactSchema = z2.union([
+  leaderboardDefinitionSchema,
+  z2.object({ code: z2.string().min(1).max(2e6) }).strict()
+]);
+var publishedLeaderboardSchema = z2.object({
+  version: identifier,
+  definition: leaderboardDefinitionSchema,
+  publishedAt: timestamp,
+  actor: z2.string().nullable()
+});
+var leaderboardQuerySchema = z2.object({
+  limit: z2.coerce.number().int().min(1).max(100).default(25),
+  cursor: z2.string().max(4096).optional()
+}).strict();
+var leaderboardRowSchema = z2.object({
+  participant: identifier,
+  member: identifier.optional(),
+  name: z2.string(),
+  score: integer,
+  rank: integer.positive()
+});
+var leaderboardPageSchema = z2.object({
+  leaderboard: identifier,
+  title: z2.string(),
+  version: identifier,
+  calculation: z2.enum(["balance", "earned", "net"]),
+  period: z2.object({ start: timestamp.nullable(), end: timestamp.nullable() }),
+  calculatedAt: timestamp,
+  lastEntryAt: timestamp.nullable(),
+  total: integer.nonnegative(),
+  items: z2.array(leaderboardRowSchema),
+  me: leaderboardRowSchema.nullable(),
+  nearby: z2.array(leaderboardRowSchema),
+  nextCursor: z2.string().nullable()
+});
+var leaderboardPreviewSchema = z2.object({
+  published: publishedLeaderboardSchema,
+  before: leaderboardPageSchema.nullable(),
+  after: leaderboardPageSchema
+});
+var mutationBase = {
+  actionId: identifier,
+  member: identifier,
+  balance: identifier,
+  reason: z2.string().trim().min(1).max(1e3)
+};
+var datedMutation = { ...mutationBase, effectiveAt: timestamp.optional() };
+var pointsMutationSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    ...datedMutation,
+    kind: z2.literal("award"),
+    referralEligible: z2.boolean().optional(),
+    amount: integer.positive()
+  }).strict(),
+  z2.object({
+    ...datedMutation,
+    kind: z2.literal("spend"),
+    amount: integer.positive()
+  }).strict(),
+  z2.object({
+    ...datedMutation,
+    kind: z2.literal("adjust"),
+    amount: integer.refine((n) => n !== 0)
+  }).strict(),
+  z2.object({
+    ...datedMutation,
+    kind: z2.literal("set"),
+    total: integer.nonnegative(),
+    expectedTotal: integer.nonnegative(),
+    classification: z2.enum(["earned", "spend"])
+  }).strict(),
+  z2.object({
+    ...mutationBase,
+    kind: z2.literal("reverse"),
+    entry: identifier,
+    amount: integer.positive()
+  }).strict()
+]);
+var pointsEntrySchema = z2.object({
+  id: identifier,
+  completion: z2.string().nullable(),
+  member: identifier,
+  balance: identifier,
+  amount: integer,
+  kind: z2.enum(["award", "spend", "adjust", "reverse"]),
+  effectiveAt: timestamp,
+  receivedAt: timestamp,
+  quest: identifier.nullable(),
+  original: identifier.nullable(),
+  reason: z2.string(),
+  actor: z2.string().nullable()
+});
+var pointsResultSchema = z2.object({
+  entry: pointsEntrySchema,
+  total: integer.nonnegative()
+});
+var pointsAccountSchema = z2.object({
+  member: identifier,
+  balance: identifier,
+  total: integer.nonnegative(),
+  held: integer.nonnegative()
+});
+var leaderboardExclusionSchema = z2.object({
+  actionId: identifier,
+  member: identifier,
+  excluded: z2.boolean(),
+  reason: z2.string().trim().min(1).max(1e3)
+}).strict();
+var leaderboardGroupSchema = z2.object({
+  actionId: identifier,
+  member: identifier,
+  included: z2.boolean(),
+  reason: z2.string().trim().min(1).max(1e3)
+}).strict();
+
+export {
+  referralDefinitionSchema,
+  defineReferral,
+  referralArtifactSchema,
+  publishedReferralSchema,
+  referralAcceptSchema,
+  referralControlSchema,
+  referralRelationshipSchema,
+  referralAccountSchema,
+  referralSummarySchema,
+  referralHistorySchema,
+  referralManagementSchema,
+  leaderboardWindowSchema,
+  leaderboardDefinitionSchema,
+  defineLeaderboard,
+  leaderboardArtifactSchema,
+  publishedLeaderboardSchema,
+  leaderboardQuerySchema,
+  leaderboardRowSchema,
+  leaderboardPageSchema,
+  leaderboardPreviewSchema,
+  pointsMutationSchema,
+  pointsEntrySchema,
+  pointsResultSchema,
+  pointsAccountSchema,
+  leaderboardExclusionSchema,
+  leaderboardGroupSchema
+};