@maxhub/max-bot-api 0.2.1

package/dist/core/helpers/upload.js

@@ -0,0 +1,166 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Upload = void 0;
+const fs = __importStar(require("fs"));
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = __importDefault(require("node:path"));
+const api_1 = require("../network/api");
+const DEFAULT_UPLOAD_TIMEOUT = 20000; // ms
+class Upload {
+    constructor(api) {
+        this.api = api;
+        this.getStreamFromSource = async (source) => {
+            if (typeof source === 'string') {
+                const stat = await fs.promises.stat(source);
+                const fileName = node_path_1.default.basename(source);
+                if (!stat.isFile()) {
+                    throw new Error(`Failed to upload ${fileName}. Not a file`);
+                }
+                const stream = fs.createReadStream(source);
+                return {
+                    stream,
+                    fileName,
+                    contentLength: stat.size,
+                };
+            }
+            if (source instanceof Buffer) {
+                return {
+                    buffer: source,
+                    fileName: (0, node_crypto_1.randomUUID)(),
+                };
+            }
+            const stat = await fs.promises.stat(source.path);
+            let fileName;
+            if (typeof source.path === 'string') {
+                fileName = node_path_1.default.basename(source.path);
+            }
+            else {
+                fileName = (0, node_crypto_1.randomUUID)();
+            }
+            return {
+                stream: source,
+                contentLength: stat.size,
+                fileName,
+            };
+        };
+        this.upload = async (type, file, options) => {
+            const { url: uploadUrl } = await this.api.raw.uploads.getUploadUrl({ type });
+            const uploadController = new AbortController();
+            const uploadInterval = setTimeout(() => {
+                uploadController.abort();
+            }, options?.timeout || DEFAULT_UPLOAD_TIMEOUT);
+            try {
+                if ('stream' in file) {
+                    return await this.uploadFromStream({
+                        file,
+                        uploadUrl,
+                        abortController: uploadController,
+                    });
+                }
+                return await this.uploadFromBuffer({
+                    file,
+                    uploadUrl,
+                    abortController: uploadController,
+                });
+            }
+            finally {
+                clearTimeout(uploadInterval);
+            }
+        };
+        this.uploadFromStream = async ({ file, uploadUrl, abortController }) => {
+            return new Promise((resolve, reject) => {
+                let prevChunk = -1;
+                let uploadData = null;
+                file.stream.on('data', async (chunk) => {
+                    file.stream.pause();
+                    const startBite = prevChunk + 1;
+                    const endBite = prevChunk + chunk.length;
+                    const uploadRes = await fetch(uploadUrl, {
+                        method: 'POST',
+                        body: chunk,
+                        headers: {
+                            'Content-Disposition': `attachment; filename="${file.fileName}"`,
+                            'Content-Range': `bytes ${startBite}-${endBite}/${file.contentLength}`,
+                        },
+                        signal: abortController?.signal,
+                    });
+                    if (uploadRes.status >= 400) {
+                        const error = await uploadRes.json();
+                        throw new api_1.MaxError(uploadRes.status, error);
+                    }
+                    if (!uploadData) {
+                        uploadData = await uploadRes.json();
+                    }
+                    file.stream.resume();
+                    prevChunk += chunk.length;
+                });
+                file.stream.on('end', async () => {
+                    if (!uploadData) {
+                        reject(new Error('Failed to upload'));
+                        return;
+                    }
+                    resolve(uploadData);
+                });
+                file.stream.on('error', (err) => {
+                    reject(err);
+                });
+            });
+        };
+        this.uploadFromBuffer = async ({ file, uploadUrl, abortController }) => {
+            const formData = new FormData();
+            formData.append('data', new Blob([file.buffer]), file.fileName);
+            const res = await fetch(uploadUrl, {
+                method: 'POST',
+                body: formData,
+                signal: abortController?.signal,
+            });
+            return await res.json();
+        };
+        this.image = async ({ timeout, ...source }) => {
+            if ('url' in source) {
+                return { url: source.url };
+            }
+            const fileBlob = await this.getStreamFromSource(source.source);
+            return this.upload('image', fileBlob, { timeout });
+        };
+        this.video = async ({ source, ...options }) => {
+            const fileBlob = await this.getStreamFromSource(source);
+            return this.upload('video', fileBlob, options);
+        };
+        this.file = async ({ source, ...options }) => {
+            const fileBlob = await this.getStreamFromSource(source);
+            return this.upload('file', fileBlob, options);
+        };
+        this.audio = async ({ source, ...options }) => {
+            const fileBlob = await this.getStreamFromSource(source);
+            return this.upload('audio', fileBlob, options);
+        };
+    }
+}
+exports.Upload = Upload;

