@lightsparkdev/core 1.4.3 → 1.4.4

package/src/requester/DefaultRequester.ts

@@ -0,0 +1,46 @@
+import type AuthProvider from "../auth/AuthProvider.js";
+import { isBare, isNode } from "../utils/environment.js";
+import Requester from "./Requester.js";
+
+export class DefaultRequester extends Requester {
+  protected async initWsClient(baseUrl: string, authProvider: AuthProvider) {
+    if (!this.resolveWsClient) {
+      /* If resolveWsClient is null assume already initialized: */
+      return this.wsClient;
+    }
+
+    if (isBare) {
+      /* graphql-ws library is currently not supported in Bare environment, see LIG-7942 */
+      return null;
+    }
+
+    let websocketImpl;
+    if (isNode && typeof WebSocket === "undefined") {
+      const wsModule = await import("ws");
+      websocketImpl = wsModule.default;
+    }
+    let websocketProtocol = "wss";
+    if (baseUrl.startsWith("http://")) {
+      websocketProtocol = "ws";
+    }
+
+    const graphqlWsModule = await import("graphql-ws");
+    const { createClient } = graphqlWsModule;
+
+    const wsClient = createClient({
+      url: `${websocketProtocol}://${this.stripProtocol(this.baseUrl)}/${
+        this.schemaEndpoint
+      }`,
+      connectionParams: () => authProvider.addWsConnectionParams({}),
+      webSocketImpl: websocketImpl,
+    });
+
+    if (this.resolveWsClient) {
+      this.resolveWsClient(wsClient);
+      this.resolveWsClient = null;
+    }
+
+    return wsClient;
+  }
+}
+export default DefaultRequester;

package/src/requester/Requester.ts

@@ -17,7 +17,7 @@ import type { SigningKey } from "../crypto/SigningKey.js";
 import LightsparkException from "../LightsparkException.js";
 import { logger } from "../Logger.js";
 import { b64encode } from "../utils/base64.js";
-import { isBare, isNode } from "../utils/environment.js";
+import { isNode } from "../utils/environment.js";
 
 const DEFAULT_BASE_URL = "api.lightspark.com";
 dayjs.extend(utc);
