@nmtjs/client 0.15.3 → 0.16.0-beta.10

package/src/clients/static.ts

@@ -1,16 +1,48 @@
 import type { TAnyRouterContract } from '@nmtjs/contract'
 
-import type { BaseClientOptions } from '../core.ts'
+import type { BaseClientOptions } from '../client.ts'
+import type { RpcLayerApi } from '../layers/rpc.ts'
 import type { ClientTransportFactory } from '../transport.ts'
 import type {
-  ClientCallers,
   ClientCallOptions,
   StaticInputContractTypeProvider,
   StaticOutputContractTypeProvider,
 } from '../types.ts'
-import { BaseClient } from '../core.ts'
+import { Client } from '../client.ts'
 import { BaseClientTransformer } from '../transformers.ts'
 
+const buildStaticCallers = (
+  rpc: RpcLayerApi,
+  isStream: boolean,
+  path: string[] = [],
+): Record<string, unknown> => {
+  const createProxy = <T>(
+    target: Record<string, unknown>,
+    current: string[],
+  ) => {
+    return new Proxy(target, {
+      get: (obj, prop) => {
+        if (prop === 'then') return obj
+
+        const nextPath = [...current, String(prop)]
+        const caller = (
+          payload?: unknown,
+          options?: Partial<ClientCallOptions>,
+        ) => {
+          return rpc.call(nextPath.join('/'), payload, {
+            ...options,
+            _stream_response: isStream || options?._stream_response,
+          })
+        }
+
+        return createProxy(caller as any, nextPath)
+      },
+    }) as T
+  }
+
+  return createProxy(Object.create(null), path)
+}
+
 export class StaticClient<
   Transport extends ClientTransportFactory<any, any> = ClientTransportFactory<
     any,
@@ -18,15 +50,13 @@ export class StaticClient<
   >,
   RouterContract extends TAnyRouterContract = TAnyRouterContract,
   SafeCall extends boolean = false,
-> extends BaseClient<
+> extends Client<
   Transport,
   RouterContract,
   SafeCall,
   StaticInputContractTypeProvider,
   StaticOutputContractTypeProvider
 > {
-  protected readonly transformer: BaseClientTransformer
-
   constructor(
     options: BaseClientOptions<RouterContract, SafeCall>,
     transport: Transport,
@@ -37,37 +67,15 @@ export class StaticClient<
       ? Options
       : never,
   ) {
-    super(options, transport, transportOptions)
-    this.transformer = new BaseClientTransformer()
-  }
-
-  override get call(): ClientCallers<this['_']['routes'], SafeCall, false> {
-    return this.createProxy(Object.create(null), false)
-  }
-
-  override get stream(): ClientCallers<this['_']['routes'], SafeCall, true> {
-    return this.createProxy(Object.create(null), true)
-  }
-
-  protected createProxy<T>(
-    target: Record<string, unknown>,
-    isStream: boolean,
-    path: string[] = [],
-  ) {
-    return new Proxy(target, {
-      get: (obj, prop) => {
-        if (prop === 'then') return obj
-        const newPath = [...path, String(prop)]
-        const caller = (
-          payload?: unknown,
-          options?: Partial<ClientCallOptions>,
-        ) =>
-          this._call(newPath.join('/'), payload, {
-            ...options,
-            _stream_response: isStream || options?._stream_response,
-          })
-        return this.createProxy(caller as any, isStream, newPath)
-      },
-    }) as T
+    super(
+      options,
+      transport,
+      transportOptions,
+      new BaseClientTransformer(),
+      (rpc) => ({
+        call: buildStaticCallers(rpc, false),
+        stream: buildStaticCallers(rpc, true),
+      }),
+    )
   }
 }