@inline-chat/realtime-sdk 0.0.1

package/dist/sdk/types.d.ts

@@ -0,0 +1,177 @@
+import type { Message, Peer, Reaction, RpcCall, RpcResult, Update, UpdateBucket, UpdatesPayload } from "@inline-chat/protocol/core";
+import type { InlineId } from "../ids.js";
+import type { InlineUnixSeconds } from "../time.js";
+import type { InlineSdkLogger } from "./logger.js";
+import type { Transport } from "../realtime/transport.js";
+export type InlineSdkClientOptions = {
+    baseUrl?: string;
+    token: string;
+    logger?: InlineSdkLogger;
+    state?: InlineSdkStateStore;
+    transport?: Transport;
+};
+export type InlineInboundEvent = {
+    kind: "message.new";
+    chatId: InlineId;
+    message: Message;
+    seq: number;
+    date: InlineUnixSeconds;
+} | {
+    kind: "message.edit";
+    chatId: InlineId;
+    message: Message;
+    seq: number;
+    date: InlineUnixSeconds;
+} | {
+    kind: "message.delete";
+    chatId: InlineId;
+    messageIds: InlineId[];
+    seq: number;
+    date: InlineUnixSeconds;
+} | {
+    kind: "reaction.add";
+    chatId: InlineId;
+    reaction: Reaction;
+    seq: number;
+    date: InlineUnixSeconds;
+} | {
+    kind: "reaction.delete";
+    chatId: InlineId;
+    emoji: string;
+    messageId: InlineId;
+    userId: InlineId;
+    seq: number;
+    date: InlineUnixSeconds;
+} | {
+    kind: "chat.hasUpdates";
+    chatId: InlineId;
+    seq: number;
+    date: InlineUnixSeconds;
+} | {
+    kind: "space.hasUpdates";
+    spaceId: InlineId;
+    seq: number;
+    date: InlineUnixSeconds;
+};
+export type InlineSdkState = {
+    version: 1;
+    dateCursor?: InlineUnixSeconds;
+    lastSeqByChatId?: Record<string, number>;
+};
+export interface InlineSdkStateStore {
+    load(): Promise<InlineSdkState | null>;
+    save(next: InlineSdkState): Promise<void>;
+}
+export type RpcInputKind = RpcCall["input"]["oneofKind"];
+export type RpcResultKind = RpcResult["result"]["oneofKind"];
+export declare const rpcInputKindByMethod: {
+    readonly 0: undefined;
+    readonly 1: "getMe";
+    readonly 2: "sendMessage";
+    readonly 3: "getPeerPhoto";
+    readonly 4: "deleteMessages";
+    readonly 5: "getChatHistory";
+    readonly 6: "addReaction";
+    readonly 7: "deleteReaction";
+    readonly 8: "editMessage";
+    readonly 9: "createChat";
+    readonly 10: "getSpaceMembers";
+    readonly 11: "deleteChat";
+    readonly 12: "inviteToSpace";
+    readonly 13: "getChatParticipants";
+    readonly 14: "addChatParticipant";
+    readonly 15: "removeChatParticipant";
+    readonly 16: "translateMessages";
+    readonly 17: "getChats";
+    readonly 18: "updateUserSettings";
+    readonly 19: "getUserSettings";
+    readonly 20: "sendComposeAction";
+    readonly 21: "createBot";
+    readonly 22: "deleteMember";
+    readonly 23: "markAsUnread";
+    readonly 24: "getUpdatesState";
+    readonly 25: "getChat";
+    readonly 26: "getUpdates";
+    readonly 27: "updateMemberAccess";
+    readonly 28: "searchMessages";
+    readonly 29: "forwardMessages";
+    readonly 30: "updateChatVisibility";
+    readonly 31: "pinMessage";
+    readonly 32: "updateChatInfo";
+    readonly 33: "listBots";
+    readonly 34: "revealBotToken";
+    readonly 35: "moveThread";
+};
+export declare const rpcResultKindByMethod: {
+    readonly 0: undefined;
+    readonly 1: "getMe";
+    readonly 2: "sendMessage";
+    readonly 3: "getPeerPhoto";
+    readonly 4: "deleteMessages";
+    readonly 5: "getChatHistory";
+    readonly 6: "addReaction";
+    readonly 7: "deleteReaction";
+    readonly 8: "editMessage";
+    readonly 9: "createChat";
+    readonly 10: "getSpaceMembers";
+    readonly 11: "deleteChat";
+    readonly 12: "inviteToSpace";
+    readonly 13: "getChatParticipants";
+    readonly 14: "addChatParticipant";
+    readonly 15: "removeChatParticipant";
+    readonly 16: "translateMessages";
+    readonly 17: "getChats";
+    readonly 18: "updateUserSettings";
+    readonly 19: "getUserSettings";
+    readonly 20: "sendComposeAction";
+    readonly 21: "createBot";
+    readonly 22: "deleteMember";
+    readonly 23: "markAsUnread";
+    readonly 24: "getUpdatesState";
+    readonly 25: "getChat";
+    readonly 26: "getUpdates";
+    readonly 27: "updateMemberAccess";
+    readonly 28: "searchMessages";
+    readonly 29: "forwardMessages";
+    readonly 30: "updateChatVisibility";
+    readonly 31: "pinMessage";
+    readonly 32: "updateChatInfo";
+    readonly 33: "listBots";
+    readonly 34: "revealBotToken";
+    readonly 35: "moveThread";
+};
+type RpcInputKindByMethod = typeof rpcInputKindByMethod;
+type RpcResultKindByMethod = typeof rpcResultKindByMethod;
+export type MappedMethod = keyof RpcInputKindByMethod & keyof RpcResultKindByMethod;
+export type RpcInputForMethod<M extends MappedMethod> = RpcInputKindByMethod[M] extends RpcInputKind ? Extract<RpcCall["input"], {
+    oneofKind: RpcInputKindByMethod[M];
+}> : Extract<RpcCall["input"], {
+    oneofKind: undefined;
+}>;
+export type RpcResultForMethod<M extends MappedMethod> = RpcResultKindByMethod[M] extends RpcResultKind ? Extract<RpcResult["result"], {
+    oneofKind: RpcResultKindByMethod[M];
+}> : Extract<RpcResult["result"], {
+    oneofKind: undefined;
+}>;
+export type RawUpdatesEvent = {
+    updates: UpdatesPayload;
+};
+export type UpdateHandlerContext = {
+    emit: (event: InlineInboundEvent) => Promise<void>;
+    catchUpChat?: (params: {
+        chatId: InlineId;
+        peer?: Peer;
+        updateSeq: number;
+        update: Update;
+    }) => Promise<void>;
+    catchUpSpace?: (params: {
+        spaceId: InlineId;
+        updateSeq: number;
+        update: Update;
+    }) => Promise<void>;
+    updateBucketForChat: (params: {
+        chatId: InlineId;
+        peer?: Peer;
+    }) => UpdateBucket;
+};
+export {};

