taverns.js 0.2.0

package/dist/rest.js

@@ -0,0 +1,425 @@
+"use strict";
+/**
+ * taverns.js - REST Client
+ *
+ * HTTP client for the Taverns API.
+ * Handles bot token authentication, rate limiting, and retries.
+ */
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TavernAPIError = exports.RESTClient = void 0;
+const events_1 = require("events");
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const url_1 = require("url");
+const constants_1 = require("./constants");
+class RESTClient extends events_1.EventEmitter {
+    constructor(token, baseUrl = constants_1.DEFAULT_API_URL) {
+        super();
+        this.buckets = new Map();
+        this.globalRateLimit = null;
+        this.token = token;
+        this.baseUrl = baseUrl;
+    }
+    /** Update the bot token (used when login() provides a new token). */
+    setToken(token) {
+        this.token = token;
+    }
+    // ─── Core HTTP Methods ──────────────────────────────────
+    async get(path, query) {
+        return this.request({ method: 'GET', path, query });
+    }
+    async post(path, body) {
+        return this.request({ method: 'POST', path, body });
+    }
+    async patch(path, body) {
+        return this.request({ method: 'PATCH', path, body });
+    }
+    async put(path, body) {
+        return this.request({ method: 'PUT', path, body });
+    }
+    async delete(path, body) {
+        return this.request({ method: 'DELETE', path, body });
+    }
+    // ─── Bot Identity ──────────────────────────────────────
+    /** Get the bot's own profile and installed taverns. */
+    async getSelf() {
+        return this.get('/bots/@me');
+    }
+    /** Get the list of taverns the bot is installed in. */
+    async getMyTaverns() {
+        return this.get('/bots/@me/taverns');
+    }
+    // ─── Taverns ───────────────────────────────────────────
+    /** Get a tavern by ID. */
+    async getTavern(tavernId) {
+        return this.get(`/taverns/${tavernId}`);
+    }
+    // ─── Channels ──────────────────────────────────────────
+    /** List all channels in a tavern. */
+    async getChannels(tavernId) {
+        return this.get(`/taverns/${tavernId}/channels`);
+    }
+    /** Create a new channel in a tavern. */
+    async createChannel(tavernId, options) {
+        return this.post(`/taverns/${tavernId}/channels`, options);
+    }
+    /** Update a channel. */
+    async updateChannel(tavernId, channelId, options) {
+        return this.patch(`/taverns/${tavernId}/channels/${channelId}`, options);
+    }
+    /** Delete a channel. */
+    async deleteChannel(tavernId, channelId) {
+        await this.delete(`/taverns/${tavernId}/channels/${channelId}`);
+    }
+    // ─── Messages ──────────────────────────────────────────
+    /** Send a message to a channel. */
+    async sendMessage(tavernId, channelId, options) {
+        return this.post(`/taverns/${tavernId}/channels/${channelId}/messages`, options);
+    }
+    /** Get messages from a channel. */
+    async getMessages(tavernId, channelId, options) {
+        const query = {};
+        if (options?.limit)
+            query.limit = options.limit;
+        if (options?.before)
+            query.before = options.before;
+        if (options?.after)
+            query.after = options.after;
+        return this.get(`/taverns/${tavernId}/channels/${channelId}/messages`, query);
+    }
+    /** Edit a message. */
+    async editMessage(tavernId, messageId, options) {
+        return this.patch(`/taverns/${tavernId}/messages/${messageId}`, options);
+    }
+    /** Delete a message. */
+    async deleteMessage(tavernId, messageId) {
+        await this.delete(`/taverns/${tavernId}/messages/${messageId}`);
+    }
+    /** Pin a message. */
+    async pinMessage(tavernId, messageId) {
+        await this.post(`/taverns/${tavernId}/messages/${messageId}/pin`);
+    }
+    /** Unpin a message. */
+    async unpinMessage(tavernId, messageId) {
+        await this.delete(`/taverns/${tavernId}/messages/${messageId}/pin`);
+    }
+    /** Get pinned messages in a channel. */
+    async getPinnedMessages(tavernId, channelId) {
+        return this.get(`/taverns/${tavernId}/channels/${channelId}/pins`);
+    }
+    /** Search messages in a tavern or specific channel. */
+    async searchMessages(tavernId, options) {
+        const query = {
+            query: options.query,
+        };
+        if (options.senderId)
+            query.senderId = options.senderId;
+        if (options.limit)
+            query.limit = options.limit;
+        if (options.offset)
+            query.offset = options.offset;
+        if (options.channelId) {
+            return this.get(`/taverns/${tavernId}/channels/${options.channelId}/messages/search`, query);
+        }
+        return this.get(`/taverns/${tavernId}/messages/search`, query);
+    }
+    /** Add a reaction to a message. */
+    async addReaction(tavernId, messageId, emoji) {
+        await this.post(`/taverns/${tavernId}/messages/${messageId}/reactions`, { emoji });
+    }
+    /** Remove a reaction from a message. */
+    async removeReaction(tavernId, messageId, emoji) {
+        await this.delete(`/taverns/${tavernId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}`);
+    }
+    /** Bulk delete messages in a channel. */
+    async bulkDeleteMessages(tavernId, channelId, messageIds) {
+        await this.post(`/taverns/${tavernId}/channels/${channelId}/messages/bulk-delete`, { messageIds });
+    }
+    // ─── Members ───────────────────────────────────────────
+    /** List members of a tavern. */
+    async getMembers(tavernId, options) {
+        const query = {};
+        if (options?.limit)
+            query.limit = options.limit;
+        if (options?.after)
+            query.after = options.after;
+        return this.get(`/taverns/${tavernId}/members`, query);
+    }
+    /** Get a specific member. */
+    async getMember(tavernId, userId) {
+        return this.get(`/taverns/${tavernId}/members/${userId}`);
+    }
+    /** Kick a member from a tavern. */
+    async kickMember(tavernId, userId, reason) {
+        await this.delete(`/taverns/${tavernId}/members/${userId}`, reason ? { reason } : undefined);
+    }
+    /** Ban a member from a tavern. */
+    async banMember(tavernId, userId, reason) {
+        await this.post(`/taverns/${tavernId}/bans/${userId}`, reason ? { reason } : undefined);
+    }
+    /** Unban a member from a tavern. */
+    async unbanMember(tavernId, userId) {
+        await this.delete(`/taverns/${tavernId}/bans/${userId}`);
+    }
+    // ─── Roles ─────────────────────────────────────────────
+    /** List roles in a tavern. */
+    async getRoles(tavernId) {
+        return this.get(`/taverns/${tavernId}/roles`);
+    }
+    /** Create a new role in a tavern. */
+    async createRole(tavernId, options) {
+        return this.post(`/taverns/${tavernId}/roles`, options);
+    }
+    /** Update a role. */
+    async updateRole(tavernId, roleId, options) {
+        return this.patch(`/taverns/${tavernId}/roles/${roleId}`, options);
+    }
+    /** Delete a role. */
+    async deleteRole(tavernId, roleId) {
+        await this.delete(`/taverns/${tavernId}/roles/${roleId}`);
+    }
+    /** Add a role to a member. */
+    async addMemberRole(tavernId, userId, roleId) {
+        await this.post(`/taverns/${tavernId}/members/${userId}/roles/${roleId}`);
+    }
+    /** Remove a role from a member. */
+    async removeMemberRole(tavernId, userId, roleId) {
+        await this.delete(`/taverns/${tavernId}/members/${userId}/roles/${roleId}`);
+    }
+    // ─── Threads ───────────────────────────────────────────
+    /** Create a thread in a channel. */
+    async createThread(tavernId, channelId, options) {
+        return this.post(`/taverns/${tavernId}/channels/${channelId}/threads`, options);
+    }
+    /** List threads in a channel. */
+    async getThreads(tavernId, channelId) {
+        return this.get(`/taverns/${tavernId}/channels/${channelId}/threads`);
+    }
+    /** Get active threads across the tavern. */
+    async getActiveThreads(tavernId) {
+        return this.get(`/taverns/${tavernId}/active-threads`);
+    }
+    // ─── Bot Commands (Slash Commands) ─────────────────────
+    /** Register or overwrite all slash commands for this bot. */
+    async registerCommands(commands) {
+        return this.put('/bots/@me/commands', commands);
+    }
+    /** Get all registered commands for this bot. */
+    async getCommands() {
+        return this.get('/bots/@me/commands');
+    }
+    /** Delete a registered command by ID. */
+    async deleteCommand(commandId) {
+        await this.delete(`/bots/@me/commands/${commandId}`);
+    }
+    // ─── Interactions ─────────────────────────────────────
+    /** Reply to an interaction. */
+    async replyToInteraction(interactionId, data) {
+        await this.post(`/interactions/${interactionId}/callback`, data);
+    }
+    /** Acknowledge an interaction with a deferred response (shows loading state). */
+    async deferInteraction(interactionId) {
+        await this.post(`/interactions/${interactionId}/defer`);
+    }
+    /** Send a follow-up message after replying or deferring an interaction. */
+    async followUpInteraction(interactionId, data) {
+        await this.post(`/interactions/${interactionId}/followup`, data);
+    }
+    // ─── Internal Request Logic ────────────────────────────
+    async request(options, retryCount = 0) {
+        // Check global rate limit
+        if (this.globalRateLimit && Date.now() < this.globalRateLimit) {
+            const waitMs = this.globalRateLimit - Date.now();
+            this.emit('debug', `Global rate limit hit, waiting ${waitMs}ms`);
+            await this.sleep(waitMs);
+        }
+        // Check bucket rate limit
+        const bucketKey = `${options.method}:${options.path.split('/').slice(0, 4).join('/')}`;
+        const bucket = this.buckets.get(bucketKey);
+        if (bucket && bucket.remaining <= 0 && Date.now() < bucket.reset) {
+            const waitMs = bucket.reset - Date.now();
+            this.emit('debug', `Bucket rate limit hit for ${bucketKey}, waiting ${waitMs}ms`);
+            await this.sleep(waitMs);
+        }
+        // Build URL
+        let url = `${this.baseUrl}${options.path}`;
+        if (options.query) {
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(options.query)) {
+                if (value !== undefined)
+                    params.append(key, String(value));
+            }
+            const queryString = params.toString();
+            if (queryString)
+                url += `?${queryString}`;
+        }
+        const parsedUrl = new url_1.URL(url);
+        const isHttps = parsedUrl.protocol === 'https:';
+        const transport = isHttps ? https : http;
+        const bodyStr = options.body ? JSON.stringify(options.body) : undefined;
+        const requestOptions = {
+            hostname: parsedUrl.hostname,
+            port: parsedUrl.port || (isHttps ? 443 : 80),
+            path: parsedUrl.pathname + parsedUrl.search,
+            method: options.method,
+            headers: {
+                'Authorization': `Bot ${this.token}`,
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                'User-Agent': 'taverns.js/0.1.0',
+            },
+        };
+        if (bodyStr) {
+            requestOptions.headers['Content-Length'] = Buffer.byteLength(bodyStr).toString();
+        }
+        return new Promise((resolve, reject) => {
+            const req = transport.request(requestOptions, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
+                res.on('end', () => {
+                    const raw = Buffer.concat(chunks).toString('utf-8');
+                    // Update rate limit tracking
+                    this.updateRateLimits(bucketKey, res.headers);
+                    const status = res.statusCode || 0;
+                    // Handle 429 (rate limited)
+                    if (status === 429) {
+                        const retryAfter = this.parseRetryAfter(res.headers);
+                        const isGlobal = res.headers['x-ratelimit-global'] === 'true';
+                        if (isGlobal) {
+                            this.globalRateLimit = Date.now() + retryAfter;
+                        }
+                        if (retryCount < 5) {
+                            this.emit('debug', `Rate limited (attempt ${retryCount + 1}), retrying in ${retryAfter}ms`);
+                            this.sleep(retryAfter).then(() => {
+                                this.request(options, retryCount + 1).then(resolve, reject);
+                            });
+                            return;
+                        }
+                        reject(new TavernAPIError('Rate limited', status, raw));
+                        return;
+                    }
+                    // Handle 204 (no content)
+                    if (status === 204 || !raw) {
+                        resolve(undefined);
+                        return;
+                    }
+                    // Parse JSON response
+                    let data;
+                    try {
+                        data = JSON.parse(raw);
+                    }
+                    catch {
+                        if (status >= 200 && status < 300) {
+                            resolve(undefined);
+                            return;
+                        }
+                        reject(new TavernAPIError(`HTTP ${status}: ${raw}`, status, raw));
+                        return;
+                    }
+                    // Success
+                    if (status >= 200 && status < 300) {
+                        resolve(data);
+                        return;
+                    }
+                    // Server errors - retry with backoff
+                    if (status >= 500 && retryCount < 3) {
+                        const backoff = Math.min(1000 * Math.pow(2, retryCount), 10000);
+                        this.emit('debug', `Server error ${status}, retrying in ${backoff}ms (attempt ${retryCount + 1})`);
+                        this.sleep(backoff).then(() => {
+                            this.request(options, retryCount + 1).then(resolve, reject);
+                        });
+                        return;
+                    }
+                    // Client/server error
+                    const errorMessage = typeof data === 'object' && data !== null && 'message' in data
+                        ? String(data.message)
+                        : `HTTP ${status}`;
+                    reject(new TavernAPIError(errorMessage, status, raw));
+                });
+            });
+            req.on('error', (error) => {
+                // Network errors - retry with backoff
+                if (retryCount < 3) {
+                    const backoff = Math.min(1000 * Math.pow(2, retryCount), 10000);
+                    this.emit('debug', `Network error: ${error.message}, retrying in ${backoff}ms`);
+                    this.sleep(backoff).then(() => {
+                        this.request(options, retryCount + 1).then(resolve, reject);
+                    });
+                    return;
+                }
+                reject(error);
+            });
+            if (bodyStr) {
+                req.write(bodyStr);
+            }
+            req.end();
+        });
+    }
+    updateRateLimits(bucketKey, headers) {
+        const limit = headers['x-ratelimit-limit'];
+        const remaining = headers['x-ratelimit-remaining'];
+        const reset = headers['x-ratelimit-reset'];
+        if (limit !== undefined && remaining !== undefined) {
+            this.buckets.set(bucketKey, {
+                limit: Number(limit),
+                remaining: Number(remaining),
+                reset: reset ? Number(reset) * 1000 : Date.now() + 1000,
+            });
+        }
+    }
+    parseRetryAfter(headers) {
+        const retryAfter = headers['retry-after'];
+        if (retryAfter) {
+            const seconds = Number(retryAfter);
+            return isNaN(seconds) ? 5000 : seconds * 1000;
+        }
+        return 5000;
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.RESTClient = RESTClient;
+// ─── API Error ──────────────────────────────────────────────
+class TavernAPIError extends Error {
+    constructor(message, status, body) {
+        super(message);
+        this.name = 'TavernAPIError';
+        this.status = status;
+        this.body = body;
+    }
+}
+exports.TavernAPIError = TavernAPIError;