@blackglory/geyser-js 0.9.0 → 0.9.1

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@blackglory/geyser-js",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "",
   "keywords": [],
   "files": [
-    "lib"
+    "lib",
+    "src"
   ],
   "type": "module",
   "main": "lib/index.js",

package/src/contract.ts

@@ -0,0 +1,34 @@
+import { JSONObject } from 'justypes'
+import { CustomError } from '@blackglory/errors'
+
+export const expectedVersion = '^0.5.0'
+
+export interface IRateLimiterConfig extends JSONObject {
+  duration: number | null
+  limit: number | null
+}
+
+export interface IAPI {
+  getAllRateLimiterIds(): string[]
+
+  getRateLimiter(rateLimiterId: string): IRateLimiterConfig | null
+  setRateLimiter(rateLimiterId: string, config: IRateLimiterConfig): null
+  removeRateLimiter(rateLimiterId: string): null
+
+  /**
+   * 重置速率限制器的状态.
+   * 
+   * @throws {RateLimiterNotFound}
+   */
+  resetRateLimiter(rateLimiterId: string): null
+
+  /**
+   * @throws {RateLimiterNotFound}
+   */
+  acquireToken(rateLimiterId: string): null
+}
+
+/**
+ * 速率限制器在未经配置的情况下, 相当于不存在.
+ */
+export class RateLimiterNotFound extends CustomError {}

package/src/geyser-client.ts

@@ -0,0 +1,99 @@
+import { createRPCClient } from '@utils/rpc-client.js'
+import { ClientProxy } from 'delight-rpc'
+import { timeoutSignal, withAbortSignal } from 'extra-abort'
+import { IAPI, IRateLimiterConfig } from './contract.js'
+export { IRateLimiterConfig, RateLimiterNotFound } from './contract.js'
+
+export interface IGeyserClientOptions {
+  server: string
+  timeout?: number
+  retryIntervalForReconnection?: number
+}
+
+export class GeyserClient {
+  static async create(options: IGeyserClientOptions): Promise<GeyserClient> {
+    const { client, close } = await createRPCClient(
+      options.server
+    , options.retryIntervalForReconnection
+    )
+    return new GeyserClient(client, close, options.timeout)
+  }
+
+  private constructor(
+    private client: ClientProxy<IAPI>
+  , private closeClients: () => Promise<void>
+  , private timeout?: number
+  ) {}
+
+  async close(): Promise<void> {
+    await this.closeClients()
+  }
+
+  async getAllRateLimiterIds(timeout?: number): Promise<string[]> {
+    return await this.withTimeout(
+      () => this.client.getAllRateLimiterIds()
+    , timeout ?? this.timeout
+    )
+  }
+
+  async getRateLimiter(
+    rateLimiterId: string
+  , timeout?: number
+  ): Promise<IRateLimiterConfig | null> {
+    return await this.withTimeout(
+      () => this.client.getRateLimiter(rateLimiterId)
+    , timeout ?? this.timeout
+    )
+  }
+
+  async setRateLimiter(
+    rateLimiterId: string
+  , config: IRateLimiterConfig
+  , timeout?: number
+  ): Promise<void> {
+    await this.withTimeout(
+      () => this.client.setRateLimiter(rateLimiterId, config)
+    , timeout ?? this.timeout
+    )
+  }
+
+  async removeRateLimiter(rateLimiterId: string, timeout?: number): Promise<void> {
+    await this.withTimeout(
+      () => this.client.removeRateLimiter(rateLimiterId)
+    , timeout ?? this.timeout
+    )
+  }
+
+  /**
+   * 重置速率限制器的状态.
+   * 
+   * @throws {RateLimiterNotFound}
+   */
+  async resetRateLimiter(rateLimiterId: string, timeout?: number): Promise<void> {
+    await this.withTimeout(
+      () => this.client.removeRateLimiter(rateLimiterId)
+    , timeout ?? this.timeout
+    )
+  }
+
+  /**
+   * @throws {RateLimiterNotFound}
+   */
+  async acquireToken(rateLimiterId: string, timeout?: number): Promise<void> {
+    await this.withTimeout(
+      () => this.client.acquireToken(rateLimiterId)
+    , timeout ?? this.timeout
+    )
+  }
+
+  private async withTimeout<T>(
+    fn: () => PromiseLike<T>
+  , timeout: number | undefined = this.timeout
+  ): Promise<T> {
+    if (timeout) {
+      return await withAbortSignal(timeoutSignal(timeout), fn)
+    } else {
+      return await fn()
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './geyser-client.js'

package/src/utils/rpc-client.browser.ts

@@ -0,0 +1,27 @@
+import { IAPI, expectedVersion } from '@src/contract.js'
+import { ClientProxy } from 'delight-rpc'
+import { createClient } from '@delight-rpc/extra-native-websocket'
+import { ExtraNativeWebSocket, autoReconnect } from 'extra-native-websocket'
+
+export async function createRPCClient(
+  url: string
+, retryIntervalForReconnection?: number
+): Promise<{
+  client: ClientProxy<IAPI>
+  close: () => Promise<void>
+}> {
+  const ws = new ExtraNativeWebSocket(() => new WebSocket(url))
+  const cancelAutoReconnect = autoReconnect(ws, retryIntervalForReconnection)
+  await ws.connect()
+
+  const [client, closeClient] = createClient<IAPI>(ws, { expectedVersion })
+
+  return {
+    client
+  , close: async () => {
+      closeClient()
+      cancelAutoReconnect()
+      await ws.close()
+    }
+  }
+}

package/src/utils/rpc-client.ts

@@ -0,0 +1,28 @@
+import { IAPI, expectedVersion } from '@src/contract.js'
+import { ClientProxy } from 'delight-rpc'
+import { createClient } from '@delight-rpc/extra-websocket'
+import { WebSocket } from 'ws'
+import { ExtraWebSocket, autoReconnect } from 'extra-websocket'
+
+export async function createRPCClient(
+  url: string
+, retryIntervalForReconnection?: number
+): Promise<{
+  client: ClientProxy<IAPI>
+  close: () => Promise<void>
+}> {
+  const ws = new ExtraWebSocket(() => new WebSocket(url))
+  const cancelAutoReconnect = autoReconnect(ws, retryIntervalForReconnection)
+  await ws.connect()
+
+  const [client, closeClient] = createClient<IAPI>(ws, { expectedVersion })
+
+  return {
+    client
+  , close: async () => {
+      closeClient()
+      cancelAutoReconnect()
+      await ws.close()
+    }
+  }
+}