chore(packages/client)!: rewrite and rename package

This commit is contained in:
PalmDevs
2023-11-24 23:03:56 +07:00
parent abf532704f
commit ab44312e7b
8 changed files with 1068 additions and 0 deletions

View File

@@ -0,0 +1,134 @@
import { ClientOperation, Packet, ServerOperation } from '@revanced/bot-shared'
import ClientGateway, { ClientGatewayEventHandlers } from './ClientGateway.js'
/**
* The client that connects to the API.
*/
export default class Client {
ready: boolean = false
gateway: ClientGateway
#parseId: number = 0
constructor(options: ClientOptions) {
this.gateway = new ClientGateway({
url: options.api.gatewayUrl,
})
this.gateway.on('ready', () => {
this.ready = true
})
}
connect() {
return this.gateway.connect()
}
isReady(): this is ReadiedClient {
return this.ready
}
async parseText(text: string) {
this.#throwIfNotReady()
const currentId = (this.#parseId++).toString()
this.gateway.send({
op: ClientOperation.ParseText,
d: {
text,
id: currentId,
},
})
type CorrectPacket = Packet<ServerOperation.ParsedText>
const promise = new Promise<CorrectPacket>((rs, rj) => {
const parsedTextListener = (packet: CorrectPacket) => {
if (packet.d.id !== currentId) return
this.gateway.off('parsedText', parsedTextListener)
rs(packet)
}
const parseTextFailedListener = (packet: Packet<ServerOperation.ParseTextFailed>) => {
if (packet.d.id !== currentId) return
this.gateway.off('parseTextFailed', parseTextFailedListener)
rj(packet)
}
this.gateway.on('parsedText', parsedTextListener)
this.gateway.on('parseTextFailed', parseTextFailedListener)
})
return await promise
}
async parseImage(url: string) {
this.#throwIfNotReady()
const currentId = (this.#parseId++).toString()
this.gateway.send({
op: ClientOperation.ParseImage,
d: {
image_url: url,
id: currentId,
},
})
type CorrectPacket = Packet<ServerOperation.ParsedImage>
const promise = new Promise<CorrectPacket>((rs, rj) => {
const parsedImageListener = (packet: CorrectPacket) => {
if (packet.d.id !== currentId) return
this.gateway.off('parsedImage', parsedImageListener)
rs(packet)
}
const parseImageFailedListener = (packet: Packet<ServerOperation.ParseImageFailed>) => {
if (packet.d.id !== currentId) return
this.gateway.off('parseImageFailed', parseImageFailedListener)
rj(packet)
}
this.gateway.on('parsedImage', parsedImageListener)
this.gateway.on('parseImageFailed', parseImageFailedListener)
})
return await promise
}
on<TOpName extends keyof ClientGatewayEventHandlers>(
name: TOpName,
handler: ClientGatewayEventHandlers[typeof name]
) {
this.gateway.on(name, handler)
}
off<TOpName extends keyof ClientGatewayEventHandlers>(
name: TOpName,
handler: ClientGatewayEventHandlers[typeof name]
) {
this.gateway.off(name, handler)
}
once<TOpName extends keyof ClientGatewayEventHandlers>(
name: TOpName,
handler: ClientGatewayEventHandlers[typeof name]
) {
this.gateway.once(name, handler)
}
#throwIfNotReady() {
if (!this.isReady()) throw new Error('Client is not ready')
}
}
export type ReadiedClient = Client & { ready: true }
export interface ClientOptions {
api: ClientApiOptions
}
export interface ClientApiOptions {
gatewayUrl: string
}

View File

@@ -0,0 +1,198 @@
import { type RawData, WebSocket } from 'ws'
import type TypedEmitter from 'typed-emitter'
import {
ClientOperation,
DisconnectReason,
Packet,
ServerOperation,
deserializePacket,
isServerPacket,
serializePacket,
uncapitalize,
} from '@revanced/bot-shared'
import { EventEmitter } from 'events'
/**
* The class that handles the WebSocket connection to the server.
* This is the only relevant class for the time being. But in the future, there may be more classes to handle different protocols of the API.
*/
export default class ClientGateway {
readonly url: string
ready: boolean = false
disconnected: boolean | DisconnectReason = DisconnectReason.NeverConnected
config: Readonly<Packet<ServerOperation.Hello>['d']> | null = null!
#hbTimeout: NodeJS.Timeout = null!
#socket: WebSocket = null!
#emitter =
new EventEmitter() as TypedEmitter<ClientGatewayEventHandlers>
constructor(options: ClientGatewayOptions) {
this.url = options.url
}
connect() {
return new Promise<void>((rs, rj) => {
try {
this.#socket = new WebSocket(this.url)
this.#socket.on('open', () => {
this.disconnected = false
rs()
})
this.#socket.on('close', () =>
this.#handleDisconnect(DisconnectReason.Generic)
)
this.#listen()
this.ready = true
this.#emitter.emit('ready')
} catch (e) {
rj(e)
}
})
}
on<TOpName extends keyof ClientGatewayEventHandlers>(
name: TOpName,
handler: ClientGatewayEventHandlers[typeof name]
) {
this.#emitter.on(name, handler)
}
off<TOpName extends keyof ClientGatewayEventHandlers>(
name: TOpName,
handler: ClientGatewayEventHandlers[typeof name]
) {
this.#emitter.off(name, handler)
}
once<TOpName extends keyof ClientGatewayEventHandlers>(
name: TOpName,
handler: ClientGatewayEventHandlers[typeof name]
) {
this.#emitter.once(name, handler)
}
send<TOp extends ClientOperation>(packet: Packet<TOp>) {
this.#throwIfDisconnected(
'Cannot send a packet when already disconnected from the server'
)
return new Promise<void>((resolve, reject) =>
this.#socket.send(serializePacket(packet), err =>
err ? reject(err) : resolve()
)
)
}
disconnect() {
this.#throwIfDisconnected(
'Cannot disconnect when already disconnected from the server'
)
this.#handleDisconnect(DisconnectReason.Generic)
}
isReady(): this is ReadiedClientGateway {
return this.ready
}
#listen() {
this.#socket.on('message', data => {
const packet = deserializePacket(this._toBuffer(data))
// TODO: maybe log this?
// Just ignore the invalid packet, we don't have to disconnect
if (!isServerPacket(packet)) return
this.#emitter.emit('packet', packet)
switch (packet.op) {
case ServerOperation.Hello:
const data = Object.freeze(
(packet as Packet<ServerOperation.Hello>).d
)
this.config = data
this.#emitter.emit('hello', data)
this.#startHeartbeating()
break
case ServerOperation.Disconnect:
return this.#handleDisconnect(
(packet as Packet<ServerOperation.Disconnect>).d.reason
)
default:
return this.#emitter.emit(
uncapitalize(
ServerOperation[packet.op] as ClientGatewayServerEventName
),
// @ts-expect-error
packet
)
}
})
}
#throwIfDisconnected(errorMessage: string) {
if (this.disconnected !== false) throw new Error(errorMessage)
if (this.#socket.readyState !== this.#socket.OPEN)
throw new Error(errorMessage)
}
#handleDisconnect(reason: DisconnectReason) {
clearTimeout(this.#hbTimeout)
this.disconnected = reason
this.#socket.close()
this.#emitter.emit('disconnect', reason)
}
#startHeartbeating() {
this.on('heartbeatAck', packet => {
this.#hbTimeout = setTimeout(() => {
this.send({
op: ClientOperation.Heartbeat,
d: null,
})
}, packet.d.nextHeartbeat - Date.now())
})
// Immediately send a heartbeat so we can get when to send the next one
this.send({
op: ClientOperation.Heartbeat,
d: null,
})
}
protected _toBuffer(data: RawData) {
if (data instanceof Buffer) return data
else if (data instanceof ArrayBuffer) return Buffer.from(data)
else return Buffer.concat(data)
}
}
export interface ClientGatewayOptions {
/**
* The gateway URL to connect to
*/
url: string
}
export type ClientGatewayServerEventName = keyof typeof ServerOperation
export type ClientGatewayEventHandlers = {
[K in Uncapitalize<ClientGatewayServerEventName>]: (
packet: Packet<(typeof ServerOperation)[Capitalize<K>]>
) => Promise<void> | void
} & {
hello: (
config: NonNullable<ClientGateway['config']>
) => Promise<void> | void
ready: () => Promise<void> | void
packet: (packet: Packet<ServerOperation>) => Promise<void> | void
disconnect: (reason: DisconnectReason) => Promise<void> | void
}
export type ReadiedClientGateway = RequiredProperty<
InstanceType<typeof ClientGateway>
>

View File

@@ -0,0 +1,4 @@
export { default as Client } from './Client.js'
export * from './Client.js'
export { default as ClientGateway } from './ClientGateway.js'
export * from './ClientGateway.js'