status-sharding/src/other/message.ts

Welcome to Status Sharding! This package is designed to provide an efficient and flexible solution for sharding Discord bots, allowing you to scale your bot across multiple processes or workers.

import { EvalOptions, MessageTypes, SerializableInput, Serializable, PackageType } from '../types';
import { ClusterClient } from '../core/clusterClient';
import { Cluster } from '../core/cluster';

/** Eval message type. */
export type EvalMessage<P extends object = object> = {
	options?: EvalOptions<P>;
	script: string;
};

/** Respawn message type. */
export type RespawnMessage = {
	clusterDelay?: number; // Only when respawning all clusters.
	respawnDelay?: number;
	timeout?: number;
	except?: number[];
};

/** Respawn some message type. */
export type RespawnSomeMessage = {
	clusterIds: number[];
	clusterDelay?: number; // Only when respawning all clusters.
	respawnDelay?: number;
	timeout?: number;
};

/** Result of an eval message. */
export type EvalResultMessage = unknown;
/** The type of the message. */
export type DataType = 'normal' | 'eval' | 'respawnAll' | 'evalResult' | 'readyOrSpawn' | 'heartbeat' | 'error' | 'reply' | 'respawnSome';

/** The type of the message. */
export type DataTypes<A = object, P extends object = object> = {
	normal: A extends never ? Serializable : A;
	reply: DataTypes<A, P>['normal'];
	eval: EvalMessage<P>;
	readyOrSpawn: { packageType?: PackageType | null } | undefined;
	heartbeat: undefined;
	respawnAll: RespawnMessage;
	respawnSome: RespawnSomeMessage;
	evalResult: EvalResultMessage;
	error: {
		message: string;
		script: string;
		stack?: string;
		name: string;
	};
};

/** Base message for IPC communication. */
export type BaseMessage<D extends DataType, A = Serializable, P extends object = object> = {
	_type: MessageTypes;
	_nonce: string;
	data: DataTypes<A, P>[D];
}

/** Serializable input. */
export type BaseMessageInput<D extends DataType, A extends Serializable = Serializable> = Omit<BaseMessage<D, A>, '_nonce'>;

/** Message that is sent on IPC. */
export class ProcessMessage<D extends DataType = 'normal', A extends Serializable = Serializable, P extends object = object> {
	/** Instance of the cluster client or cluster. */
	private _instance: ClusterClient | Cluster;
	/** The nonce of the message. */
	private _nonce: string;
	/** The data of the message. */
	public data: DataTypes<A, object>[D];

	/** Creates an instance of ProcessMessage. */
	constructor (instance: ClusterClient | Cluster, data: BaseMessage<D, A, P>) {
		this.data = data.data;
		this._nonce = data._nonce;
		this._instance = instance;
	}

	/** Replies to the message. */
	public async reply<T extends Serializable>(message: SerializableInput<T>): Promise<void> {
		return this._instance._sendInstance({
			data: message,
			_type: MessageTypes.CustomReply,
			_nonce: this._nonce,
		} as BaseMessage<'reply'>) as Promise<void>;
	}
}