@inline-chat/realtime-sdk 0.0.1 → 0.0.2

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { InlineSdkClient } from "./sdk/inline-sdk-client.js";
-export type { InlineSdkClientOptions, InlineSdkState, InlineSdkStateStore, InlineInboundEvent, RpcInputForMethod, RpcResultForMethod, } from "./sdk/types.js";
+export type { InlineSdkClientOptions, InlineSdkSendMessageMedia, InlineSdkSendMessageParams, InlineSdkState, InlineSdkStateStore, InlineSdkUploadFileParams, InlineSdkUploadFileResult, InlineSdkUploadFileType, InlineInboundEvent, RpcInputForMethod, RpcResultForMethod, } from "./sdk/types.js";
 export type { InlineSdkLogger } from "./sdk/logger.js";
 export { JsonFileStateStore } from "./state/json-file-state-store.js";
 export { serializeStateV1, deserializeStateV1 } from "./state/serde.js";

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

@@ -1,16 +1,11 @@
-import { MessageEntities, Method, type Peer, type RpcCall, type RpcResult } from "@inline-chat/protocol/core";
+import { 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;
-};
+import type { InlineSdkClientOptions, InlineInboundEvent, InlineSdkSendMessageParams, InlineSdkState, InlineSdkUploadFileParams, InlineSdkUploadFileResult, MappedMethod, RpcInputForMethod, RpcResultForMethod } from "./types.js";
 export declare class InlineSdkClient {
     private readonly options;
     private readonly log;
+    private readonly httpBaseUrl;
+    private readonly fetchImpl;
     private readonly transport;
     private readonly protocol;
     private readonly eventStream;
@@ -38,15 +33,10 @@ export declare class InlineSdkClient {
         peer?: Peer;
         title: string;
     }>;
-    sendMessage(params: SendMessageTarget & {
-        text: string;
-        replyToMsgId?: InlineIdLike;
-        parseMarkdown?: boolean;
-        sendMode?: "silent";
-        entities?: MessageEntities;
-    }): Promise<{
+    sendMessage(params: InlineSdkSendMessageParams): Promise<{
         messageId: bigint | null;
     }>;
+    uploadFile(params: InlineSdkUploadFileParams): Promise<InlineSdkUploadFileResult>;
     sendTyping(params: {
         chatId: InlineIdLike;
         typing: boolean;
@@ -76,4 +66,3 @@ export declare class InlineSdkClient {
     private scheduleStateSave;
     private flushStateSave;
 }
-export {};

package/dist/sdk/inline-sdk-client.js

@@ -1,4 +1,4 @@
-import { GetChatInput, GetMeInput, GetUpdatesInput, GetUpdatesResult_ResultType, GetUpdatesStateInput, InputPeer, MessageEntities, MessageSendMode, Method, UpdateBucket, UpdateComposeAction_ComposeAction, } from "@inline-chat/protocol/core";
+import { GetChatInput, GetMeInput, GetUpdatesInput, GetUpdatesResult_ResultType, GetUpdatesStateInput, InputPeer, MessageSendMode, Method, UpdateBucket, UpdateComposeAction_ComposeAction, } from "@inline-chat/protocol/core";
 import { asInlineId } from "../ids.js";
 import { AsyncChannel } from "../utils/async-channel.js";
 import { ProtocolClient } from "../realtime/protocol-client.js";
@@ -8,6 +8,10 @@ import { noopLogger } from "./logger.js";
 import { getSdkVersion } from "./sdk-version.js";
 const nowSeconds = () => BigInt(Math.floor(Date.now() / 1000));
 const sdkLayer = 1;
+const defaultApiBaseUrl = "https://api.inline.chat";
+const defaultVideoWidth = 1280;
+const defaultVideoHeight = 720;
+const defaultVideoDuration = 1;
 function extractFirstMessageId(updates) {
     for (const update of updates ?? []) {
         if (update.update.oneofKind === "newMessage") {
@@ -21,6 +25,8 @@ function extractFirstMessageId(updates) {
 export class InlineSdkClient {
     options;
     log;
+    httpBaseUrl;
+    fetchImpl;
     transport;
     protocol;
     eventStream = new AsyncChannel();
@@ -35,8 +41,9 @@ export class InlineSdkClient {
     constructor(options) {
         this.options = options;
         this.log = options.logger ?? noopLogger;
-        const baseUrl = options.baseUrl ?? "https://api.inline.chat";
-        const url = resolveRealtimeUrl(baseUrl);
+        this.httpBaseUrl = normalizeHttpBaseUrl(options.baseUrl ?? defaultApiBaseUrl);
+        this.fetchImpl = options.fetch ?? fetch;
+        const url = resolveRealtimeUrl(this.httpBaseUrl);
         this.transport = options.transport ?? new WebSocketTransport({ url, logger: options.logger });
         this.protocol = new ProtocolClient({
             transport: this.transport,
@@ -143,12 +150,24 @@ export class InlineSdkClient {
         if (params.entities != null && params.parseMarkdown != null) {
             throw new Error("sendMessage: provide either `entities` or `parseMarkdown`, not both");
         }
+        const hasText = typeof params.text === "string" && params.text.length > 0;
+        if (!hasText && params.media == null) {
+            throw new Error("sendMessage: provide `text` and/or `media`");
+        }
+        if (params.parseMarkdown != null && !hasText) {
+            throw new Error("sendMessage: `parseMarkdown` requires non-empty `text`");
+        }
+        if (params.entities != null && !hasText) {
+            throw new Error("sendMessage: `entities` requires non-empty `text`");
+        }
         const peerId = this.inputPeerFromTarget(params, "sendMessage");
+        const media = params.media != null ? toInputMedia(params.media) : undefined;
         const result = await this.invoke(Method.SEND_MESSAGE, {
             oneofKind: "sendMessage",
             sendMessage: {
                 peerId,
-                message: params.text,
+                ...(hasText ? { message: params.text } : {}),
+                ...(media != null ? { media } : {}),
                 ...(params.replyToMsgId != null ? { replyToMsgId: asInlineId(params.replyToMsgId, "replyToMsgId") } : {}),
                 ...(params.parseMarkdown != null ? { parseMarkdown: params.parseMarkdown } : {}),
                 ...(params.entities != null ? { entities: params.entities } : {}),
@@ -158,6 +177,59 @@ export class InlineSdkClient {
         const messageId = extractFirstMessageId(result.sendMessage.updates);
         return { messageId };
     }
+    async uploadFile(params) {
+        const form = new FormData();
+        form.set("type", params.type);
+        const fileName = normalizeUploadFileName(params.fileName, params.type);
+        const fileContentType = resolveUploadContentType(params.type, params.contentType);
+        form.set("file", toBlob(params.file, fileContentType), fileName);
+        if (params.thumbnail != null) {
+            const thumbnailName = normalizeUploadFileName(params.thumbnailFileName, "photo");
+            const thumbnailContentType = resolveUploadContentType("photo", params.thumbnailContentType);
+            form.set("thumbnail", toBlob(params.thumbnail, thumbnailContentType), thumbnailName);
+        }
+        if (params.type === "video") {
+            const width = normalizePositiveInt(params.width, "width") ?? defaultVideoWidth;
+            const height = normalizePositiveInt(params.height, "height") ?? defaultVideoHeight;
+            const duration = normalizePositiveInt(params.duration, "duration") ?? defaultVideoDuration;
+            form.set("width", String(width));
+            form.set("height", String(height));
+            form.set("duration", String(duration));
+        }
+        const response = await this.fetchImpl(new URL("uploadFile", `${this.httpBaseUrl}/`), {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.options.token}`,
+            },
+            body: form,
+        });
+        const payload = await parseJsonResponse(response);
+        if (!response.ok) {
+            const detail = describeUploadFailure(payload);
+            throw new Error(`uploadFile: request failed with status ${response.status}${detail ? ` (${detail})` : ""}`);
+        }
+        if (!isRecord(payload) || payload.ok !== true) {
+            const detail = describeUploadFailure(payload);
+            throw new Error(`uploadFile: API error${detail ? ` (${detail})` : ""}`);
+        }
+        const result = payload.result;
+        if (!isRecord(result)) {
+            throw new Error("uploadFile: malformed success payload");
+        }
+        const fileUniqueId = typeof result.fileUniqueId === "string" ? result.fileUniqueId.trim() : "";
+        if (!fileUniqueId) {
+            throw new Error("uploadFile: response missing fileUniqueId");
+        }
+        const photoId = parseOptionalBigInt(result.photoId, "photoId");
+        const videoId = parseOptionalBigInt(result.videoId, "videoId");
+        const documentId = parseOptionalBigInt(result.documentId, "documentId");
+        return {
+            fileUniqueId,
+            ...(photoId != null ? { photoId } : {}),
+            ...(videoId != null ? { videoId } : {}),
+            ...(documentId != null ? { documentId } : {}),
+        };
+    }
     async sendTyping(params) {
         const peerId = InputPeer.create({
             type: { oneofKind: "chat", chat: { chatId: asInlineId(params.chatId, "chatId") } },
@@ -530,6 +602,138 @@ export class InlineSdkClient {
         await this.saveInFlight;
     }
 }
+function toInputMedia(media) {
+    switch (media.kind) {
+        case "photo":
+            return {
+                media: {
+                    oneofKind: "photo",
+                    photo: {
+                        photoId: asInlineId(media.photoId, "photoId"),
+                    },
+                },
+            };
+        case "video":
+            return {
+                media: {
+                    oneofKind: "video",
+                    video: {
+                        videoId: asInlineId(media.videoId, "videoId"),
+                    },
+                },
+            };
+        case "document":
+            return {
+                media: {
+                    oneofKind: "document",
+                    document: {
+                        documentId: asInlineId(media.documentId, "documentId"),
+                    },
+                },
+            };
+    }
+}
+function normalizeHttpBaseUrl(baseUrl) {
+    const url = new URL(baseUrl);
+    const path = url.pathname.replace(/\/+$/, "");
+    url.pathname = path || "/";
+    return url.toString().replace(/\/$/, "");
+}
+function normalizeUploadFileName(raw, type) {
+    const trimmed = raw?.trim();
+    if (trimmed)
+        return trimmed;
+    switch (type) {
+        case "photo":
+            return "photo.jpg";
+        case "video":
+            return "video.mp4";
+        case "document":
+            return "document.bin";
+    }
+}
+function resolveUploadContentType(type, explicit) {
+    const trimmed = explicit?.trim();
+    if (trimmed)
+        return trimmed;
+    switch (type) {
+        case "photo":
+            return "image/jpeg";
+        case "video":
+            return "video/mp4";
+        case "document":
+            return "application/octet-stream";
+    }
+}
+function toBlob(input, type) {
+    if (input instanceof Blob) {
+        return input.type === type ? input : new Blob([input], { type });
+    }
+    return new Blob([input], { type });
+}
+function normalizePositiveInt(value, field) {
+    if (value == null)
+        return undefined;
+    if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+        throw new Error(`uploadFile: ${field} must be a positive integer`);
+    }
+    return value;
+}
+async function parseJsonResponse(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.includes("application/json")) {
+        const text = await response.text();
+        return text;
+    }
+    try {
+        return await response.json();
+    }
+    catch {
+        return null;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function describeUploadFailure(payload) {
+    if (typeof payload === "string") {
+        const trimmed = payload.trim();
+        return trimmed ? trimmed : "";
+    }
+    if (!isRecord(payload))
+        return "";
+    const description = typeof payload.description === "string" ? payload.description.trim() : "";
+    if (description)
+        return description;
+    const error = typeof payload.error === "string" ? payload.error.trim() : "";
+    if (error)
+        return error;
+    return "";
+}
+function parseOptionalBigInt(value, field) {
+    if (value == null)
+        return undefined;
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value) || !Number.isInteger(value) || !Number.isSafeInteger(value)) {
+            throw new Error(`uploadFile: invalid ${field} in response`);
+        }
+        return BigInt(value);
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return undefined;
+        try {
+            return BigInt(trimmed);
+        }
+        catch {
+            throw new Error(`uploadFile: invalid ${field} in response`);
+        }
+    }
+    throw new Error(`uploadFile: invalid ${field} in response`);
+}
 const resolveRealtimeUrl = (baseUrl) => {
     const url = new URL(baseUrl);
     const isSecure = url.protocol === "https:";

package/dist/sdk/types.d.ts

@@ -1,5 +1,5 @@
-import type { Message, Peer, Reaction, RpcCall, RpcResult, Update, UpdateBucket, UpdatesPayload } from "@inline-chat/protocol/core";
-import type { InlineId } from "../ids.js";
+import type { Message, MessageEntities, Peer, Reaction, RpcCall, RpcResult, Update, UpdateBucket, UpdatesPayload } from "@inline-chat/protocol/core";
+import type { InlineId, InlineIdLike } from "../ids.js";
 import type { InlineUnixSeconds } from "../time.js";
 import type { InlineSdkLogger } from "./logger.js";
 import type { Transport } from "../realtime/transport.js";
@@ -9,6 +9,56 @@ export type InlineSdkClientOptions = {
     logger?: InlineSdkLogger;
     state?: InlineSdkStateStore;
     transport?: Transport;
+    fetch?: typeof fetch;
+};
+export type InlineSdkSendMessageMedia = {
+    kind: "photo";
+    photoId: InlineIdLike;
+} | {
+    kind: "video";
+    videoId: InlineIdLike;
+} | {
+    kind: "document";
+    documentId: InlineIdLike;
+};
+export type InlineSdkSendMessageParams = {
+    chatId: InlineIdLike;
+    userId?: never;
+    text?: string;
+    media?: InlineSdkSendMessageMedia;
+    replyToMsgId?: InlineIdLike;
+    parseMarkdown?: boolean;
+    sendMode?: "silent";
+    entities?: MessageEntities;
+} | {
+    userId: InlineIdLike;
+    chatId?: never;
+    text?: string;
+    media?: InlineSdkSendMessageMedia;
+    replyToMsgId?: InlineIdLike;
+    parseMarkdown?: boolean;
+    sendMode?: "silent";
+    entities?: MessageEntities;
+};
+export type InlineSdkBinaryInput = Blob | Uint8Array | ArrayBuffer | SharedArrayBuffer;
+export type InlineSdkUploadFileType = "photo" | "video" | "document";
+export type InlineSdkUploadFileParams = {
+    type: InlineSdkUploadFileType;
+    file: InlineSdkBinaryInput;
+    fileName?: string;
+    contentType?: string;
+    thumbnail?: InlineSdkBinaryInput;
+    thumbnailFileName?: string;
+    thumbnailContentType?: string;
+    width?: number;
+    height?: number;
+    duration?: number;
+};
+export type InlineSdkUploadFileResult = {
+    fileUniqueId: string;
+    photoId?: bigint;
+    videoId?: bigint;
+    documentId?: bigint;
 };
 export type InlineInboundEvent = {
     kind: "message.new";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inline-chat/realtime-sdk",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "private": false,
   "type": "module",
   "files": [