@buildonspark/spark-sdk 0.3.6 → 0.3.8

package/src/services/connection/connection.browser.ts

@@ -7,6 +7,7 @@ import {
   type ClientFactory as ClientFactoryWeb,
 } from "nice-grpc-web";
 import { ClientMiddlewareCall, Metadata } from "nice-grpc-common";
+import type { ClientMiddleware } from "nice-grpc-common";
 import { retryMiddleware } from "nice-grpc-client-middleware-retry";
 import { RetryOptions, SparkCallOptions } from "../../types/grpc.js";
 import { WalletConfigService } from "../config.js";
@@ -26,7 +27,7 @@ export class ConnectionManagerBrowser extends ConnectionManager {
     this.transport = transport;
   }
 
-  protected async createChannelWithTLS(address: string, certPath?: string) {
+  protected async createChannelWithTLS(address: string) {
     try {
       return createChannel(address, this.transport);
     } catch (error) {
@@ -45,9 +46,9 @@ export class ConnectionManagerBrowser extends ConnectionManager {
   }
 
   protected createAuthnMiddleware() {
-    return async function* (
+    return async function* <Req, Res>(
       this: ConnectionManagerBrowser,
-      call: ClientMiddlewareCall<any, any>,
+      call: ClientMiddlewareCall<Req, Res>,
       options: SparkCallOptions,
     ) {
       const metadata = Metadata(options.metadata)
@@ -55,17 +56,20 @@ export class ConnectionManagerBrowser extends ConnectionManager {
         .set("X-Grpc-Web", "1")
         .set("X-Client-Env", clientEnv)
         .set("Content-Type", "application/grpc-web+proto");
-      return yield* call.next(call.request, {
+      return yield* call.next(call.request as Req, {
         ...options,
         metadata,
       });
-    }.bind(this);
+    }.bind(this) as <Req, Res>(
+      call: ClientMiddlewareCall<Req, Res>,
+      options: SparkCallOptions,
+    ) => AsyncGenerator<Res, Res | void, undefined>;
   }
 
-  protected createMiddleware(address: string, initialAuthToken: string) {
-    return async function* (
+  protected createMiddleware(address: string) {
+    return async function* <Req, Res>(
       this: ConnectionManagerBrowser,
-      call: ClientMiddlewareCall<any, any>,
+      call: ClientMiddlewareCall<Req, Res>,
       options: SparkCallOptions,
     ) {
       const metadata = Metadata(options.metadata)
@@ -75,14 +79,12 @@ export class ConnectionManagerBrowser extends ConnectionManager {
         .set("Content-Type", "application/grpc-web+proto");
 
       try {
-        return yield* call.next(call.request, {
+        const token = await this.authenticate(address);
+        return yield* call.next(call.request as Req, {
           ...options,
-          metadata: metadata.set(
-            "Authorization",
-            `Bearer ${this.clients.get(address)?.authToken || initialAuthToken}`,
-          ),
+          metadata: metadata.set("Authorization", `Bearer ${token}`),
         });
-      } catch (error: any) {
+      } catch (error: unknown) {
         return yield* this.handleMiddlewareError(
           error,
           address,
@@ -91,17 +93,21 @@ export class ConnectionManagerBrowser extends ConnectionManager {
           options,
         );
       }
-    }.bind(this);
+    }.bind(this) as <Req, Res>(
+      call: ClientMiddlewareCall<Req, Res>,
+      options: SparkCallOptions,
+    ) => AsyncGenerator<Res, Res | void, undefined>;
   }
 
   protected async createGrpcClient<T>(
-    defintion:
+    definition:
       | SparkAuthnServiceDefinition
       | SparkServiceDefinition
       | SparkTokenServiceDefinition,
     channel: ChannelWeb,
     withRetries: boolean,
-    middleware?: any,
+    middleware?: ClientMiddleware<RetryOptions, {}>,
+    channelKey?: string,
   ) {
     let clientFactory: ClientFactoryWeb;
 
@@ -119,12 +125,14 @@ export class ConnectionManagerBrowser extends ConnectionManager {
     if (middleware) {
       clientFactory = clientFactory.use(middleware);
     }
-    const client = clientFactory.create(defintion, channel, {
+    const client = clientFactory.create(definition, channel, {
       "*": options,
     }) as T;
     return {
       ...client,
-      close: undefined,
+      close: channelKey
+        ? () => ConnectionManager.releaseChannel(channelKey)
+        : undefined,
     };
   }
 }

package/src/services/connection/connection.node.ts

@@ -7,6 +7,7 @@ import {
   type Channel,
 } from "nice-grpc";
 import { ClientMiddlewareCall, Metadata } from "nice-grpc-common";
+import type { ClientMiddleware } from "nice-grpc-common";
 import { RetryOptions, SparkCallOptions } from "../../types/grpc.js";
 import { MockServiceClient, MockServiceDefinition } from "../../proto/mock.js";
 import { SparkServiceDefinition } from "../../proto/spark.js";
@@ -20,6 +21,8 @@ import { clientEnv } from "../../constants.js";
 import fs from "fs";
 
 export class ConnectionManagerNodeJS extends ConnectionManager {
+  private certPath: string | null = null;
+
   constructor(config: WalletConfigService) {
     super(config);
   }
@@ -29,17 +32,25 @@ export class ConnectionManagerNodeJS extends ConnectionManager {
       close: () => void;
     }
   > {
-    const channel = await this.createChannelWithTLS(address);
-
+    const key = this.makeChannelKey(address, false);
+    const channel = await ConnectionManager.acquireChannel<Channel>(key, () =>
+      this.createChannelWithTLS(address, false),
+    );
     const client = createClient(MockServiceDefinition, channel);
-    return { ...client, close: () => channel.close() };
+    return {
+      ...client,
+      close: () => ConnectionManager.releaseChannel(key),
+    };
   }
 
-  protected async createChannelWithTLS(address: string, certPath?: string) {
+  protected async createChannelWithTLS(
+    address: string,
+    isStreamClientType: boolean = false,
+  ) {
     try {
-      if (certPath) {
+      if (this.certPath) {
         try {
-          const cert = fs.readFileSync(certPath);
+          const cert = fs.readFileSync(this.certPath);
           return createChannel(address, ChannelCredentials.createSsl(cert));
         } catch (error) {
           console.error("Error reading certificate:", error);
@@ -53,12 +64,13 @@ export class ConnectionManagerNodeJS extends ConnectionManager {
         }
       } else {
         // No cert provided, use insecure SSL for development
-        return createChannel(
+        const ch = createChannel(
           address,
           ChannelCredentials.createSsl(null, null, null, {
             rejectUnauthorized: false,
           }),
         );
+        return ch;
       }
     } catch (error) {
       console.error("Channel creation error:", error);
@@ -76,26 +88,29 @@ export class ConnectionManagerNodeJS extends ConnectionManager {
   }
 
   protected createAuthnMiddleware() {
-    return async function* (
+    return async function* <Req, Res>(
       this: ConnectionManagerNodeJS,
-      call: ClientMiddlewareCall<any, any>,
+      call: ClientMiddlewareCall<Req, Res>,
       options: SparkCallOptions,
     ) {
       const metadata = Metadata(options.metadata).set(
         "X-Client-Env",
         clientEnv,
       );
-      return yield* call.next(call.request, {
+      return yield* call.next(call.request as Req, {
         ...options,
         metadata,
       });
-    }.bind(this);
+    }.bind(this) as <Req, Res>(
+      call: ClientMiddlewareCall<Req, Res>,
+      options: SparkCallOptions,
+    ) => AsyncGenerator<Res, Res | void, undefined>;
   }
 
-  protected createMiddleware(address: string, initialAuthToken: string) {
-    return async function* (
+  protected createMiddleware(address: string) {
+    return async function* <Req, Res>(
       this: ConnectionManagerNodeJS,
-      call: ClientMiddlewareCall<any, any>,
+      call: ClientMiddlewareCall<Req, Res>,
       options: SparkCallOptions,
     ) {
       const metadata = Metadata(options.metadata).set(
@@ -103,12 +118,10 @@ export class ConnectionManagerNodeJS extends ConnectionManager {
         clientEnv,
       );
       try {
-        return yield* call.next(call.request, {
+        const token = await this.authenticate(address);
+        return yield* call.next(call.request as Req, {
           ...options,
-          metadata: metadata.set(
-            "Authorization",
-            `Bearer ${this.clients.get(address)?.authToken || initialAuthToken}`,
-          ),
+          metadata: metadata.set("Authorization", `Bearer ${token}`),
         });
       } catch (error: unknown) {
         return yield* this.handleMiddlewareError(
@@ -119,17 +132,21 @@ export class ConnectionManagerNodeJS extends ConnectionManager {
           options,
         );
       }
-    }.bind(this);
+    }.bind(this) as <Req, Res>(
+      call: ClientMiddlewareCall<Req, Res>,
+      options: SparkCallOptions,
+    ) => AsyncGenerator<Res, Res | void, undefined>;
   }
 
   protected async createGrpcClient<T>(
-    defintion:
+    definition:
       | SparkAuthnServiceDefinition
       | SparkServiceDefinition
       | SparkTokenServiceDefinition,
     channel: Channel,
     withRetries: boolean,
-    middleware?: any,
+    middleware?: ClientMiddleware<RetryOptions, {}>,
+    channelKey?: string,
   ) {
     const retryOptions = {
       retry: true,
@@ -147,12 +164,50 @@ export class ConnectionManagerNodeJS extends ConnectionManager {
     if (middleware) {
       clientFactory = clientFactory.use(middleware);
     }
-    const client = clientFactory.create(defintion, channel, {
+    const client = clientFactory.create(definition, channel, {
       "*": options,
     }) as T;
     return {
       ...client,
-      close: channel.close.bind(channel),
+      close: channelKey
+        ? () => ConnectionManager.releaseChannel(channelKey)
+        : channel.close.bind(channel),
     };
   }
+
+  override async subscribeToEvents(address: string, signal: AbortSignal) {
+    const stream = super.subscribeToEvents(address, signal);
+    const channel = await this.getChannelForClient("stream", address);
+
+    if (!channel) {
+      throw new Error("Failed to get channel for client");
+    }
+
+    // In Node.js, long-lived gRPC streams keep the underlying socket "ref'd",
+    // which prevents the process from exiting. To avoid that (e.g. in CLI tools),
+    // we manually unref the socket so Node can shut down when nothing else is active.
+    //
+    // The gRPC client doesn't expose the socket directly, so we dig through
+    // internal fields to find it. This is a bit of a hack and may break if the
+    // internals change.
+    //
+    // Since the socket isn't always immediately available, we retry with setTimeout
+    // until it shows up.
+    const maybeUnref = () => {
+      const internalChannel = (channel as any).internalChannel;
+      if (
+        internalChannel?.currentPicker?.subchannel?.child?.transport?.session
+          ?.socket
+      ) {
+        internalChannel.currentPicker.subchannel.child.transport.session.socket.unref();
+      } else {
+        setTimeout(maybeUnref, 100);
+      }
+    };
+
+    // Only need to unref in Node environments.
+    // In the browser and React Native, the runtime handles shutdown when the tab/app closes.
+    maybeUnref();
+    return stream;
+  }
 }