@skravets/eapi 0.0.1

package/dist/api-types.d.ts

@@ -0,0 +1,498 @@
+/**
+ * @module
+ *
+ * Сгенерированные TypeScript типы для [API](...).
+ */
+/**
+ * Сгенерированные из OpenAPI типы для `paths`
+ */
+interface paths {
+    "/": {
+        /** Get Hello World! */
+        get: operations["app.getHello"];
+    };
+    "/channels": {
+        /** Get Hello World! */
+        get: operations["channels.getHello"];
+    };
+    "/channels/{channelId}/last-message": {
+        /** Get last channel message */
+        get: operations["channels.getLastMessage"];
+    };
+    "/channels/{channelId}/new-messages": {
+        /** Get channel messages */
+        post: operations["channels.getMessages"];
+    };
+    "/subscriptions": {
+        /** Create subscription */
+        post: operations["subscriptions.create"];
+    };
+    "/subscriptions/{subId}": {
+        /** Get subscription by subscription id */
+        get: operations["subscriptions.getById"];
+        /** Update subscription by subscription id */
+        put: operations["subscriptions.update"];
+        /** Delete subscription by subscription id */
+        delete: operations["subscriptions.delete"];
+    };
+}
+/**
+ * Сгенерированные из OpenAPI типы для `components`
+ */
+interface components {
+    schemas: {
+        IGetChannelMessages: {
+            /**
+             * @description Cursor to get messages from id to id
+             * @example {
+             *       "from": 1,
+             *       "to": 10
+             *     }
+             */
+            cursor: Record<string, never>;
+        };
+        ChatDataDto: {
+            /** @example true */
+            id?: boolean;
+            /** @example true */
+            username?: boolean;
+            /** @example true */
+            title?: boolean;
+            /** @example true */
+            type?: boolean;
+            /** @example true */
+            participants_count?: boolean;
+            /** @example true */
+            last_offset_id?: boolean;
+            /** @example true */
+            last_parsed_date?: boolean;
+            /** @example true */
+            is_locked?: boolean;
+            /** @example true */
+            about?: boolean;
+            /** @example true */
+            avatar_id?: boolean;
+        };
+        SubscriptionChatDataDto: {
+            /**
+             * @description Chat schema
+             * @example {
+             *       "id": true,
+             *       "username": true,
+             *       "title": true,
+             *       "type": true,
+             *       "participants_count": true,
+             *       "last_offset_id": true,
+             *       "last_parsed_date": true,
+             *       "is_locked": true,
+             *       "about": true,
+             *       "avatar_id": true
+             *     }
+             */
+            data: components["schemas"]["ChatDataDto"];
+        };
+        SubscriptionMessageDataDto: {
+            /**
+             * @description Messages schema
+             * @example {
+             *       "channel_id": true,
+             *       "created_at": true,
+             *       "first_name": true,
+             *       "has_comments": true,
+             *       "has_reactions": true,
+             *       "last_name": true,
+             *       "message_created_at": true,
+             *       "message_id": true,
+             *       "reply_message_id": true,
+             *       "search_text": true,
+             *       "text": true,
+             *       "user_id": true,
+             *       "username": true
+             *     }
+             */
+            data: Record<string, never>;
+            /** @description Messages limit per request */
+            limit?: number;
+        };
+        SubscriptionDataDto: {
+            /**
+             * @description Chat meta data
+             * @example {
+             *       "data": {
+             *         "id": true,
+             *         "username": true,
+             *         "title": true,
+             *         "type": true,
+             *         "participants_count": true,
+             *         "last_offset_id": true,
+             *         "last_parsed_date": true,
+             *         "is_locked": true,
+             *         "about": true,
+             *         "avatar_id": true
+             *       }
+             *     }
+             */
+            chat?: components["schemas"]["SubscriptionChatDataDto"];
+            /**
+             * @description Messages data
+             * @example {
+             *       "data": {
+             *         "channel_id": true,
+             *         "created_at": true,
+             *         "first_name": true,
+             *         "has_comments": true,
+             *         "has_reactions": true,
+             *         "last_name": true,
+             *         "message_created_at": true,
+             *         "message_id": true,
+             *         "reply_message_id": true,
+             *         "search_text": true,
+             *         "text": true,
+             *         "user_id": true,
+             *         "username": true
+             *       },
+             *       "limit": 100
+             *     }
+             */
+            messages?: components["schemas"]["SubscriptionMessageDataDto"];
+        };
+        SubscribeDto: {
+            /**
+             * @description Chat Id to subscribe
+             * @example 1234567890
+             */
+            chatId: number;
+            /** @example {
+             *       "chat": {
+             *         "data": {
+             *           "id": true,
+             *           "username": true,
+             *           "title": true,
+             *           "type": true,
+             *           "participants_count": true,
+             *           "last_offset_id": true,
+             *           "last_parsed_date": true,
+             *           "is_locked": true,
+             *           "about": true,
+             *           "avatar_id": true
+             *         }
+             *       },
+             *       "messages": {
+             *         "data": {
+             *           "channel_id": true,
+             *           "created_at": true,
+             *           "first_name": true,
+             *           "has_comments": true,
+             *           "has_reactions": true,
+             *           "last_name": true,
+             *           "message_created_at": true,
+             *           "message_id": true,
+             *           "reply_message_id": true,
+             *           "search_text": true,
+             *           "text": true,
+             *           "user_id": true,
+             *           "username": true
+             *         },
+             *         "limit": 100
+             *       }
+             *     } */
+            data: components["schemas"]["SubscriptionDataDto"];
+            /**
+             * @description Webhook url
+             * @example https://example.com/webhook
+             */
+            webhookUrl: string;
+            /**
+             * @description Short description
+             * @example to get messages from chat 123
+             */
+            description?: string;
+        };
+        UpdateSubscribeDto: {
+            /**
+             * @description Scopes to subscribe
+             * @example {
+             *       "chat": {
+             *         "data": {
+             *           "username": true
+             *         }
+             *       }
+             *     }
+             */
+            data?: components["schemas"]["SubscriptionDataDto"];
+            /**
+             * @description Webhook url
+             * @example https://example.com/webhook
+             */
+            webhookUrl?: string;
+        };
+    };
+}
+type $defs = Record<string, never>;
+/**
+ * Сгенерированные из OpenAPI типы для `operations`
+ */
+interface operations {
+    "app.getHello": {
+        parameters: {
+            header: {
+                /** @description `Basic token`, where token is `id:secret` base64 encoded */
+                Authorization: string;
+            };
+        };
+        responses: {
+            /** @description returns Hello World! */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    "channels.getHello": {
+        parameters: {
+            header: {
+                /** @description `Basic token`, where token is `id:secret` base64 encoded */
+                Authorization: string;
+            };
+        };
+        responses: {
+            /** @description returns Hello World! */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+            };
+        };
+    };
+    "channels.getLastMessage": {
+        parameters: {
+            header: {
+                /** @description `Basic token`, where token is `id:secret` base64 encoded */
+                Authorization: string;
+            };
+            path: {
+                channelId: number;
+            };
+        };
+        responses: {
+            /** @description Returns array with last message by channel id */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+            };
+        };
+    };
+    "channels.getMessages": {
+        parameters: {
+            header: {
+                /** @description `Basic token`, where token is `id:secret` base64 encoded */
+                Authorization: string;
+            };
+            path: {
+                channelId: number;
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["IGetChannelMessages"];
+            };
+        };
+        responses: {
+            /** @description Returns array of messages by channel id and cursors */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+            };
+        };
+    };
+    "subscriptions.create": {
+        parameters: {
+            header: {
+                /** @description `Basic token`, where token is `id:secret` base64 encoded */
+                Authorization: string;
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SubscribeDto"];
+            };
+        };
+        responses: {
+            /** @description Subscription created, returns created subscription */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SubscribeDto"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+            };
+        };
+    };
+    "subscriptions.getById": {
+        parameters: {
+            header: {
+                /** @description `Basic token`, where token is `id:secret` base64 encoded */
+                Authorization: string;
+            };
+            path: {
+                subId: number;
+            };
+        };
+        responses: {
+            /** @description Subscription found, returns subscription */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SubscribeDto"];
+                };
+            };
+            /** @description Invalid subscription id */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+            };
+            /** @description You have no rights to manipulate subscription */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+            };
+        };
+    };
+    "subscriptions.update": {
+        parameters: {
+            header: {
+                /** @description `Basic token`, where token is `id:secret` base64 encoded */
+                Authorization: string;
+            };
+            path: {
+                subId: number;
+            };
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateSubscribeDto"];
+            };
+        };
+        responses: {
+            /** @description Subscription updated, returns updated subscription */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SubscribeDto"];
+                };
+            };
+            /** @description Invalid subscription id */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+            };
+            /** @description You have no rights to manipulate subscription */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+            };
+        };
+    };
+    "subscriptions.delete": {
+        parameters: {
+            header: {
+                /** @description `Basic token`, where token is `id:secret` base64 encoded */
+                Authorization: string;
+            };
+            path: {
+                subId: number;
+            };
+        };
+        responses: {
+            /** @description Subscription deleted, returns deleted subscription */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["SubscribeDto"];
+                };
+            };
+            /** @description Invalid subscription id */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+            };
+            /** @description You have no rights to manipulate subscription */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+            };
+        };
+    };
+}
+
+export type { $defs, components, operations, paths };