package/dist/core/network/api/base-api.d.ts

@@ -0,0 +1,14 @@
+import type { Client } from './client';
+import type { ApiMethods } from './modules/types';
+type ApiCallFn<HTTPMethod extends keyof ApiMethods> = <Method extends keyof ApiMethods[HTTPMethod]>(method: Method, options: ApiMethods[HTTPMethod][Method]['req']) => Promise<ApiMethods[HTTPMethod][Method]['res']>;
+export declare class BaseApi {
+    private readonly call;
+    constructor(client: Client);
+    private callApi;
+    protected _get: ApiCallFn<'GET'>;
+    protected _post: ApiCallFn<'POST'>;
+    protected _patch: ApiCallFn<'PATCH'>;
+    protected _put: ApiCallFn<'PUT'>;
+    protected _delete: ApiCallFn<'DELETE'>;
+}
+export {};

package/dist/core/network/api/base-api.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseApi = void 0;
+const error_1 = require("./error");
+class BaseApi {
+    constructor(client) {
+        this.callApi = async (method, options) => {
+            const result = await this.call({
+                method,
+                options,
+            });
+            if (result.status !== 200) {
+                throw new error_1.MaxError(result.status, result.data);
+            }
+            return result.data;
+        };
+        this._get = async (method, options) => {
+            return this.callApi(method, { ...options, method: 'GET' });
+        };
+        this._post = async (method, options) => {
+            return this.callApi(method, { ...options, method: 'POST' });
+        };
+        this._patch = async (method, options) => {
+            return this.callApi(method, { ...options, method: 'PATCH' });
+        };
+        this._put = async (method, options) => {
+            return this.callApi(method, { ...options, method: 'PUT' });
+        };
+        this._delete = async (method, options) => {
+            return this.callApi(method, { ...options, method: 'DELETE' });
+        };
+        this.call = client.call;
+    }
+}
+exports.BaseApi = BaseApi;

package/dist/core/network/api/client.d.ts

@@ -0,0 +1,23 @@
+declare const defaultOptions: {
+    readonly baseUrl: "https://botapi.max.ru";
+};
+export type ClientOptions = Partial<typeof defaultOptions>;
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export type ReqOptions = {
+    method?: HTTPMethod;
+    body?: object | null;
+    query?: Record<string, string | number | boolean | null | undefined>;
+    path?: Record<string, string | number>;
+};
+type CallOptions = {
+    method: string;
+    options: ReqOptions;
+};
+export declare const createClient: (token: string, options?: ClientOptions) => {
+    call: ({ method, options: callOptions }: CallOptions) => Promise<{
+        status: number;
+        data: any;
+    }>;
+};
+export type Client = ReturnType<typeof createClient>;
+export {};

package/dist/core/network/api/client.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = void 0;
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('one-me:client');
+const defaultOptions = {
+    baseUrl: 'https://botapi.max.ru',
+};
+const createClient = (token, options = {}) => {
+    const { baseUrl } = { ...defaultOptions, ...options };
+    const call = async ({ method, options: callOptions }) => {
+        const httpMethod = callOptions.method || 'GET';
+        debug(`Call method ${httpMethod} /${method}`, JSON.stringify(callOptions, null, 2));
+        if (!token) {
+            return {
+                status: 401,
+                data: {
+                    code: 'verify.token',
+                    message: 'Empty access_token',
+                },
+            };
+        }
+        const url = new URL(buildUrl(method, token, callOptions.path), baseUrl);
+        Object.keys(callOptions.query ?? {}).forEach((param) => {
+            const value = callOptions.query?.[param];
+            if (!value)
+                return;
+            url.searchParams.set(param, value.toString());
+        });
+        const init = { ...getResponseInit(callOptions?.body), method: httpMethod };
+        const res = await fetch(url.href, init);
+        if (res.status === 401) {
+            return {
+                status: 401,
+                data: {
+                    code: 'verify.token',
+                    message: 'Invalid access_token',
+                },
+            };
+        }
+        return {
+            status: res.status,
+            data: await res.json(),
+        };
+    };
+    return { call };
+};
+exports.createClient = createClient;
+const getResponseInit = (body) => {
+    if (!body)
+        return {};
+    return {
+        body: JSON.stringify(body),
+        headers: {
+            'content-type': 'application/json',
+        },
+    };
+};
+const buildUrl = (baseUrl, token, path) => {
+    let url = baseUrl;
+    if (path) {
+        Object.keys(path)?.forEach((key) => {
+            const regexp = new RegExp(`{${key}}`, 'g');
+            const value = path[key].toString();
+            url = url.replace(regexp, value);
+        });
+    }
+    return `${url}?access_token=${token}`;
+};

