revbot.js 0.2.5 → 0.2.6

package/dist/index.js

@@ -468,6 +468,9 @@ var Events = /* @__PURE__ */ ((Events2) => {
   Events2["TYPING_START"] = "typingStart";
   Events2["TYPING_STOP"] = "typingStop";
   Events2["USER_UPDATE"] = "userUpdate";
+  Events2["WEBHOOKS_CREATE"] = "webhookCreate";
+  Events2["WEBHOOKS_DELETE"] = "webhookDelete";
+  Events2["WEBHOOKS_UPDATE"] = "webhookUpdate";
   return Events2;
 })(Events || {});
 var WSEvents = /* @__PURE__ */ ((WSEvents2) => {
@@ -501,6 +504,9 @@ var WSEvents = /* @__PURE__ */ ((WSEvents2) => {
   WSEvents2["SERVER_UPDATE"] = "ServerUpdate";
   WSEvents2["USER_RELATIONSHIP"] = "UserRelationship";
   WSEvents2["USER_UPDATE"] = "UserUpdate";
+  WSEvents2["WEBHOOKS_CREATE"] = "WebhooksCreate";
+  WSEvents2["WEBHOOKS_DELETE"] = "WebhooksDelete";
+  WSEvents2["WEBHOOKS_UPDATE"] = "WebhooksUpdate";
   return WSEvents2;
 })(WSEvents || {});
 var ChannelTypes = /* @__PURE__ */ ((ChannelTypes2) => {
@@ -1472,6 +1478,237 @@ var Channel = class extends Base {
   fetch(force = true) {
     return this.client.channels.fetch(this, { force });
   }
+  edit(data) {
+    return __async(this, null, function* () {
+      const id = this.id;
+      if (!id) {
+        throw new TypeError("INVALID_ID");
+      }
+      const response = yield this.client.api.patch(`/channels/${id}`, {
+        body: data
+      });
+      return response;
+    });
+  }
+  // Implementation
+  setRolePermissions(roleId, allowOrOptions, deny) {
+    return __async(this, null, function* () {
+      const id = this.id;
+      if (!id) {
+        throw new TypeError("INVALID_ID");
+      }
+      let allow;
+      let denyPermissions;
+      if (Array.isArray(allowOrOptions)) {
+        allow = allowOrOptions;
+        denyPermissions = deny;
+      } else if (allowOrOptions && typeof allowOrOptions === "object") {
+        allow = allowOrOptions.allow;
+        denyPermissions = allowOrOptions.deny;
+        if (allow === void 0 && denyPermissions === void 0) {
+          throw new TypeError(
+            "At least one of 'allow' or 'deny' must be provided in options"
+          );
+        }
+      } else {
+        throw new TypeError("Invalid arguments provided");
+      }
+      const requestBody = {
+        allow: 0,
+        deny: 0
+      };
+      if (allow !== void 0) {
+        requestBody.allow = new FullPermissions(allow).bitfield;
+      }
+      if (denyPermissions !== void 0) {
+        requestBody.deny = new FullPermissions(denyPermissions).bitfield;
+      }
+      yield this.client.api.put(`/channels/${id}/permissions/${roleId}`, {
+        body: { permissions: requestBody }
+      });
+    });
+  }
+  // Implementation
+  setDefaultPermissions(allowOrOptionsOrPermissions) {
+    return __async(this, null, function* () {
+      const id = this.id;
+      if (!id) {
+        throw new TypeError("INVALID_ID");
+      }
+      let allow;
+      let deny;
+      if (Array.isArray(allowOrOptionsOrPermissions)) {
+        allow = allowOrOptionsOrPermissions;
+      } else if (allowOrOptionsOrPermissions && typeof allowOrOptionsOrPermissions === "object") {
+        if ("a" in allowOrOptionsOrPermissions || "d" in allowOrOptionsOrPermissions) {
+          const legacyPerms = allowOrOptionsOrPermissions;
+          allow = legacyPerms.a;
+          deny = legacyPerms.d;
+        } else {
+          const options = allowOrOptionsOrPermissions;
+          allow = options.allow;
+          deny = options.deny;
+          if (allow === void 0 && deny === void 0) {
+            throw new TypeError(
+              "At least one of 'allow' or 'deny' must be provided in options"
+            );
+          }
+        }
+      } else {
+        throw new TypeError("Invalid arguments provided");
+      }
+      const requestBody = {};
+      if (allow !== void 0) {
+        requestBody.allow = new FullPermissions(allow).bitfield;
+      }
+      if (deny !== void 0) {
+        requestBody.deny = new FullPermissions(deny).bitfield;
+      }
+      if (requestBody.allow === void 0) {
+        requestBody.allow = 0;
+      }
+      if (requestBody.deny === void 0) {
+        requestBody.deny = 0;
+      }
+      yield this.client.api.put(`/channels/${id}/permissions/default`, {
+        body: { permissions: requestBody }
+      });
+    });
+  }
+  /**
+   * Creates a new webhook in this channel.
+   *
+   * @param name - The name of the webhook
+   * @param avatar - Optional avatar for the webhook. Can be a URL string, Readable stream, or File object
+   * @returns Promise resolving to the created webhook response
+   *
+   * @example
+   * ```typescript
+   * const webhook = await channel.createWebhook("My Webhook", "https://example.com/avatar.png");
+   * ```
+   */
+  createWebhook(name, avatar) {
+    return __async(this, null, function* () {
+      return this.client.webhooks.create(this.id, name, avatar);
+    });
+  }
+  /**
+   * Retrieves all webhooks for this channel.
+   *
+   * @returns Promise resolving to an array of webhook responses
+   *
+   * @example
+   * ```typescript
+   * const webhooks = await channel.getWebhooks();
+   * console.log(`Found ${webhooks.length} webhooks`);
+   * ```
+   */
+  getWebhooks() {
+    return __async(this, null, function* () {
+      return this.client.webhooks.getAll(this.id);
+    });
+  }
+  /**
+   * Retrieves a specific webhook by ID and token.
+   *
+   * @param webhookId - The ID of the webhook to retrieve
+   * @param token - The token of the webhook
+   * @returns Promise resolving to the webhook response
+   *
+   * @example
+   * ```typescript
+   * const webhook = await channel.getWebhook("webhookId", "webhookToken");
+   * console.log(`Webhook name: ${webhook.name}`);
+   * ```
+   */
+  getWebhook(webhookId, token) {
+    return __async(this, null, function* () {
+      return this.client.webhooks.get(webhookId, token);
+    });
+  }
+  /**
+   * Sends a message through a webhook in this channel.
+   *
+   * @param webhookId - The ID of the webhook to send the message through
+   * @param token - The token of the webhook
+   * @param content - The message content. Can be a string or MessageOptions object with attachments and embeds
+   * @returns Promise resolving to the sent message
+   *
+   * @example
+   * ```typescript
+   * // Send a simple text message
+   * await channel.sendWebhookMessage("webhookId", "token", "Hello, world!");
+   *
+   * // Send a message with embeds and attachments
+   * await channel.sendWebhookMessage("webhookId", "token", {
+   *   content: "Check out this image!",
+   *   attachments: ["https://example.com/image.png"],
+   *   embeds: [myEmbed]
+   * });
+   * ```
+   */
+  sendWebhookMessage(webhookId, token, content) {
+    return __async(this, null, function* () {
+      return this.client.webhooks.send(webhookId, token, content);
+    });
+  }
+  /**
+   * Deletes a webhook.
+   *
+   * @param webhookId - The ID of the webhook to delete
+   * @param token - The token of the webhook
+   * @returns Promise that resolves when the webhook is deleted
+   *
+   * @example
+   * ```typescript
+   * await channel.deleteWebhook("webhookId", "webhookToken");
+   * console.log("Webhook deleted successfully");
+   * ```
+   */
+  deleteWebhook(webhookId, token) {
+    return __async(this, null, function* () {
+      return this.client.webhooks.delete(webhookId, token);
+    });
+  }
+  /**
+   * Edits a webhook's properties.
+   *
+   * @param webhookId - The ID of the webhook to edit
+   * @param token - The token of the webhook
+   * @param options - The options to edit on the webhook
+   * @returns Promise resolving to the updated webhook response
+   *
+   * @example
+   * ```typescript
+   * const updatedWebhook = await channel.editWebhook("webhookId", "token", {
+   *   name: "New Webhook Name",
+   *   avatar: "https://example.com/new-avatar.png"
+   * });
+   * ```
+   */
+  editWebhook(webhookId, token, options) {
+    return __async(this, null, function* () {
+      return this.client.webhooks.edit(webhookId, token, options);
+    });
+  }
+  /**
+   * Retrieves partial information about a webhook using only its ID.
+   * This method provides limited webhook information without requiring a token.
+   *
+   * @param webhookId - The ID of the webhook to retrieve partial information for
+   * @returns Promise resolving to the webhook response with partial information
+   *
+   * @example
+   * ```typescript
+   * const partialWebhook = await channel.getPartialWebhook("webhookId");
+   * console.log(`Webhook name: ${partialWebhook.name}`);
+   * ```
+   */
+  getPartialWebhook(webhookId) {
+    return __async(this, null, function* () {
+      return this.client.webhooks.getPartial(webhookId);
+    });
+  }
 };
 
 // src/struct/dmChannel.ts
@@ -3374,17 +3611,283 @@ var ServerMemberManager = class extends BaseManager {
   }
 };
 
+// src/managers/webhookManager.ts
+var import_stream3 = require("stream");
+var import_axios3 = __toESM(require("axios"));
+var import_form_data3 = __toESM(require("form-data"));
+var WebhookManager = class {
+  /**
+   * Creates a new WebhookManager instance.
+   *
+   * @param client - The client instance this manager belongs to
+   */
+  constructor(client3) {
+    this.client = client3;
+  }
+  /**
+   * Creates a new webhook in the specified channel.
+   *
+   * @param channelId - The ID of the channel where the webhook will be created
+   * @param name - The name of the webhook
+   * @param avatar - Optional avatar for the webhook. Can be a URL string, Readable stream, or File object
+   * @returns Promise resolving to the created webhook response
+   *
+   * @example
+   * ```typescript
+   * const webhook = await client.webhooks.create("channelId", "My Webhook", "https://example.com/avatar.png");
+   * ```
+   */
+  create(channelId, name, avatar) {
+    return __async(this, null, function* () {
+      const data = new import_form_data3.default();
+      let avatarID = void 0;
+      if (typeof avatar === "string") {
+        const readableStream = yield import_axios3.default.get(avatar, {
+          responseType: "stream"
+        });
+        data.append("file", readableStream.data, {
+          filename: avatar.split("/").pop()
+        });
+      }
+      if (avatar instanceof import_stream3.Readable) {
+        data.append("file", avatar, { filename: "avatar.png" });
+      }
+      if (avatar instanceof File) {
+        const buffer = Buffer.from(yield avatar.arrayBuffer());
+        data.append("file", buffer, { filename: avatar.name });
+      }
+      if (avatar) {
+        yield this.client.cdn.post("/avatars", data).then((attachment) => {
+          const { id } = attachment;
+          avatarID = id;
+        });
+      }
+      const response = yield this.client.api.post(
+        `/channels/${channelId}/webhooks`,
+        {
+          body: {
+            name,
+            avatar: avatarID
+          }
+        }
+      );
+      return response;
+    });
+  }
+  /**
+   * Retrieves all webhooks for the specified channel.
+   *
+   * @param channelId - The ID of the channel to get webhooks from
+   * @returns Promise resolving to an array of webhook responses
+   *
+   * @example
+   * ```typescript
+   * const webhooks = await client.webhooks.getAll("channelId");
+   * console.log(`Found ${webhooks.length} webhooks`);
+   * ```
+   */
+  getAll(channelId) {
+    return __async(this, null, function* () {
+      const response = yield this.client.api.get(
+        `/channels/${channelId}/webhooks`
+      );
+      return response;
+    });
+  }
+  /**
+   * Retrieves a specific webhook by ID and token.
+   *
+   * @param webhookId - The ID of the webhook to retrieve
+   * @param token - The token of the webhook
+   * @returns Promise resolving to the webhook response
+   *
+   * @example
+   * ```typescript
+   * const webhook = await client.webhooks.get("webhookId", "webhookToken");
+   * console.log(`Webhook name: ${webhook.name}`);
+   * ```
+   */
+  get(webhookId, token) {
+    return __async(this, null, function* () {
+      const response = yield this.client.api.get(
+        `/webhooks/${webhookId}/${token}`
+      );
+      return response;
+    });
+  }
+  /**
+   * Sends a message through a webhook.
+   *
+   * @param webhookId - The ID of the webhook to send the message through
+   * @param token - The token of the webhook
+   * @param content - The message content. Can be a string or MessageOptions object with attachments and embeds
+   * @returns Promise resolving to the sent message
+   *
+   * @example
+   * ```typescript
+   * // Send a simple text message
+   * await client.webhooks.send("webhookId", "token", "Hello, world!");
+   *
+   * // Send a message with embeds and attachments
+   * await client.webhooks.send("webhookId", "token", {
+   *   content: "Check out this image!",
+   *   attachments: ["https://example.com/image.png"],
+   *   embeds: [myEmbed]
+   * });
+   * ```
+   */
+  send(webhookId, token, content) {
+    return __async(this, null, function* () {
+      if (typeof content === "string") content = { content };
+      let attachments = [];
+      let embeds = [];
+      if (Array.isArray(content.attachments)) {
+        const promises = content.attachments.map((att) => __async(this, null, function* () {
+          const data = new import_form_data3.default();
+          if (typeof att === "string") {
+            const readableStream = yield import_axios3.default.get(att, {
+              responseType: "stream"
+            });
+            data.append("file", readableStream.data, {
+              filename: att.split("/").pop()
+            });
+          }
+          if (att instanceof import_stream3.Readable) {
+            data.append("file", att);
+          }
+          if (att instanceof File) {
+            const buffer = Buffer.from(yield att.arrayBuffer());
+            data.append("file", buffer, { filename: att.name });
+          }
+          yield this.client.cdn.post("/attachments", data).then((attachment) => {
+            const { id } = attachment;
+            attachments.push(id);
+          });
+        }));
+        yield Promise.all(promises);
+      }
+      if (Array.isArray(content.embeds)) {
+        const promises = content.embeds.map((embed) => __async(this, null, function* () {
+          const json = yield embed.toJSONWithMedia(this.client);
+          embeds.push(json);
+        }));
+        yield Promise.all(promises);
+      }
+      const resp = yield this.client.api.post(
+        `/webhooks/${webhookId}/${token}`,
+        {
+          body: __spreadProps(__spreadValues({}, content), { attachments, embeds, nonce: UUID.generate() })
+        }
+      );
+      return resp;
+    });
+  }
+  /**
+   * Deletes a webhook.
+   *
+   * @param webhookId - The ID of the webhook to delete
+   * @param token - The token of the webhook
+   * @returns Promise that resolves when the webhook is deleted
+   *
+   * @example
+   * ```typescript
+   * await client.webhooks.delete("webhookId", "webhookToken");
+   * console.log("Webhook deleted successfully");
+   * ```
+   */
+  delete(webhookId, token) {
+    return __async(this, null, function* () {
+      yield this.client.api.delete(`/webhooks/${webhookId}/${token}`);
+    });
+  }
+  /**
+   * Edits a webhook's properties.
+   *
+   * @param webhookId - The ID of the webhook to edit
+   * @param token - The token of the webhook
+   * @param options - The options to edit on the webhook
+   * @returns Promise resolving to the updated webhook response
+   *
+   * @example
+   * ```typescript
+   * const updatedWebhook = await client.webhooks.edit("webhookId", "token", {
+   *   name: "New Webhook Name",
+   *   avatar: "https://example.com/new-avatar.png"
+   * });
+   * ```
+   */
+  edit(webhookId, token, options) {
+    return __async(this, null, function* () {
+      var _a;
+      const data = new import_form_data3.default();
+      let avatarID = void 0;
+      if (typeof options.avatar === "string") {
+        const readableStream = yield import_axios3.default.get(options.avatar, {
+          responseType: "stream"
+        });
+        data.append("file", readableStream.data, {
+          filename: options.avatar.split("/").pop()
+        });
+      }
+      if (options.avatar instanceof import_stream3.Readable) {
+        data.append("file", options.avatar, { filename: "avatar.png" });
+      }
+      if (options.avatar instanceof File) {
+        const buffer = Buffer.from(yield options.avatar.arrayBuffer());
+        data.append("file", buffer, { filename: options.avatar.name });
+      }
+      if (options.avatar) {
+        yield this.client.cdn.post("/avatars", data).then((attachment) => {
+          const { id } = attachment;
+          avatarID = id;
+        });
+      }
+      const response = yield this.client.api.patch(
+        `/webhooks/${webhookId}/${token}`,
+        {
+          body: __spreadProps(__spreadValues({}, options), {
+            avatar: avatarID,
+            remove: (_a = options.remove) != null ? _a : []
+          })
+        }
+      );
+      return response;
+    });
+  }
+  /**
+   * Retrieves partial information about a webhook using only its ID.
+   * This method provides limited webhook information without requiring a token.
+   *
+   * @param webhookId - The ID of the webhook to retrieve partial information for
+   * @returns Promise resolving to the webhook response with partial information
+   *
+   * @example
+   * ```typescript
+   * const partialWebhook = await client.webhooks.getPartial("webhookId");
+   * console.log(`Webhook name: ${partialWebhook.name}`);
+   * ```
+   */
+  getPartial(webhookId) {
+    return __async(this, null, function* () {
+      const response = yield this.client.api.get(
+        `/webhooks/${webhookId}`
+      );
+      return response;
+    });
+  }
+};
+
 // src/client/baseClient.ts
 var import_node_events = require("events");
 
 // src/rest/restClient.ts
-var import_axios4 = __toESM(require("axios"));
+var import_axios5 = __toESM(require("axios"));
 
 // package.json
-var version = "0.2.5";
+var version = "0.2.6";
 
 // src/rest/restUtils/rateLimitQueue.ts
-var import_axios3 = __toESM(require("axios"));
+var import_axios4 = __toESM(require("axios"));
 var RateLimitQueue = class {
   constructor() {
     this.bucketMap = /* @__PURE__ */ new Map();
@@ -3413,7 +3916,7 @@ var RateLimitQueue = class {
   }
   _doRequest(config, path) {
     return __async(this, null, function* () {
-      const response = yield (0, import_axios3.default)(config);
+      const response = yield (0, import_axios4.default)(config);
       this._updateRateLimit(path, response);
       return response;
     });
@@ -3479,7 +3982,7 @@ var RestClient = class {
    */
   request(method, url, body, query, retry) {
     return __async(this, null, function* () {
-      var _a, _b, _c, _d, _e;
+      var _a, _b, _c, _d, _e, _f;
       try {
         if (!this.client.token) throw new Error("Token is required");
         const authHeader = this.client.bot ? "X-Bot-Token" : "X-Session-Token";
@@ -3499,13 +4002,20 @@ var RestClient = class {
         return response.data;
       } catch (error) {
         if (retry) throw typeof error;
-        if (error instanceof import_axios4.AxiosError) {
+        if (error instanceof import_axios5.AxiosError) {
           if (error.status && (error.status === 429 || error.status >= 500)) {
             return this.retryRequest(0, method, url, body, query);
           }
           if (error.status) {
+            if (process.env.NODE_ENV === "test") {
+              console.error("Error details:", error);
+              console.error("Error response data:", (_e = error.response) == null ? void 0 : _e.data);
+              console.error("Error request config:", error.config);
+              console.error("Error message:", error.message);
+              console.error("Error URL:", url);
+            }
             throw new Error(
-              `API call failed with status ${error.status}: ${(_e = error.response) == null ? void 0 : _e.statusText}`
+              `API call failed with status ${error.status}: ${(_f = error.response) == null ? void 0 : _f.statusText}`
             );
           }
         }
@@ -3519,7 +4029,7 @@ var RestClient = class {
     return __async(this, null, function* () {
       var _a, _b;
       try {
-        const response = yield import_axios4.default.get(
+        const response = yield import_axios5.default.get(
           `${((_a = this.client.options.rest) == null ? void 0 : _a.instanceURL) ? (_b = this.client.options.rest) == null ? void 0 : _b.instanceURL : apiUrl}/`
         );
         const config = response.data;
@@ -3619,7 +4129,7 @@ var RestClient = class {
 };
 
 // src/rest/CDNClient.ts
-var import_axios5 = require("axios");
+var import_axios6 = require("axios");
 var CDNClient = class {
   constructor(client3) {
     this.client = client3;
@@ -3657,7 +4167,7 @@ var CDNClient = class {
         return response.data;
       } catch (error) {
         if (retry) throw typeof error;
-        if (error instanceof import_axios5.AxiosError) {
+        if (error instanceof import_axios6.AxiosError) {
           if (error.status && (error.status === 429 || error.status >= 500)) {
             return this.retryRequest(0, method, url, data, query);
           }
@@ -4269,6 +4779,58 @@ var MessageUnreact = class extends Event {
   }
 };
 
+// src/client/events/webhookCreate.ts
+var WebhookCreate = class extends Event {
+  /**
+   * Handles the webhook create event.
+   * @param {id: string, channel_id: string, server_id: string, name: string} data - The data for the event, containing the webhook ID, channel ID, server ID, and name.
+   * @returns {void}
+   */
+  handle(data) {
+    const webhookData = {
+      webhookId: data.id,
+      channelId: data.channel_id,
+      name: data.name,
+      creatorId: data.creator_id,
+      token: data.token
+    };
+    this.client.emit("webhookCreate" /* WEBHOOKS_CREATE */, webhookData);
+  }
+};
+
+// src/client/events/webhookDelete.ts
+var WebhookDelete = class extends Event {
+  /**
+   * Handles the webhook delete event.
+   * @param {id: string, channel_id: string, server_id: string} data - The data for the event, containing the webhook ID, channel ID, and server ID.
+   * @returns {void}
+   */
+  handle(data) {
+    const webhookData = {
+      webhookId: data.id
+    };
+    this.client.emit("webhookDelete" /* WEBHOOKS_DELETE */, webhookData);
+  }
+};
+
+// src/client/events/webhookUpdate.ts
+var WebhookUpdate = class extends Event {
+  /**
+   * Handles the webhook update event.
+   * @param {id: string, data: { name: string; avatar?: { _id: string; tag: string; filename: string; metadata: any; content_type: string; size: number; }; remove: string[]; }} data- The data for the event, containing the webhook ID and updated webhook data.
+   * @returns {void}
+   */
+  handle(data) {
+    const webhookData = {
+      webhookId: data.id,
+      name: data.data.name,
+      avatar: data.data.avatar,
+      remove: data.data.remove
+    };
+    this.client.emit("webhookUpdate" /* WEBHOOKS_UPDATE */, webhookData);
+  }
+};
+
 // src/client/events/index.ts
 var EventMap = {
   bulkMessageDelete: BulkMessageDelete,
@@ -4292,7 +4854,10 @@ var EventMap = {
   serverUpdate: ServerUpdate,
   userUpdate: UserUpdate,
   messageReact: MessageReact,
-  messageUnreact: MessageUnreact
+  messageUnreact: MessageUnreact,
+  webhookCreate: WebhookCreate,
+  webhookDelete: WebhookDelete,
+  webhookUpdate: WebhookUpdate
 };
 
 // src/client/events/eventManager.ts
@@ -4684,6 +5249,8 @@ var client2 = class extends BaseClient {
     this.users = new UserManager(this);
     /** Manages the events in the client. */
     this.events = new EventManager(this);
+    /** Manages the webhooks in the client. */
+    this.webhooks = new WebhookManager(this);
     /** The authenticated user, or `null` if not logged in. */
     this.user = null;
     /** The timestamp when the client became ready, or `null` if not ready. */