@@ -31,14 +31,14 @@ type BodyData = {
 };
 
 class Requester {
-  private wsClient: Promise<WsClient | null>;
-  private resolveWsClient: ((value: WsClient | null) => void) | null = null;
+  protected wsClient: Promise<WsClient | null>;
+  protected resolveWsClient: ((value: WsClient | null) => void) | null = null;
   constructor(
     private readonly nodeKeyCache: NodeKeyCache,
-    private readonly schemaEndpoint: string,
+    protected readonly schemaEndpoint: string,
     private readonly sdkUserAgent: string,
     private readonly authProvider: AuthProvider = new StubAuthProvider(),
-    private readonly baseUrl: string = DEFAULT_BASE_URL,
+    protected readonly baseUrl: string = DEFAULT_BASE_URL,
     private readonly cryptoImpl: CryptoInterface = DefaultCrypto,
     private readonly signingKey?: SigningKey,
     private readonly fetchImpl: typeof fetch = fetch,
@@ -50,44 +50,11 @@ class Requester {
     autoBind(this);
   }
 
-  private async initWsClient(baseUrl: string, authProvider: AuthProvider) {
-    if (!this.resolveWsClient) {
-      /* If resolveWsClient is null assume already initialized: */
-      return this.wsClient;
-    }
-
-    if (isBare) {
-      /* graphql-ws library is currently not supported in Bare environment, see LIG-7942 */
-      return null;
-    }
-
-    let websocketImpl;
-    if (isNode && typeof WebSocket === "undefined") {
-      const wsModule = await import("ws");
-      websocketImpl = wsModule.default;
-    }
-    let websocketProtocol = "wss";
-    if (baseUrl.startsWith("http://")) {
-      websocketProtocol = "ws";
-    }
-
-    const graphqlWsModule = await import("graphql-ws");
-    const { createClient } = graphqlWsModule;
-
-    const wsClient = createClient({
-      url: `${websocketProtocol}://${this.stripProtocol(this.baseUrl)}/${
-        this.schemaEndpoint
-      }`,
-      connectionParams: () => authProvider.addWsConnectionParams({}),
-      webSocketImpl: websocketImpl,
-    });
-
-    if (this.resolveWsClient) {
-      this.resolveWsClient(wsClient);
-      this.resolveWsClient = null;
-    }
-
-    return wsClient;
+  protected initWsClient(
+    baseUrl: string,
+    authProvider: AuthProvider,
+  ): Promise<WsClient | null> {
+    return Promise.resolve(null);
   }
 
   public async executeQuery<T>(query: Query<T>): Promise<T | null> {
@@ -293,7 +260,7 @@ class Requester {
     return `${this.sdkUserAgent} ${platform}/${platformVersion}`;
   }
 
-  private stripProtocol(url: string): string {
+  protected stripProtocol(url: string): string {
     return url.replace(/.*?:\/\//g, "");
   }
 

package/src/requester/tests/DefaultRequester.test.ts

@@ -0,0 +1,129 @@
+import { beforeEach, jest } from "@jest/globals";
+
+import type { Client as WsClient } from "graphql-ws";
+import type AuthProvider from "../../auth/AuthProvider.js";
+import type { CryptoInterface } from "../../crypto/crypto.js";
+import type NodeKeyCache from "../../crypto/NodeKeyCache.js";
+import type { SigningKey } from "../../crypto/SigningKey.js";
+import { SigningKeyType } from "../../crypto/types.js";
+
+/* Mocking ESM modules (when running node with --experimental-vm-modules)
+   requires unstable_mockModule, see https://bit.ly/433nRV1 */
+await jest.unstable_mockModule("graphql-ws", () => ({
+  __esModule: true,
+  createClient: jest.fn(),
+}));
+/* Since Requester uses graphql-ws we need a dynamic import after the above mock */
+const { DefaultRequester } = await import("../DefaultRequester.js");
+
+describe("DefaultRequester", () => {
+  const schemaEndpoint = "graphql";
+  const sdkUserAgent = "test-agent";
+  const baseUrl = "https://api.example.com";
+
+  let nodeKeyCache: NodeKeyCache;
+  let authProvider: AuthProvider;
+  let signingKey: SigningKey;
+  let cryptoImpl: CryptoInterface;
+  let fetchImpl: typeof fetch;
+
+  beforeEach(() => {
+    nodeKeyCache = {
+      getKey: jest.fn(),
+      hasKey: jest.fn(),
+    } as unknown as NodeKeyCache;
+
+    authProvider = {
+      addAuthHeaders: jest.fn(async (headers: Record<string, string>) => ({
+        ...headers,
+        "X-Test": "1",
+      })),
+      isAuthorized: jest.fn(async () => true),
+      addWsConnectionParams: jest.fn(
+        async (params: Record<string, unknown>) => ({
+          ...params,
+          ws: true,
+        }),
+      ),
+    } satisfies AuthProvider;
+
+    signingKey = {
+      type: SigningKeyType.RSASigningKey,
+      sign: jest.fn(async (data: Uint8Array) => new Uint8Array([1, 2, 3])),
+    } satisfies SigningKey;
+
+    cryptoImpl = {
+      decryptSecretWithNodePassword: jest.fn(async () => new ArrayBuffer(0)),
+      generateSigningKeyPair: jest.fn(async () => ({
+        publicKey: "",
+        privateKey: "",
+      })),
+      serializeSigningKey: jest.fn(async () => new ArrayBuffer(0)),
+      getNonce: jest.fn(async () => 123),
+      sign: jest.fn(async () => new ArrayBuffer(0)),
+      importPrivateSigningKey: jest.fn(async () => ""),
+    } satisfies CryptoInterface;
+
+    fetchImpl = jest.fn(
+      async () =>
+        ({
+          ok: true,
+          json: async () => ({ data: { foo: "bar" }, errors: undefined }),
+          statusText: "OK",
+        }) as Response,
+    );
+  });
+
+  describe("subscribe", () => {
+    it("returns an Observable for a valid subscription", async () => {
+      // Mock wsClient and its subscribe method
+      const wsClient = {
+        subscribe: jest.fn(
+          (
+            _body,
+            handlers: { next?: (data: unknown) => void; complete?: () => void },
+          ) => {
+            setTimeout(() => {
+              handlers.next?.({ data: { foo: "bar" } });
+              handlers.complete?.();
+            }, 10);
+            return jest.fn();
+          },
+        ),
+      } as unknown as WsClient;
+
+      const { createClient } = await import("graphql-ws");
+      (createClient as jest.Mock).mockReturnValue(wsClient);
+
+      const requester = new DefaultRequester(
+        nodeKeyCache,
+        schemaEndpoint,
+        sdkUserAgent,
+        authProvider,
+        baseUrl,
+        cryptoImpl,
+        signingKey,
+        fetchImpl,
+      );
+
+      const observable = requester.subscribe<{ foo: string }>(
+        "subscription TestSub { foo }",
+      );
+
+      const results: { foo: string }[] = [];
+      await new Promise<void>((resolve) => {
+        observable.subscribe({
+          next: (data: { data: { foo: string } }) => {
+            results.push(data.data);
+          },
+          complete: () => {
+            expect(results).toEqual([{ foo: "bar" }]);
+            resolve();
+          },
+        });
+      });
+
+      expect(wsClient.subscribe).toHaveBeenCalled();
+    });
+  });
+});

package/src/requester/tests/Requester.test.ts

@@ -1,6 +1,5 @@
 import { beforeEach, jest } from "@jest/globals";
 
-import type { Client as WsClient } from "graphql-ws";
 import type AuthProvider from "../../auth/AuthProvider.js";
 import type { CryptoInterface } from "../../crypto/crypto.js";
 import type NodeKeyCache from "../../crypto/NodeKeyCache.js";
@@ -16,7 +15,7 @@ await jest.unstable_mockModule("graphql-ws", () => ({
   createClient: jest.fn(),
 }));
 /* Since Requester uses graphql-ws we need a dynamic import after the above mock */
-const { Requester } = await import("../index.js");
+const { default: Requester } = await import("../Requester.js");
 
 describe("Requester", () => {
   const schemaEndpoint = "graphql";
@@ -257,26 +256,7 @@ describe("Requester", () => {
       expect(() => requester.subscribe("invalid")).toThrow(LightsparkException);
     });
 
-    it("returns an Observable for a valid subscription", async () => {
-      // Mock wsClient and its subscribe method
-      const wsClient = {
-        subscribe: jest.fn(
-          (
-            _body,
-            handlers: { next?: (data: unknown) => void; complete?: () => void },
-          ) => {
-            setTimeout(() => {
-              handlers.next?.({ data: { foo: "bar" } });
-              handlers.complete?.();
-            }, 10);
-            return jest.fn();
-          },
-        ),
-      } as unknown as WsClient;
-
-      const { createClient } = await import("graphql-ws");
-      (createClient as jest.Mock).mockReturnValue(wsClient);
-
+    it("emits error when wsClient is not initialized", async () => {
       const requester = new Requester(
         nodeKeyCache,
         schemaEndpoint,
@@ -287,25 +267,36 @@ describe("Requester", () => {
         signingKey,
         fetchImpl,
       );
+      // Resolve internal wsClient promise to null so the observable emits an error.
+      (
+        requester as unknown as {
+          resolveWsClient: ((v: unknown) => void) | null;
+        }
+      ).resolveWsClient?.(null);
 
-      const observable = requester.subscribe<{ foo: string }>(
-        "subscription TestSub { foo }",
-      );
+      const observable = requester.subscribe("subscription TestSub { foo }");
 
-      const results: { foo: string }[] = [];
       await new Promise<void>((resolve) => {
         observable.subscribe({
-          next: (data) => {
-            results.push(data.data);
+          next: () => {
+            throw new Error(
+              "Should not emit next when wsClient is uninitialized",
+            );
           },
-          complete: () => {
-            expect(results).toEqual([{ foo: "bar" }]);
+          error: (err) => {
+            expect(err).toBeInstanceOf(LightsparkException);
+            expect(String((err as Error).message)).toMatch(
+              /WebSocket client is not initialized/,
+            );
             resolve();
           },
+          complete: () => {
+            throw new Error(
+              "Should not complete when wsClient is uninitialized",
+            );
+          },
         });
       });
-
-      expect(wsClient.subscribe).toHaveBeenCalled();
     });
   });
 

package/src/shared.ts

@@ -0,0 +1,10 @@
+export * from "./auth/index.js";
+export * from "./constants/index.js";
+export * from "./crypto/index.js";
+export { default as LightsparkException } from "./LightsparkException.js";
+export { Logger, LoggingLevel, logger } from "./Logger.js";
+export {
+  default as ServerEnvironment,
+  apiDomainForEnvironment,
+} from "./ServerEnvironment.js";
+export * from "./utils/index.js";

package/src/utils/environment.ts

@@ -14,3 +14,6 @@ export const isTest = isNode && process.env.NODE_ENV === "test";
 
 /* https://github.com/holepunchto/which-runtime/blob/main/index.js */
 export const isBare = typeof Bare !== "undefined";
+
+export const isReactNative =
+  typeof navigator !== "undefined" && navigator.product === "ReactNative";