package/dist/core/network/api/error.d.ts

@@ -0,0 +1,11 @@
+export type ErrorResponse = {
+    code: string;
+    message: string;
+};
+export declare class MaxError extends Error {
+    readonly status: number;
+    private readonly response;
+    constructor(status: number, response: ErrorResponse);
+    get code(): string;
+    get description(): string;
+}

package/dist/core/network/api/error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxError = void 0;
+class MaxError extends Error {
+    constructor(status, response) {
+        super(`${status}: ${response.message}`);
+        this.status = status;
+        this.response = response;
+    }
+    get code() {
+        return this.response.code;
+    }
+    get description() {
+        return this.response.message;
+    }
+}
+exports.MaxError = MaxError;

package/dist/core/network/api/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './modules/types';
+export { createClient, type Client, type ClientOptions } from './client';
+export { MaxError } from './error';
+export { RawApi } from './raw-api';

package/dist/core/network/api/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawApi = exports.MaxError = exports.createClient = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./modules/types"), exports);
+var client_1 = require("./client");
+Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return client_1.createClient; } });
+var error_1 = require("./error");
+Object.defineProperty(exports, "MaxError", { enumerable: true, get: function () { return error_1.MaxError; } });
+var raw_api_1 = require("./raw-api");
+Object.defineProperty(exports, "RawApi", { enumerable: true, get: function () { return raw_api_1.RawApi; } });

package/dist/core/network/api/modules/bots/api.d.ts

@@ -0,0 +1,7 @@
+import { BaseApi } from '../../base-api';
+import type { FlattenReq } from '../types';
+import type { EditMyInfoDTO } from './types';
+export declare class BotsApi extends BaseApi {
+    getMyInfo: () => Promise<import("../..").BotInfo>;
+    editMyInfo: ({ ...body }: FlattenReq<EditMyInfoDTO>) => Promise<import("../..").BotInfo>;
+}

package/dist/core/network/api/modules/bots/api.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotsApi = void 0;
+const base_api_1 = require("../../base-api");
+class BotsApi extends base_api_1.BaseApi {
+    constructor() {
+        super(...arguments);
+        this.getMyInfo = async () => {
+            return this._get('me', {});
+        };
+        this.editMyInfo = async ({ ...body }) => {
+            return this._patch('me', { body });
+        };
+    }
+}
+exports.BotsApi = BotsApi;

package/dist/core/network/api/modules/bots/types.d.ts

@@ -0,0 +1,11 @@
+import type { BotCommand, BotInfo, PhotoAttachmentRequestPayload } from '../../types';
+export type GetMyInfoResponse = BotInfo;
+export type EditMyInfoDTO = {
+    body: {
+        name?: string | null;
+        description?: string | null;
+        commands?: BotCommand[] | null;
+        photo?: PhotoAttachmentRequestPayload;
+    };
+};
+export type EditMyInfoResponse = BotInfo;

package/dist/core/network/api/modules/bots/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/network/api/modules/chats/api.d.ts