package/dist/sdk/types.js

@@ -0,0 +1,76 @@
+export const rpcInputKindByMethod = {
+    0: undefined, // UNSPECIFIED
+    1: "getMe",
+    2: "sendMessage",
+    3: "getPeerPhoto",
+    4: "deleteMessages",
+    5: "getChatHistory",
+    6: "addReaction",
+    7: "deleteReaction",
+    8: "editMessage",
+    9: "createChat",
+    10: "getSpaceMembers",
+    11: "deleteChat",
+    12: "inviteToSpace",
+    13: "getChatParticipants",
+    14: "addChatParticipant",
+    15: "removeChatParticipant",
+    16: "translateMessages",
+    17: "getChats",
+    18: "updateUserSettings",
+    19: "getUserSettings",
+    20: "sendComposeAction",
+    21: "createBot",
+    22: "deleteMember",
+    23: "markAsUnread",
+    24: "getUpdatesState",
+    25: "getChat",
+    26: "getUpdates",
+    27: "updateMemberAccess",
+    28: "searchMessages",
+    29: "forwardMessages",
+    30: "updateChatVisibility",
+    31: "pinMessage",
+    32: "updateChatInfo",
+    33: "listBots",
+    34: "revealBotToken",
+    35: "moveThread",
+};
+export const rpcResultKindByMethod = {
+    0: undefined, // UNSPECIFIED
+    1: "getMe",
+    2: "sendMessage",
+    3: "getPeerPhoto",
+    4: "deleteMessages",
+    5: "getChatHistory",
+    6: "addReaction",
+    7: "deleteReaction",
+    8: "editMessage",
+    9: "createChat",
+    10: "getSpaceMembers",
+    11: "deleteChat",
+    12: "inviteToSpace",
+    13: "getChatParticipants",
+    14: "addChatParticipant",
+    15: "removeChatParticipant",
+    16: "translateMessages",
+    17: "getChats",
+    18: "updateUserSettings",
+    19: "getUserSettings",
+    20: "sendComposeAction",
+    21: "createBot",
+    22: "deleteMember",
+    23: "markAsUnread",
+    24: "getUpdatesState",
+    25: "getChat",
+    26: "getUpdates",
+    27: "updateMemberAccess",
+    28: "searchMessages",
+    29: "forwardMessages",
+    30: "updateChatVisibility",
+    31: "pinMessage",
+    32: "updateChatInfo",
+    33: "listBots",
+    34: "revealBotToken",
+    35: "moveThread",
+};

package/dist/state/json-file-state-store.d.ts

@@ -0,0 +1,7 @@
+import type { InlineSdkState, InlineSdkStateStore } from "../sdk/types.js";
+export declare class JsonFileStateStore implements InlineSdkStateStore {
+    private readonly path;
+    constructor(path: string);
+    load(): Promise<InlineSdkState | null>;
+    save(next: InlineSdkState): Promise<void>;
+}

