@relaymessenger/sdk 0.2.0 → 0.3.0-staging.1

package/dist/client.js

@@ -1,156 +1,532 @@
-import { RelayApiError, classifyRelayHttpStatus, isAbortError, } from "./errors.js";
-import { normalizeRelayBaseUrl } from "./url.js";
-async function readErrorDetail(response) {
-    try {
-        const body = (await response.json());
-        return {
-            ...(body?.error?.code ? { code: body.error.code } : {}),
-            ...(body?.error?.details ? { details: body.error.details } : {}),
-            message: body?.error?.message ?? body?.message ?? "",
-        };
-    }
-    catch {
-        return { message: "" };
+import { RelayAPIError, isAbortError } from "./errors.js";
+import { ChatsPage, MessagesPage } from "./pagination.js";
+import { Webhooks } from "./webhooks.js";
+import { runWebSocket, } from "./websocket.js";
+const delay = async (milliseconds, signal) => {
+    if (milliseconds <= 0)
+        return;
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, milliseconds);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        }, { once: true });
+    });
+};
+const pathID = (value) => encodeURIComponent(value);
+class Transport {
+    baseURL;
+    #apiKey;
+    #fetch;
+    #maxRetries;
+    #timeout;
+    #retryBaseDelayMs;
+    constructor(options) {
+        if (!options.apiKey?.trim())
+            throw new Error("Relay API key is required.");
+        this.baseURL = (options.baseURL ?? "https://api.relayapp.im").replace(/\/+$/, "");
+        this.#apiKey = options.apiKey;
+        this.#fetch = options.fetch ?? globalThis.fetch;
+        this.#maxRetries = options.maxRetries ?? 2;
+        this.#timeout = options.timeout ?? 15_000;
+        this.#retryBaseDelayMs = options.retryBaseDelayMs ?? 250;
     }
-}
-export function createRelayClient(options) {
-    if (!options.token.trim()) {
-        throw new Error("relay: Agent Token is required");
-    }
-    const baseUrl = normalizeRelayBaseUrl(options.baseUrl);
-    const fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
-    const requestTimeoutMs = options.requestTimeoutMs ?? 15_000;
-    const request = async (params) => {
-        const url = new URL(`${baseUrl}${params.path}`);
-        for (const [key, value] of Object.entries(params.query ?? {})) {
+    async request(request) {
+        const url = new URL(`${this.baseURL}${request.path}`);
+        for (const [name, value] of Object.entries(request.query ?? {})) {
             if (value !== undefined)
-                url.searchParams.set(key, String(value));
+                url.searchParams.set(name, String(value));
+        }
+        const maxRetries = request.options?.maxRetries ?? this.#maxRetries;
+        const mayRetry = request.retryable === true
+            || request.method === "GET"
+            || request.method === "PUT"
+            || request.method === "PATCH"
+            || request.method === "DELETE"
+            || request.idempotencyKey !== undefined;
+        for (let attempt = 0;; attempt += 1) {
+            const timeout = request.options?.timeout ?? this.#timeout;
+            const timeoutSignal = AbortSignal.timeout(timeout);
+            const signal = request.options?.signal
+                ? AbortSignal.any([request.options.signal, timeoutSignal])
+                : timeoutSignal;
+            const headers = new Headers(request.options?.headers);
+            headers.set("authorization", `Bearer ${this.#apiKey}`);
+            headers.set("accept", "application/json");
+            if (request.body !== undefined)
+                headers.set("content-type", "application/json");
+            if (request.idempotencyKey) {
+                headers.set("idempotency-key", request.idempotencyKey);
+            }
+            let response;
+            try {
+                response = await this.#fetch(url, {
+                    method: request.method,
+                    headers,
+                    ...(request.body === undefined
+                        ? {}
+                        : { body: JSON.stringify(request.body) }),
+                    signal,
+                });
+            }
+            catch (cause) {
+                if (request.options?.signal?.aborted)
+                    throw cause;
+                if (isAbortError(cause) && !timeoutSignal.aborted)
+                    throw cause;
+                const error = new RelayAPIError(timeoutSignal.aborted
+                    ? `Relay request timed out after ${timeout}ms.`
+                    : "Relay network request failed.", { cause });
+                if (!mayRetry || attempt >= maxRetries)
+                    throw error;
+                await delay(this.#retryBaseDelayMs * 2 ** attempt, request.options?.signal);
+                continue;
+            }
+            if (response.ok) {
+                if (response.status === 204)
+                    return undefined;
+                const text = await response.text();
+                return (text ? JSON.parse(text) : undefined);
+            }
+            const text = await response.text();
+            let body;
+            try {
+                body = text ? JSON.parse(text) : undefined;
+            }
+            catch {
+                body = undefined;
+            }
+            const retryAfter = body?.error?.retry_after
+                ?? Number(response.headers.get("retry-after") ?? NaN);
+            const error = new RelayAPIError(body?.error?.message
+                ?? `Relay request failed with HTTP ${response.status}.`, {
+                status: response.status,
+                ...(body?.error?.code === undefined ? {} : { code: body.error.code }),
+                ...(body?.trace_id === undefined ? {} : { traceId: body.trace_id }),
+                ...(body?.error?.doc_url === undefined
+                    ? {}
+                    : { docURL: body.error.doc_url }),
+                ...(Number.isFinite(retryAfter) ? { retryAfter } : {}),
+                body: body ?? text,
+            });
+            if (!mayRetry || !error.retryable || attempt >= maxRetries)
+                throw error;
+            const wait = Number.isFinite(retryAfter)
+                ? retryAfter * 1_000
+                : this.#retryBaseDelayMs * 2 ** attempt;
+            await delay(wait, request.options?.signal);
+        }
+    }
+    async upload(allocation, data, options = {}) {
+        const headers = new Headers(allocation.required_headers);
+        for (const [name, value] of new Headers(options.headers)) {
+            headers.set(name, value);
         }
-        const timeoutSignal = AbortSignal.timeout(params.timeoutMs ?? requestTimeoutMs);
-        const signal = params.signal
-            ? AbortSignal.any([params.signal, timeoutSignal])
-            : timeoutSignal;
         let response;
         try {
-            response = await fetchImpl(url.toString(), {
-                method: params.method,
-                headers: {
-                    authorization: `Bearer ${options.token}`,
-                    ...(params.body === undefined ? {} : { "content-type": "application/json" }),
-                    ...params.headers,
-                },
-                ...(params.body === undefined ? {} : { body: JSON.stringify(params.body) }),
-                signal,
+            response = await this.#fetch(allocation.upload_url, {
+                method: "PUT",
+                headers,
+                body: data,
+                ...(options.signal ? { signal: options.signal } : {}),
             });
         }
-        catch (error) {
-            if (timeoutSignal.aborted && !params.signal?.aborted) {
-                throw new RelayApiError(`relay: ${params.method} ${params.path} timed out after ${params.timeoutMs ?? requestTimeoutMs}ms`, { kind: "retryable" });
-            }
-            if (isAbortError(error))
-                throw error;
-            throw new RelayApiError(`relay: network error: ${String(error)}`, {
-                kind: "retryable",
-            });
+        catch (cause) {
+            throw new RelayAPIError("Relay attachment upload failed.", { cause });
         }
         if (!response.ok) {
-            const detail = await readErrorDetail(response);
-            throw new RelayApiError(`relay: ${params.method} ${params.path} failed with ${response.status}${detail.message ? `: ${detail.message}` : ""}`, {
-                status: response.status,
-                kind: classifyRelayHttpStatus(response.status),
-                ...(detail.code ? { code: detail.code } : {}),
-                ...(detail.details ? { details: detail.details } : {}),
-            });
+            throw new RelayAPIError(`Relay attachment upload failed with HTTP ${response.status}.`, { status: response.status });
         }
-        return response;
-    };
-    const client = {
-        baseUrl,
-        getMe: async (params) => {
-            const response = await request({
-                method: "GET",
-                path: "/v1/agents/me",
-                ...(params?.signal ? { signal: params.signal } : {}),
-            });
-            const body = (await response.json());
-            return body.agent;
-        },
-        pollEvents: async (params) => {
-            const timeoutSeconds = Math.min(Math.max(params.timeoutSeconds ?? 30, 1), 30);
-            const response = await request({
-                method: "GET",
-                path: "/v1/events",
-                query: {
-                    cursor: params.cursor,
-                    timeout: timeoutSeconds,
-                    ...(params.limit === undefined ? {} : { limit: params.limit }),
-                },
-                ...(params.signal ? { signal: params.signal } : {}),
-                timeoutMs: (timeoutSeconds + 15) * 1_000,
-            });
-            const body = (await response.json());
-            const events = Array.isArray(body.events) ? body.events : [];
-            const nextCursor = typeof body.next_cursor === "number" && Number.isSafeInteger(body.next_cursor)
-                ? body.next_cursor
-                : params.cursor;
-            return { events, nextCursor };
-        },
-        sendMessage: async (params) => {
-            const response = await request({
-                method: "POST",
-                path: "/v1/messages",
-                headers: { "idempotency-key": params.idempotencyKey },
-                body: {
-                    conversation_id: params.conversationId,
-                    parts: params.parts,
-                    ...(params.invocationId ? { invocation_id: params.invocationId } : {}),
-                    ...(params.replyTo ? { reply_to: params.replyTo } : {}),
-                },
-                ...(params.signal ? { signal: params.signal } : {}),
-            });
-            const body = (await response.json());
-            return { messages: body.messages };
-        },
-        sendText: async (params) => {
-            const { text, ...rest } = params;
-            return client.sendMessage({
-                ...rest,
-                parts: [{ type: "text", text }],
-            });
-        },
-        setTyping: async (params) => {
-            await request({
-                method: "POST",
-                path: `/v1/conversations/${encodeURIComponent(params.conversationId)}/typing`,
-                body: {
-                    started: params.started,
-                    ...(params.label ? { label: params.label } : {}),
-                    ...(params.invocationId ? { invocation_id: params.invocationId } : {}),
-                },
-                ...(params.signal ? { signal: params.signal } : {}),
-            });
-        },
-        setResponding: async (params) => {
-            await request({
-                method: "POST",
-                path: `/v1/conversations/${encodeURIComponent(params.conversationId)}/responding`,
-                body: {
-                    message_id: params.messageId,
-                    ...(params.label ? { label: params.label } : {}),
-                    ...(params.invocationId ? { invocation_id: params.invocationId } : {}),
-                },
-                ...(params.signal ? { signal: params.signal } : {}),
-            });
-        },
-        markRead: async (params) => {
-            await request({
-                method: "POST",
-                path: `/v1/conversations/${encodeURIComponent(params.conversationId)}/read`,
-                body: { message_id: params.messageId },
-                ...(params.signal ? { signal: params.signal } : {}),
-            });
-        },
-    };
-    return client;
+    }
+    runWebSocket(options) {
+        return runWebSocket(this.baseURL, this.#apiKey, options);
+    }
+}
+class ChatMessages {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async list(chatID, query = {}, options) {
+        const body = await this.transport.request({
+            method: "GET",
+            path: `/v1/chats/${pathID(chatID)}/messages`,
+            query,
+            options,
+        });
+        return new MessagesPage({ data: body.messages, nextCursor: body.next_cursor ?? null }, (cursor) => this.list(chatID, { ...query, cursor }, options));
+    }
+    send(chatID, body, options) {
+        return this.transport.request({
+            method: "POST",
+            path: `/v1/chats/${pathID(chatID)}/messages`,
+            body,
+            options,
+            ...(body.message.idempotency_key
+                ? { idempotencyKey: body.message.idempotency_key }
+                : {}),
+        });
+    }
+}
+class ChatParticipants {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    add(chatID, body, options) {
+        return this.transport.request({
+            method: "POST",
+            path: `/v1/chats/${pathID(chatID)}/participants`,
+            body,
+            options,
+        });
+    }
+    remove(chatID, body, options) {
+        return this.transport.request({
+            method: "DELETE",
+            path: `/v1/chats/${pathID(chatID)}/participants`,
+            body,
+            options,
+        });
+    }
+}
+export class Chats {
+    transport;
+    messages;
+    participants;
+    constructor(transport) {
+        this.transport = transport;
+        this.messages = new ChatMessages(transport);
+        this.participants = new ChatParticipants(transport);
+    }
+    create(body, options) {
+        return this.transport.request({
+            method: "POST",
+            path: "/v1/chats",
+            body,
+            options,
+            ...(body.message.idempotency_key
+                ? { idempotencyKey: body.message.idempotency_key }
+                : {}),
+        });
+    }
+    retrieve(chatID, options) {
+        return this.transport.request({
+            method: "GET",
+            path: `/v1/chats/${pathID(chatID)}`,
+            options,
+        });
+    }
+    update(chatID, body, options) {
+        return this.transport.request({
+            method: "PUT",
+            path: `/v1/chats/${pathID(chatID)}`,
+            body,
+            options,
+        });
+    }
+    async listChats(query = {}, options) {
+        const body = await this.transport.request({
+            method: "GET",
+            path: "/v1/chats",
+            query,
+            options,
+        });
+        return new ChatsPage({ data: body.chats, nextCursor: body.next_cursor ?? null }, (cursor) => this.listChats({ ...query, cursor }, options));
+    }
+    leaveChat(chatID, options) {
+        return this.transport.request({
+            method: "POST",
+            path: `/v1/chats/${pathID(chatID)}/leave`,
+            options,
+        });
+    }
+    startTyping(chatID, options) {
+        return this.transport.request({
+            method: "POST",
+            path: `/v1/chats/${pathID(chatID)}/typing`,
+            options,
+            retryable: true,
+        });
+    }
+    stopTyping(chatID, options) {
+        return this.transport.request({
+            method: "DELETE",
+            path: `/v1/chats/${pathID(chatID)}/typing`,
+            options,
+            retryable: true,
+        });
+    }
+    markAsRead(chatID, options) {
+        return this.transport.request({
+            method: "POST",
+            path: `/v1/chats/${pathID(chatID)}/read`,
+            options,
+            retryable: true,
+        });
+    }
+    shareContactCard(chatID, options) {
+        return this.transport.request({
+            method: "POST",
+            path: `/v1/chats/${pathID(chatID)}/share_contact_card`,
+            options,
+        });
+    }
+    sendVoicememo(chatID, body, options) {
+        return this.transport.request({
+            method: "POST",
+            path: `/v1/chats/${pathID(chatID)}/voicememo`,
+            body,
+            options,
+        });
+    }
+}
+export class Messages {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    create(params, options) {
+        const { "Idempotency-Key": headerKey, ...body } = params;
+        const idempotencyKey = headerKey ?? body.message.idempotency_key;
+        return this.transport.request({
+            method: "POST",
+            path: "/v1/messages",
+            body,
+            options,
+            ...(idempotencyKey ? { idempotencyKey } : {}),
+        });
+    }
+    retrieve(messageID, options) {
+        return this.transport.request({
+            method: "GET",
+            path: `/v1/messages/${pathID(messageID)}`,
+            options,
+        });
+    }
+    addReaction(messageID, body, options) {
+        return this.transport.request({
+            method: "POST",
+            path: `/v1/messages/${pathID(messageID)}/reactions`,
+            body,
+            options,
+        });
+    }
+    async listMessagesThread(messageID, query = {}, options) {
+        const body = await this.transport.request({
+            method: "GET",
+            path: `/v1/messages/${pathID(messageID)}/thread`,
+            query,
+            options,
+        });
+        return new MessagesPage({ data: body.messages, nextCursor: body.next_cursor ?? null }, (cursor) => this.listMessagesThread(messageID, { ...query, cursor }, options));
+    }
+}
+export class Attachments {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    create(body, options) {
+        return this.transport.request({
+            method: "POST",
+            path: "/v1/attachments",
+            body,
+            options,
+        });
+    }
+    retrieve(attachmentID, options) {
+        return this.transport.request({
+            method: "GET",
+            path: `/v1/attachments/${pathID(attachmentID)}`,
+            options,
+        });
+    }
+    delete(attachmentID, options) {
+        return this.transport.request({
+            method: "DELETE",
+            path: `/v1/attachments/${pathID(attachmentID)}`,
+            options,
+        });
+    }
+    upload(allocation, data, options) {
+        return this.transport.upload(allocation, data, options);
+    }
+}
+export class WebhookEvents {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    list(options) {
+        return this.transport.request({
+            method: "GET",
+            path: "/v1/webhook-events",
+            options,
+        });
+    }
+}
+export class WebhookSubscriptions {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    create(body, options) {
+        return this.transport.request({
+            method: "POST",
+            path: "/v1/webhook-subscriptions",
+            body,
+            options,
+        });
+    }
+    retrieve(subscriptionID, options) {
+        return this.transport.request({
+            method: "GET",
+            path: `/v1/webhook-subscriptions/${pathID(subscriptionID)}`,
+            options,
+        });
+    }
+    update(subscriptionID, body, options) {
+        return this.transport.request({
+            method: "PUT",
+            path: `/v1/webhook-subscriptions/${pathID(subscriptionID)}`,
+            body,
+            options,
+        });
+    }
+    list(options) {
+        return this.transport.request({
+            method: "GET",
+            path: "/v1/webhook-subscriptions",
+            options,
+        });
+    }
+    delete(subscriptionID, options) {
+        return this.transport.request({
+            method: "DELETE",
+            path: `/v1/webhook-subscriptions/${pathID(subscriptionID)}`,
+            options,
+        });
+    }
+}
+export class ContactCard {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    create(body, options) {
+        return this.transport.request({
+            method: "POST",
+            path: "/v1/contact_card",
+            body,
+            options,
+        });
+    }
+    retrieve(query = {}, options) {
+        return this.transport.request({
+            method: "GET",
+            path: "/v1/contact_card",
+            query,
+            options,
+        });
+    }
+    update(params, options) {
+        const { handle, ...body } = params;
+        return this.transport.request({
+            method: "PATCH",
+            path: "/v1/contact_card",
+            query: { handle },
+            body,
+            options,
+        });
+    }
+}
+export class ContactRequests {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    create(params, options) {
+        const { "Idempotency-Key": idempotencyKey, ...body } = params;
+        return this.transport.request({
+            method: "POST",
+            path: "/v1/contact_requests",
+            body,
+            options,
+            ...(idempotencyKey ? { idempotencyKey } : {}),
+        });
+    }
+}
+export class BlockedHandles {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    list(options) {
+        return this.transport.request({
+            method: "GET",
+            path: "/v1/blocked_handles",
+            options,
+        });
+    }
+    block(body, options) {
+        return this.transport.request({
+            method: "POST",
+            path: "/v1/blocked_handles",
+            body,
+            options,
+        });
+    }
+    unblock(body, options) {
+        return this.transport.request({
+            method: "DELETE",
+            path: "/v1/blocked_handles",
+            body,
+            options,
+        });
+    }
+}
+export class WebSocket {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /**
+     * Keeps one outbound WebSocket connection alive. `onEvent` must return
+     * only after the event is committed to a durable inbox; the SDK sends the
+     * cumulative ACK after that promise resolves. `onFullSync` must return only
+     * after a complete REST snapshot is durably applied.
+     */
+    run(options) {
+        return this.transport.runWebSocket(options);
+    }
+}
+export class Relay {
+    baseURL;
+    chats;
+    messages;
+    attachments;
+    webhookEvents;
+    webhookSubscriptions;
+    contactCard;
+    contactRequests;
+    blockedHandles;
+    websocket;
+    webhooks;
+    constructor(options) {
+        const transport = new Transport(options);
+        this.baseURL = transport.baseURL;
+        this.chats = new Chats(transport);
+        this.messages = new Messages(transport);
+        this.attachments = new Attachments(transport);
+        this.webhookEvents = new WebhookEvents(transport);
+        this.webhookSubscriptions = new WebhookSubscriptions(transport);
+        this.contactCard = new ContactCard(transport);
+        this.contactRequests = new ContactRequests(transport);
+        this.blockedHandles = new BlockedHandles(transport);
+        this.websocket = new WebSocket(transport);
+        this.webhooks = new Webhooks(options.webhookSecret ?? null);
+    }
 }
+export default Relay;
 //# sourceMappingURL=client.js.map