@bakit/gateway 2.1.8 → 3.0.0

package/dist/cluster.js

@@ -0,0 +1,23 @@
+import { Cluster, ClusterProcess } from '@bakit/gateway';
+
+// src/lib/internal/cluster.ts
+var {
+  BAKIT_CLUSTER_ID,
+  BAKIT_DISCORD_TOKEN,
+  BAKIT_DISCORD_INTENTS,
+  BAKIT_DISCORD_GATEWAY_URL,
+  BAKIT_DISCORD_GATEWAY_VERSION,
+  BAKIT_CLUSTER_SHARD_TOTAL,
+  BAKIT_CLUSTER_SHARD_LIST
+} = process.env, cluster = new Cluster(Number(BAKIT_CLUSTER_ID), {
+  token: BAKIT_DISCORD_TOKEN,
+  intents: Number(BAKIT_DISCORD_INTENTS),
+  total: Number(BAKIT_CLUSTER_SHARD_TOTAL),
+  shards: JSON.parse(BAKIT_CLUSTER_SHARD_LIST),
+  gateway: {
+    baseURL: BAKIT_DISCORD_GATEWAY_URL,
+    version: Number(BAKIT_DISCORD_GATEWAY_VERSION)
+  }
+});
+ClusterProcess.bindProcess(cluster);
+await cluster.spawn();

package/dist/index.d.ts

@@ -1,155 +1,201 @@
-import { EventBus, ReadonlyCollection } from '@bakit/utils';
-import { GatewayReadyDispatchData, GatewayReceivePayload, GatewayDispatchPayload, GatewaySendPayload } from 'discord-api-types/gateway';
-import { ValueOf } from 'type-fest';
-import { GatewayReadyDispatchData as GatewayReadyDispatchData$1, GatewayReceivePayload as GatewayReceivePayload$1, GatewayDispatchPayload as GatewayDispatchPayload$1, GatewaySendPayload as GatewaySendPayload$1 } from 'discord-api-types/v10';
-import { REST } from '@bakit/rest';
+import EventEmitter from 'node:events';
+import { GatewayReadyDispatchData, GatewayReceivePayload, GatewayDispatchPayload, GatewaySendPayload } from 'discord-api-types/v10';
+import { ChildProcess } from 'node:child_process';
+import { Collection } from '@bakit/utils';
+import { REST, RESTProxy } from '@bakit/rest';
 
+declare enum ShardState {
+    Idle = 0,
+    Connecting = 1,
+    Ready = 2,
+    Resuming = 3,
+    Disconnecting = 4,
+    Disconnected = 5
+}
+declare enum ShardStrategy {
+    Resume = 0,
+    Reconnect = 1,
+    Shutdown = 2
+}
 interface ShardOptions {
-    id: number;
     total: number;
     token: string;
     intents: number | bigint;
-    gateway?: ShardGatewayOptions;
-}
-interface ShardGatewayOptions {
-    baseURL: string;
-    version: number;
+    gateway: {
+        baseURL: string;
+        version: number;
+    };
 }
 interface ShardEvents {
-    ready: [payload: GatewayReadyDispatchData];
+    ready: [data: GatewayReadyDispatchData];
     disconnect: [code: number];
     resume: [];
     error: [error: Error];
     debug: [message: string];
     raw: [payload: GatewayReceivePayload];
     dispatch: [payload: GatewayDispatchPayload];
-    requestIdentify: [];
-}
-/**
- * High-level lifecycle state of the shard connection.
- */
-declare const ShardState: {
-    /** Not connected. */
-    Idle: number;
-    /** Initialzing connection. */
-    Connecting: number;
-    /** Connected to gateway and identified. */
-    Ready: number;
-    /** Resuming the session. */
-    Resuming: number;
-    /** Disconnected the connection. */
-    Disconnected: number;
-};
-type ShardState = ValueOf<typeof ShardState>;
-/**
- * Strategy describes *what to do next after a disconnect*.
- * This is intentionally separate from ShardState.
- */
-declare const ShardStrategy: {
-    /** No decision yet (default on close). */
-    Unknown: number;
-    /** Reconnect with IDENTIFY (new session). */
-    Reconnect: number;
-    /** Reconnect and try RESUME. */
-    Resume: number;
-    /** Do not reconnect. */
-    Shutdown: number;
-};
-type ShardStrategy = ValueOf<typeof ShardStrategy>;
-interface Shard extends EventBus<ShardEvents> {
+    needIdentify: [];
+}
+declare class Shard extends EventEmitter<ShardEvents> {
+    #private;
     readonly id: number;
-    readonly state: ShardState;
-    readonly latency: number;
+    readonly options: ShardOptions;
+    constructor(id: number, options: ShardOptions);
+    get state(): ShardState;
+    get latency(): number;
+    get resumable(): boolean;
     connect(): Promise<void>;
-    disconnect(code?: number): Promise<void>;
-    send(payload: GatewaySendPayload): void;
+    disconnect(code: number): Promise<void>;
+    resume(): void;
     identify(): void;
+    send(payload: GatewaySendPayload): void;
+    sendHeartbeat(): void;
 }