@@ -0,0 +1,19 @@
+import { BaseApi } from '../../base-api';
+import type { FlattenReq } from '../types';
+import type { AddChatMembersDTO, AddChatMembersResponse, EditChatInfoDTO, EditChatInfoResponse, GetAllChatsDTO, GetAllChatsResponse, GetChatAdminsDTO, GetChatAdminsResponse, GetChatByIdDTO, GetChatByIdResponse, GetChatByLinkDTO, GetChatByLinkResponse, GetChatMembersDTO, GetChatMembershipDTO, GetChatMembershipResponse, GetChatMembersResponse, GetPinnedMessageDTO, GetPinnedMessageResponse, LeaveChatDTO, LeaveChatResponse, PinMessageDTO, PinMessageResponse, RemoveChatMemberDTO, RemoveChatMemberResponse, SendActionDTO, SendActionResponse, UnpinMessageDTO, UnpinMessageResponse } from './types';
+export declare class ChatsApi extends BaseApi {
+    getAll({ ...query }: FlattenReq<GetAllChatsDTO>): Promise<GetAllChatsResponse>;
+    getById({ chat_id }: FlattenReq<GetChatByIdDTO>): Promise<GetChatByIdResponse>;
+    getByLink({ chat_link }: FlattenReq<GetChatByLinkDTO>): Promise<GetChatByLinkResponse>;
+    edit({ chat_id, ...body }: FlattenReq<EditChatInfoDTO>): Promise<EditChatInfoResponse>;
+    getChatMembership({ chat_id }: FlattenReq<GetChatMembershipDTO>): Promise<GetChatMembershipResponse>;
+    getChatAdmins({ chat_id }: FlattenReq<GetChatAdminsDTO>): Promise<GetChatAdminsResponse>;
+    addChatMembers({ chat_id, ...body }: FlattenReq<AddChatMembersDTO>): Promise<AddChatMembersResponse>;
+    getChatMembers({ chat_id, ...query }: FlattenReq<GetChatMembersDTO>): Promise<GetChatMembersResponse>;
+    removeChatMember({ chat_id, ...body }: FlattenReq<RemoveChatMemberDTO>): Promise<RemoveChatMemberResponse>;
+    getPinnedMessage({ chat_id }: FlattenReq<GetPinnedMessageDTO>): Promise<GetPinnedMessageResponse>;
+    pinMessage({ chat_id, ...body }: FlattenReq<PinMessageDTO>): Promise<PinMessageResponse>;
+    unpinMessage({ chat_id }: FlattenReq<UnpinMessageDTO>): Promise<UnpinMessageResponse>;
+    sendAction({ chat_id, ...body }: FlattenReq<SendActionDTO>): Promise<SendActionResponse>;
+    leaveChat({ chat_id }: FlattenReq<LeaveChatDTO>): Promise<LeaveChatResponse>;
+}

package/dist/core/network/api/modules/chats/api.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatsApi = void 0;
+const base_api_1 = require("../../base-api");
+class ChatsApi extends base_api_1.BaseApi {
+    async getAll({ ...query }) {
+        return this._get('chats', {
+            query,
+        });
+    }
+    async getById({ chat_id }) {
+        return this._get('chats/{chat_id}', {
+            path: { chat_id },
+        });
+    }
+    async getByLink({ chat_link }) {
+        return this._get('chats/{chat_link}', {
+            path: { chat_link },
+        });
+    }
+    async edit({ chat_id, ...body }) {
+        return this._patch('chats/{chat_id}', {
+            path: { chat_id },
+            body,
+        });
+    }
+    async getChatMembership({ chat_id }) {
+        return this._get('chats/{chat_id}/members/me', {
+            path: { chat_id },
+        });
+    }
+    async getChatAdmins({ chat_id }) {
+        return this._get('chats/{chat_id}/members/admins', {
+            path: { chat_id },
+        });
+    }
+    async addChatMembers({ chat_id, ...body }) {
+        return this._post('chats/{chat_id}/members', {
+            path: { chat_id },
+            body,
+        });
+    }
+    async getChatMembers({ chat_id, ...query }) {
+        return this._get('chats/{chat_id}/members', {
+            path: { chat_id },
+            query,
+        });
+    }
+    async removeChatMember({ chat_id, ...body }) {
+        return this._delete('chats/{chat_id}/members', {
+            path: { chat_id },
+            body,
+        });
+    }
+    async getPinnedMessage({ chat_id }) {
+        return this._get('chats/{chat_id}/pin', {
+            path: { chat_id },
+        });
+    }
+    async pinMessage({ chat_id, ...body }) {
+        return this._put('chats/{chat_id}/pin', {
+            path: { chat_id },
+            body,
+        });
+    }
+    async unpinMessage({ chat_id }) {
+        return this._delete('chats/{chat_id}/pin', {
+            path: { chat_id },
+        });
+    }
+    async sendAction({ chat_id, ...body }) {
+        return this._post('chats/{chat_id}/actions', {
+            path: { chat_id },
+            body,
+        });
+    }
+    async leaveChat({ chat_id }) {
+        return this._delete('chats/{chat_id}/members/me', {
+            path: { chat_id },
+        });
+    }
+}
+exports.ChatsApi = ChatsApi;

