@lightsparkdev/core 1.3.1 → 1.4.1

package/dist/utils/index.cjs

@@ -62,7 +62,7 @@ __export(utils_exports, {
   isErrorWithMessage: () => isErrorWithMessage,
   isNode: () => isNode,
   isNumber: () => isNumber,
-  isObject: () => isObject2,
+  isObject: () => isObject,
   isRecord: () => isRecord,
   isSDKCurrencyAmount: () => isSDKCurrencyAmount,
   isTest: () => isTest,
@@ -974,6 +974,18 @@ function localeToCurrencySymbol(locale) {
   return symbol;
 }
 
+// src/utils/typeGuards.ts
+function isUint8Array(value) {
+  return value instanceof Uint8Array;
+}
+function isObject(value) {
+  const type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+
 // src/utils/errors.ts
 var isError = (e) => {
   return Boolean(
@@ -994,31 +1006,71 @@ var isErrorMsg = (e, msg) => {
   }
   return false;
 };
-function errorToJSON(err) {
+function normalizeObject(obj) {
+  const normalized = {};
+  if (isObject(obj)) {
+    const props = Object.getOwnPropertyNames(obj);
+    for (const prop of props) {
+      const objRecord = obj;
+      normalized[prop] = objRecord[prop];
+    }
+  }
+  return normalized;
+}
+function errorToJSON(err, stringifyObjects = false) {
   if (!err) {
     return null;
   }
-  if (typeof err === "object" && "toJSON" in err && typeof err.toJSON === "function") {
+  if (isObject(err) && "toJSON" in err && typeof err.toJSON === "function") {
+    if (stringifyObjects === true) {
+      return objectToJSON(err.toJSON());
+    }
     return err.toJSON();
   }
   if (typeof err === "object" && /* This happens for certain errors like DOMException: */
   Object.getOwnPropertyNames(err).length === 0 && "message" in err && typeof err.message === "string") {
     return { message: err.message };
   }
+  return objectToJSON(err);
+}
+function objectToJSON(obj) {
+  const normalizedObj = normalizeObject(obj);
   return JSON.parse(
-    JSON.stringify(err, Object.getOwnPropertyNames(err))
+    JSON.stringify(normalizedObj, (key, value) => {
+      if (key === "") {
+        return value;
+      }
+      const objProps = Object.getOwnPropertyNames(normalizedObj);
+      if (!objProps.includes(key)) {
+        return void 0;
+      }
+      if (isObject(value)) {
+        return JSON.stringify(value);
+      }
+      return value;
+    })
   );
 }
 
 // src/utils/localStorage.ts
 function getLocalStorageConfigItem(key) {
-  return getLocalStorageBoolean(key);
+  const localStorageBoolean = getLocalStorageBoolean(key);
+  if (localStorageBoolean == null) {
+    return false;
+  }
+  return localStorageBoolean;
 }
 function getLocalStorageBoolean(key) {
   try {
-    return localStorage.getItem(key) === "1";
+    if (localStorage.getItem(key) === "1") {
+      return true;
+    } else if (localStorage.getItem(key) == null) {
+      return null;
+    } else {
+      return false;
+    }
   } catch (e) {
-    return false;
+    return null;
   }
 }
 function setLocalStorageBoolean(key, value) {
@@ -1092,11 +1144,11 @@ function baseGetTag(value) {
 var baseGetTag_default = baseGetTag;
 
 // ../../node_modules/lodash-es/isObject.js
-function isObject(value) {
+function isObject2(value) {
   var type = typeof value;
   return value != null && (type == "object" || type == "function");
 }
-var isObject_default = isObject;
+var isObject_default = isObject2;
 
 // ../../node_modules/lodash-es/isFunction.js
 var asyncTag = "[object AsyncFunction]";
@@ -1160,15 +1212,6 @@ function lsidToUUID(lsid) {
   return lsid.replace(/^[^:]+:(.*)$/, "$1");
 }
 
-// src/utils/typeGuards.ts
-function isUint8Array(value) {
-  return value instanceof Uint8Array;
-}
-function isObject2(value) {
-  const type = typeof value;
-  return value != null && (type == "object" || type == "function");
-}
-
 // src/utils/types.ts
 var isType = (typename) => (node) => {
   return node?.__typename === typename;
@@ -1176,9 +1219,6 @@ var isType = (typename) => (node) => {
 function notNullUndefined(value) {
   return value !== null && value !== void 0;
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CurrencyUnit,

package/dist/utils/index.d.cts

@@ -1 +1 @@
-export { A as AppendUnitsOptions, aa as ById, al as Complete, o as CurrencyAmountArg, k as CurrencyAmountInputObj, m as CurrencyAmountObj, n as CurrencyAmountPreferenceObj, V as CurrencyCodes, T as CurrencyLocales, j as CurrencyMap, f as CurrencyUnit, g as CurrencyUnitType, ae as DeepPartial, D as DeprecatedCurrencyAmountObj, a9 as ExpandRecursively, ad as ExtractByTypename, af as JSONLiteral, ah as JSONObject, ag as JSONType, a8 as Maybe, ai as NN, ab as OmitTypename, ak as PartialBy, am as RequiredKeys, S as SDKCurrencyAmountType, U as UmaCurrency, l as UmaCurrencyAmount, z as abbrCurrencyUnit, b as b64decode, a as b64encode, O as bytesToHex, $ as clamp, i as convertCurrencyAmount, h as convertCurrencyAmountValue, R as countryCodesToCurrencyCodes, c as createSha256Hash, d as defaultCurrencyCode, _ as deleteLocalStorageItem, e as ensureArray, N as errorToJSON, B as formatCurrencyStr, w as getCurrencyAmount, Q as getCurrentLocale, L as getErrorMsg, Y as getLocalStorageBoolean, X as getLocalStorageConfigItem, P as hexToBytes, G as isBrowser, p as isCurrencyAmountInputObj, s as isCurrencyAmountObj, t as isCurrencyAmountPreferenceObj, y as isCurrencyMap, r as isDeprecatedCurrencyAmountObj, J as isError, M as isErrorMsg, K as isErrorWithMessage, H as isNode, a2 as isNumber, a7 as isObject, an as isRecord, v as isSDKCurrencyAmount, I as isTest, ac as isType, a6 as isUint8Array, q as isUmaCurrencyAmount, a0 as linearInterpolate, W as localeToCurrencyCode, F as localeToCurrencySymbol, a5 as lsidToUUID, x as mapCurrencyAmount, aj as notNullUndefined, a3 as pollUntil, a1 as round, E as separateCurrencyStrParts, Z as setLocalStorageBoolean, a4 as sleep, u as urlsafe_b64decode } from '../index-C7dqDM91.cjs';
+export { A as AppendUnitsOptions, ab as ById, am as Complete, o as CurrencyAmountArg, k as CurrencyAmountInputObj, m as CurrencyAmountObj, n as CurrencyAmountPreferenceObj, V as CurrencyCodes, T as CurrencyLocales, j as CurrencyMap, f as CurrencyUnit, g as CurrencyUnitType, af as DeepPartial, D as DeprecatedCurrencyAmountObj, aa as ExpandRecursively, ae as ExtractByTypename, ag as JSONLiteral, ai as JSONObject, ah as JSONType, a9 as Maybe, aj as NN, ac as OmitTypename, al as PartialBy, an as RequiredKeys, S as SDKCurrencyAmountType, U as UmaCurrency, l as UmaCurrencyAmount, z as abbrCurrencyUnit, b as b64decode, a as b64encode, O as bytesToHex, $ as clamp, i as convertCurrencyAmount, h as convertCurrencyAmountValue, R as countryCodesToCurrencyCodes, c as createSha256Hash, d as defaultCurrencyCode, _ as deleteLocalStorageItem, e as ensureArray, N as errorToJSON, B as formatCurrencyStr, w as getCurrencyAmount, Q as getCurrentLocale, L as getErrorMsg, Y as getLocalStorageBoolean, X as getLocalStorageConfigItem, P as hexToBytes, G as isBrowser, p as isCurrencyAmountInputObj, s as isCurrencyAmountObj, t as isCurrencyAmountPreferenceObj, y as isCurrencyMap, r as isDeprecatedCurrencyAmountObj, J as isError, M as isErrorMsg, K as isErrorWithMessage, H as isNode, a2 as isNumber, a7 as isObject, a8 as isRecord, v as isSDKCurrencyAmount, I as isTest, ad as isType, a6 as isUint8Array, q as isUmaCurrencyAmount, a0 as linearInterpolate, W as localeToCurrencyCode, F as localeToCurrencySymbol, a5 as lsidToUUID, x as mapCurrencyAmount, ak as notNullUndefined, a3 as pollUntil, a1 as round, E as separateCurrencyStrParts, Z as setLocalStorageBoolean, a4 as sleep, u as urlsafe_b64decode } from '../index-DZbfPQqd.cjs';

package/dist/utils/index.d.ts

@@ -1 +1 @@
-export { A as AppendUnitsOptions, aa as ById, al as Complete, o as CurrencyAmountArg, k as CurrencyAmountInputObj, m as CurrencyAmountObj, n as CurrencyAmountPreferenceObj, V as CurrencyCodes, T as CurrencyLocales, j as CurrencyMap, f as CurrencyUnit, g as CurrencyUnitType, ae as DeepPartial, D as DeprecatedCurrencyAmountObj, a9 as ExpandRecursively, ad as ExtractByTypename, af as JSONLiteral, ah as JSONObject, ag as JSONType, a8 as Maybe, ai as NN, ab as OmitTypename, ak as PartialBy, am as RequiredKeys, S as SDKCurrencyAmountType, U as UmaCurrency, l as UmaCurrencyAmount, z as abbrCurrencyUnit, b as b64decode, a as b64encode, O as bytesToHex, $ as clamp, i as convertCurrencyAmount, h as convertCurrencyAmountValue, R as countryCodesToCurrencyCodes, c as createSha256Hash, d as defaultCurrencyCode, _ as deleteLocalStorageItem, e as ensureArray, N as errorToJSON, B as formatCurrencyStr, w as getCurrencyAmount, Q as getCurrentLocale, L as getErrorMsg, Y as getLocalStorageBoolean, X as getLocalStorageConfigItem, P as hexToBytes, G as isBrowser, p as isCurrencyAmountInputObj, s as isCurrencyAmountObj, t as isCurrencyAmountPreferenceObj, y as isCurrencyMap, r as isDeprecatedCurrencyAmountObj, J as isError, M as isErrorMsg, K as isErrorWithMessage, H as isNode, a2 as isNumber, a7 as isObject, an as isRecord, v as isSDKCurrencyAmount, I as isTest, ac as isType, a6 as isUint8Array, q as isUmaCurrencyAmount, a0 as linearInterpolate, W as localeToCurrencyCode, F as localeToCurrencySymbol, a5 as lsidToUUID, x as mapCurrencyAmount, aj as notNullUndefined, a3 as pollUntil, a1 as round, E as separateCurrencyStrParts, Z as setLocalStorageBoolean, a4 as sleep, u as urlsafe_b64decode } from '../index-C7dqDM91.js';
+export { A as AppendUnitsOptions, ab as ById, am as Complete, o as CurrencyAmountArg, k as CurrencyAmountInputObj, m as CurrencyAmountObj, n as CurrencyAmountPreferenceObj, V as CurrencyCodes, T as CurrencyLocales, j as CurrencyMap, f as CurrencyUnit, g as CurrencyUnitType, af as DeepPartial, D as DeprecatedCurrencyAmountObj, aa as ExpandRecursively, ae as ExtractByTypename, ag as JSONLiteral, ai as JSONObject, ah as JSONType, a9 as Maybe, aj as NN, ac as OmitTypename, al as PartialBy, an as RequiredKeys, S as SDKCurrencyAmountType, U as UmaCurrency, l as UmaCurrencyAmount, z as abbrCurrencyUnit, b as b64decode, a as b64encode, O as bytesToHex, $ as clamp, i as convertCurrencyAmount, h as convertCurrencyAmountValue, R as countryCodesToCurrencyCodes, c as createSha256Hash, d as defaultCurrencyCode, _ as deleteLocalStorageItem, e as ensureArray, N as errorToJSON, B as formatCurrencyStr, w as getCurrencyAmount, Q as getCurrentLocale, L as getErrorMsg, Y as getLocalStorageBoolean, X as getLocalStorageConfigItem, P as hexToBytes, G as isBrowser, p as isCurrencyAmountInputObj, s as isCurrencyAmountObj, t as isCurrencyAmountPreferenceObj, y as isCurrencyMap, r as isDeprecatedCurrencyAmountObj, J as isError, M as isErrorMsg, K as isErrorWithMessage, H as isNode, a2 as isNumber, a7 as isObject, a8 as isRecord, v as isSDKCurrencyAmount, I as isTest, ad as isType, a6 as isUint8Array, q as isUmaCurrencyAmount, a0 as linearInterpolate, W as localeToCurrencyCode, F as localeToCurrencySymbol, a5 as lsidToUUID, x as mapCurrencyAmount, ak as notNullUndefined, a3 as pollUntil, a1 as round, E as separateCurrencyStrParts, Z as setLocalStorageBoolean, a4 as sleep, u as urlsafe_b64decode } from '../index-DZbfPQqd.js';

package/dist/utils/index.js

@@ -50,7 +50,7 @@ import {
   setLocalStorageBoolean,
   sleep,
   urlsafe_b64decode
-} from "../chunk-23SS5EX2.js";
+} from "../chunk-NV53XYAS.js";
 export {
   CurrencyUnit,
   abbrCurrencyUnit,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightsparkdev/core",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "description": "Lightspark JS SDK",
   "author": "Lightspark Inc.",
   "keywords": [
@@ -53,13 +53,13 @@
     "lint": "eslint .",
     "package:checks": "yarn publint && yarn attw --pack .",
     "postversion": "yarn build",
-    "test": "node --experimental-vm-modules $(yarn bin jest) --no-cache --runInBand --bail src/**/tests/**/*.test.ts",
+    "test-cmd": "node --experimental-vm-modules $(yarn bin jest) --no-cache --runInBand --bail",
+    "test": "yarn test-cmd -- src/**/tests/**/*.test.ts",
     "types:watch": "tsc-absolute --watch",
     "types": "tsc"
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "crypto-browserify": "^3.12.0",
     "dayjs": "^1.11.7",
     "graphql": "^16.6.0",
     "graphql-ws": "^5.11.3",

package/src/requester/Requester.ts

@@ -5,7 +5,6 @@ import dayjs from "dayjs";
 import utc from "dayjs/plugin/utc.js";
 import type { Client as WsClient } from "graphql-ws";
 import { createClient } from "graphql-ws";
-import NodeWebSocket from "ws";
 import { Observable } from "zen-observable-ts";
 
 import type Query from "./Query.js";
@@ -33,7 +32,8 @@ type BodyData = {
 };
 
 class Requester {
-  private readonly wsClient: WsClient;
+  private wsClient: Promise<WsClient>;
+  private resolveWsClient: ((value: WsClient) => void) | null = null;
   constructor(
     private readonly nodeKeyCache: NodeKeyCache,
     private readonly schemaEndpoint: string,
@@ -44,22 +44,43 @@ class Requester {
     private readonly signingKey?: SigningKey,
     private readonly fetchImpl: typeof fetch = fetch,
   ) {
+    this.wsClient = new Promise<WsClient>((resolve) => {
+      this.resolveWsClient = resolve;
+    });
+    void this.initWsClient(baseUrl, authProvider);
+    autoBind(this);
+  }
+
+  private async initWsClient(baseUrl: string, authProvider: AuthProvider) {
+    if (!this.resolveWsClient) {
+      /* If resolveWsClient is null assume already initialized: */
+      return this.wsClient;
+    }
+
     let websocketImpl;
-    if (typeof WebSocket === "undefined" && typeof window === "undefined") {
-      websocketImpl = NodeWebSocket;
+    if (isNode && typeof WebSocket === "undefined") {
+      const wsModule = await import("ws");
+      websocketImpl = wsModule.default;
     }
     let websocketProtocol = "wss";
     if (baseUrl.startsWith("http://")) {
       websocketProtocol = "ws";
     }
-    this.wsClient = createClient({
+
+    const wsClient = createClient({
       url: `${websocketProtocol}://${this.stripProtocol(this.baseUrl)}/${
         this.schemaEndpoint
       }`,
       connectionParams: () => authProvider.addWsConnectionParams({}),
       webSocketImpl: websocketImpl,
     });
-    autoBind(this);
+
+    if (this.resolveWsClient) {
+      this.resolveWsClient(wsClient);
+      this.resolveWsClient = null;
+    }
+
+    return wsClient;
   }
 
   public async executeQuery<T>(query: Query<T>): Promise<T | null> {
@@ -106,11 +127,31 @@ class Requester {
 
     return new Observable<{ data: T }>((observer) => {
       logger.trace(`Requester.subscribe observer`, observer);
-      return this.wsClient.subscribe(bodyData, {
-        next: (data) => observer.next(data as { data: T }),
-        error: (err) => observer.error(err),
-        complete: () => observer.complete(),
-      });
+
+      let cleanup: (() => void) | null = null;
+      let canceled = false;
+
+      void (async () => {
+        try {
+          const wsClient = await this.wsClient;
+          if (!canceled) {
+            cleanup = wsClient.subscribe(bodyData, {
+              next: (data) => observer.next(data as { data: T }),
+              error: (err) => observer.error(err),
+              complete: () => observer.complete(),
+            });
+          }
+        } catch (err) {
+          observer.error(err);
+        }
+      })();
+
+      return () => {
+        canceled = true;
+        if (cleanup) {
+          cleanup();
+        }
+      };
     });
   }
 

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

@@ -0,0 +1,347 @@
+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";
+import LightsparkException from "../../LightsparkException.js";
+import type Query from "../Query.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 { Requester } = await import("../index.js");
+
+describe("Requester", () => {
+  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,
+    );
+  });
+
+  it("constructs without error", () => {
+    expect(
+      () =>
+        new Requester(
+          nodeKeyCache,
+          schemaEndpoint,
+          sdkUserAgent,
+          authProvider,
+          baseUrl,
+          cryptoImpl,
+          signingKey,
+          fetchImpl,
+        ),
+    ).not.toThrow();
+  });
+
+  describe("executeQuery", () => {
+    it("calls makeRawRequest and returns constructed object", async () => {
+      const requester = new Requester(
+        nodeKeyCache,
+        schemaEndpoint,
+        sdkUserAgent,
+        authProvider,
+        baseUrl,
+        cryptoImpl,
+        signingKey,
+        fetchImpl,
+      );
+      const query: Query<{ foo: string }> = {
+        queryPayload: "query TestQuery { foo }",
+        variables: { a: 1 },
+        constructObject: (rawData) => ({
+          foo: (rawData as { foo: string }).foo,
+        }),
+      };
+      jest.spyOn(requester, "makeRawRequest").mockResolvedValue({ foo: "bar" });
+      const result = await requester.executeQuery(query);
+      expect(result).toEqual({ foo: "bar" });
+    });
+  });
+
+  describe("makeRawRequest", () => {
+    it("makes a successful request and returns data", async () => {
+      const requester = new Requester(
+        nodeKeyCache,
+        schemaEndpoint,
+        sdkUserAgent,
+        authProvider,
+        baseUrl,
+        cryptoImpl,
+        signingKey,
+        fetchImpl,
+      );
+      const result = await requester.makeRawRequest("query TestQuery { foo }", {
+        a: 1,
+      });
+      expect(result).toEqual({ foo: "bar" });
+      expect(fetchImpl).toHaveBeenCalled();
+    });
+
+    it("throws on invalid query", async () => {
+      const requester = new Requester(
+        nodeKeyCache,
+        schemaEndpoint,
+        sdkUserAgent,
+        authProvider,
+        baseUrl,
+        cryptoImpl,
+        signingKey,
+        fetchImpl,
+      );
+      await expect(requester.makeRawRequest("invalid", {})).rejects.toThrow(
+        LightsparkException,
+      );
+    });
+
+    it("throws on subscription query", async () => {
+      const requester = new Requester(
+        nodeKeyCache,
+        schemaEndpoint,
+        sdkUserAgent,
+        authProvider,
+        baseUrl,
+        cryptoImpl,
+        signingKey,
+        fetchImpl,
+      );
+      await expect(
+        requester.makeRawRequest("subscription TestSub { foo }", {}),
+      ).rejects.toThrow(LightsparkException);
+    });
+
+    it("throws on failed response", async () => {
+      fetchImpl = jest.fn(
+        async () =>
+          ({
+            ok: false,
+            statusText: "Bad Request",
+            json: async () => ({
+              errors: [
+                { message: "fail", extensions: { error_name: "TestError" } },
+              ],
+            }),
+          }) as Response,
+      );
+      const requester = new Requester(
+        nodeKeyCache,
+        schemaEndpoint,
+        sdkUserAgent,
+        authProvider,
+        baseUrl,
+        cryptoImpl,
+        signingKey,
+        fetchImpl,
+      );
+      await expect(
+        requester.makeRawRequest("query TestQuery { foo }", {}),
+      ).rejects.toThrow(LightsparkException);
+    });
+
+    it("throws if response has no data and errors", async () => {
+      fetchImpl = jest.fn(
+        async () =>
+          ({
+            ok: true,
+            json: async () => ({
+              data: undefined,
+              errors: [
+                { message: "fail", extensions: { error_name: "TestError" } },
+              ],
+            }),
+            statusText: "OK",
+          }) as Response,
+      );
+      const requester = new Requester(
+        nodeKeyCache,
+        schemaEndpoint,
+        sdkUserAgent,
+        authProvider,
+        baseUrl,
+        cryptoImpl,
+        signingKey,
+        fetchImpl,
+      );
+      await expect(
+        requester.makeRawRequest("query TestQuery { foo }", {}),
+      ).rejects.toThrow(LightsparkException);
+    });
+  });
+
+  describe("subscribe", () => {
+    it("throws on mutation query", () => {
+      const requester = new Requester(
+        nodeKeyCache,
+        schemaEndpoint,
+        sdkUserAgent,
+        authProvider,
+        baseUrl,
+        cryptoImpl,
+        signingKey,
+        fetchImpl,
+      );
+      expect(() =>
+        requester.subscribe("mutation TestMutation { foo }"),
+      ).toThrow(LightsparkException);
+    });
+
+    it("throws on invalid query", () => {
+      const requester = new Requester(
+        nodeKeyCache,
+        schemaEndpoint,
+        sdkUserAgent,
+        authProvider,
+        baseUrl,
+        cryptoImpl,
+        signingKey,
+        fetchImpl,
+      );
+      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);
+
+      const requester = new Requester(
+        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) => {
+            results.push(data.data);
+          },
+          complete: () => {
+            expect(results).toEqual([{ foo: "bar" }]);
+            resolve();
+          },
+        });
+      });
+
+      expect(wsClient.subscribe).toHaveBeenCalled();
+    });
+  });
+
+  describe("signing logic", () => {
+    it("adds signing headers if signingNodeId is provided", async () => {
+      (nodeKeyCache.getKey as jest.Mock).mockReturnValue(signingKey);
+      const requester = new Requester(
+        nodeKeyCache,
+        schemaEndpoint,
+        sdkUserAgent,
+        authProvider,
+        baseUrl,
+        cryptoImpl,
+        undefined,
+        fetchImpl,
+      );
+      const spy = jest.spyOn(signingKey, "sign");
+      await requester.makeRawRequest("query TestQuery { foo }", {}, "node123");
+      expect(spy).toHaveBeenCalled();
+    });
+
+    it("throws if signingKey is missing", async () => {
+      (nodeKeyCache.getKey as jest.Mock).mockReturnValue(undefined);
+      const requester = new Requester(
+        nodeKeyCache,
+        schemaEndpoint,
+        sdkUserAgent,
+        authProvider,
+        baseUrl,
+        cryptoImpl,
+        undefined,
+        fetchImpl,
+      );
+      await expect(
+        requester.makeRawRequest("query TestQuery { foo }", {}, "node123"),
+      ).rejects.toThrow();
+    });
+  });
+});