@domino-sdk/relay 0.6.0 → 0.8.0

package/dist/chunk-XVHWBZRG.js

@@ -0,0 +1,388 @@
+import {
+  identifier,
+  pointsRewardSchema,
+  tierRewardSchema
+} from "./chunk-Z43O273V.js";
+
+// src/authoring-identity.ts
+import { z } from "zod";
+var authoringIdentityShape = {
+  key: identifier.optional(),
+  id: identifier.optional()
+};
+function validateAuthoringIdentity(value, ctx) {
+  if (!value.key && !value.id)
+    ctx.addIssue({
+      code: "custom",
+      path: ["key"],
+      message: "Provide an authoring key. Legacy id is also accepted."
+    });
+  if (value.key && value.id && value.key !== value.id)
+    ctx.addIssue({
+      code: "custom",
+      path: ["key"],
+      message: "id and key must match. Keep the existing authoring name to preserve identity."
+    });
+}
+function normalizeAuthoringIdentity(value) {
+  const { id, key, ...properties } = value;
+  return { ...properties, key: identifier.parse(key ?? id) };
+}
+var identitySchema = z.object(authoringIdentityShape).superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
+var authoringKey = (input) => identitySchema.parse(input).key;
+
+// src/referrals.ts
+import { z as z2 } from "zod";
+var rewardSchema = z2.union([pointsRewardSchema, tierRewardSchema]);
+var amount = z2.number().int().safe().nonnegative();
+var reason = z2.string().trim().min(1).max(1e3);
+var referralDefinitionSchema = z2.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z2.string().trim().min(1).max(120),
+  enabled: z2.boolean().default(true),
+  qualification: z2.discriminatedUnion("kind", [
+    z2.object({ kind: z2.literal("signup") }).strict(),
+    z2.object({ kind: z2.literal("quest"), quest: identifier }).strict(),
+    z2.object({ kind: z2.literal("external") }).strict()
+  ]),
+  inviterGroup: identifier.optional(),
+  rewards: z2.object({
+    inviter: z2.array(rewardSchema).max(10).default([]),
+    invitee: z2.array(rewardSchema).max(10).default([])
+  }).strict().default({ inviter: [], invitee: [] }),
+  milestones: z2.array(
+    z2.object({
+      id: identifier,
+      count: amount.min(1),
+      rewards: z2.array(rewardSchema).min(1).max(10)
+    }).strict()
+  ).max(30).default([]),
+  bonuses: z2.array(
+    z2.object({
+      id: identifier,
+      balance: identifier,
+      basisPoints: amount.min(1).max(1e4),
+      quests: z2.array(identifier).min(1).max(100).optional(),
+      external: z2.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" });
+});
+var referralAuthoringSchema = z2.object(referralDefinitionSchema.shape).omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).superRefine((value, ctx) => {
+  for (const entries of [value.milestones, value.bonuses])
+    if (new Set(entries.map((entry) => entry.id)).size !== entries.length)
+      ctx.addIssue({ code: "custom", message: "Rule keys must be unique" });
+}).transform(normalizeAuthoringIdentity);
+function defineReferral(input) {
+  const definition = referralAuthoringSchema.parse(input);
+  return {
+    ...definition,
+    /** @deprecated Use key. */
+    id: definition.key
+  };
+}
+var referralArtifactSchema = z2.union([
+  referralAuthoringSchema,
+  z2.object({ code: z2.string().min(1).max(2e6) }).strict()
+]);
+var publishedReferralSchema = z2.object({
+  version: identifier,
+  definition: referralDefinitionSchema,
+  publishedAt: amount,
+  actor: z2.string().nullable()
+});
+var referralAcceptSchema = z2.object({ actionId: identifier, code: identifier }).strict();
+var referralControlSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("suspend"),
+    actionId: identifier,
+    member: identifier,
+    suspended: z2.boolean(),
+    reason
+  }).strict(),
+  z2.object({
+    kind: z2.literal("qualify"),
+    actionId: identifier,
+    member: identifier,
+    program: identifier,
+    qualified: z2.boolean(),
+    reason
+  }).strict(),
+  z2.object({
+    kind: z2.literal("resolve-reward"),
+    actionId: identifier,
+    entitlement: identifier,
+    reason
+  }).strict()
+]);
+var referralRelationshipSchema = z2.object({
+  member: identifier,
+  inviter: identifier,
+  acceptedAt: amount,
+  suspended: z2.boolean()
+});
+var referralAccountSchema = z2.object({
+  id: identifier,
+  program: identifier,
+  kind: z2.enum(["bonus", "fixed", "milestone"]),
+  balance: identifier,
+  earned: amount,
+  settled: amount,
+  outstanding: amount
+});
+var referralSummarySchema = z2.object({
+  code: identifier,
+  attributed: amount,
+  programs: z2.array(
+    z2.object({
+      definition: referralDefinitionSchema,
+      qualified: amount,
+      milestones: z2.array(
+        z2.object({ id: identifier, count: amount, reached: z2.boolean() })
+      )
+    })
+  ),
+  accounts: z2.array(referralAccountSchema)
+});
+var referralHistorySchema = z2.object({
+  items: z2.array(
+    z2.object({
+      id: amount,
+      program: identifier,
+      balance: identifier,
+      amount: z2.number().int().safe(),
+      at: amount,
+      reason: z2.string()
+    })
+  ),
+  next: amount.nullable()
+});
+var referralManagementSchema = z2.object({
+  relationships: z2.array(referralRelationshipSchema),
+  qualifications: z2.array(
+    z2.object({
+      member: identifier,
+      program: identifier,
+      qualified: z2.boolean(),
+      qualifiedAt: amount
+    })
+  ),
+  accounts: z2.array(
+    referralAccountSchema.extend({ member: identifier, invitee: z2.string() })
+  ),
+  reviews: z2.array(
+    z2.object({
+      entitlement: identifier,
+      member: identifier,
+      program: identifier,
+      reason: z2.string()
+    })
+  ),
+  next: amount.nullable()
+});
+
+// src/leaderboards.ts
+import { z as z3 } from "zod";
+var integer = z3.number().int().safe();
+var timestamp = integer.nonnegative().max(864e13);
+var leaderboardWindowSchema = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("all-time") }).strict(),
+  z3.object({ kind: z3.literal("fixed"), start: timestamp, end: timestamp }).strict().refine((w) => w.end > w.start, "Window end must follow its start"),
+  z3.object({ kind: z3.literal("rolling"), days: integer.min(1).max(3660) }).strict(),
+  z3.object({
+    kind: z3.literal("calendar"),
+    period: z3.enum(["day", "week", "month"]),
+    timeZone: z3.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: z3.array(identifier).min(1).max(100).optional()
+};
+var leaderboardDefinitionSchema = z3.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z3.string().trim().min(1).max(120),
+  balance: identifier,
+  score: z3.discriminatedUnion("kind", [
+    z3.object({ kind: z3.literal("balance") }).strict(),
+    z3.object({ kind: z3.literal("earned"), ...periodScore }).strict(),
+    z3.object({
+      kind: z3.literal("net"),
+      window: leaderboardWindowSchema.default({ kind: "all-time" })
+    }).strict()
+  ]).default({ kind: "balance" }),
+  access: z3.enum(["participants", "public"]).default("participants"),
+  group: identifier.optional()
+}).strict();
+var leaderboardAuthoringSchema = leaderboardDefinitionSchema.omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
+function defineLeaderboard(input) {
+  const definition = leaderboardAuthoringSchema.parse(input);
+  return {
+    ...definition,
+    /** @deprecated Use key. */
+    id: definition.key
+  };
+}
+var leaderboardArtifactSchema = z3.union([
+  leaderboardAuthoringSchema,
+  z3.object({ code: z3.string().min(1).max(2e6) }).strict()
+]);
+var publishedLeaderboardSchema = z3.object({
+  version: identifier,
+  definition: leaderboardDefinitionSchema,
+  publishedAt: timestamp,
+  actor: z3.string().nullable()
+});
+var leaderboardQuerySchema = z3.object({
+  limit: z3.coerce.number().int().min(1).max(100).default(25),
+  cursor: z3.string().max(4096).optional()
+}).strict();
+var leaderboardRowSchema = z3.object({
+  participant: identifier,
+  member: identifier.optional(),
+  name: z3.string(),
+  score: integer,
+  rank: integer.positive()
+});
+var leaderboardPageSchema = z3.object({
+  leaderboard: identifier,
+  title: z3.string(),
+  version: identifier,
+  calculation: z3.enum(["balance", "earned", "net"]),
+  period: z3.object({ start: timestamp.nullable(), end: timestamp.nullable() }),
+  calculatedAt: timestamp,
+  lastEntryAt: timestamp.nullable(),
+  total: integer.nonnegative(),
+  items: z3.array(leaderboardRowSchema),
+  me: leaderboardRowSchema.nullable(),
+  nearby: z3.array(leaderboardRowSchema),
+  nextCursor: z3.string().nullable()
+});
+var leaderboardPreviewSchema = z3.object({
+  published: publishedLeaderboardSchema,
+  before: leaderboardPageSchema.nullable(),
+  after: leaderboardPageSchema
+});
+var mutationBase = {
+  actionId: identifier,
+  member: identifier,
+  balance: identifier,
+  reason: z3.string().trim().min(1).max(1e3)
+};
+var datedMutation = { ...mutationBase, effectiveAt: timestamp.optional() };
+var pointsMutationSchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    ...datedMutation,
+    kind: z3.literal("award"),
+    referralEligible: z3.boolean().optional(),
+    amount: integer.positive()
+  }).strict(),
+  z3.object({
+    ...datedMutation,
+    kind: z3.literal("spend"),
+    amount: integer.positive()
+  }).strict(),
+  z3.object({
+    ...datedMutation,
+    kind: z3.literal("adjust"),
+    amount: integer.refine((n) => n !== 0)
+  }).strict(),
+  z3.object({
+    ...datedMutation,
+    kind: z3.literal("set"),
+    total: integer.nonnegative(),
+    expectedTotal: integer.nonnegative(),
+    classification: z3.enum(["earned", "spend"])
+  }).strict(),
+  z3.object({
+    ...mutationBase,
+    kind: z3.literal("reverse"),
+    entry: identifier,
+    amount: integer.positive()
+  }).strict()
+]);
+var pointsEntrySchema = z3.object({
+  id: identifier,
+  completion: z3.string().nullable(),
+  member: identifier,
+  balance: identifier,
+  amount: integer,
+  kind: z3.enum(["award", "spend", "adjust", "reverse"]),
+  effectiveAt: timestamp,
+  receivedAt: timestamp,
+  quest: identifier.nullable(),
+  original: identifier.nullable(),
+  reason: z3.string(),
+  actor: z3.string().nullable()
+});
+var pointsResultSchema = z3.object({
+  entry: pointsEntrySchema,
+  total: integer.nonnegative()
+});
+var pointsAccountSchema = z3.object({
+  member: identifier,
+  balance: identifier,
+  total: integer.nonnegative(),
+  held: integer.nonnegative()
+});
+var leaderboardExclusionSchema = z3.object({
+  actionId: identifier,
+  member: identifier,
+  excluded: z3.boolean(),
+  reason: z3.string().trim().min(1).max(1e3)
+}).strict();
+var leaderboardGroupSchema = z3.object({
+  actionId: identifier,
+  member: identifier,
+  included: z3.boolean(),
+  reason: z3.string().trim().min(1).max(1e3)
+}).strict();
+
+export {
+  authoringIdentityShape,
+  validateAuthoringIdentity,
+  normalizeAuthoringIdentity,
+  authoringKey,
+  referralDefinitionSchema,
+  referralAuthoringSchema,
+  defineReferral,
+  referralArtifactSchema,
+  publishedReferralSchema,
+  referralAcceptSchema,
+  referralControlSchema,
+  referralRelationshipSchema,
+  referralAccountSchema,
+  referralSummarySchema,
+  referralHistorySchema,
+  referralManagementSchema,
+  leaderboardWindowSchema,
+  leaderboardDefinitionSchema,
+  leaderboardAuthoringSchema,
+  defineLeaderboard,
+  leaderboardArtifactSchema,
+  publishedLeaderboardSchema,
+  leaderboardQuerySchema,
+  leaderboardRowSchema,
+  leaderboardPageSchema,
+  leaderboardPreviewSchema,
+  pointsMutationSchema,
+  pointsEntrySchema,
+  pointsResultSchema,
+  pointsAccountSchema,
+  leaderboardExclusionSchema,
+  leaderboardGroupSchema
+};

