@inline-chat/realtime-sdk 0.0.1

package/dist/realtime/ws-transport.js

@@ -0,0 +1,147 @@
+import { WebSocket } from "ws";
+import { ClientMessage, ServerProtocolMessage } from "@inline-chat/protocol/core";
+import { AsyncChannel } from "../utils/async-channel.js";
+import { TransportError } from "./transport.js";
+export class WebSocketTransport {
+    events = new AsyncChannel();
+    url;
+    log;
+    state = "idle";
+    connectionAttemptNo = 0;
+    socket = null;
+    reconnectionTimer = null;
+    constructor(options) {
+        this.url = options.url;
+        this.log = options.logger ?? {};
+    }
+    async start() {
+        if (this.state !== "idle")
+            return;
+        await this.setConnecting();
+        await this.openConnection();
+    }
+    async stop() {
+        if (this.state === "idle")
+            return;
+        await this.setIdle();
+        this.cleanUpPreviousConnection();
+    }
+    async send(message) {
+        if (this.state !== "connected" || !this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw TransportError.notConnected();
+        }
+        this.socket.send(ClientMessage.toBinary(message));
+    }
+    async stopConnection() {
+        this.cleanUpPreviousConnection();
+    }
+    async reconnect(options) {
+        const skipDelay = options?.skipDelay ?? false;
+        await this.setConnecting();
+        this.cleanUpPreviousConnection();
+        this.connectionAttemptNo = (this.connectionAttemptNo + 1) >>> 0;
+        const delaySeconds = this.getReconnectionDelaySeconds(this.connectionAttemptNo);
+        this.log.debug?.("reconnect scheduled", { attempt: this.connectionAttemptNo, delaySeconds });
+        this.reconnectionTimer = setTimeout(() => {
+            this.reconnectionTimer = null;
+            if (this.state === "idle" || this.state === "connected")
+                return;
+            void this.openConnection();
+        }, skipDelay ? 0 : delaySeconds * 1000);
+    }
+    cleanUpPreviousConnection() {
+        if (this.reconnectionTimer) {
+            clearTimeout(this.reconnectionTimer);
+            this.reconnectionTimer = null;
+        }
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.close();
+            this.socket = null;
+        }
+    }
+    getReconnectionDelaySeconds(attemptNo) {
+        // Exponential-ish backoff with jitter.
+        // Cap quickly so callers don't stall for too long.
+        const base = Math.min(8.0, 0.2 + Math.pow(attemptNo, 1.5) * 0.4);
+        const jitter = attemptNo >= 8 ? Math.random() * 4.0 : 0;
+        return base + jitter;
+    }
+    async openConnection() {
+        if (this.state === "idle")
+            return;
+        const socket = new WebSocket(this.url);
+        this.socket = socket;
+        socket.on("open", () => {
+            void this.connectionDidOpen(socket);
+        });
+        socket.on("message", (data) => {
+            void this.handleMessage(socket, data);
+        });
+        socket.on("close", (code, reason) => {
+            void this.handleClose(socket, code, reason);
+        });
+        socket.on("error", (error) => {
+            void this.handleError(socket, error);
+        });
+    }
+    async connectionDidOpen(socket) {
+        if (this.socket !== socket)
+            return;
+        if (this.state !== "connecting")
+            return;
+        this.connectionAttemptNo = 0;
+        this.state = "connected";
+        await this.events.send({ type: "connected" });
+    }
+    async handleMessage(socket, data) {
+        if (this.socket !== socket)
+            return;
+        try {
+            const payload = this.coerceBinary(data);
+            const message = ServerProtocolMessage.fromBinary(payload);
+            await this.events.send({ type: "message", message });
+        }
+        catch (error) {
+            this.log.error?.("Failed to decode message", error);
+        }
+    }
+    coerceBinary(data) {
+        if (data instanceof ArrayBuffer)
+            return new Uint8Array(data);
+        // Covers Buffer and other typed-array views.
+        if (ArrayBuffer.isView(data))
+            return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        if (Array.isArray(data))
+            return new Uint8Array(Buffer.concat(data));
+        throw new Error("Unsupported WebSocket message payload");
+    }
+    async handleClose(socket, code, reason) {
+        if (this.socket !== socket)
+            return;
+        if (this.state === "idle")
+            return;
+        this.log.warn?.("WebSocket closed", { code, reason: reason.toString("utf8") });
+        await this.reconnect();
+    }
+    async handleError(socket, error) {
+        if (this.socket !== socket)
+            return;
+        if (this.state === "idle")
+            return;
+        this.log.error?.("WebSocket error", error);
+        await this.reconnect();
+    }
+    async setIdle() {
+        if (this.state === "idle")
+            return;
+        this.state = "idle";
+        await this.events.send({ type: "stopping" });
+    }
+    async setConnecting() {
+        if (this.state === "connecting")
+            return;
+        this.state = "connecting";
+        await this.events.send({ type: "connecting" });
+    }
+}

