lunibee 0.1.5 → 0.1.7

package/dist/rest/index.js

@@ -1,9 +1,64 @@
 // @bun
+// packages/rest/package.json
+var package_default = {
+  name: "@lunibee/rest",
+  version: "0.1.7",
+  type: "module",
+  module: "./src/index.ts",
+  types: "./src/index.ts",
+  exports: {
+    ".": "./src/index.ts"
+  }
+};
+
+// packages/rest/src/store.ts
+class MemoryRateLimitStore {
+  #buckets = new Map;
+  #routeBuckets = new Map;
+  #globalResetAt = 0;
+  static #PRUNE_INTERVAL = 60000;
+  #lastPruneAt = 0;
+  getBucketHash(route) {
+    return this.#routeBuckets.get(route);
+  }
+  setBucketHash(route, hash) {
+    this.#routeBuckets.set(route, hash);
+  }
+  getBucket(key) {
+    return this.#buckets.get(key);
+  }
+  updateBucket(key, state) {
+    this.#buckets.set(key, state);
+    const now = Date.now();
+    if (now - this.#lastPruneAt >= MemoryRateLimitStore.#PRUNE_INTERVAL) {
+      this.#lastPruneAt = now;
+      this.prune();
+    }
+  }
+  prune(maxAge = 0) {
+    const cutoff = Date.now() - Math.max(0, maxAge);
+    for (const [key, state] of this.#buckets) {
+      if (state.resetAt <= cutoff)
+        this.#buckets.delete(key);
+    }
+  }
+  getGlobalReset() {
+    return this.#globalResetAt;
+  }
+  setGlobalReset(resetAt) {
+    this.#globalResetAt = resetAt;
+  }
+}
+
 // packages/rest/src/routes.ts
 var Routes = {
   user: () => "/users/@me",
   userById: (userId) => `/users/${snowflake(userId, "User ID")}`,
   guild: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}`,
+  guildPreview: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/preview`,
+  guildActiveThreads: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/threads/active`,
+  guildWebhooks: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/webhooks`,
+  guildInvites: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/invites`,
   guildChannels: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/channels`,
   guildMember: (guildId, userId) => `/guilds/${snowflake(guildId, "Guild ID")}/members/${snowflake(userId, "User ID")}`,
   guildRoles: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/roles`,
@@ -31,7 +86,6 @@ var Routes = {
   guildApplicationCommand: (applicationId, guildId, commandId) => `/applications/${snowflake(applicationId, "Application ID")}/guilds/${snowflake(guildId, "Guild ID")}/commands/${snowflake(commandId, "Command ID")}`,
   interactionCallback: (interactionId, token) => `/interactions/${snowflake(interactionId, "Interaction ID")}/${encodeURIComponent(token)}/callback`,
   interactionOriginalResponse: (applicationId, token) => `/webhooks/${snowflake(applicationId, "Application ID")}/${encodeURIComponent(token)}/messages/@original`,
-  guildActiveThreads: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/threads/active`,
   channelPublicArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads/archived/public`,
   channelPrivateArchivedThreads: (channelId) => `/channels/${snowflake(channelId, "Channel ID")}/threads/archived/private`,
   threadMembers: (threadId) => `/channels/${snowflake(threadId, "Thread ID")}/thread-members`,
@@ -41,13 +95,122 @@ var Routes = {
   guildAutoModerationRule: (guildId, ruleId) => `/guilds/${snowflake(guildId, "Guild ID")}/auto-moderation/rules/${snowflake(ruleId, "Rule ID")}`,
   voiceRegions: () => "/voice/regions",
   gateway: () => "/gateway",
-  gatewayBot: () => "/gateway/bot"
+  gatewayBot: () => "/gateway/bot",
+  guildAuditLog: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/audit-logs`,
+  guildMembers: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/members`,
+  guildWelcomeScreen: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/welcome-screen`,
+  guildOnboarding: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/onboarding`,
+  guildPrune: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/prune`,
+  stageInstances: () => "/stage-instances",
+  stageInstanceByChannel: (channelId) => `/stage-instances/${snowflake(channelId, "Channel ID")}`,
+  invite: (code) => `/invites/${encodeURIComponent(code)}`,
+  guildVanity: (guildId) => `/guilds/${snowflake(guildId, "Guild ID")}/vanity-url`,
+  guildEmoji: (guildId, emojiId) => emojiId ? `/guilds/${snowflake(guildId, "Guild ID")}/emojis/${snowflake(emojiId, "Emoji ID")}` : `/guilds/${snowflake(guildId, "Guild ID")}/emojis`,
+  applicationEmoji: (applicationId, emojiId) => emojiId ? `/applications/${snowflake(applicationId, "Application ID")}/emojis/${snowflake(emojiId, "Emoji ID")}` : `/applications/${snowflake(applicationId, "Application ID")}/emojis`
 };
 function snowflake(value, field) {
   if (!/^\d{1,20}$/.test(value))
     throw new TypeError(`${field} must be a valid Discord snowflake.`);
   return value;
 }