package/dist/index.cjs

@@ -0,0 +1,214 @@
+'use strict';
+
+const frameworks = {
+  elysia: ({ body }) => ({
+    body,
+    response: () => new Response("OK")
+  }),
+  fastify: (request, reply) => ({
+    body: request.body,
+    response: () => reply.send("OK")
+  }),
+  hono: (c) => ({ body: c.req.json(), response: () => c.text("OK") }),
+  express: (req, res) => ({ body: req.body, response: () => res.send("OK") }),
+  koa: (ctx) => ({
+    body: ctx.request.body,
+    response: () => {
+      ctx.body = "OK";
+    }
+  }),
+  http: (req, res) => ({
+    body: new Promise((resolve) => {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk.toString();
+      });
+      req.on("end", () => resolve(JSON.parse(body)));
+    }),
+    response: () => res.writeHead(200).end("OK")
+  }),
+  "std/http": (req) => ({
+    body: req.json(),
+    response: () => new Response("OK")
+  }),
+  "Bun.serve": (req) => ({
+    body: req.json(),
+    response: () => new Response("OK")
+  })
+};
+function webhookHandler(eApi, framework) {
+  const frameworkAdapter = frameworks[framework];
+  return async (...args) => {
+    const { body, response } = frameworkAdapter(...args);
+    await eApi.emit(await body);
+    if (response)
+      return response();
+  };
+}
+
+class EApi {
+  options;
+  listeners = [];
+  constructor(options) {
+    this.options = options;
+  }
+  async request(path, data, options) {
+    const requestOptions = {
+      method: options?.method || "POST",
+      mimeType: "json",
+      ...this.options.requestOptions,
+      ...options,
+      body: data ? JSON.stringify(data) : void 0,
+      headers: {
+        "user-agent": "EAPI SDK",
+        Authorization: `Basic ${btoa(`${this.options.client.id}:${this.options.client.secret}`)}`,
+        ...this.options.requestOptions?.headers,
+        ...options?.headers
+      }
+    };
+    requestOptions.mimeType = void 0;
+    const response = await fetch(this.options.host + path, requestOptions);
+    if (!response.ok) {
+      throw new Error(`${response.status} ${await response.text()}`);
+    }
+    return response.json();
+  }
+  on(type, handler) {
+    this.listeners.push({ event: type, handler });
+  }
+  test = {};
+  async emit(data) {
+    const listeners = this.listeners.find((x) => x.event === data.type);
+    if (listeners)
+      await listeners.handler(data);
+  }
+  /** @generated start-generate-methods */
+  /**
+   * @tags app
+   */
+  app = {
+    /**
+     *
+     *
+     * @tags App
+     * @summary Get Hello World!
+     *
+     * [Documentation](.../App/operation/app.getHello)
+     */
+    getHello: (options) => {
+      return this.request(`/`, void 0, { method: "GET", ...options });
+    }
+  };
+  /**
+   * @tags channels
+   */
+  channels = {
+    /**
+     *
+     *
+     * @tags Channels
+     * @summary Get Hello World!
+     *
+     * [Documentation](.../Channels/operation/channels.getHello)
+     */
+    getHello: (options) => {
+      return this.request(`/channels`, void 0, {
+        method: "GET",
+        ...options
+      });
+    },
+    /**
+     *
+     *
+     * @tags Channels
+     * @summary Get last channel message
+     *
+     * [Documentation](.../Channels/operation/channels.getLastMessage)
+     */
+    getLastMessage: (channelId, options) => {
+      return this.request(`/channels/${channelId}/last-message`, void 0, {
+        method: "GET",
+        ...options
+      });
+    },
+    /**
+     *
+     *
+     * @tags Channels
+     * @summary Get channel messages
+     *
+     * [Documentation](.../Channels/operation/channels.getMessages)
+     */
+    getMessages: (channelId, body, options) => {
+      return this.request(`/channels/${channelId}/new-messages`, body, {
+        method: "POST",
+        ...options
+      });
+    }
+  };
+  /**
+   * @tags subscriptions
+   */
+  subscriptions = {
+    /**
+     *
+     *
+     * @tags Subscriptions
+     * @summary Create subscription
+     *
+     * [Documentation](.../Subscriptions/operation/subscriptions.create)
+     */
+    create: (body, options) => {
+      return this.request(`/subscriptions`, body, {
+        method: "POST",
+        ...options
+      });
+    },
+    /**
+     *
+     *
+     * @tags Subscriptions
+     * @summary Get subscription by subscription id
+     *
+     * [Documentation](.../Subscriptions/operation/subscriptions.getById)
+     */
+    getById: (subId, options) => {
+      return this.request(`/subscriptions/${subId}`, void 0, {
+        method: "GET",
+        ...options
+      });
+    },
+    /**
+     *
+     *
+     * @tags Subscriptions
+     * @summary Update subscription by subscription id
+     *
+     * [Documentation](.../Subscriptions/operation/subscriptions.update)
+     */
+    update: (subId, body, options) => {
+      return this.request(`/subscriptions/${subId}`, body, {
+        method: "PUT",
+        ...options
+      });
+    },
+    /**
+     *
+     *
+     * @tags Subscriptions
+     * @summary Delete subscription by subscription id
+     *
+     * [Documentation](.../Subscriptions/operation/subscriptions.delete)
+     */
+    delete: (subId, options) => {
+      return this.request(`/subscriptions/${subId}`, void 0, {
+        method: "DELETE",
+        ...options
+      });
+    }
+  };
+  /** @generated stop-generate-methods */
+}
+
+exports.EApi = EApi;
+exports.webhookHandler = webhookHandler;