@jnode/discord 1.0.18 → 2.0.1

package/README.md

@@ -1,189 +1,165 @@
-# JustDiscord
+# `@jnode/discord`
 
 Simple Discord API package for Node.js.
 
-```shell
-npm install @jnode/discord
-```
+**Note:** This package requires Node.js **v22.4.0** or later to use the built-in `WebSocket` for Discord gateway connections.
 
-## Basic Usage
+## Installation
 
-### Import JustDiscord
-```js
-const discord = require('@jnode/discord');
 ```
+npm i @jnode/discord
+```
+
+## Quick start
+
+### Import
 
-### Create a Client
 ```js
-const client = new discord.Client('BOT_TOKEN');
+const { Client, Attachment } = require('@jnode/discord');
 ```
 
-### Connect to Discord Gateway
+### Start a simple "Ping-Pong" bot
+
 ```js
-client.connectGateway((gateway) => {
-    // receive Discord gateway "READY" event
-    gateway.on('READY', (d) => {
-        console.log('Connected to Discord.');
+const client = new Client('YOUR_BOT_TOKEN');
+
+// Initialize the gateway to receive events
+const gateway = client.gateway({
+  intents: 3276799 // All intents (ensure they are enabled in dev portal)
+});
+
+// Listen for message events
+gateway.on('MESSAGE_CREATE', async (message) => {
+  if (message.content === '!ping') {
+    // Send a reply using the REST client
+    await client.request('POST', `/channels/${message.channel_id}/messages`, {
+      content: 'Pong!'
     });
+  }
 });
 ```
 
-## Class: `Client`
-
-The main class for interacting with the Discord API and Gateway.
+### Sending files (Attachments)
 
-### Constructor
 ```js
-new discord.Client(token, options = {})
+const fs = require('fs');
+
+async function sendImage(channelId) {
+  const fileData = fs.readFileSync('./image.png');
+  const image = new Attachment('image.png', 'image/png', fileData);
+
+  await client.request('POST', `/channels/${channelId}/messages`, 
+    { content: 'Here is your image!' },
+    [image] // Pass attachments as an array
+  );
+}
 ```
-- `token`: Your Discord bot token.
-- `options`: An optional object for setting various client options:
-  - `apiVersion`: The Discord API version. Default is `10`.
-  - `apiBase`: The base URL of the Discord API. Default is `discord.com/api`.
-  - `apiAutoRetry`: Whether to auto-retry requests when receiving a 429 error. Default is `true`.
-  - `apiThrowError`: Whether to throw errors when the API status code is not 2xx. Default is `true`.
-  - `gatewayIntents`: The gateway intents used for connecting to the Gateway. Default is `0b11111111111111111000110011`. You can find more about intents in the [Discord Developer Documentation](https://discord.com/developers/docs/events/gateway).
-  - `gatewayUrl`: The base URL for the Discord Gateway. Default is `wss://gateway.discord.gg`.
-  - `gatewayReconnectDelay`: The delay (in milliseconds) before attempting to reconnect to the gateway. Default is `5000`. Set to less than 0 to disable auto-reconnect.
-  - `gatewayConnectTimeout`: The timeout (in milliseconds) before giving up on connecting to the gateway. Default is `5000`. Set to less than 0 to disable connect timeout.
-  - `gatewayThrowError`: Whether to throw errors when the gateway encounters an issue. Default is `true`.
-
-### Methods
-
-- `apiUrl(path)`: Returns the full API URL with the base, version, and given path.
-    - `path`: API endpoint path. Example: `/channels/123456789`.
-    - **Returns**: `string` - The full API URL. Example: `https://discord.com/api/v10/channels/123456789`.
-
-- `async apiRequest(method = 'GET', path = '/', body)`: Makes an HTTP request to the Discord API, find out more at [Discord Developer Documentation](https://discord.com/developers/docs).
-    - `method`: HTTP method (e.g. `GET`, `POST`, `PUT`, `DELETE`). Default is `GET`.
-    - `path`: API endpoint path. Default is `/`. Example: `/channels/123456789/messages`.
-    - `body`: Request body data (will be stringified). Example: `{ content: 'Hello, Discord!' }`.
-    - **Returns**: `Promise<RequestResponse>` - A promise that resolves to a `RequestResponse` object.
-    - **Example**:
-    ```js
-    client.apiRequest('POST', '/channels/123456789/messages', { content: 'Hello, Discord!' })
-    .then(res => {
-        if (res.statusCode === 200) {
-            console.log('Message sent successfully!');
-        } else {
-            console.error('Failed to send message:', res.statusCode, res.text());
-        }
-    }).catch(err => {
-        console.error('Error sending message:', err);
-    });
-    ```
-
-- `async apiRequestMultipart(method = 'GET', path = '/', body, attachments = [])`: Makes a multipart HTTP request to the Discord API.
-    - `method`: HTTP method (e.g. `GET`, `POST`, `PUT`, `DELETE`). Default is `GET`.
-    - `path`: API endpoint path. Default is `/`. Example: `/channels/123456789/messages`.
-    - `body`: Request body data (will be stringified). Example: `{ content: 'Hello, Discord!' }`.
-    - `attachments`: An array of attachments, each attachment is an object:
-        - `name`: Name of the file. Example: `image.png`
-        - `type` (Optional): Content type of the data. Defaults to `application/octet-stream`.
-        - `data` (Option 1): Data (string or Buffer) of this file.
-        - `file` (Option 2): Path to a local file.
-        - `encoded`/`base64` (Option 3): base64 encoded data string.
-        - `stream` (Option 4): Any readable stream.
-    - **Returns**: `Promise<RequestResponse>` - A promise that resolves to a `RequestResponse` object.
-    - **Example**:
-    ```js
-    const fs = require('fs').promises;
-
-    async function uploadFile(channelId, filePath) {
-        const fileData = await fs.readFile(filePath);
-        const fileType = 'image/png';
-        const fileName = 'my_image.png';
-
-        client.apiRequestMultipart('POST', `/channels/${channelId}/messages`, { content: 'Here\'s an image!' }, [{
-            name: fileName,
-            type: fileType,
-            data: fileData
-        }]).then(res => {
-            if (res.statusCode === 200) {
-                console.log('File uploaded successfully!');
-            } else {
-                console.error('Failed to upload file:', res.statusCode, res.text());
-            }
-        }).catch(err => {
-            console.error('Error uploading file:', err);
-        });
-    }
-    uploadFile('123456789', './my_image.png');
-    ```
-
-- `async connectGateway(cb)`: Connects to the Discord Gateway.
-    - `cb`: A callback function that takes a `gateway` object as an argument.
-    - **Returns**: `Promise<Gateway>` - A promise that resolves to a `Gateway` object.
-    - **Example**:
-    ```js
-    client.connectGateway((gateway) => {
-        gateway.on('READY', (data) => {
-            console.log('Connected to Discord, user id:', data.user.id);
-        });
-        gateway.on('MESSAGE_CREATE', (message) => {
-            if (message.content === '!ping') {
-               console.log('Recieve Ping Message')
-            }
-        });
-    });
-    ```
-
-## Class: `Gateway`
-
-Manages the Discord Gateway connection for receiving real-time events. You can find more about gateway events in the [Discord Developer Documentation](https://discord.com/developers/docs/events/gateway).
-
-### Events
-
-- `socketOpened`: Emitted when the WebSocket connection is opened.
-  - `event`: A WebSocket event object.
-- `socketClosed`: Emitted when the WebSocket connection is closed.
-  - `event`: A WebSocket event object.
-- `socketError`: Emitted when a WebSocket error occurs.
-  - `event`: A WebSocket event object.
-- `socketMessage`: Emitted when a raw WebSocket message is received.
-    - `event`: A WebSocket event object.
-- `message`: Emitted when a complete JSON payload is received.
-    - `data`: A JSON object.
-- Discord Gateway Event (`READY`, `MESSAGE_CREATE`... etc.): The gateway will auto dispatch discord events. Check [Discord Developer Documentation](https://discord.com/developers/docs/events/gateway-events) for all avaliable events. The event callback will be a data object from discord.
-
-### Methods
-
-- `async getGatewayUrl()`: Retrieves the gateway URL from the Discord API.
-    - **Returns**: `Promise<string>` - A promise that resolves to the gateway URL.
-
-- `connect()`: Opens the WebSocket connection to the Discord Gateway.
-
-- `sendMessage(op, d = null)`: Sends a message to the Discord Gateway.
-    - `op`: Opcode of the message. Check [Discord Developer Documentation](https://discord.com/developers/docs/events/gateway-events) for all avaliable opcodes.
-    - `d`: Payload of the message.
-     - **Example**:
-    ```js
-    gateway.sendMessage(1, {}); //send heartbeat
-    gateway.sendMessage(2, { //Identify
-        token: 'BOT_TOKEN',
-        properties: {
-            os: process.platform,
-            browser: 'Node.js',
-            device: 'JustDiscord'
-        },
-        intents: 0b11111111111111111000110011 //replace with your intents
-    });
-    ```
 
-## Class: `DiscordAPIError`
+## How it works?
+
+`@jnode/discord` provides a lightweight wrapper around the Discord REST API and WebSocket Gateway.
+
+1. **REST Client (`Client`)**: Handles all HTTP requests to Discord (messages, channel management, etc.). It includes built-in support for rate-limit auto-retries and multipart/form-data for file uploads.
+2. **Gateway (`Gateway`)**: An `EventEmitter` that maintains a WebSocket connection to Discord. it handles heartbeats, identifies your bot, and emits events when things happen on Discord (like a new message or a member joining).
+
+We keep it simple: no heavy abstractions, just the tools you need to interact with the API directly.
+
+------
+
+# Reference
+
+## Class: `discord.Client`
+
+The main controller for interacting with the Discord REST API.
+
+### `new discord.Client(token[, options])`
+
+- `token` [\<string\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#string_type) Your Discord Bot token.
+- `options` [\<Object\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)
+  - `baseUrl` [\<string\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#string_type) The API root. **Default:** `'https://discord.com/api/v10'`.
+  - `autoRetry` [\<boolean\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#boolean_type) Whether to automatically wait and retry when hit by a **429** Rate Limit. **Default:** `true`.
+
+### `client.request(method, path[, body, attachments, options])`
+
+- `method` [\<string\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#string_type) HTTP method (e.g., `'GET'`, `'POST'`, `'PATCH'`). **Default:** `'GET'`.
+- `path` [\<string\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#string_type) The API endpoint path (e.g., `'/channels/123/messages'`).
+- `body` [\<Object\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) The JSON payload to send.
+- `attachments` [\<discord.Attachment[]\>](#class-discordattachment) An array of attachment objects for file uploads.
+- `options` [\<Object\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)
+  - `auditLog` [\<string\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#string_type) Reason to be displayed in the Discord Audit Log.
+  - `headers` [\<Object\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) Additional HTTP headers.
+  - `requestOptions` [\<Object\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) Options passed to the underlying `@jnode/request`.
+- Returns: [\<Promise\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) Fulfills with the parsed JSON response, or `null` if status is **204**.
+
+### `client.gateway([options])`
+
+- `options` [\<Object\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) Options for the gateway (see [`discord.Gateway`](#class-discordgateway)).
+- Returns: [\<discord.Gateway\>](#class-discordgateway) A new gateway instance.
+
+## Class: `discord.Gateway`
+
+- Extends: [\<EventEmitter\>](https://nodejs.org/docs/latest/api/events.html#class-eventemitter)
+
+Handles the WebSocket connection to receive real-time events.
+
+### `new discord.Gateway(client[, options])`
+
+- `client` [\<discord.Client\>](#class-discordclient) An instance of the Discord client.
+- `options` [\<Object\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)
+  - `intents` [\<number\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#number_type) Gateway intents bitmask. **Default:** `3276799` (All non-privileged).
+  - `reconnectDelay` [\<number\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#number_type) Delay (ms) before reconnecting after a close. **Default:** `5000`.
+  - `connectTimeout` [\<number\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#number_type) Timeout (ms) for the initial connection. **Default:** `5000`.
+  - `apiVersion` [\<number\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#number_type) Discord Gateway version. **Default:** `10`.
+  - `heartbeatJitter` [\<number\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#number_type) Coefficient for heartbeat interval jitter. **Default:** `0.9`.
+  - `heartbeatAckTimeout` [\<number\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#number_type) Timeout (ms) to wait for a heartbeat ACK before closing. **Default:** `3000`.
+  - `presence` [\<Object\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) Initial presence information.
+  - `shard` [\<number[]\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) Array of two integers `[shard_id, num_shards]`.
+
+### `gateway.send(op[, d])`
+
+- `op` [\<number\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#number_type) Gateway Opcode.
+- `d` [\<any\>] Data payload.
+
+Sends a raw event through the gateway.
+
+### `gateway.close()`
+
+Closes the WebSocket connection.
+
+### Event: `'socketOpen'`
+
+Emitted when the WebSocket connection is established.
+
+### Event: `'socketClose'`
+
+- `event` [\<CloseEvent\>]
+
+Emitted when the WebSocket connection is closed.
+
+### Event: `'message'`
+
+- `data` [\<Object\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)
+
+Emitted for every raw message received from the gateway.
+
+### Event: `<DISPATCH_EVENT_NAME>`
+
+- `data` [\<Object\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)
+
+Emitted when a specific Discord Dispatch event is received (Opcode 0). E.G., `'READY'`, `'MESSAGE_CREATE'`, `'GUILD_CREATE'`.
+
+### Event: `'error'`
+
+- `err` [\<Error\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
 
-An error that is thrown when the Discord API returns a non-2xx status code.
+Emitted when a critical gateway error occurs (e.g., invalid token).
 
-### Properties
+## Class: `discord.Attachment`
 
-- `message`: The error message.
-- `body`: The response body.
-- `headers`: The response headers.
+Represents a file to be uploaded.
 
-## Helper functions
+### `new discord.Attachment(filename, type, body)`
 
-- `RequestResponse` class with properties like:
-    - `statusCode`: Status code.
-    - `headers`: Response headers.
-    - `text(encoding)`: Return response body in string, with optional encoding. Example: `res.text('utf-8')`.
-    - `json()`: Return response body in JSON format, or `undefined` when cannot parse JSON. Example: `res.json()`.
+- `filename` [\<string\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#string_type) The name of the file (e.g., `'photo.jpg'`).
+- `type` [\<string\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#string_type) The MIME type (e.g., `'image/jpeg'`).
+- `body` [\<Buffer\>](https://nodejs.org/docs/latest/api/buffer.html#class-buffer) | [\<string\>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#string_type) The actual file content.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jnode/discord",
-  "version": "1.0.18",
+  "version": "2.0.1",
   "description": "Simple Discord API package for Node.js.",
   "main": "src/index.js",
   "scripts": {
@@ -25,6 +25,6 @@
     "node": ">=22.4.0"
   },
   "dependencies": {
-    "@jnode/request": ">=1.1.3 <2.0.0"
+    "@jnode/request": "^2.1.3"
   }
 }

package/src/attachment.js

@@ -0,0 +1,21 @@
+/*
+@jnode/discord/attachment.js
+v2
+
+Simple Discord API package for Node.js.
+Must use Node.js v22.4.0 or later for WebSocket (Discord gateway).
+
+by JustApple
+*/
+
+// attachment class
+class Attachment {
+    constructor(filename, type, body) {
+        this.filename = filename;
+        this.type = type;
+        this.body = body;
+    }
+}
+
+// export
+module.exports = Attachment;

package/src/client.js

@@ -1,125 +1,85 @@
 /*
-JustDiscord/client.js
-v.1.0.0
+@jnode/discord/client.js
+v2
 
 Simple Discord API package for Node.js.
 Must use Node.js v22.4.0 or later for WebSocket (Discord gateway).
 
-by JustNode Dev Team / JustApple
+by JustApple
 */
 
-//load jnode packages
-const request = require('@jnode/request');
-
-//load classes and functions
+// dependencies
+const { request, FormPart } = require('@jnode/request');
 const DiscordGateway = require('./gateway.js');
 
-//error types
-//errors from Discord API
+// errors from Discord API
 class DiscordAPIError extends Error {
-	constructor(code, body, headers) {
-		super(`Discord API respond with code ${code}.`);
-		this.body = body;
-		this.headers = headers;
+	constructor(res) {
+		super(`Discord API respond with code ${res.statusCode}.`);
+		this.res = res;
 	}
 }
 
-//Discord Client, everything starts here
+// Discord client
 class DiscordClient {
 	constructor(token, options = {}) {
 		this.token = token;
 
-		//client api options
-		this.apiVersion = options.apiVersion ?? 10;
-		this.apiBase = options.apiBase ?? 'discord.com/api';
-		this.apiAutoRetry = options.apiAutoRetry ?? true;
-		this.apiThrowError = options.apiThrowError ?? true; //throw error while api status code is not 2xx
-
-		//client gateway options
-		this.gatewayIntents = options.gatewayIntents ?? 0b11001100011111111111111111;
-		this.gatewayUrl = options.gatewayUrl ?? 'wss://gateway.discord.gg';
-		this.gatewayOriginalUrl = this.gatewayUrl;
-		this.gatewayReconnectDelay = options.gatewayReconnectDelay ?? 5000; //less than 0 to disable auto reconnect
-		this.gatewayConnectTimeout = options.gatewayConnectTimeout ?? 5000; //less than 0 to disable connect timeout (may cause error)
-		this.gatewayThrowError = options.gatewayThrowError ?? true; //throw error while gateway went something wrong
-
-		//gateway
-		this.gateway = new DiscordGateway(this);
+		// client api options
+		this.baseUrl = options.baseUrl ?? 'https://discord.com/api/v10';
+		this.autoRetry = options.autoRetry ?? true;
 	}
 
-	//get full api url with base, version and path
-	apiUrl(path) {
-		return `https://${this.apiBase}/v${this.apiVersion}${path}`;
-	}
+	// make request
+	async request(method = 'GET', path = '/', body, attachments = [], options = {}) {
+		// generate body
+		let reqBody;
+		if (!attachments?.length) {
+			reqBody = JSON.stringify(body);
+		} else {
+			reqBody = [new FormPart('payload_json', JSON.stringify(body), { 'Content-Type': 'application/json' })];
+
+			// add every attachment
+			for (let i in attachments) {
+				attachments[i].name = attachments[i].name ?? `files[${i}]`;
+				reqBody.push(attachments[i]);
+			}
+		}
 
-	//make an request to Discord
-	async apiRequest(method = 'GET', path = '/', body) {
-		const res = await request.request(method, this.apiUrl(path), {
+		// make request
+		const res = await request(method, this.baseUrl + path, reqBody, {
 			'Authorization': `Bot ${this.token}`,
 			'User-Agent': 'DiscordBot',
-			'Content-Type': (body !== undefined) ? 'application/json' : null
-		}, (body !== undefined) ? JSON.stringify(body) : undefined); //make an request
-
-		if ((res.statusCode === 429) && this.apiAutoRetry) { //retry if recieved 429
-			await delay(res.json().retry_after);
-			return this.apiRequest(method, path, body);
-		}
-
-		if (((res.statusCode > 299) || (res.statusCode < 200)) && this.apiThrowError) { //throw error if not 2xx
-			throw new DiscordAPIError(res.statusCode, res.json() ?? res.text(), res.headers);
+			'Content-Type': (body !== undefined) ? 'application/json' : null,
+			'X-Audit-Log-Reason': options.auditLog ? encodeURIComponent(options.auditLog) : null,
+			...options.headers
+		}, options.requestOptions);
+
+		// retry if recieved 429
+		if ((res.statusCode === 429) && this.autoRetry) {
+			await delay((await res.json()).retry_after * 1000);
+			return this.request(method, path, body, attachments, options);
 		}
 
-		return res;
-	}
+		// throw error if not 2xx
+		if ((res.statusCode > 299) || (res.statusCode < 200)) throw new DiscordAPIError(res);
 
-	//make an multi part request to Discord
-	async apiRequestMultipart(method = 'GET', path = '/', body, attachments = []) {
-		let parts = [];
-		parts.push({ //json data
-			disposition: 'form-data; name="payload_json"',
-			type: 'application/json',
-			data: JSON.stringify(body)
-		});
-
-		for (let i = 0; i < attachments.length; i++) { //add every attachment
-			parts.push({
-				disposition: `form-data; name="files[${i}]"; filename="${encodeURIComponent(attachments[i].name)}"`,
-				type: attachments[i].type,
-				data: attachments[i].data,
-				base64: attachments[i].encoded ?? attachments[i].base64,
-				stream: attachments[i].stream,
-				file: attachments[i].file
-			});
-		}
-
-		const res = await request.multipartRequest(method, this.apiUrl(path), {
-			'Authorization': `Bot ${this.token}`,
-			'User-Agent': 'DiscordBot'
-		}, parts); //make an request
-
-		if ((res.statusCode === 429) && this.apiAutoRetry) { //retry if recieved 429
-			await delay(res.json().retry_after);
-			return this.apiRequestMultipart(method, path, body, attachments);
-		}
-
-		if (((res.statusCode > 299) || (res.statusCode < 200)) && this.apiThrowError) { //throw error if not 2xx
-			throw new DiscordAPIError(res.statusCode, res.json() ?? res.text(), res.headers);
+		try {
+			return (res.statusCode === 204) ? null : await res.json();
+		} catch {
+			return await res.text();
 		}
-
-		return res;
 	}
 
-	async connectGateway(cb) {
-		await this.gateway.getGatewayUrl();
-		this.gateway.connect();
-		if (cb) cb(this.gateway);
-		return this.gateway;
+	gateway(options) {
+		return new DiscordGateway(this, options);
 	}
 }
 
-//wait time (ms)
+// wait time (ms)
 function delay(ms) {
 	return new Promise((resolve, reject) => { setTimeout(resolve, ms); });
 }
 
+// export
 module.exports = DiscordClient;

package/src/gateway.js

@@ -1,6 +1,6 @@
 /*
-JustDiscord/gateway.js
-v.1.0.0
+@jnode/discord/gateway.js
+v2
 
 Simple Discord API package for Node.js.
 Must use Node.js v22.4.0 or later for WebSocket (Discord gateway).
@@ -8,144 +8,176 @@ Must use Node.js v22.4.0 or later for WebSocket (Discord gateway).
 by JustNode Dev Team / JustApple
 */
 
-//load classes and functions
-//errors from Discord Gateway
-class DiscordGatewayError extends Error { constructor(...i) { super(...i); } }
-
-//load node packages
+// dependencies
 const EventEmitter = require('events');
 
-//Discord Gateway, recieve live messages with WebSocket
+// Discord gateway, recieve live events with WebSocket
 class DiscordGateway extends EventEmitter {
-	constructor(client) {
+	constructor(client, options = {}) {
 		super();
-		
+
 		this.client = client;
-		this.socket = {};
-		this.s = null;
-	}
-	
-	//get gateway url from api
-	async getGatewayUrl() {
-		const res = await this.client.apiRequest('GET', '/gateway/bot'); //make an api request
-		this.client.gatewayUrl = res.json().url;
-		this.client.gatewayOriginalUrl = res.json().url;
-		return res.json().url;
+
+		// gateway options
+		this.intents = options.intents ?? 0b11001100011111111111111111;
+		this.reconnectDelay = options.reconnectDelay ?? 5000;
+		this.connectTimeout = options.connectTimeout ?? 5000;
+		this.apiVersion = options.apiVersion ?? 10;
+		this.heartbeatJitter = options.heartbeatJitter ?? 0.9;
+		this.heartbeatAckTimeout = options.heartbeatAckTimeout ?? 3000;
+		this.shard = options.shard;
+		this.largeThreshold = options.largeThreshold;
+		this.presence = options.presence;
+
+		this._s = null;
+
+		// connect anyways
+		this.connect();
 	}
-	
-	//connect to gateway
-	connect() {
-		if ((this.socket.readyState !== 3) && this.socket.close) this.socket.close(); //close privous connect
-		
-		this.socket = new WebSocket(`${this.client.gatewayUrl}?v=${this.client.apiVersion}&encoding=json`); //connect
-		
-		if (this.client.gatewayConnectTimeout !== 0) { //set connect timeout
-			this.connectTimeout = setTimeout(() => {
-				this.socket.close(); //close socket
+
+	// connect to gateway
+	async connect() {
+		// get gateway url
+		const gatewayUrl = this._resumeUrl ?? this.client._gatewayUrl ?? (this.client._gatewayUrl = (await this.client.request('GET', '/gateway/bot')).url);
+
+		// create connection
+		this.socket = new WebSocket(`${gatewayUrl}?v=${this.apiVersion}&encoding=json`);
+
+		// connect timeout
+		if (this.connectTimeout > 0) {
+			clearTimeout(this._connectTimeout);
+			this._connectTimeout = setTimeout(() => {
+				this.socket.close();
 				this.emit('timeout');
-				
-				if (this.client.gatewayReconnectDelay >= 0) { //if auto reconnect is allowed
-					setTimeout(() => {
-						this.connect();
-					}, this.client.gatewayReconnectDelay); //reconnect after specific time
-				}
-			}, this.client.gatewayConnectTimeout);
+			}, this.connectTimeout);
 		}
-		
-		this.socket.addEventListener('open', (event) => { //socket opened
-			this.emit('socketOpened', event); //send event with socket event
-			clearTimeout(this.connectTimeout); //clear timeout if successfully connected
+
+		// socket open
+		this.socket.addEventListener('open', (event) => {
+			this.emit('socketOpen', event);
 		});
-		
-		this.socket.addEventListener('close', (event) => { //socket closed
-			this.emit('socketClosed', event); //send event with event (may have close code and reason)
-			clearInterval(this.heartbeatInterval); //clear heatbeat interval
-			
-			
-			if (this.client.gatewayReconnectDelay >= 0) { //if auto reconnect is allowed
+
+		// socket close
+		this.socket.addEventListener('close', (event) => {
+			this.emit('socketClose', event);
+			clearTimeout(this._connectTimeout);
+			clearInterval(this._heartbeatInterval);
+			clearTimeout(this._heartbeatTimeout);
+
+			// error close
+			if ([4004, 4010, 4011, 4012, 4013, 4014].includes(event.code)) {
+				const err = new Error(event.reason);
+				err.code = event.code;
+				this.emit('error', err);
+				return;
+			}
+
+			// reconnect
+			if (this.reconnectDelay >= 0) {
 				setTimeout(() => {
 					this.connect();
-				}, this.client.gatewayReconnectDelay); //reconnect after specific time
+				}, this.reconnectDelay);
 			}
 		});
-		
-		this.socket.addEventListener('error', (event) => { //socket error
-			this.emit('socketError', event); //send event with event (may have error info)
+
+		// error
+		this.socket.addEventListener('error', (event) => {
+			this.emit('socketError', event);
 		});
-		
-		this.socket.addEventListener('message', (event) => { //recieve gateway message
-			try {
-				this.emit('socketMessage', event); //send event with event (may have data and more)
-				
-				const data = JSON.parse(event.data); //parse json data
-				this.emit('message', data); //send event with json data
-				
-				//auto handle by op
-				switch (data.op) {
-					case 0: //Dispatch
-						this.emit(data.t, data.d); //send t event with d
-						this.s = data.s ?? this.s; //save s number there is
-						
-						//auto handle by t
-						switch (data.t) {
-							case 'READY': //save resume data
-								this.sessionId = data.d['session_id'];
-								this.client.gatewayUrl = data.d['resume_gateway_url'];
-								break;
-							default:
-								break;
-						}
-						break;
-					case 7: //Reconnect, need to reconnect
-						this.socket.close(); //close socket
-						break;
-					case 9: //Invalid Session, need to reconnect
-						this.client.gatewayUrl = this.client.gatewayOriginalUrl; //reset url
-						this.sessionId = undefined; //reset session id
-						this.socket.close(); //close socket
-						break;
-					case 10: //Hello
-						this.heartbeatIntervalMS = data.d['heartbeat_interval'] * 0.9; //save heart beat interval time
-						this.sendMessage(1); //send first heartbeat
-						
-						clearInterval(this.heartbeatInterval); //clear old interval
-						this.heartbeatInterval = setInterval(() => { //start heartbeat interval
-							this.sendMessage(1);
-						}, this.heartbeatIntervalMS);
-						
-						if (this.sessionId) { //may be resumed
-							this.sendMessage(6, { //Resume
-								token: this.client.token,
-								session_id: this.sessionId,
-								seq: this.s
-							});
-						} else { //start new session
-							this.sendMessage(2, { //Identify
-								token: this.client.token,
-								properties: {
-									os: process.platform,
-									browser: 'Node.js',
-									device: 'JustDiscord'
-								},
-								intents: this.client.gatewayIntents
-							});
-						}
-						break;
-					default:
-						break;
-				}
-			} catch (err) {
-				if (this.client.gatewayThrowError) { //throw gateway error
-					err.name = 'DiscordGatewayError'; //change the name of the error
-					throw err;
-				}
+
+		// message
+		this.socket.addEventListener('message', (event) => {
+			this.emit('socketMessage', event);
+
+			const data = JSON.parse(event.data);
+			this.emit('message', data);
+
+			// handle by op
+			switch (data.op) {
+				case 0: // dispatch
+					this.emit(data.t, data.d);
+					this._s = data.s ?? this._s;
+
+					// ready event
+					if (data.t === 'READY') {
+						this._sessionId = data.d.session_id;
+						this._resumeUrl = data.d.resume_gateway_url;
+					}
+					break;
+				case 7: // reconnect
+					this.socket.close();
+
+					break;
+				case 9: // invaild session
+					if (!data.d) { // start new connection
+						this._resumeUrl = null;
+						this._sessionId = null;
+						this._s = null;
+					}
+					this.socket.close();
+					break;
+				case 10: // hello
+					clearTimeout(this._connectTimeout);
+
+					this.heartbeat();
+
+					// start heatbeat interval
+					clearInterval(this._heartbeatInterval);
+					this._heartbeatInterval = setInterval(() => {
+						this.heartbeat();
+					}, data.d.heartbeat_interval * this.heartbeatJitter);
+
+					// start identify or resume
+					if (this._sessionId && this._resumeUrl) { // resume
+						this.send(6, {
+							token: this.client.token,
+							session_id: this._sessionId,
+							seq: this._s
+						});
+					} else { // identify
+						this.send(2, {
+							token: this.client.token,
+							intents: this.intents,
+							properties: {
+								os: process.platform,
+								browser: 'jnode_discord',
+								device: 'jnode_discord'
+							},
+							presence: this.presence,
+							shard: this.shard,
+							large_threshold: this.largeThreshold
+						});
+					}
+
+					break;
+				case 11: // heartbeat ack
+					clearTimeout(this._heartbeatTimeout);
+					break;
 			}
 		});
 	}
-	
-	sendMessage(op, d = null) {
+
+	heartbeat() {
+		this.send(1, this._s);
+
+		// could not receive heartbeat ack
+		clearTimeout(this._heartbeatTimeout);
+		this._heartbeatTimeout = setTimeout(() => {
+			this.emit('heartbeatTimeout');
+			this.socket.close();
+		}, this.heartbeatAckTimeout);
+	}
+
+	// sends a gateway event
+	send(op, d = null) {
 		this.socket.send(JSON.stringify({ op, d }));
 	}
+
+	// closes the gateway
+	close() {
+		this.socket.close();
+	}
 }
 
+// export
 module.exports = DiscordGateway;

package/src/index.js

@@ -1,14 +1,16 @@
 /*
-JustDiscord/index.js
-v.1.0.0
+@jnode/discord/index.js
+v2
 
 Simple Discord API package for Node.js.
 Must use Node.js v22.4.0 or later for WebSocket (Discord gateway).
 
-by JustNode Dev Team / JustApple
+by JustApple
 */
 
+// export
 module.exports = {
+	Attachment: require('./attachment.js'),
 	Client: require('./client.js'),
 	Gateway: require('./gateway.js')
 };