package/dist/state/json-file-state-store.js

@@ -0,0 +1,25 @@
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { deserializeStateV1, serializeStateV1 } from "./serde.js";
+export class JsonFileStateStore {
+    path;
+    constructor(path) {
+        this.path = path;
+    }
+    async load() {
+        try {
+            const raw = await readFile(this.path, "utf8");
+            return deserializeStateV1(raw);
+        }
+        catch (error) {
+            // File missing or invalid: treat as no state.
+            return null;
+        }
+    }
+    async save(next) {
+        const tempPath = `${this.path}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        const payload = serializeStateV1(next);
+        await writeFile(tempPath, payload, "utf8");
+        // Best-effort atomic replace on most platforms (write temp in same directory, then rename).
+        await rename(tempPath, this.path);
+    }
+}

package/dist/state/serde.d.ts

@@ -0,0 +1,3 @@
+import type { InlineSdkState } from "../sdk/types.js";
+export declare const serializeStateV1: (state: InlineSdkState) => string;
+export declare const deserializeStateV1: (raw: string) => InlineSdkState;

package/dist/state/serde.js

@@ -0,0 +1,37 @@
+export const serializeStateV1 = (state) => {
+    const json = {
+        version: 1,
+        ...(state.dateCursor != null ? { dateCursor: state.dateCursor.toString() } : {}),
+        ...(state.lastSeqByChatId != null ? { lastSeqByChatId: state.lastSeqByChatId } : {}),
+    };
+    return JSON.stringify(json, null, 2);
+};
+export const deserializeStateV1 = (raw) => {
+    const parsed = JSON.parse(raw);
+    if (!isStateJsonV1(parsed)) {
+        throw new Error("invalid state json");
+    }
+    return {
+        version: 1,
+        ...(parsed.dateCursor != null ? { dateCursor: BigInt(parsed.dateCursor) } : {}),
+        ...(parsed.lastSeqByChatId != null ? { lastSeqByChatId: parsed.lastSeqByChatId } : {}),
+    };
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isStateJsonV1 = (value) => {
+    if (!isRecord(value))
+        return false;
+    if (value.version !== 1)
+        return false;
+    if (value.dateCursor != null && typeof value.dateCursor !== "string")
+        return false;
+    if (value.lastSeqByChatId != null) {
+        if (!isRecord(value.lastSeqByChatId))
+            return false;
+        for (const v of Object.values(value.lastSeqByChatId)) {
+            if (typeof v !== "number" || !Number.isFinite(v))
+                return false;
+        }
+    }
+    return true;
+};

package/dist/time.d.ts

@@ -0,0 +1,6 @@
+export type InlineUnixSeconds = bigint;
+export type InlineUnixSecondsLike = InlineUnixSeconds | number;
+export declare class InlineUnixSecondsError extends Error {
+    constructor(message: string);
+}
+export declare const asInlineUnixSeconds: (value: InlineUnixSecondsLike, fieldName?: string) => InlineUnixSeconds;

package/dist/time.js

@@ -0,0 +1,17 @@
+export class InlineUnixSecondsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InlineUnixSecondsError";
+    }
+}
+export const asInlineUnixSeconds = (value, fieldName = "unixSeconds") => {
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value !== "number") {
+        throw new InlineUnixSecondsError(`invalid ${fieldName}: expected number|bigint`);
+    }
+    if (!Number.isSafeInteger(value)) {
+        throw new InlineUnixSecondsError(`invalid ${fieldName}: number must be a safe integer`);
+    }
+    return BigInt(value);
+};

package/dist/utils/async-channel.d.ts

@@ -0,0 +1,8 @@
+export declare class AsyncChannel<T> implements AsyncIterable<T> {
+    private queue;
+    private resolvers;
+    private closed;
+    send(value: T): Promise<void>;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}

package/dist/utils/async-channel.js

@@ -0,0 +1,41 @@
+export class AsyncChannel {
+    queue = [];
+    resolvers = [];
+    closed = false;
+    async send(value) {
+        if (this.closed)
+            return;
+        const resolver = this.resolvers.shift();
+        if (resolver) {
+            resolver({ value, done: false });
+            return;
+        }
+        this.queue.push(value);
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const resolver of this.resolvers) {
+            resolver({ value: undefined, done: true });
+        }
+        this.resolvers = [];
+        this.queue = [];
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                if (this.queue.length > 0) {
+                    const value = this.queue.shift();
+                    return Promise.resolve({ value, done: false });
+                }
+                if (this.closed) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise((resolve) => {
+                    this.resolvers.push(resolve);
+                });
+            },
+        };
+    }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@inline-chat/realtime-sdk",
+  "version": "0.0.1",
+  "private": false,
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@inline-chat/protocol": "^0.0.1",
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "@types/ws": "^8.5.12",
+    "@vitest/coverage-v8": "4.0.16",
+    "typescript": "^5.8.3",
+    "vitest": "^4.0.16"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}