package/dist/{chunk-MXK7KEDA.js → chunk-Z43O273V.js}

@@ -145,6 +145,10 @@ var channelSourceSchema = z6.object({
   types: z6.array(z6.enum(["text", "announcement"])).min(1)
 }).strict();
 var resourceSourceSchema = z6.union([
+  z6.object({
+    provider: z6.literal("domino"),
+    resource: z6.literal("point-ledger")
+  }).strict(),
   channelSourceSchema,
   z6.object({
     provider: z6.literal("discord"),
@@ -187,12 +191,17 @@ var discord = {
     });
   }
 };
+var pointLedgers = () => ({
+  provider: "domino",
+  resource: "point-ledger"
+});
 
 // src/settings.ts
 var instant = z7.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
 var resourceId = z7.union([z7.literal(""), z7.string().regex(/^\S{1,200}$/)]);
 var base = { label: z7.string().min(1), description: z7.string().optional() };
 var settingFieldSchema = z7.discriminatedUnion("kind", [
+  z7.object({ ...base, kind: z7.literal("point-ledger"), default: identifier }).strict(),
   z7.object({ ...base, kind: z7.literal("datetime"), default: instant }).strict(),
   z7.object({
     ...base,
@@ -233,6 +242,14 @@ var settingsValuesSchema = z7.record(
   z7.union([z7.string(), z7.number().finite(), z7.boolean(), quizContentSchema])
 );
 var settings = {
+  pointLedger(options) {
+    const field = {
+      ...options,
+      kind: "point-ledger",
+      default: identifier.parse(options.default)
+    };
+    return identifier.default(field.default).meta(field);
+  },
   datetime(options) {
     const field = {
       ...options,
@@ -281,6 +298,9 @@ function parseSettings(fields, input) {
   const shape = {};
   for (const [key, field] of Object.entries(fields)) {
     switch (field.kind) {
+      case "point-ledger":
+        shape[key] = identifier.default(field.default);
+        break;
       case "datetime":
         shape[key] = instant.default(field.default);
         break;
@@ -310,7 +330,7 @@ function missingResourceSettings(fields, values) {
   return Object.entries(fields).filter(([key, field]) => field.kind === "resource" && !values[key]).map(([key]) => key);
 }
 function compatibleSettingKinds(previous, next) {
-  return previous.kind === next.kind || previous.kind === "text" && (next.kind === "resource" || next.kind === "datetime");
+  return previous.kind === next.kind || previous.kind === "text" && (next.kind === "resource" || next.kind === "datetime" || next.kind === "point-ledger");
 }
 
 // src/schema.ts
@@ -448,6 +468,7 @@ var questSettingsInputSchema = z8.object({
   reset: z8.array(z8.string())
 }).strict();
 var storedReleaseSchema = questDescriptionSchema.extend({
+  key: identifier.optional(),
   code: z8.string(),
   provider: reviewModeSchema,
   id: identifier,
@@ -583,7 +604,22 @@ var configurePickupSchema = z8.object({
   reward: identifier,
   revision: z8.number().int().nonnegative(),
   actionId: identifier,
-  policy: pickupPolicySchema
+  policy: z8.discriminatedUnion("kind", [
+    z8.object({ kind: z8.literal("untracked") }).strict(),
+    z8.object({
+      kind: z8.literal("at-pickup"),
+      tiers: z8.array(
+        z8.object({
+          tier: identifier,
+          variants: z8.array(
+            pickupAllocationSchema.extend({
+              item: identifier.optional()
+            })
+          ).min(1).max(100)
+        }).strict()
+      ).min(1).max(100)
+    }).strict()
+  ])
 }).strict();
 var entitlementBase = {
   id: identifier,
@@ -647,6 +683,7 @@ var memberProgressSchema = z8.object({
   quests: z8.array(
     z8.object({
       quest: identifier,
+      key: identifier.optional(),
       release: identifier.optional(),
       title: z8.string(),
       presentation: questPresentationSchema.default({}),
@@ -732,6 +769,8 @@ var memberPageSchema = z8.object({
   items: z8.array(z8.object({ member: identifier })).max(100),
   nextCursor: z8.string().nullable()
 });
+var createStockItemSchema = z8.object({ actionId: identifier, name: z8.string().trim().min(1).max(80) }).strict();
+var stockItemSchema = z8.object({ id: identifier, name: z8.string() });
 
 export {
   identifier,
@@ -760,6 +799,7 @@ export {
   resourceRequestSchema,
   resourceOptionsSchema,
   discord,
+  pointLedgers,
   settingFieldSchema,
   settingsFieldsSchema,
   settingsValuesSchema,
@@ -815,5 +855,7 @@ export {
   memberListSchema,
   reviewItemSchema,
   reviewPageSchema,
-  memberPageSchema
+  memberPageSchema,
+  createStockItemSchema,
+  stockItemSchema
 };