package/dist/core/network/api/modules/chats/types.d.ts

@@ -0,0 +1,109 @@
+import { ActionResponse, Chat, ChatMember, Message, type PhotoAttachmentRequestPayload, SenderAction } from '../../types';
+import { FlattenReq } from '../types';
+export type GetAllChatsDTO = {
+    query: {
+        count?: number;
+        marker?: number | null;
+    };
+};
+export type GetAllChatsExtra = FlattenReq<GetAllChatsDTO>;
+type DefaultPath = {
+    chat_id: number;
+};
+export type GetAllChatsResponse = {
+    chats: Chat[];
+    marker: number | null;
+};
+export type GetChatByIdDTO = {
+    path: DefaultPath;
+};
+export type GetChatByIdResponse = Chat;
+export type GetChatByLinkDTO = {
+    path: {
+        chat_link: string;
+    };
+};
+export type GetChatByLinkResponse = Chat;
+export type EditChatInfoDTO = {
+    path: DefaultPath;
+    body: {
+        icon?: PhotoAttachmentRequestPayload | null;
+        title?: string | null;
+        pin?: string | null;
+        notify?: boolean | null;
+    };
+};
+export type EditChatExtra = Omit<FlattenReq<EditChatInfoDTO>, 'chat_id'>;
+export type EditChatInfoResponse = Chat;
+export type SendActionDTO = {
+    path: DefaultPath;
+    body: {
+        action: SenderAction;
+    };
+};
+export type SendActionResponse = ActionResponse;
+export type GetPinnedMessageDTO = {
+    path: DefaultPath;
+};
+export type GetPinnedMessageResponse = {
+    message: Message | null;
+};
+export type PinMessageDTO = {
+    path: DefaultPath;
+    body: {
+        message_id: string;
+        notify?: boolean | null;
+    };
+};
+export type PinMessageExtra = Omit<FlattenReq<PinMessageDTO>, 'chat_id' | 'message_id'>;
+export type PinMessageResponse = ActionResponse;
+export type UnpinMessageDTO = {
+    path: DefaultPath;
+};
+export type UnpinMessageResponse = ActionResponse;
+export type GetChatMembershipDTO = {
+    path: DefaultPath;
+};
+export type GetChatMembershipResponse = ChatMember;
+export type LeaveChatDTO = {
+    path: DefaultPath;
+};
+export type LeaveChatResponse = ActionResponse;
+export type GetChatAdminsDTO = {
+    path: DefaultPath;
+};
+export type GetChatAdminsResponse = {
+    members: ChatMember[];
+    marker?: number | null;
+};
+export type GetChatMembersDTO = {
+    path: DefaultPath;
+    query: {
+        user_ids?: string;
+        marker?: number;
+        count?: number;
+    };
+};
+export type GetChatMembersExtra = Omit<FlattenReq<GetChatMembersDTO>, 'chat_id' | 'user_ids'> & {
+    user_ids?: number[];
+};
+export type GetChatMembersResponse = {
+    members: ChatMember[];
+    marker?: number | null;
+};
+export type AddChatMembersDTO = {
+    path: DefaultPath;
+    body: {
+        user_ids: number[];
+    };
+};
+export type AddChatMembersResponse = ActionResponse;
+export type RemoveChatMemberDTO = {
+    path: DefaultPath;
+    body: {
+        user_id: number;
+        block?: boolean;
+    };
+};
+export type RemoveChatMemberResponse = ActionResponse;
+export {};

package/dist/core/network/api/modules/chats/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/network/api/modules/index.d.ts

@@ -0,0 +1,12 @@
+export { BaseApi } from '../base-api';
+export { FlattenReq } from './types';
+export { BotsApi } from './bots/api';
+export * from './bots/types';
+export { MessagesApi } from './messages/api';
+export * from './messages/types';
+export { SubscriptionsApi } from './subscriptions/api';
+export * from './subscriptions/types';
+export { UploadsApi } from './uploads/api';
+export * from './uploads/types';
+export { ChatsApi } from './chats/api';
+export * from './chats/types';