@domino-sdk/relay 1.0.0-next.8 → 1.0.0

package/dist/chunk-MC6V6VMG.js

@@ -0,0 +1,49 @@
+// src/capability-error.ts
+import { z } from "zod";
+var capabilityErrorCodes = [
+  "not-linked",
+  "provider-unavailable",
+  "author-error"
+];
+var isKnown = (code) => capabilityErrorCodes.includes(code);
+var capabilityFailureSchema = z.looseObject({
+  code: z.string().min(1),
+  message: z.string().min(1),
+  /**
+   * True when Relay retries the attempt if the error reaches it uncaught, and calls the provider
+   * again. A failure that is not retryable is captured (or follows from the attempt's pinned
+   * inputs), so every run of the attempt sees it again. A retryable failure that quest code
+   * handles and moves past is final for the attempt; one that escapes the evaluation is retried.
+   */
+  retryable: z.boolean()
+});
+var brand = /* @__PURE__ */ Symbol.for("@domino-sdk/relay/CapabilityError");
+var CapabilityError = class _CapabilityError extends Error {
+  code;
+  retryable;
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = "CapabilityError";
+    this.code = code;
+    this.retryable = options.retryable ?? code === "provider-unavailable";
+    Object.defineProperty(this, brand, { value: true });
+  }
+  static [Symbol.hasInstance](value) {
+    return typeof value === "object" && value !== null && value[brand] === true;
+  }
+  /**
+   * The error for a captured or transported failure. A code this SDK does not know is never
+   * retryable: nothing tells it a retry would help.
+   */
+  static from(failure) {
+    return new _CapabilityError(failure.code, failure.message, {
+      retryable: isKnown(failure.code) && failure.retryable
+    });
+  }
+};
+
+export {
+  capabilityErrorCodes,
+  capabilityFailureSchema,
+  CapabilityError
+};

package/dist/chunk-NPGENI7K.js

@@ -0,0 +1,37 @@
+// src/request-error.ts
+var requestErrorBrand = /* @__PURE__ */ Symbol.for("@domino-sdk/relay.RequestError");
+function isRequestError(value) {
+  return typeof value === "object" && value !== null && value[requestErrorBrand] === true;
+}
+var RequestError = class extends Error {
+  name = "RequestError";
+  [requestErrorBrand] = true;
+  kind;
+  uncertain;
+  status;
+  code;
+  operationId;
+  /** `replay` for a replay-safe operation ID, else `reconcile`; only when `uncertain`. */
+  recovery;
+  /**
+   * Milliseconds the server asked the client to wait before trying again, from the `Retry-After`
+   * header of an error answer such as a 429 or 503. The client's own retries never wait past the
+   * call's deadline, so a longer wait is left to the caller.
+   */
+  retryAfter;
+  constructor(message, details) {
+    super(message, details.cause === void 0 ? {} : { cause: details.cause });
+    this.kind = details.kind;
+    this.uncertain = details.uncertain ?? false;
+    this.status = details.status;
+    this.code = details.code;
+    this.operationId = details.operationId;
+    this.retryAfter = details.retryAfter;
+    this.recovery = this.uncertain ? details.operationId && (details.replaySafe ?? true) ? "replay" : "reconcile" : void 0;
+  }
+};
+
+export {
+  isRequestError,
+  RequestError
+};

package/dist/chunk-VFHHLN6A.js

