@domino-sdk/relay 1.14.0 → 1.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domino-sdk/relay",
-  "version": "1.14.0",
+  "version": "1.16.0",
   "type": "module",
   "exports": {
     ".": {
@@ -56,6 +56,7 @@
   "dependencies": {
     "@dicebear/core": "9.4.3",
     "@dicebear/shapes": "9.4.3",
+    "croner": "10.0.1",
     "zod": "4.3.6"
   },
   "peerDependencies": {

package/dist/action-9Xl0StBg.d.ts

@@ -1,33 +0,0 @@
-import { R as RequestError } from './request-error-D_dUPLwo.js';
-
-/** SDK input convenience; the wire request always carries a key. */
-type OptionalActionId<T> = T extends {
-    actionId: string;
-} ? Omit<T, "actionId"> & {
-    actionId?: string;
-} : never;
-/** One logical write. Keep this object until its outcome is definite. */
-type RelayAction<T> = {
-    /** The pending write's key, also available on its uncertain error as `operationId`. */
-    readonly actionId: string | undefined;
-    readonly busy: boolean;
-    readonly error: RequestError | undefined;
-    /**
-     * Starts a write with a generated key. While an uncertain write is pending, replays its saved
-     * callback instead of accepting a different write. Concurrent calls share one request.
-     * Put refreshes and other follow-up work outside the callback.
-     */
-    run(task: (actionId: string) => Promise<T>): Promise<T>;
-    /** Replays the exact pending callback and key, only when the error's recovery is `replay`. */
-    retry(): Promise<T>;
-    /** Acknowledge an authoritative, definite outcome after reconciliation. Refuses while busy. */
-    settle(): boolean;
-};
-/**
- * Owns a mutation key across uncertain answers. A definite success or refusal ends the action;
- * the next `run` gets a new key. `reconcile` failures stay pending and cannot be replayed.
- * In-memory only: persist the key yourself if recovery must survive a reload or process restart.
- */
-declare function createRelayAction<T = unknown>(): RelayAction<T>;
-
-export { type OptionalActionId as O, type RelayAction as R, createRelayAction as c };

package/dist/referral-reward-kinds-DnvQXL8L.d.ts

@@ -1,268 +0,0 @@
-import { ar as PublishedRelease, O as OpenIdentityKind, n as TrackerSource, a0 as TrackerDataSchema, aO as TrackerSourceResponse, at as QuestDescription } from './schema-K-Pg5lPz.js';
-import { z } from 'zod';
-import { d as ImageFields, g as ImageRequest } from './images-D5kpqHxv.js';
-import { R as RequestError, b as RequestErrorKind } from './request-error-D_dUPLwo.js';
-
-/** Older releases did not record ownership. Preserve every value, including defaults. */
-declare function questConfiguration(release: PublishedRelease): {
-    defaults: Record<string, string | number | boolean | {
-        id: string;
-        prompt: string;
-        choices: {
-            id: string;
-            label: string;
-        }[];
-        correct: string;
-    }[]>;
-    overrides: Record<string, string | number | boolean | {
-        id: string;
-        prompt: string;
-        choices: {
-            id: string;
-            label: string;
-        }[];
-        correct: string;
-    }[]>;
-    preserved: string[];
-};
-
-declare const identityIntegrationInputSchema: z.ZodObject<{
-    name: z.ZodString;
-    origin: z.ZodString;
-    identityKind: z.ZodOptional<z.ZodTemplateLiteral<`app:${string}`>>;
-    adoptIdentitiesFrom: z.ZodOptional<z.ZodString>;
-    reason: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-/** An integration as responses return it: fields a newer Relay adds are ignored. */
-declare const identityIntegrationSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    origin: z.ZodString;
-    expiresAt: z.ZodNumber;
-    identityKind: z.ZodDefault<z.ZodNullable<z.ZodType<OpenIdentityKind, unknown, z.core.$ZodTypeInternals<OpenIdentityKind, unknown>>>>;
-    organization: z.ZodString;
-    project: z.ZodString;
-    environment: z.ZodEnum<{
-        test: "test";
-        live: "live";
-    }>;
-}, z.core.$strip>;
-declare const identityIntegrationSecretSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    origin: z.ZodString;
-    expiresAt: z.ZodNumber;
-    identityKind: z.ZodDefault<z.ZodNullable<z.ZodType<OpenIdentityKind, unknown, z.core.$ZodTypeInternals<OpenIdentityKind, unknown>>>>;
-    organization: z.ZodString;
-    project: z.ZodString;
-    environment: z.ZodEnum<{
-        test: "test";
-        live: "live";
-    }>;
-    token: z.ZodString;
-}, z.core.$strip>;
-/**
- * An `app:<name>` kind claimed in the project and environment, and the integration that owns its
- * identities: the live one, or the disconnected one a new integration would adopt them from.
- */
-declare const identityKindClaimSchema: z.ZodObject<{
-    kind: z.ZodType<OpenIdentityKind, unknown, z.core.$ZodTypeInternals<OpenIdentityKind, unknown>>;
-    integration: z.ZodString;
-    integrationName: z.ZodString;
-    connected: z.ZodBoolean;
-    linked: z.ZodNumber;
-    unlinked: z.ZodNumber;
-    claimedAt: z.ZodNumber;
-}, z.core.$strip>;
-type IdentityKindClaim = z.infer<typeof identityKindClaimSchema>;
-declare const participantExchangeSchema: z.ZodObject<{
-    subject: z.ZodString;
-    previousToken: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-
-/** Every declared field is present with its declared type or null; nothing else is returned. */
-declare function parseImageExtraction(raw: ImageFields, value: unknown): {
-    values: Record<string, string | number | boolean | null>;
-    reason: string;
-};
-declare function parseImageResult(request: ImageRequest, value: unknown): {
-    kind: "pass" | "fail" | "unclear";
-    reason: string;
-} | {
-    width: number;
-    height: number;
-    format: "jpeg" | "png" | "webp" | "gif" | "avif";
-    bytes: number;
-    sha256: string;
-    phash: string;
-    dhash: string;
-} | {
-    identical: boolean;
-    phashDistance: number;
-    dhashDistance: number;
-} | {
-    values: Record<string, string | number | boolean | null>;
-    reason: string;
-} | {
-    matches: number;
-    closestDistance: number | null;
-    firstSeenAt: number | null;
-};
-
-/**
- * One participant route. `path` uses the API's route syntax: every parameter is `:name{pattern}`,
- * one path segment matched by `pattern`.
- */
-type ParticipantRoute = {
-    method: "GET" | "POST";
-    path: `/v1/${string}`;
-    /**
-     * Sign-in routes only hosted apps reach: identity integrations' apps have their own login. They
-     * still connect accounts through /v1/auth/start and /v1/auth/complete.
-     */
-    hostedOnly?: true;
-};
-declare const participantRoutes: readonly ParticipantRoute[];
-/**
- * The expression a route path matches: its literal parts exactly, each `:name{pattern}` one path
- * segment. A parameter whose pattern can match "/" would span segments, so it is refused, as is a
- * parameter without a pattern.
- */
-declare function participantRoutePattern(path: string): RegExp;
-/**
- * A route a hosted app reaches through `proxyParticipant`: exactly a listed method and path.
- * Another method on a listed path is not a participant route either.
- */
-declare function isParticipantRoute(path: string, method: string): boolean;
-/**
- * A path an identity integration reaches, with any method: the API answers a method its route
- * does not register with 405, and OPTIONS with the route's `Allow` header. Sign-in routes are
- * hosted-only.
- */
-declare function isIntegrationParticipantPath(path: string): boolean;
-
-/**
- * How a management call failed, as in every Domino client error (see `RequestError`):
- * - `http`: the server answered with an error status. `message`, `code` and `details` are its own.
- * - `network`: no usable answer arrived: the connection failed before a response, or broke while
- *   the body was read.
- * - `timeout`: the call's deadline passed (`timeout`, 30 seconds unless the client or call sets
- *   another), retries included.
- * - `aborted`: the caller's `signal` cancelled the call.
- * - `invalid-response`: the server answered 2xx, but the body was not JSON or did not match the
- *   response this client expects.
- * - `client`: the call never left: its input, its options or the client's `getToken` failed.
- */
-type ManagementErrorKind = RequestErrorKind;
-/** The codes the client itself sets; with kind `http`, `code` is the server's own. */
-declare const ManagementErrorCode: {
-    /** The input or an option failed validation before anything was sent (kind `client`). */
-    readonly InvalidInput: "invalid-input";
-    /** The client's `getToken` failed before anything was sent (kind `client` or `network`). */
-    readonly Credential: "credential";
-    readonly Network: "network";
-    readonly Timeout: "timeout";
-    readonly Aborted: "aborted";
-    readonly InvalidResponse: "invalid-response";
-};
-/**
- * The management API's error body: the message in `error`, a machine-readable `code`, and any
- * other fields (such as `moved`), which a `ManagementError` keeps as `details`. `code` is open:
- * the API adds codes over time, and a client keeps one it does not know.
- */
-declare const managementErrorSchema: z.ZodObject<{
-    error: z.ZodString;
-    code: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>;
-type ManagementErrorInit = {
-    kind: ManagementErrorKind;
-    message: string;
-    /** The request's method and path, once a request was formed. */
-    method?: string;
-    path?: string;
-    status?: number;
-    code?: string;
-    details?: Record<string, unknown>;
-    /** The action ID the request body carried; the error reports it as `operationId`. */
-    actionId?: string;
-    /** Whether the route keeps a receipt that makes repeating the action safe. */
-    replaySafe?: boolean;
-    /** Overrides the default: set false when the request was never sent. */
-    uncertain?: boolean;
-    /** The answer's `Retry-After`, in milliseconds. */
-    retryAfter?: number;
-    cause?: unknown;
-};
-declare const managementErrorBrand: unique symbol;
-/** Whether `value` is a `ManagementError` from any copy of the SDK. Prefer it to `instanceof`. */
-declare function isManagementError(value: unknown): value is ManagementError;
-/**
- * Every failure of a typed management call, including input refused before sending (`client`):
- * the shared `RequestError` fields, plus the request's `method`, `path` and the server's `details`.
- *
- * When `uncertain` is true, a write may have been applied, and `recovery` says what to do:
- * `replay` repeats the same call with the same `operationId` (the request's `actionId`), which the
- * server applies at most once; `reconcile` reads the resource before deciding.
- *
- * @compat sealed
- */
-declare class ManagementError extends RequestError {
-    readonly name: string;
-    readonly [managementErrorBrand] = true;
-    /** The rest of the server's error body besides `error` and `code`, such as `moved`; absent when there is none. */
-    readonly details: Readonly<Record<string, unknown>> | undefined;
-    /** The request's method; absent when the call failed before forming a request. */
-    readonly method: string | undefined;
-    /** The management API path, below `/management/v1`, without its query; absent like `method`. */
-    readonly path: string | undefined;
-    constructor(init: ManagementErrorInit);
-}
-/**
- * Per-call options every typed management method accepts as its last argument.
- *
- * @compat input
- */
-type ManagementCallOptions = {
-    /**
-     * Cancels the call; it then fails with a `ManagementError` of kind `aborted`. Cancelling stops
-     * any retry; a write already sent stays `uncertain`, since the server may have applied it.
-     */
-    signal?: AbortSignal;
-    /**
-     * The call's deadline in milliseconds, covering every attempt, the waits between them and the
-     * answer's body. Replaces the client's `timeout` for this call.
-     */
-    timeout?: number;
-};
-/** The deadline a call gets when neither the client nor the call sets `timeout`. */
-declare const DEFAULT_MANAGEMENT_TIMEOUT = 30000;
-
-/**
- * How Relay reads back a cursor it issued over a numeric position. Clients treat cursors as
- * opaque strings (`pageCursorSchema`); only the server parses them, so the format can change.
- */
-declare const sequenceCursorSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>;
-
-/** The account roles a source's records can name: `author` and any others the source declares. */
-declare function sourceRoles(source: TrackerSourceResponse): readonly string[];
-/**
- * The schema a source's record `data` matches: a custom source's declared schema, a Discord
- * source's fixed one, or undefined for X (provider payloads) and untyped custom trackers.
- */
-declare function sourceDataSchema(source: TrackerSource): TrackerDataSchema | undefined;
-
-/** Rules independent of published resources, permissions and another release. */
-type QuestShape = Pick<QuestDescription, "trigger" | "performance"> & {
-    completion: Pick<QuestDescription["completion"], "kind">;
-    requires: readonly unknown[];
-};
-/** The same trigger/completion matrix for authoring, publication and graph validation. */
-declare function validateQuestShape(description: QuestShape, options?: {
-    template?: boolean;
-}): void;
-
-declare const REFERRAL_INTEGRATION_REWARD_ERROR = "Referral programs can grant points and tiered rewards; Discord roles need a quest";
-/** Detect the unsupported reward in loose authoring, published, or reward-list shapes. */
-declare function containsReferralIntegrationReward(value: unknown): boolean;
-
-export { DEFAULT_MANAGEMENT_TIMEOUT as D, type IdentityKindClaim as I, type ManagementCallOptions as M, type ParticipantRoute as P, REFERRAL_INTEGRATION_REWARD_ERROR as R, identityIntegrationSchema as a, identityIntegrationSecretSchema as b, containsReferralIntegrationReward as c, identityKindClaimSchema as d, isIntegrationParticipantPath as e, isParticipantRoute as f, parseImageResult as g, participantExchangeSchema as h, identityIntegrationInputSchema as i, participantRoutePattern as j, participantRoutes as k, sourceDataSchema as l, sourceRoles as m, ManagementError as n, ManagementErrorCode as o, parseImageExtraction as p, questConfiguration as q, type ManagementErrorInit as r, sequenceCursorSchema as s, type ManagementErrorKind as t, isManagementError as u, validateQuestShape as v, managementErrorSchema as w };