@domino-sdk/relay 1.61.0 → 1.62.0

package/dist/chunk-GTDW453U.js

@@ -0,0 +1,522 @@
+import {
+  authoringIdentityShape,
+  calendarPeriodSchema,
+  contentMetricSchema,
+  contentMetricsSchema,
+  identifier,
+  maxPointsAmount,
+  missingPrerequisiteSchema,
+  pageCursorSchema,
+  pointsRewardSchema,
+  prerequisiteSchema,
+  resourceHandle,
+  responseShape,
+  tierRewardSchema
+} from "./chunk-MK425RXJ.js";
+
+// src/engagement.ts
+import * as z from "zod";
+var amount = z.number().int().safe().nonnegative();
+var engagementBudgetSchema = z.strictObject({
+  scope: z.enum(["member", "project"]),
+  period: calendarPeriodSchema,
+  limit: amount
+});
+var engagementDefinitionSchema = z.strictObject({
+  key: identifier,
+  qualifiedBy: identifier,
+  balance: identifier,
+  metrics: z.array(contentMetricSchema).min(1).max(10).refine(
+    (metrics) => new Set(metrics).size === metrics.length,
+    "Metrics must be unique"
+  ),
+  baseline: z.literal("historical"),
+  maxAgeMs: z.number().int().positive().max(864e5).default(36e5),
+  budgets: z.array(engagementBudgetSchema).max(8).default([]).refine(
+    (budgets) => new Set(budgets.map((b) => b.scope + ":" + b.period)).size === budgets.length,
+    "Give each scope and period one budget"
+  )
+});
+var engagementScoreInputSchema = z.strictObject({
+  metrics: contentMetricsSchema,
+  baseline: contentMetricsSchema
+});
+var engagementScoreSchema = z.strictObject({
+  target: amount,
+  baseline: amount
+});
+var engagementPublishSchema = z.strictObject({
+  actionId: identifier,
+  code: z.string().min(1).max(1e6)
+});
+var engagementRuleSchema = z.strictObject({
+  version: identifier,
+  definition: engagementDefinitionSchema,
+  publishedAt: amount
+});
+var engagementPageQuerySchema = z.strictObject({
+  rule: identifier,
+  content: z.string().min(1).max(256),
+  member: identifier.optional(),
+  cursor: pageCursorSchema.optional()
+});
+var engagementSettlementSchema = z.strictObject({
+  id: identifier,
+  day: z.string(),
+  observation: identifier,
+  qualification: identifier,
+  earned: amount,
+  growth: amount,
+  paid: amount,
+  excluded: amount,
+  entry: identifier.nullable(),
+  createdAt: amount
+});
+var engagementPageSchema = z.strictObject({
+  rule: engagementRuleSchema,
+  account: z.strictObject({
+    member: identifier,
+    earned: amount,
+    accounted: amount,
+    paid: amount,
+    excluded: amount,
+    pending: amount,
+    counters: contentMetricsSchema,
+    baseline: contentMetricsSchema,
+    observation: identifier.nullable(),
+    nextSettlementAt: amount.nullable(),
+    reason: z.string().nullable()
+  }).nullable(),
+  items: z.array(engagementSettlementSchema),
+  nextCursor: pageCursorSchema.nullable()
+});
+var engagementChangePreviewInputSchema = z.strictObject({
+  code: z.string().min(1).max(1e6)
+});
+var engagementChangeSchema = engagementPublishSchema.extend({
+  expectedVersion: identifier,
+  previewHash: identifier
+});
+var total = z.string().regex(/^(0|[1-9][0-9]*)$/);
+var engagementChangePreviewSchema = z.strictObject({
+  rule: identifier,
+  fromVersion: identifier,
+  toVersion: identifier,
+  previewHash: identifier,
+  definition: engagementDefinitionSchema,
+  boundary: z.literal("available-eligible-observation"),
+  settlement: z.literal("deferred"),
+  summary: z.strictObject({
+    knownAdmissions: amount,
+    accounts: amount,
+    uninitialized: amount,
+    pendingTransitions: amount,
+    earned: total,
+    paid: total,
+    excluded: total,
+    pending: total
+  })
+});
+var engagementVersionSchema = engagementRuleSchema.extend({
+  previousVersion: identifier.nullable()
+});
+var engagementRuleVersionPageSchema = z.object({
+  items: z.array(
+    z.object({
+      version: identifier,
+      definition: z.object({
+        ...engagementDefinitionSchema.shape,
+        budgets: z.array(z.object(engagementBudgetSchema.shape)).max(8).default([])
+      }),
+      publishedAt: amount,
+      previousVersion: identifier.nullable()
+    })
+  ),
+  nextCursor: pageCursorSchema.nullable()
+});
+var engagementVersionPageSchema = z.strictObject({
+  items: z.array(engagementVersionSchema),
+  next: amount.nullable()
+});
+var engagementVersionQuerySchema = z.strictObject({
+  rule: identifier,
+  before: z.coerce.number().int().positive().safe().optional()
+});
+var engagementBoundaryPageSchema = z.strictObject({
+  current: engagementRuleSchema.nullable(),
+  requested: engagementRuleSchema,
+  items: z.array(
+    z.strictObject({
+      from: identifier,
+      to: identifier,
+      baseline: contentMetricsSchema,
+      observedAt: amount,
+      settlement: engagementSettlementSchema
+    })
+  ),
+  nextCursor: pageCursorSchema.nullable()
+});
+var engagementArtifactSchema = engagementPublishSchema.omit({
+  actionId: true
+});
+var deploymentEntry = engagementArtifactSchema.extend({
+  rule: engagementRuleSchema
+});
+var engagementDeploymentEntrySchema = z.discriminatedUnion("kind", [
+  deploymentEntry.extend({ kind: z.literal("create") }),
+  deploymentEntry.extend({ kind: z.literal("unchanged") }),
+  deploymentEntry.extend({
+    kind: z.literal("change"),
+    change: engagementChangePreviewSchema
+  })
+]);
+
+// src/referrals.ts
+import * as z2 from "zod";
+var rewardSchema = z2.union([pointsRewardSchema, tierRewardSchema]);
+var amount2 = 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: amount2.min(1),
+      rewards: z2.array(rewardSchema).min(1).max(10)
+    }).strict()
+  ).max(30).default([]),
+  bonuses: z2.array(
+    z2.object({
+      id: identifier,
+      balance: identifier,
+      basisPoints: amount2.min(1).max(1e4),
+      quests: z2.array(identifier).min(1).max(100).optional(),
+      external: z2.boolean().default(false),
+      durationDays: amount2.min(1).max(36500).optional(),
+      maxPoints: amount2.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,
+  inviterGroup: identifier.optional()
+}).strict().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" });
+    }
+  }
+});
+var referralArtifactSchema = z2.union([
+  referralAuthoringSchema,
+  z2.object({ code: z2.string().min(1).max(2e6) }).strict()
+]);
+var publishedReferralSchema = z2.object({
+  archivedAt: z2.number().int().nonnegative().nullable().optional(),
+  version: identifier,
+  definition: referralDefinitionSchema,
+  publishedAt: amount2,
+  actor: z2.string().nullable()
+});
+var referralAcceptSchema = z2.object({ actionId: identifier, code: identifier }).strict();
+var referralSuspensionSchema = z2.object({ actionId: identifier, suspended: z2.boolean(), reason }).strict();
+var referralQualificationSchema = z2.object({ actionId: identifier, qualified: z2.boolean(), reason }).strict();
+var referralRewardResolutionSchema = z2.object({ actionId: identifier, reason }).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: amount2,
+  suspended: z2.boolean(),
+  /** The member import that recorded this referral, or null when the friend accepted an invitation. */
+  import: identifier.nullable().optional()
+});
+var referralAccountSchema = z2.object({
+  id: identifier,
+  program: identifier,
+  kind: z2.enum(["bonus", "fixed", "milestone"]),
+  balance: identifier,
+  earned: amount2,
+  settled: amount2,
+  outstanding: amount2
+});
+var referralSummarySchema = z2.object({
+  code: identifier,
+  attributed: amount2,
+  programs: z2.array(
+    z2.object({
+      definition: referralDefinitionSchema,
+      qualified: amount2,
+      milestones: z2.array(
+        z2.object({ id: identifier, count: amount2, reached: z2.boolean() })
+      )
+    })
+  ),
+  accounts: z2.array(referralAccountSchema)
+});
+var referralHistorySchema = z2.object({
+  items: z2.array(
+    z2.object({
+      id: amount2,
+      program: identifier,
+      balance: identifier,
+      amount: z2.number().int().safe(),
+      at: amount2,
+      reason: z2.string()
+    })
+  ),
+  nextCursor: pageCursorSchema.nullable()
+});
+var referralManagementSchema = z2.object({
+  relationships: z2.array(referralRelationshipSchema),
+  qualifications: z2.array(
+    z2.object({
+      member: identifier,
+      program: identifier,
+      qualified: z2.boolean(),
+      qualifiedAt: amount2,
+      /** The member import that recorded this qualification, which paid no reward, or null. */
+      import: identifier.nullable().optional()
+    })
+  ),
+  accounts: z2.array(
+    referralAccountSchema.extend({ member: identifier, invitee: z2.string() })
+  ),
+  reviews: z2.array(
+    z2.object({
+      entitlement: identifier,
+      member: identifier,
+      program: identifier,
+      reason: z2.string()
+    })
+  ),
+  nextCursor: pageCursorSchema.nullable().default(null),
+  /** @deprecated Use `nextCursor`, passed back as `cursor`. Removed in 2.0.0. */
+  next: amount2.nullable()
+});
+
+// src/definition-error.ts
+function issueText(issues) {
+  return issues.map(
+    (issue) => issue.path.length ? issue.path.map(String).join(".") + ": " + issue.message : issue.message
+  ).join("; ");
+}
+function parseDefinition(kind, schema, input) {
+  const parsed = schema.safeParse(input);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  const key = typeof input === "object" && input !== null && "key" in input && typeof input.key === "string" ? ` "${input.key}"` : "";
+  parsed.error.message = `${kind}${key} is invalid: ${issueText(parsed.error.issues)}`;
+  throw parsed.error;
+}
+
+// src/offers.ts
+import * as z3 from "zod";
+var quantity = z3.number().int().safe().nonnegative();
+var offerPriceSchema = pointsRewardSchema.extend({
+  amount: z3.number().int().positive().max(maxPointsAmount)
+});
+var offerLimitSchema = z3.object({ perMember: z3.number().int().positive().max(1e4) }).strict();
+var offerDefinitionSchema = z3.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z3.string().trim().min(1).max(120),
+  price: offerPriceSchema,
+  reward: tierRewardSchema,
+  stock: quantity.max(1e6),
+  limit: offerLimitSchema.default({ perMember: 1 }),
+  /**
+   * What a member must meet to redeem, the same prerequisites quests take: `completed`,
+   * `balanceAtLeast` and `inGroup`. Checked when the member redeems; absent, anyone can.
+   */
+  requires: z3.array(prerequisiteSchema).max(30).optional(),
+  enabled: z3.boolean().default(true)
+}).strict();
+var offerAuthoringSchema = offerDefinitionSchema.omit({ id: true, title: true, enabled: true }).extend({
+  ...authoringIdentityShape,
+  title: z3.string().trim().min(1).max(120).optional(),
+  // `defineOffer` returns `enabled: true`, and a deployment describes the module's default
+  // export and parses it again, so the output has to read back. Pause an offer in Console.
+  enabled: z3.literal(true).optional()
+}).strict().transform(({ enabled: _, ...offer }) => ({
+  ...offer,
+  title: offer.title ?? offer.reward.reward.title,
+  enabled: true
+}));
+var offerArtifactSchema = z3.union([
+  offerAuthoringSchema,
+  z3.object({ code: z3.string().min(1).max(2e6) }).strict()
+]);
+var offerAvailabilitySchema = responseShape(
+  z3.discriminatedUnion("kind", [
+    z3.object({ kind: z3.literal("available"), remaining: quantity }).strict(),
+    z3.object({ kind: z3.literal("out-of-stock") }).strict(),
+    z3.object({ kind: z3.literal("limit-reached") }).strict(),
+    z3.object({ kind: z3.literal("paused") }).strict()
+  ])
+);
+var offerSchema = responseShape(
+  offerDefinitionSchema.extend({
+    revision: z3.number().int().positive(),
+    available: quantity,
+    redeemed: quantity,
+    availability: offerAvailabilitySchema,
+    /**
+     * When an operator archived the offer, or `null`. Only management reads carry it and list an
+     * archived offer; it refuses new redemptions with `offer-paused` until it is restored.
+     */
+    archivedAt: z3.number().int().nonnegative().nullable().optional(),
+    /**
+     * The prerequisites the signed-in member has not met yet, so an app can show the offer locked
+     * and why. Empty when nothing is missing or the read has no member; redeeming while it is not
+     * empty fails with `prerequisites-incomplete`.
+     */
+    missing: z3.array(missingPrerequisiteSchema).default([])
+  })
+);
+var redeemOfferSchema = z3.object({ actionId: identifier }).strict();
+var redemptionBase = {
+  id: identifier,
+  offer: identifier,
+  member: identifier,
+  /**
+   * @deprecated Use `id` to refer to a redemption. A redemption is fulfilled in the request that
+   * makes it, so nothing is reserved beforehand; the ID refers to no other record. Removed in
+   * 2.0.0.
+   */
+  reservation: identifier,
+  price: offerPriceSchema,
+  reward: tierRewardSchema,
+  entitlement: identifier,
+  revision: z3.number().int().positive(),
+  redeemedAt: z3.number().int().safe().nonnegative()
+};
+var redemptionSchema = responseShape(
+  z3.discriminatedUnion("status", [
+    z3.object({ ...redemptionBase, status: z3.literal("fulfilled") }).strict(),
+    z3.object({
+      ...redemptionBase,
+      status: z3.literal("canceled"),
+      canceledAt: z3.number().int().safe().nonnegative(),
+      reason: z3.string().min(1).max(500)
+    }).strict()
+  ])
+);
+var redemptionQuerySchema = z3.strictObject({
+  member: identifier.optional(),
+  cursor: pageCursorSchema.optional(),
+  limit: z3.coerce.number().int().min(1).max(100).optional()
+});
+var redemptionPageSchema = z3.object({
+  items: z3.array(redemptionSchema),
+  nextCursor: pageCursorSchema.nullable()
+});
+var offerControlSchema = z3.object({
+  actionId: identifier,
+  revision: z3.number().int().positive(),
+  enabled: z3.boolean(),
+  reason: z3.string().trim().min(1).max(500)
+}).strict();
+var redemptionCancellationSchema = z3.object({
+  actionId: identifier,
+  revision: z3.number().int().positive(),
+  reason: z3.string().trim().min(1).max(500)
+}).strict();
+function defineOffer(input) {
+  return resourceHandle(
+    "offer",
+    parseDefinition("Offer", offerAuthoringSchema, input)
+  );
+}
+
+export {
+  engagementBudgetSchema,
+  engagementDefinitionSchema,
+  engagementScoreInputSchema,
+  engagementScoreSchema,
+  engagementPublishSchema,
+  engagementRuleSchema,
+  engagementPageQuerySchema,
+  engagementSettlementSchema,
+  engagementPageSchema,
+  engagementChangePreviewInputSchema,
+  engagementChangeSchema,
+  engagementChangePreviewSchema,
+  engagementRuleVersionPageSchema,
+  engagementVersionPageSchema,
+  engagementVersionQuerySchema,
+  engagementBoundaryPageSchema,
+  engagementArtifactSchema,
+  engagementDeploymentEntrySchema,
+  referralDefinitionSchema,
+  referralAuthoringSchema,
+  referralArtifactSchema,
+  publishedReferralSchema,
+  referralAcceptSchema,
+  referralSuspensionSchema,
+  referralQualificationSchema,
+  referralRewardResolutionSchema,
+  referralControlSchema,
+  referralRelationshipSchema,
+  referralAccountSchema,
+  referralSummarySchema,
+  referralHistorySchema,
+  referralManagementSchema,
+  parseDefinition,
+  offerPriceSchema,
+  offerLimitSchema,
+  offerDefinitionSchema,
+  offerAuthoringSchema,
+  offerArtifactSchema,
+  offerAvailabilitySchema,
+  offerSchema,
+  redeemOfferSchema,
+  redemptionSchema,
+  redemptionQuerySchema,
+  redemptionPageSchema,
+  offerControlSchema,
+  redemptionCancellationSchema,
+  defineOffer
+};