@@ -0,0 +1,284 @@
+import {
+  imageAssetArtifactSchema,
+  publishedImageSchema
+} from "./chunk-BGGKNIRP.js";
+import {
+  catalogDeploymentSchema,
+  interactionSchema,
+  questCollectionSchema,
+  questTypeVersionSchema
+} from "./chunk-EYH5RDIE.js";
+import {
+  engagementArtifactSchema,
+  engagementDeploymentEntrySchema,
+  leaderboardArtifactSchema,
+  leaderboardPreviewSchema,
+  offerArtifactSchema,
+  offerDefinitionSchema,
+  pointLedgerArtifactSchema,
+  pointLedgerSchema,
+  publishedReferralSchema,
+  referralArtifactSchema
+} from "./chunk-36HTX2BM.js";
+import {
+  identifier,
+  pageCursorSchema,
+  projectCalendarDeclarationSchema,
+  publishedReleaseSchema,
+  publishedTrackerSchema,
+  questBudgetViewSchema,
+  releaseSchema,
+  rewardSchema,
+  timeZoneNameSchema,
+  trackerArtifactSchema
+} from "./chunk-JON5SESL.js";
+
+// src/deployments.ts
+import { z } from "zod";
+var projectCatalogArtifactSchema = catalogDeploymentSchema.omit({ expectedRevision: true }).extend({
+  engagement: z.array(engagementArtifactSchema).max(50).default([]),
+  trackers: z.array(trackerArtifactSchema).max(50).default([]),
+  pointLedgers: z.array(pointLedgerArtifactSchema).max(50).default([]),
+  offers: z.array(offerArtifactSchema).max(100).default([]),
+  referrals: z.array(referralArtifactSchema).max(50).default([]),
+  leaderboards: z.array(leaderboardArtifactSchema).max(50).default([]),
+  images: z.array(imageAssetArtifactSchema).max(10).default([]),
+  /** relay.json `calendar`: the project timezone. Omitted, the deployment leaves it unchanged. */
+  calendar: projectCalendarDeclarationSchema.optional()
+});
+var projectDeploymentSchema = projectCatalogArtifactSchema.extend({ releases: z.array(releaseSchema).max(50).default([]) }).refine(
+  (value) => value.engagement.length > 0 || value.trackers.length > 0 || value.pointLedgers.length > 0 || value.offers.length > 0 || value.releases.length > 0 || value.leaderboards.length > 0 || value.referrals.length > 0 || value.images.length > 0 || value.types.length > 0 || value.collections.length > 0 || value.supportedInteractions !== void 0 || value.calendar !== void 0,
+  "No resources configured. Add engagement, trackers, quests, questTypes, pointLedgers, offers, leaderboards, referrals, images, collections, supportedInteractions, or calendar to relay.json."
+);
+var deploymentPreviewSchema = z.object({
+  id: identifier,
+  engagement: z.array(engagementDeploymentEntrySchema).default([]),
+  trackers: z.array(publishedTrackerSchema).default([]),
+  baseRevision: z.number().int().nonnegative(),
+  pointLedgers: z.array(pointLedgerSchema).default([]),
+  offers: z.array(offerDefinitionSchema).default([]),
+  releases: z.array(publishedReleaseSchema),
+  types: z.array(questTypeVersionSchema),
+  collections: z.array(questCollectionSchema),
+  supportedInteractions: z.array(interactionSchema),
+  referrals: z.array(publishedReferralSchema).default([]),
+  leaderboards: z.array(leaderboardPreviewSchema).default([]),
+  images: z.array(publishedImageSchema).default([]),
+  /**
+   * The project timezone change this deployment makes, or null for none. A declared timezone
+   * applies only when relay.json changes it, so a change made in Console stays until relay.json
+   * changes. `effectiveAt` is when a scheduled change takes effect; null means the deployment keeps
+   * `timeZone` and cancels a pending change. Publishing makes exactly this change, or fails when the
+   * calendar moved since the preview (such as past a day boundary).
+   */
+  calendar: z.object({
+    timeZone: timeZoneNameSchema,
+    effectiveAt: z.number().int().nullable()
+  }).nullable().default(null)
+});
+var publishDeploymentSchema = z.object({ id: identifier }).strict();
+var deploymentResultSchema = deploymentPreviewSchema.extend({
+  revision: z.number().int().positive()
+});
+var deploymentSourceSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("direct") }).strict(),
+  z.object({ kind: z.literal("promotion"), deployment: identifier }).strict(),
+  z.object({ kind: z.literal("rollback"), deployment: identifier }).strict()
+]);
+var deploymentRecordMetadata = {
+  source: deploymentSourceSchema,
+  createdAt: z.number().int().nonnegative(),
+  createdBy: z.string().nullable()
+};
+var submittedDeploymentMetadata = {
+  submittedAt: z.number().int().nonnegative(),
+  submittedBy: z.string().nullable()
+};
+var deploymentRecordSchema = z.discriminatedUnion("status", [
+  deploymentPreviewSchema.extend({
+    ...deploymentRecordMetadata,
+    status: z.literal("preview")
+  }),
+  deploymentPreviewSchema.extend({
+    ...deploymentRecordMetadata,
+    ...submittedDeploymentMetadata,
+    status: z.literal("pending")
+  }),
+  deploymentPreviewSchema.extend({
+    ...deploymentRecordMetadata,
+    ...submittedDeploymentMetadata,
+    status: z.literal("rejected"),
+    decidedAt: z.number().int().nonnegative(),
+    decidedBy: z.string().nullable(),
+    reason: z.string().trim().min(1).max(1e3)
+  }),
+  deploymentResultSchema.extend({
+    ...deploymentRecordMetadata,
+    status: z.literal("published"),
+    submittedAt: z.number().int().nonnegative().nullable(),
+    submittedBy: z.string().nullable(),
+    publishedAt: z.number().int().nonnegative(),
+    publishedBy: z.string().nullable()
+  })
+]);
+var submitDeploymentSchema = z.object({ id: identifier }).strict();
+var rejectDeploymentSchema = z.object({
+  id: identifier,
+  reason: z.string().trim().min(1).max(1e3)
+}).strict();
+var repeatableDeploymentSchema = z.object({ actionId: z.string().uuid(), id: identifier }).strict();
+var promoteDeploymentSchema = repeatableDeploymentSchema;
+var rollbackDeploymentSchema = repeatableDeploymentSchema;
+
+// src/activity.ts
+import { z as z2 } from "zod";
+var activityTypes = {
+  attemptRejected: "attempt.rejected",
+  entitlementGranted: "entitlement.granted",
+  rewardDeliveryUpdated: "reward.delivery.updated",
+  completionCreated: "completion.created",
+  pointsAwarded: "points.awarded",
+  reviewPending: "review.pending",
+  rewardDeliveryFailed: "reward.delivery.failed",
+  entitlementCollected: "entitlement.collected",
+  referralQualified: "referral.qualified"
+};
+var activityTypeSchema = z2.string().min(1).max(100);
+
+// src/automatic-outcomes.ts
+import { z as z3 } from "zod";
+var automaticEventSchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    kind: z3.literal("completion"),
+    attempt: identifier,
+    generation: z3.number().int().nonnegative()
+  }),
+  z3.object({ kind: z3.literal("points"), entry: identifier }),
+  z3.object({ kind: z3.literal("group"), action: identifier }),
+  z3.object({ kind: z3.literal("campaign"), action: identifier }),
+  z3.object({ kind: z3.literal("publication"), revision: identifier }),
+  z3.object({ kind: z3.literal("revocation"), action: identifier })
+]);
+var knownEventKinds = new Set(
+  automaticEventSchema.options.map((option) => option.shape.kind.value)
+);
+var automaticEventResponseSchema = z3.union([
+  automaticEventSchema,
+  z3.looseObject({
+    kind: z3.string().refine((kind) => !knownEventKinds.has(kind))
+  }).catchall(z3.json())
+]);
+var automaticOutcomeSchema = z3.object({
+  id: identifier,
+  quest: identifier,
+  member: identifier,
+  release: identifier,
+  event: automaticEventResponseSchema,
+  state: z3.enum(["admitted", "skipped"]),
+  code: z3.string().nullable(),
+  reason: z3.string().nullable(),
+  attempt: identifier.nullable(),
+  revision: z3.number().int().nonnegative(),
+  createdAt: z3.number().int().safe(),
+  updatedAt: z3.number().int().safe()
+});
+var automaticOutcomeQuerySchema = z3.strictObject({
+  quest: identifier.optional(),
+  member: identifier.optional(),
+  state: z3.enum(["admitted", "skipped"]).optional(),
+  code: z3.string().max(100).optional(),
+  cursor: pageCursorSchema.optional()
+});
+var automaticOutcomePageSchema = z3.object({
+  items: z3.array(automaticOutcomeSchema),
+  nextCursor: pageCursorSchema.nullable()
+});
+var automaticCatchUpInputSchema = z3.strictObject({
+  quest: identifier,
+  outcomes: z3.array(identifier).min(1).max(50)
+});
+var automaticCatchUpPreviewSchema = z3.object({
+  quest: identifier,
+  release: identifier,
+  token: identifier,
+  items: z3.array(
+    z3.object({
+      outcome: automaticOutcomeSchema,
+      code: z3.string().nullable(),
+      reason: z3.string().nullable(),
+      attempt: identifier.nullable(),
+      wouldAdmit: z3.boolean(),
+      budgets: z3.array(questBudgetViewSchema)
+    })
+  ),
+  /** Declared rewards per successful evaluation. Evaluators may choose different rewards. */
+  rewards: z3.array(rewardSchema),
+  /** Each budget's declared cost per successful evaluation; dynamic costs remain explicit. */
+  costs: z3.array(
+    z3.object({
+      budget: identifier,
+      cost: z3.union([z3.number(), z3.literal("dynamic")])
+    })
+  )
+});
+var automaticCatchUpConfirmSchema = automaticCatchUpInputSchema.extend(
+  {
+    actionId: identifier,
+    token: identifier,
+    reason: z3.string().trim().min(1).max(1e3)
+  }
+);
+var automaticCatchUpResultSchema = z3.object({
+  items: z3.array(automaticOutcomeSchema)
+});
+var automaticSchedulingQuerySchema = z3.strictObject({
+  member: identifier.optional(),
+  cursor: pageCursorSchema.optional()
+});
+var automaticSchedulingSchema = z3.object({
+  id: identifier,
+  member: identifier,
+  event: automaticEventResponseSchema,
+  state: z3.enum(["pending", "retrying", "failed"]),
+  attempts: z3.number().int().nonnegative(),
+  error: z3.string().nullable(),
+  createdAt: z3.number().int().safe(),
+  nextAttemptAt: z3.number().int().safe()
+});
+var automaticSchedulingPageSchema = z3.object({
+  items: z3.array(automaticSchedulingSchema),
+  nextCursor: pageCursorSchema.nullable()
+});
+var automaticSchedulingRetrySchema = z3.strictObject({
+  actionId: identifier,
+  id: identifier,
+  reason: z3.string().trim().min(1).max(1e3)
+});
+
+export {
+  projectCatalogArtifactSchema,
+  projectDeploymentSchema,
+  deploymentPreviewSchema,
+  publishDeploymentSchema,
+  deploymentResultSchema,
+  deploymentSourceSchema,
+  deploymentRecordSchema,
+  submitDeploymentSchema,
+  rejectDeploymentSchema,
+  promoteDeploymentSchema,
+  rollbackDeploymentSchema,
+  activityTypes,
+  activityTypeSchema,
+  automaticEventSchema,
+  automaticOutcomeSchema,
+  automaticOutcomeQuerySchema,
+  automaticOutcomePageSchema,
+  automaticCatchUpInputSchema,
+  automaticCatchUpPreviewSchema,
+  automaticCatchUpConfirmSchema,
+  automaticCatchUpResultSchema,
+  automaticSchedulingQuerySchema,
+  automaticSchedulingSchema,
+  automaticSchedulingPageSchema,
+  automaticSchedulingRetrySchema
+};