package/dist/sdk/inline-sdk-client.d.ts

@@ -0,0 +1,79 @@
+import { MessageEntities, Method, type Peer, type RpcCall, type RpcResult } from "@inline-chat/protocol/core";
+import { type InlineIdLike } from "../ids.js";
+import type { InlineSdkClientOptions, InlineInboundEvent, InlineSdkState, MappedMethod, RpcInputForMethod, RpcResultForMethod } from "./types.js";
+type SendMessageTarget = {
+    chatId: InlineIdLike;
+    userId?: never;
+} | {
+    userId: InlineIdLike;
+    chatId?: never;
+};
+export declare class InlineSdkClient {
+    private readonly options;
+    private readonly log;
+    private readonly transport;
+    private readonly protocol;
+    private readonly eventStream;
+    private started;
+    private openPromise;
+    private openResolver;
+    private openRejecter;
+    private state;
+    private saveTimer;
+    private saveInFlight;
+    private catchUpInFlightByChatId;
+    constructor(options: InlineSdkClientOptions);
+    connect(signal?: AbortSignal): Promise<void>;
+    close(): Promise<void>;
+    private rejectOpen;
+    events(): AsyncIterable<InlineInboundEvent>;
+    exportState(): InlineSdkState;
+    getMe(): Promise<{
+        userId: bigint;
+    }>;
+    getChat(params: {
+        chatId: InlineIdLike;
+    }): Promise<{
+        chatId: bigint;
+        peer?: Peer;
+        title: string;
+    }>;
+    sendMessage(params: SendMessageTarget & {
+        text: string;
+        replyToMsgId?: InlineIdLike;
+        parseMarkdown?: boolean;
+        sendMode?: "silent";
+        entities?: MessageEntities;
+    }): Promise<{
+        messageId: bigint | null;
+    }>;
+    sendTyping(params: {
+        chatId: InlineIdLike;
+        typing: boolean;
+    }): Promise<void>;
+    invokeRaw(method: Method, input?: RpcCall["input"], options?: {
+        timeoutMs?: number;
+    }): Promise<RpcResult["result"]>;
+    invokeUncheckedRaw(method: Method, input?: RpcCall["input"], options?: {
+        timeoutMs?: number;
+    }): Promise<RpcResult["result"]>;
+    invoke<M extends MappedMethod>(method: M, input: RpcInputForMethod<M>, options?: {
+        timeoutMs?: number;
+    }): Promise<RpcResultForMethod<M>>;
+    private assertMethodInputMatch;
+    private assertMethodResultMatch;
+    private startListeners;
+    private onOpen;
+    private initializeDateCursor;
+    private onUpdates;
+    private handleUpdate;
+    private bumpChatSeq;
+    private catchUpChat;
+    private doCatchUpChat;
+    private peerToInputPeer;
+    private inputPeerFromTarget;
+    private loadState;
+    private scheduleStateSave;
+    private flushStateSave;
+}
+export {};