@domino-sdk/relay 0.2.0 → 0.4.0

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
+};