+// packages/rest/src/redis.ts
+class RedisRateLimitStore {
+  #client;
+  #prefix;
+  #onErrorCallback;
+  #lastError;
+  constructor(options) {
+    this.#client = options.client;
+    this.#prefix = options.prefix ?? "lunibee:rest:";
+    this.#onErrorCallback = options.onError;
+  }
+  get lastError() {
+    return this.#lastError;
+  }
+  isHealthy() {
+    return this.#lastError === undefined;
+  }
+  #onError(operation, error) {
+    this.#lastError = error;
+    console.warn(`[lunibee/rest] Redis rate-limit store ${operation} failed; ` + `falling back to local limiting for this call.`, error);
+    try {
+      this.#onErrorCallback?.(operation, error);
+    } catch {}
+  }
+  #markHealthy() {
+    this.#lastError = undefined;
+  }
+  async getBucketHash(route) {
+    try {
+      const hash = await this.#client.get(`${this.#prefix}route:${route}`);
+      this.#markHealthy();
+      return hash ?? undefined;
+    } catch (error) {
+      this.#onError("getBucketHash", error);
+      return;
+    }
+  }
+  async setBucketHash(route, hash) {
+    try {
+      await this.#client.set(`${this.#prefix}route:${route}`, hash, "EX", 604800);
+      this.#markHealthy();
+    } catch (error) {
+      this.#onError("setBucketHash", error);
+    }
+  }
+  async getBucket(key) {
+    try {
+      const data = await this.#client.get(`${this.#prefix}bucket:${key}`);
+      this.#markHealthy();
+      if (!data)
+        return;
+      return JSON.parse(data);
+    } catch (error) {
+      this.#onError("getBucket", error);
+      return;
+    }
+  }
+  async updateBucket(key, state) {
+    const bucketKey = `${this.#prefix}bucket:${key}`;
+    const ttl = Math.ceil((state.resetAt - Date.now()) / 1000);
+    try {
+      if (ttl <= 0) {
+        await this.#client.del(bucketKey);
+        this.#markHealthy();
+        return;
+      }
+      await this.#client.set(bucketKey, JSON.stringify(state), "EX", ttl);
+      this.#markHealthy();
+    } catch (error) {
+      this.#onError("updateBucket", error);
+    }
+  }
+  async getGlobalReset() {
+    try {
+      const resetAt = await this.#client.get(`${this.#prefix}global`);
+      this.#markHealthy();
+      return resetAt ? Number(resetAt) : 0;
+    } catch (error) {
+      this.#onError("getGlobalReset", error);
+      return 0;
+    }
+  }
+  async setGlobalReset(resetAt) {
+    const globalKey = `${this.#prefix}global`;
+    const ttl = Math.ceil((resetAt - Date.now()) / 1000);
+    try {
+      if (ttl <= 0) {
+        await this.#client.del(globalKey);
+        this.#markHealthy();
+        return;
+      }
+      await this.#client.set(globalKey, String(resetAt), "EX", ttl);
+      this.#markHealthy();
+    } catch (error) {
+      this.#onError("setGlobalReset", error);
+    }
+  }
+}
 // packages/rest/src/webhook.ts
 class WebhookClient {
   id;
@@ -72,7 +235,7 @@ class WebhookClient {
     const payload = typeof options === "string" ? { content: options } : options;
     const { thread_id, ...body } = payload;
     const query = thread_id ? `?thread_id=${thread_id}&wait=true` : `?wait=true`;
-    const formattedEmbeds = body.embeds?.map((e) => typeof e === "object" && e !== null && ("toJSON" in e) ? e.toJSON() : e);
+    const formattedEmbeds = body.embeds?.map((e) => ("toJSON" in e) ? e.toJSON() : e);
     return this.#rest.post(`${Routes.webhook(this.id, this.token)}${query}`, {
       ...body,
       embeds: formattedEmbeds
@@ -104,6 +267,52 @@ class RESTError extends Error {
     this.path = options.path;
   }
 }
+var LIBRARY_VERSION = package_default.version;
+var LIBRARY_URL = "https://github.com/Ekretos/lunibee";
+var USER_AGENT = `DiscordBot (${LIBRARY_URL}, ${package_default.version})`;
+var REQUEST_DATA_KEYS = new Set([
+  "body",
+  "files",
+  "query",
+  "headers",
+  "reason",
+  "auth",
+  "signal"
+]);
+function isRequestData(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  if (Array.isArray(value))
+    return false;
+  if (typeof FormData !== "undefined" && value instanceof FormData)
+    return false;
+  if (value instanceof Blob || value instanceof Uint8Array || value instanceof ArrayBuffer)
+    return false;
+  const keys = Object.keys(value);
+  if (keys.length === 0)
+    return false;
+  return keys.every((key) => REQUEST_DATA_KEYS.has(key));
+}
+function serializeQuery(query) {
+  if (query === undefined)
+    return "";
+  if (typeof query === "string")
+    return query.length === 0 || query.startsWith("?") ? query : `?${query}`;
+  const params = query instanceof URLSearchParams ? query : new URLSearchParams(Object.entries(query).flatMap(([key, value]) => value === undefined || value === null ? [] : [[key, String(value)]]));
+  const serialized = params.toString();
+  return serialized.length === 0 ? "" : `?${serialized}`;
+}
+function majorParameter(path) {
+  const match = /^\/(channels|guilds|webhooks)\/(\d+)(?:\/([^/?]+))?/.exec(path);
+  if (!match)
+    return "@none";
+  if (match[1] === "webhooks" && match[3] !== undefined)
+    return `${match[2]}:${match[3]}`;
+  return match[2];
+}
+function scopeBucket(hashOrRoute, major) {
+  return `${hashOrRoute}|${major}`;
+}
 function createRetryPolicy(maxRetries = 2) {
   if (!Number.isFinite(maxRetries) || maxRetries < 0)
     throw new TypeError("maxRetries must be a non-negative finite number.");
@@ -126,14 +335,21 @@ class REST {
   #timeout;
   #retryPolicy;
   #token;
-  #globalResetAt = 0;
-  #buckets = new Map;
-  #routeBuckets = new Map;
+  #store;
+  #localQueues = new Map;
+  #hooks = {};
   constructor(options = {}) {
     this.#token = options.token;
     this.#timeout = Math.max(1, options.timeout ?? 15000);
     this.#retryPolicy = options.retryPolicy ?? createRetryPolicy(options.retries ?? 2);
     this.#baseURL = (options.baseURL ?? "https://discord.com/api/v10").replace(/\/$/, "");
+    this.#store = options.store ?? new MemoryRateLimitStore;
+    if (options.hooks)
+      this.#hooks = options.hooks;
+  }
+  setHooks(hooks) {
+    this.#hooks = hooks;
+    return this;
   }
   setToken(token) {
     if (!token.trim())
@@ -146,52 +362,91 @@ class REST {
       throw new TypeError("REST method is required.");
     if (!path.startsWith("/"))
       throw new TypeError("REST paths must start with '/'.");
+    const files = options.files;
+    if (files && files.length > 0 && !(body instanceof FormData))
+      body = this.#fileForm(body, files);
+    const query = serializeQuery(options.query);
+    const finalPath = query ? `${path}${query}` : path;
     const route = `${normalizedMethod}:${this.#normalizeRoute(path)}`;
-    let bucketKey = this.#routeBuckets.get(route) ?? route;
-    let bucket = this.#buckets.get(bucketKey) ?? {
-      remaining: 1,
-      resetAt: 0,
-      queue: Promise.resolve()
-    };
-    this.#buckets.set(bucketKey, bucket);
-    const previous = bucket.queue;
+    const major = majorParameter(path);
+    let bucketKey = scopeBucket(await this.#store.getBucketHash(route) ?? route, major);
+    const queueKey = bucketKey;
+    const previous = this.#localQueues.get(queueKey) ?? Promise.resolve();
     let release;
-    bucket.queue = new Promise((resolve) => {
+    const gate = new Promise((resolve) => {
       release = resolve;
     });
+    this.#localQueues.set(queueKey, gate);
     await this.#abortable(previous, options.signal, path);
     try {
       for (let attempt = 0;attempt <= this.#retryPolicy.maxRetries; attempt++) {
-        await this.#wait(bucket, options.signal, path);
+        await this.#wait(bucketKey, options.signal, path);
         await this.#waitGlobal(options.signal, path);
         const controller = new AbortController;
         const onAbort = () => controller.abort(options.signal?.reason);
         if (options.signal?.aborted)
           throw this.#abortError(path, options.signal.reason);
-        options.signal?.addEventListener("abort", onAbort, { once: true });
+        options.signal?.addEventListener("abort", onAbort, {
+          once: true
+        });
         const timer = setTimeout(() => controller.abort(new DOMException("REST request timeout", "TimeoutError")), this.#timeout);
+        const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
+        const headers = { ...options.headers };
+        if (options.auth !== false && this.#token)
+          headers["Authorization"] = `Bot ${this.#token}`;
+        headers["User-Agent"] = USER_AGENT;
+        if (options.reason !== undefined)
+          headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
+        if (!isFormData)
+          headers["Content-Type"] = "application/json";
+        const fetchBody = isFormData ? body : body === undefined ? undefined : JSON.stringify(body);
         try {
-          const response = await fetch(`${this.#baseURL}${path}`, {
+          this.#emit(this.#hooks.onRequest, {
+            method: normalizedMethod,
+            path,
+            attempt
+          });
+          const requestStart = Date.now();
+          const response = await fetch(`${this.#baseURL}${finalPath}`, {
             method: normalizedMethod,
-            headers: {
-              ...this.#token ? { Authorization: `Bot ${this.#token}` } : {},
-              "Content-Type": "application/json",
-              "User-Agent": "Lunibee/0.1.0"
-            },
-            body: body === undefined ? undefined : JSON.stringify(body),
+            headers,
+            body: fetchBody,
             signal: controller.signal
           });
-          bucket = this.#update(response, bucket, route, bucketKey);
-          bucketKey = this.#routeBuckets.get(route) ?? bucketKey;
+          this.#emit(this.#hooks.onResponse, {
+            method: normalizedMethod,
+            path,
+            status: response.status,
+            durationMs: Date.now() - requestStart
+          });
+          bucketKey = await this.#update(response, bucketKey, route, major);
           const payload = await this.#readPayload(response);
           if (response.ok)
             return response.status === 204 ? undefined : payload;
           const data = this.#errorData(payload);
           const retryAfter = response.status === 429 ? this.#retryAfter(response, data) : undefined;
-          if (data.global && retryAfter !== undefined)
-            this.#globalResetAt = Date.now() + retryAfter * 1000;
+          if (data.global && retryAfter !== undefined) {
+            const currentGlobal = await this.#store.getGlobalReset();
+            await this.#store.setGlobalReset(Math.max(currentGlobal, Date.now() + retryAfter * 1000));
+          }
+          if (response.status === 429)
+            this.#emit(this.#hooks.onRateLimit, {
+              method: normalizedMethod,
+              path,
+              retryAfterMs: (retryAfter ?? 1) * 1000,
+              global: data.global ?? false,
+              bucket: await this.#store.getBucketHash(route)
+            });
           if (attempt < this.#retryPolicy.maxRetries && this.#retryPolicy.shouldRetry(normalizedMethod, response.status)) {
-            await this.#sleep(this.#retryPolicy.getDelay(attempt, retryAfter), options.signal, path);
+            const delay = this.#retryPolicy.getDelay(attempt, retryAfter);
+            this.#emit(this.#hooks.onRetry, {
+              method: normalizedMethod,
+              path,
+              attempt,
+              status: response.status,
+              delayMs: delay
+            });
+            await this.#sleep(delay, options.signal, path);
             continue;
           }
           throw new RESTError(data.message ?? response.statusText ?? `Discord REST request failed with status ${response.status}`, response.status, data.code, payload, { method: normalizedMethod, path });
@@ -214,30 +469,64 @@ class REST {
       throw new RESTError("Discord REST request exhausted its retry attempts", 0, undefined, undefined, { method: normalizedMethod, path });
     } finally {
       release();
+      if (this.#localQueues.get(queueKey) === gate)
+        this.#localQueues.delete(queueKey);
     }
   }
+  #dispatch(method, path, bodyOrOptions, options) {
+    if (options === undefined && isRequestData(bodyOrOptions))
+      return this.request(method, path, bodyOrOptions.body, bodyOrOptions);
+    return this.request(method, path, bodyOrOptions, options);
+  }
   get(path, options) {
-    return this.request("GET", path, undefined, options);
+    return this.request("GET", path, options?.body, options);
   }
   post(path, body, options) {
-    return this.request("POST", path, body, options);
+    return this.#dispatch("POST", path, body, options);
   }
   patch(path, body, options) {
-    return this.request("PATCH", path, body, options);
+    return this.#dispatch("PATCH", path, body, options);
   }
   put(path, body, options) {
-    return this.request("PUT", path, body, options);
+    return this.#dispatch("PUT", path, body, options);
   }
   delete(path, options) {
-    return this.request("DELETE", path, undefined, options);
+    return this.request("DELETE", path, options?.body, options);
+  }
+  #fileForm(payload, files) {
+    const form = new FormData;
+    form.append("payload_json", JSON.stringify(payload));
+    for (let i = 0;i < files.length; i++) {
+      const file = files[i];
+      const blob = file.data instanceof Blob ? file.data : new Blob([file.data], {
+        type: file.contentType ?? "application/octet-stream"
+      });
+      form.append(`files[${i}]`, blob, file.name);
+    }
+    return form;
   }
-  async#wait(bucket, signal, path) {
+  postWithFiles(path, payload, files, options) {
+    return this.request("POST", path, this.#fileForm(payload, files), options);
+  }
+  patchWithFiles(path, payload, files, options) {
+    return this.request("PATCH", path, this.#fileForm(payload, files), options);
+  }
+  #emit(hook, ctx) {
+    if (!hook)
+      return;
+    Promise.resolve().then(() => hook(ctx)).catch(() => {});
+  }
+  async#wait(bucketKey, signal, path) {
+    const bucket = await this.#store.getBucket(bucketKey);
+    if (!bucket)
+      return;
     const delay = bucket.resetAt - Date.now();
     if (bucket.remaining <= 0 && delay > 0)
       await this.#sleep(delay, signal, path);
   }
   async#waitGlobal(signal, path) {
-    const delay = this.#globalResetAt - Date.now();
+    const globalResetAt = await this.#store.getGlobalReset();
+    const delay = globalResetAt - Date.now();
     if (delay > 0)
       await this.#sleep(delay, signal, path);
   }
@@ -301,16 +590,17 @@ class REST {
     const routePath = queryIndex === -1 ? path : path.slice(0, queryIndex);
     return routePath.replace(/\/\d+(?=\/|$)/g, "/:id");
   }
-  #update(response, bucket, route, bucketKey) {
+  async#update(response, bucketKey, route, major) {
+    let currentKey = bucketKey;
     const serverBucket = response.headers.get("X-RateLimit-Bucket");
     if (serverBucket) {
-      this.#routeBuckets.set(route, serverBucket);
-      if (serverBucket !== bucketKey) {
-        const shared = this.#buckets.get(serverBucket) ?? bucket;
-        this.#buckets.set(serverBucket, shared);
-        bucket = shared;
-      }
+      await this.#store.setBucketHash(route, serverBucket);
+      currentKey = scopeBucket(serverBucket, major);
     }
+    let bucket = await this.#store.getBucket(currentKey) ?? {
+      remaining: 1,
+      resetAt: 0
+    };
     const remaining = Number(response.headers.get("X-RateLimit-Remaining"));
     const resetAfter = Number(response.headers.get("X-RateLimit-Reset-After"));
     const reset = Number(response.headers.get("X-RateLimit-Reset"));
@@ -325,20 +615,26 @@ class REST {
       if (Number.isFinite(retryAfter))
         bucket.resetAt = Math.max(bucket.resetAt, Date.now() + retryAfter * 1000);
     }
+    await this.#store.updateBucket(currentKey, bucket);
     if (response.headers.get("X-RateLimit-Global") === "true") {
       const retryAfter = Number(response.headers.get("Retry-After"));
-      if (Number.isFinite(retryAfter))
-        this.#globalResetAt = Math.max(this.#globalResetAt, Date.now() + retryAfter * 1000);
+      if (Number.isFinite(retryAfter)) {
+        const currentGlobal = await this.#store.getGlobalReset();
+        await this.#store.setGlobalReset(Math.max(currentGlobal, Date.now() + retryAfter * 1000));
+      }
     }
-    return bucket;
+    return currentKey;
   }
 }
 export {
+  RESTError as DiscordAPIError,
+  MemoryRateLimitStore,
   REST,
   RESTError,
+  RedisRateLimitStore,
   Routes,
   WebhookClient,
   createRetryPolicy
 };
 
-//# debugId=69F9FDE9A0B8ECD864756E2164756E21
+//# debugId=7273A79583E1900164756E2164756E21