@milaboratories/pl-client 2.11.0 → 2.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-client",
-  "version": "2.11.0",
+  "version": "2.11.1",
   "engines": {
     "node": ">=20.3.0"
   },

package/src/core/client.test.ts

@@ -1,8 +1,8 @@
 import { getTestClient, getTestClientConf } from '../test/test_config';
 import { PlClient } from './client';
 import { PlDriver, PlDriverDefinition } from './driver';
-import { GrpcTransport } from '@protobuf-ts/grpc-transport';
 import { Dispatcher, request } from 'undici';
+import { GrpcClientProviderFactory } from './grpc';
 
 test('test client init', async () => {
   const client = await getTestClient(undefined);
@@ -27,7 +27,7 @@ interface SimpleDriver extends PlDriver {
 
 const SimpleDriverDefinition: PlDriverDefinition<SimpleDriver> = {
   name: 'SimpleDriver',
-  init(pl: PlClient, grpcTransport: GrpcTransport, httpDispatcher: Dispatcher): SimpleDriver {
+  init(pl: PlClient, grpcClientProviderFactory: GrpcClientProviderFactory, httpDispatcher: Dispatcher): SimpleDriver {
     return {
       async ping(): Promise<string> {
         const response = await request('https://cdn.milaboratory.com/ping', {

package/src/core/client.ts

@@ -142,7 +142,7 @@ export class PlClient {
   }
 
   public async ping(): Promise<MaintenanceAPI_Ping_Response> {
-    return (await this._ll.grpcPl.ping({})).response;
+    return (await this._ll.grpcPl.get().ping({})).response;
   }
 
   public get conf(): PlClientConfig {
@@ -296,7 +296,7 @@ export class PlClient {
       if (ok) {
         // syncing on transaction if requested
         if (ops?.sync === undefined ? this.forceSync : ops?.sync)
-          await this._ll.grpcPl.txSync({ txId });
+          await this._ll.grpcPl.get().txSync({ txId });
 
         // introducing artificial delay, if requested
         if (writable && this.txDelay > 0)
@@ -342,7 +342,7 @@ export class PlClient {
   public getDriver<Drv extends PlDriver>(definition: PlDriverDefinition<Drv>): Drv {
     const attached = this.drivers.get(definition.name);
     if (attached !== undefined) return attached as Drv;
-    const driver = definition.init(this, this.grpcTransport, this.httpDispatcher);
+    const driver = definition.init(this, this._ll, this.httpDispatcher);
     this.drivers.set(definition.name, driver);
     return driver;
   }

package/src/core/driver.ts

@@ -1,8 +1,8 @@
 import type { PlClient } from './client';
-import type { GrpcTransport } from '@protobuf-ts/grpc-transport';
 import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
 import type { Dispatcher } from 'undici';
 import type { ResourceType } from './types';
+import type { GrpcClientProviderFactory } from './grpc';
 
 /** Drivers must implement this interface */
 export interface PlDriver {
@@ -15,7 +15,7 @@ export interface PlDriverDefinition<Drv extends PlDriver> {
   readonly name: string;
 
   /** Initialization routine, will be executed only once for each driver in a specific client */
-  init(pl: PlClient, grpcTransport: GrpcTransport, httpDispatcher: Dispatcher): Drv;
+  init(pl: PlClient, grpcClientProviderFactory: GrpcClientProviderFactory, httpDispatcher: Dispatcher): Drv;
 }
 
 // addRTypeToMetadata adds a metadata with resource type

package/src/core/grpc.ts

@@ -0,0 +1,17 @@
+import type { GrpcTransport } from '@protobuf-ts/grpc-transport';
+
+/**
+ * A provider for a grpc client.
+ * The client is created on demand, and is reset when the transport is reset.
+ * This is useful for cases where the client is used in a loop, and the transport is reset after each iteration.
+ */
+export interface GrpcClientProvider<Client> {
+  get(): Client;
+}
+
+/**
+ * A factory for grpc client providers.
+ */
+export interface GrpcClientProviderFactory {
+  createGrpcClientProvider<Client>(clientConstructor: (transport: GrpcTransport) => Client): GrpcClientProvider<Client>;
+}

package/src/core/ll_client.ts

@@ -21,14 +21,31 @@ import { parsePlJwt } from '../util/pl';
 import type { Dispatcher } from 'undici';
 import { inferAuthRefreshTime } from './auth';
 import { defaultHttpDispatcher } from '@milaboratories/pl-http';
+import type { GrpcClientProvider, GrpcClientProviderFactory } from './grpc';
 
 export interface PlCallOps {
   timeout?: number;
   abortSignal?: AbortSignal;
 }
 
+class GrpcClientProviderImpl<Client> implements GrpcClientProvider<Client> {
+  private client: Client | undefined = undefined;
+
+  constructor(private readonly grpcTransport: () => GrpcTransport, private readonly clientConstructor: (transport: GrpcTransport) => Client) {}
+
+  public reset(): void {
+    this.client = undefined;
+  }
+
+  public get(): Client {
+    if (this.client === undefined)
+      this.client = this.clientConstructor(this.grpcTransport());
+    return this.client;
+  }
+}
+
 /** Abstract out low level networking and authorization details */
-export class LLPlClient {
+export class LLPlClient implements GrpcClientProviderFactory {
   public readonly conf: PlClientConfig;
 
   /** Initial authorization information */
@@ -47,7 +64,9 @@ export class LLPlClient {
 
   private readonly grpcInterceptors: Interceptor[];
   private _grpcTransport!: GrpcTransport;
-  private _grpcPl!: PlatformClient;
+  private readonly providers: WeakRef<GrpcClientProviderImpl<any>>[] = [];
+
+  public readonly grpcPl: GrpcClientProvider<PlatformClient>;
 
   public readonly httpDispatcher: Dispatcher;
 
@@ -89,6 +108,8 @@ export class LLPlClient {
       this.statusListener = statusListener;
       statusListener(this._status);
     }
+
+    this.grpcPl = this.createGrpcClientProvider((transport) => new PlatformClient(transport));
   }
 
   /**
@@ -125,17 +146,52 @@ export class LLPlClient {
     const oldTransport = this._grpcTransport;
 
     this._grpcTransport = new GrpcTransport(grpcOptions);
-    this._grpcPl = new PlatformClient(this._grpcTransport);
+
+    // Reset all providers to let them reinitialize their clients
+    for (let i = 0; i < this.providers.length; i++) {
+      const provider = this.providers[i].deref();
+      if (provider === undefined) {
+        // at the same time we need to remove providers that are no longer valid
+        this.providers.splice(i, 1);
+        i--;
+      } else {
+        provider.reset();
+      }
+    }
 
     if (oldTransport !== undefined) oldTransport.close();
   }
 
-  public get grpcTransport(): GrpcTransport {
-    return this._grpcTransport;
+  private providerCleanupCounter = 0;
+
+  /**
+   * Creates a provider for a grpc client. Returned provider will create fresh client whenever the underlying transport is reset.
+   *
+   * @param clientConstructor - a factory function that creates a grpc client
+   */
+  public createGrpcClientProvider<Client>(clientConstructor: (transport: GrpcTransport) => Client): GrpcClientProvider<Client> {
+    // We need to cleanup providers periodically to avoid memory leaks.
+    // This is a simple heuristic to avoid memory leaks.
+    // We could use a more sophisticated algorithm, but this is good enough for now.
+    this.providerCleanupCounter++;
+    if (this.providerCleanupCounter >= 16) {
+      for (let i = 0; i < this.providers.length; i++) {
+        const provider = this.providers[i].deref();
+        if (provider === undefined) {
+          this.providers.splice(i, 1);
+          i--;
+        }
+      }
+      this.providerCleanupCounter = 0;
+    }
+
+    const provider = new GrpcClientProviderImpl<Client>(() => this._grpcTransport, clientConstructor);
+    this.providers.push(new WeakRef(provider));
+    return provider;
   }
 
-  public get grpcPl(): PlatformClient {
-    return this._grpcPl;
+  public get grpcTransport(): GrpcTransport {
+    return this._grpcTransport;
   }
 
   /** Returns true if client is authenticated. Even with anonymous auth information
@@ -182,7 +238,7 @@ export class LLPlClient {
     this.authRefreshInProgress = true;
     void (async () => {
       try {
-        const response = await this.grpcPl.getJWTToken({
+        const response = await this.grpcPl.get().getJWTToken({
           expiration: {
             seconds: BigInt(this.conf.authTTLSeconds),
             nanos: 0,
@@ -244,7 +300,7 @@ export class LLPlClient {
     return new LLPlTransaction((abortSignal) => {
       let totalAbortSignal = abortSignal;
       if (ops.abortSignal) totalAbortSignal = AbortSignal.any([totalAbortSignal, ops.abortSignal]);
-      return this.grpcPl.tx({
+      return this.grpcPl.get().tx({
         abort: totalAbortSignal,
         timeout:
           ops.timeout

package/src/core/unauth_client.ts

@@ -16,11 +16,11 @@ export class UnauthenticatedPlClient {
   }
 
   public async ping(): Promise<MaintenanceAPI_Ping_Response> {
-    return (await this.ll.grpcPl.ping({})).response;
+    return (await this.ll.grpcPl.get().ping({})).response;
   }
 
   public async authMethods(): Promise<AuthAPI_ListMethods_Response> {
-    return (await this.ll.grpcPl.authMethods({})).response;
+    return (await this.ll.grpcPl.get().authMethods({})).response;
   }
 
   public async requireAuth(): Promise<boolean> {
@@ -29,7 +29,7 @@ export class UnauthenticatedPlClient {
 
   public async login(user: string, password: string): Promise<AuthInformation> {
     try {
-      const response = await this.ll.grpcPl.getJWTToken(
+      const response = await this.ll.grpcPl.get().getJWTToken(
         { expiration: { seconds: BigInt(this.ll.conf.authTTLSeconds), nanos: 0 } },
         {
           meta: {

package/src/index.ts

@@ -9,6 +9,7 @@ export * from './core/default_client';
 export * from './core/unauth_client';
 export * from './core/auth';
 export * from './core/final';
+export * from './core/grpc';
 export * from './helpers/tx_helpers';
 export * from './helpers/poll';