@blackglory/cache-js 0.10.2 → 0.10.3

package/package.json

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

package/src/cache-client.ts

@@ -0,0 +1,154 @@
+import { createRPCClient } from '@utils/rpc-client.js'
+import { ClientProxy, BatchClient, BatchClientProxy } from 'delight-rpc'
+import { IAPI, INamespaceStats, IItem } from './contract.js'
+import { timeoutSignal, withAbortSignal } from 'extra-abort'
+import { JSONValue } from '@blackglory/prelude'
+export { INamespaceStats, IItem, IItemMetadata } from './contract.js'
+
+export interface ICacheClientOptions {
+  server: string
+  timeout?: number
+  retryIntervalForReconnection?: number
+}
+
+export class CacheClient {
+  static async create(options: ICacheClientOptions): Promise<CacheClient> {
+    const { client, batchClient, proxy, close } = await createRPCClient(
+      options.server
+    , options.retryIntervalForReconnection
+    )
+    return new CacheClient(client, batchClient, proxy, close, options.timeout)
+  }
+
+  private constructor(
+    private client: ClientProxy<IAPI>
+  , private batchClient: BatchClient
+  , private batchProxy: BatchClientProxy<IAPI, unknown>
+  , private closeClients: () => Promise<void>
+  , private timeout?: number
+  ) {}
+
+  async close(): Promise<void> {
+    await this.closeClients()
+  }
+
+  async getNamespaceStats(
+    namespace: string
+  , timeout?: number
+  ): Promise<INamespaceStats> {
+    return await this.withTimeout(
+      () => this.client.getNamespaceStats(namespace)
+    , timeout ?? this.timeout
+    )
+  }
+
+  async getAllNamespaces(timeout?: number): Promise<string[]> {
+    return await this.withTimeout(
+      () => this.client.getAllNamespaces()
+    , timeout ?? this.timeout
+    )
+  }
+
+  async getAllItemKeys(namespace: string, timeout?: number): Promise<string[]> {
+    return await this.withTimeout(
+      () => this.client.getAllItemKeys(namespace)
+    , timeout ?? this.timeout
+    )
+  }
+
+  async hasItem(
+    namespace: string
+  , itemKey: string
+  , timeout?: number
+  ): Promise<boolean> {
+    return await this.withTimeout(
+      () => this.client.hasItem(namespace, itemKey)
+    , timeout ?? this.timeout
+    )
+  }
+
+  async getItem(
+    namespace: string
+  , itemKey: string
+  , timeout?: number
+  ): Promise<IItem | null> {
+    return await this.withTimeout(
+      () => this.client.getItem(namespace, itemKey)
+    , timeout ?? this.timeout
+    )
+  }
+
+  async getItemValue(
+    namespace: string
+  , itemKey: string
+  , timeout?: number
+  ): Promise<JSONValue | null> {
+    return await this.withTimeout(
+      () => this.client.getItemValue(namespace, itemKey)
+    , timeout ?? this.timeout
+    )
+  }
+
+  async getItemValues(
+    namespace: string
+  , itemKeys: string[]
+  , timeout?: number
+  ): Promise<Array<JSONValue | null>> {
+    return await this.withTimeout(
+      async () => {
+        const results = await this.batchClient.parallel(
+          ...itemKeys.map(key => this.batchProxy.getItemValue(namespace, key))
+        )
+        return results.map(result => result.unwrap())
+      }
+    , timeout ?? this.timeout
+    )
+  }
+
+  async setItem(
+    namespace: string
+  , itemKey: string
+  , itemValue: JSONValue
+  , timeToLive: number | null
+  , timeout?: number
+  ): Promise<void> {
+    await this.withTimeout(
+      () => this.client.setItem(
+        namespace
+      , itemKey
+      , itemValue
+      , timeToLive
+      )
+    , timeout ?? this.timeout
+    )
+  }
+
+  async removeItem(
+    namespace: string
+  , itemKey: string
+  , timeout?: number
+  ): Promise<void> {
+    await this.withTimeout(
+      () => this.client.removeItem(namespace, itemKey)
+    , timeout ?? this.timeout
+    )
+  }
+
+  async clearItemsByNamespace(namespace: string, timeout?: number): Promise<void> {
+    await this.withTimeout(
+      () => this.client.clearItemsByNamespace(namespace)
+    , 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/contract.ts

@@ -0,0 +1,40 @@
+import { JSONValue } from '@blackglory/prelude'
+
+export const expectedVersion = '^0.9.0'
+
+export interface INamespaceStats {
+  items: number
+}
+
+export interface IItem {
+  value: JSONValue
+  metadata: IItemMetadata
+}
+
+export interface IItemMetadata {
+  updatedAt: number
+  timeToLive: number | null
+}
+
+export interface IAPI {
+  getAllNamespaces(): string[]
+  getAllItemKeys(namespace: string): string[]
+
+  getNamespaceStats(namespace: string): INamespaceStats
+
+  hasItem(namespace: string, itemKey: string): boolean
+
+  getItem(namespace: string, itemKey: string): IItem | null
+  getItemValue(namespace: string, itemKey: string): JSONValue | null
+
+  setItem(
+    namespace: string
+  , itemKey: string
+  , itemValue: JSONValue
+  , timeToLive: number | null /* ms */
+  ): null
+
+  removeItem(namespace: string, itemKey: string): null
+
+  clearItemsByNamespace(namespace: string): null
+}

package/src/index.ts

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

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

@@ -0,0 +1,34 @@
+import { IAPI, expectedVersion } from '@src/contract.js'
+import { ClientProxy, BatchClient, BatchClientProxy, createBatchProxy } from 'delight-rpc'
+import { createClient, createBatchClient } 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>
+  batchClient: BatchClient<IAPI>
+  proxy: BatchClientProxy<IAPI, unknown>
+  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 })
+  const [batchClient, closeBatchClient] = createBatchClient(ws, { expectedVersion })
+  const proxy = createBatchProxy<IAPI>()
+
+  return {
+    client
+  , batchClient
+  , proxy
+  , close: async () => {
+      closeClient()
+      closeBatchClient()
+      cancelAutoReconnect()
+      await ws.close()
+    }
+  }
+}

package/src/utils/rpc-client.ts

@@ -0,0 +1,35 @@
+import { IAPI, expectedVersion } from '@src/contract.js'
+import { ClientProxy, BatchClient, BatchClientProxy, createBatchProxy } from 'delight-rpc'
+import { createClient, createBatchClient } 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>
+  batchClient: BatchClient<IAPI>
+  proxy: BatchClientProxy<IAPI, unknown>
+  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 })
+  const [batchClient, closeBatchClient] = createBatchClient(ws, { expectedVersion })
+  const proxy = createBatchProxy<IAPI>()
+
+  return {
+    client
+  , batchClient
+  , proxy
+  , close: async () => {
+      closeClient()
+      closeBatchClient()
+      cancelAutoReconnect()
+      await ws.close()
+    }
+  }
+}