-/**
- * Creates a shard object which can be used to connect to the Discord gateway.
- *
- * @param {ShardOptions} options - The options to create the shard with.
- * @returns {Shard} - The created shard object.
- */
-declare function createShard(options: ShardOptions): Shard;
 
-interface GatewayWorkerOptions {
-    id: number;
-    total: number;
+interface ClusterOptions {
     token: string;
-    intents: number | bigint;
+    intents: bigint | number;
     shards: number[];
-    gatewayURL: string;
-}
-interface GatewayWorker extends EventBus<GatewayWorkerEvents> {
-    readonly id: number;
-    readonly shards: ReadonlyCollection<number, Shard>;
-    readonly shardIds: number[];
-    readonly latency: number;
-    readonly state: GatewayWorkerState;
-    start(): Promise<void>;
-    stop(code?: number): Promise<void>;
-    /**
-     * Broadcast the given payload to all shards connections.
-     * @param {GatewaySendPayload} payload - The payload to send.
-     */
-    broadcast(payload: GatewaySendPayload$1): void;
+    total: number;
+    gateway: {
+        baseURL: string;
+        version: number;
+    };
 }
-interface GatewayWorkerEvents {
-    ready: [];
-    stop: [];
-    resume: [];
-    degrade: [readyCount: number, total: number];
-    shardReady: [shardId: number, payload: GatewayReadyDispatchData$1];
-    shardDisconnect: [shardId: number, code: number];
-    shardRaw: [shardId: number, payload: GatewayReceivePayload$1];
-    shardDispatch: [shardId: number, payload: GatewayDispatchPayload$1];
-    shardRequestIdentify: [shardId: number];
+interface ClusterEvents {
+    shardAdd: [id: number];
+    shardReady: [id: number];
+    shardDisconnect: [id: number, code: number];
+    shardResume: [id: number];
+    shardError: [id: number, error: Error];
+    needIdentify: [id: number];
     debug: [message: string];
+    dispatch: [shardId: number, payload: GatewayDispatchPayload];
+    raw: [shardId: number, payload: GatewayReceivePayload];
+    ready: [];
     error: [error: Error];
 }
-declare const GatewayWorkerState: {
-    readonly Idle: 0;
-    readonly Starting: 1;
-    readonly Ready: 2;
-    readonly Degraded: 3;
-    readonly Stopped: 4;
-};
-type GatewayWorkerState = ValueOf<typeof GatewayWorkerState>;
-declare function createWorker(options: GatewayWorkerOptions): GatewayWorker;
-declare function bindWorkerToProcess(worker: GatewayWorker): void;
-declare function getWorkerOptions(): GatewayWorkerOptions;
+declare class Cluster extends EventEmitter<ClusterEvents> {
+    #private;
+    readonly id: number;
+    readonly options: ClusterOptions;
+    readonly shards: Collection<number, Shard>;
+    constructor(id: number, options: ClusterOptions);
+    get size(): number;
+    get ready(): boolean;
+    spawn(): Promise<void>;
+    shutdown(code?: number): Promise<void>;
+    broadcast(fn: (shard: Shard) => void): void;
+    send(payload: GatewaySendPayload): void;
+    send(shardId: number, payload: GatewaySendPayload): void;
+}
 
-declare const DEFAULT_WORKER_PATH: string;
-interface GatewayManagerOptions {
+interface ShardingManagerOptions {
     token: string;
-    intents: number | bigint;
-    workerPath?: string;
-    gatewayURL?: string;
+    intents: bigint | number;
     totalShards?: number | "auto";
-    shardsPerWorker?: number;
+    shardsPerCluster?: number;
 }
-declare const DEFAULT_GATEWAY_MANAGER_OPTIONS: {
-    readonly gatewayURL: "wss://gateway.discord.gg";
-    readonly totalShards: "auto";
-    readonly shardsPerWorker: 5;
-};
-interface GatewayManagerEvents {
-    error: [error: Error];
-    shardReady: [workerId: number, shardId: number, payload: GatewayReadyDispatchData$1];
-    shardDisconnect: [workerId: number, shardId: number, code?: number];
-    shardRaw: [workerId: number, shardId: number, payload: GatewayReceivePayload$1];
-    shardDispatch: [workerId: number, shardId: number, payload: GatewayDispatchPayload$1];
-    workerReady: [workerId: number];
-    workerStop: [workerId: number];
-}
-interface GatewayManager extends EventBus<GatewayManagerEvents> {
-    readonly rest: REST;
+interface ShardingManagerEvents {
+    shardAdd: [cluster: ClusterProcess, shardId: number];
+    shardReady: [cluster: ClusterProcess, shardId: number];
+    shardDisconnect: [cluster: ClusterProcess, shardId: number, code: number];
+    shardResume: [cluster: ClusterProcess, shardId: number];
+    shardError: [cluster: ClusterProcess, shardId: number, error: Error];
+    clusterCreate: [cluster: ClusterProcess];
+    clusterReady: [cluster: ClusterProcess];
+    clusterExit: [cluster: ClusterProcess, code: number | null];
+    clusterError: [cluster: ClusterProcess, error: Error];
+    dispatch: [cluster: ClusterProcess, shardId: number, payload: GatewayDispatchPayload];
+    raw: [cluster: ClusterProcess, shardId: number, payload: GatewayReceivePayload];
+    debug: [message: string];
+    ready: [];
+}
+declare class ShardingManager extends EventEmitter<ShardingManagerEvents> {
+    #private;
+    readonly clusters: Collection<number, ClusterProcess>;
+    readonly options: Required<ShardingManagerOptions>;
+    readonly rest: REST | RESTProxy;
+    constructor(options: ShardingManagerOptions, rest?: REST | RESTProxy);
+    get totalClusters(): number;
+    get totalShards(): number;
+    get ready(): boolean;
     spawn(): Promise<void>;
-    broadcast(payload: GatewaySendPayload$1): void;
-    sendToWorker(id: number, payload: GatewaySendPayload$1): void;
-    sendToShard(id: number, payload: GatewaySendPayload$1): void;
+    kill(signal?: NodeJS.Signals): Promise<void>;
+    broadcast(payload: GatewaySendPayload): void;
+    broadcastEval<T>(fn: (cluster: Cluster) => T | Promise<T>): Promise<EvalResult<T>[]>;
+    protected requestIdentify(cluster: ClusterProcess, shardId: number): void;
+}
+
+type ClusterIPCDispatchPayload<E extends keyof ClusterEvents = keyof ClusterEvents> = {
+    op: "dispatch";
+    t: E;
+    d: ClusterEvents[E];
+};
+interface ClusterIPCIdentifyPayload {
+    op: "identify";
+    d: number;
+}
+interface ClusterIPCGatewaySendPayload {
+    op: "send";
+    d: {
+        shardId?: number;
+        data: GatewaySendPayload;
+    };
+}
+interface ClusterIPCEvalRequestPayload {
+    op: "eval";
+    d: {
+        nonce: string;
+        script: string;
+    };
+}
+interface ClusterIPCEvalResponsePayload {
+    op: "evalResponse";
+    d: {
+        nonce: string;
+        success: boolean;
+        result: unknown;
+        error?: string;
+    };
+}
+type ClusterIPCPayload = ClusterIPCDispatchPayload | ClusterIPCIdentifyPayload | ClusterIPCGatewaySendPayload | ClusterIPCEvalRequestPayload | ClusterIPCEvalResponsePayload;
+interface EvalResult<T> {
+    /**
+     * Whether the evaluation was successful
+     */
+    success: boolean;
+    /**
+     * The result of the evaluation if successful
+     */
+    data?: T;
+    /**
+     * The error if evaluation failed
+     */
+    error?: Error;
+    /**
+     * The cluster process that executed the evaluation
+     */
+    cluster: ClusterProcess;
+}
+interface ClusterProcessOptions {
+    env?: NodeJS.ProcessEnv;
+    execArgv?: string[];
+}
+declare class ClusterProcess extends EventEmitter<ClusterEvents> {
+    #private;
+    readonly manager: ShardingManager;
+    readonly id: number;
+    readonly process: ChildProcess;
+    constructor(manager: ShardingManager, id: number, options?: ClusterProcessOptions);
+    get killed(): boolean;
+    kill(signal?: NodeJS.Signals): void;
+    eval<T, C = unknown>(fn: (cluster: Cluster, ctx: C) => T | Promise<T>, ctx?: C): Promise<EvalResult<T>>;
+    send(payload: GatewaySendPayload): void;
+    send(shardId: number, payload: GatewaySendPayload): void;
+    sendIPC(message: ClusterIPCPayload): void;
+    identifyShard(id: number): void;
+    static bindProcess(cluster: Cluster): void;
 }
-declare function createGatewayManager(options: GatewayManagerOptions, rest: REST): GatewayManager;
 
-export { DEFAULT_GATEWAY_MANAGER_OPTIONS, DEFAULT_WORKER_PATH, type GatewayManager, type GatewayManagerEvents, type GatewayManagerOptions, type GatewayWorker, type GatewayWorkerEvents, type GatewayWorkerOptions, GatewayWorkerState, type Shard, type ShardEvents, type ShardGatewayOptions, type ShardOptions, ShardState, ShardStrategy, bindWorkerToProcess, createGatewayManager, createShard, createWorker, getWorkerOptions };
+export { Cluster, type ClusterEvents, type ClusterIPCDispatchPayload, type ClusterIPCEvalRequestPayload, type ClusterIPCEvalResponsePayload, type ClusterIPCGatewaySendPayload, type ClusterIPCIdentifyPayload, type ClusterIPCPayload, type ClusterOptions, ClusterProcess, type ClusterProcessOptions, type EvalResult, Shard, type ShardEvents, type ShardOptions, ShardState, ShardStrategy, ShardingManager, type ShardingManagerEvents, type ShardingManagerOptions };