package/dist/chunk-WJSSJ7AF.js

@@ -0,0 +1,151 @@
+import {
+  imageComparisonSchema,
+  imageExtractionSchema,
+  imageFieldsSchema,
+  imageInspectionSchema,
+  imageSightingsSchema
+} from "./chunk-BGGKNIRP.js";
+import {
+  authScopeSchema
+} from "./chunk-XFMSUPNS.js";
+import {
+  appIdentityKindSchema,
+  openIdentityKindSchema,
+  photoResultSchema
+} from "./chunk-JON5SESL.js";
+
+// src/configuration.ts
+function questConfiguration(release) {
+  return release.configuration ?? {
+    defaults: Object.fromEntries(
+      Object.entries(release.fields).map(([key, field]) => [
+        key,
+        field.default
+      ])
+    ),
+    overrides: { ...release.values },
+    preserved: Object.keys(release.values)
+  };
+}
+
+// src/identity-integration.ts
+import { z } from "zod";
+var identityIntegrationInputSchema = z.object({
+  name: z.string().trim().min(1).max(80),
+  origin: z.string().url().refine((value) => {
+    const url = new URL(value);
+    return url.protocol === "https:" && url.origin === value;
+  }, "Use an exact HTTPS application origin"),
+  /**
+   * The identity kind this integration owns in the project and environment, such as
+   * `app:telegram`. Each member it signs in gets the exchanged subject as an identity of this
+   * kind, which tracker attribution and `ctx.member.identities()` read. Its kind cannot change.
+   * Omit it for an integration that only signs members in.
+   *
+   * A kind belongs to the integration that first claimed it, also after that integration is
+   * disconnected. A new integration takes a kind that already has identities only by adopting
+   * them with `adoptIdentitiesFrom`.
+   */
+  identityKind: appIdentityKindSchema.optional(),
+  /**
+   * Adopt the identities of a disconnected integration's `identityKind`: its ID, as
+   * `identityIntegrations.kinds()` lists it. Adopt only when this app's user IDs mean the same
+   * users as that integration's, because each one then signs in as the member that ID is linked
+   * to. Needs `reason`, which the audit log keeps.
+   */
+  adoptIdentitiesFrom: z.string().uuid().optional(),
+  /** Why the identities are adopted; required with `adoptIdentitiesFrom`. */
+  reason: z.string().trim().min(1).max(500).optional()
+}).strict().refine(
+  (input) => !input.adoptIdentitiesFrom || input.identityKind,
+  "Adopting identities needs the identityKind they have"
+).refine(
+  (input) => !input.adoptIdentitiesFrom === !input.reason,
+  "Give a reason when adopting identities, and only then"
+);
+var identityIntegrationSchema = z.object({
+  ...authScopeSchema.shape,
+  id: z.string().uuid(),
+  name: z.string(),
+  origin: z.string(),
+  expiresAt: z.number(),
+  /** The identity kind the integration owns; null when it only signs members in. */
+  identityKind: openIdentityKindSchema.nullable().default(null)
+});
+var identityIntegrationSecretSchema = identityIntegrationSchema.extend(
+  {
+    token: z.string()
+  }
+);
+var identityKindClaimSchema = z.object({
+  kind: openIdentityKindSchema,
+  /** The owning integration's ID; it stays after the integration is disconnected. */
+  integration: z.string(),
+  /** The owning integration's name when it claimed or adopted the kind. */
+  integrationName: z.string(),
+  /** Whether the owning integration is still connected. */
+  connected: z.boolean(),
+  /** Linked identities of the kind; adopting them is required to reuse the kind. */
+  linked: z.number().int().nonnegative(),
+  /** Identities an operator unlinked. */
+  unlinked: z.number().int().nonnegative(),
+  claimedAt: z.number().int().nonnegative()
+});
+var participantExchangeSchema = z.object({
+  subject: z.string().min(1).max(200),
+  previousToken: z.string().max(200).optional()
+}).strict();
+
+// src/image-results.ts
+import { z as z2 } from "zod";
+var invalid = (message, path) => new z2.ZodError([{ code: "custom", message, path, input: void 0 }]);
+function parseImageExtraction(raw, value) {
+  const result = imageExtractionSchema.parse(value);
+  const fields = imageFieldsSchema.parse(raw);
+  for (const [key, field] of Object.entries(fields)) {
+    const extracted = result.values[key];
+    if (extracted === void 0) {
+      throw invalid("Image extraction omitted " + key, ["values", key]);
+    }
+    if (extracted !== null && typeof extracted !== field.type) {
+      throw invalid("Image extraction returned the wrong type for " + key, [
+        "values",
+        key
+      ]);
+    }
+  }
+  if (Object.keys(result.values).some((key) => !Object.hasOwn(fields, key))) {
+    throw invalid("Image extraction returned an undeclared field", ["values"]);
+  }
+  return result;
+}
+function parseImageResult(request, value) {
+  switch (request.operation) {
+    case "inspect":
+      return imageInspectionSchema.parse(value);
+    case "compare":
+      return imageComparisonSchema.parse(value);
+    case "review":
+      return photoResultSchema.parse(value);
+    case "extract":
+      return parseImageExtraction(request.fields, value);
+    case "seen":
+      return imageSightingsSchema.parse(value);
+  }
+}
+
+// src/sequence-cursor.ts
+import { z as z3 } from "zod";
+var sequenceCursorSchema = z3.string().regex(/^[1-9][0-9]{0,15}$/, "Invalid cursor").transform(Number).pipe(z3.number().int().positive().safe());
+
+export {
+  questConfiguration,
+  identityIntegrationInputSchema,
+  identityIntegrationSchema,
+  identityIntegrationSecretSchema,
+  identityKindClaimSchema,
+  participantExchangeSchema,
+  parseImageExtraction,
+  parseImageResult,
+  sequenceCursorSchema
+};

package/dist/{chunk-QBOHLT7M.js → chunk-XFMSUPNS.js}

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