@lightsparkdev/core 1.3.0 → 1.4.0

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();
+    });
+  });
+});

package/src/utils/errors.ts

@@ -1,3 +1,4 @@
+import { isObject } from "./typeGuards.js";
 import { type JSONType } from "./types.js";
 
 export const isError = (e: unknown): e is Error => {
@@ -35,15 +36,35 @@ export const isErrorMsg = (e: unknown, msg: string) => {
   return false;
 };
 
-export function errorToJSON(err: unknown) {
+/* Make non-enumerable properties like message and stack enumerable so they
+   can be handled by JSON.stringify */
+function normalizeObject(obj: unknown): Record<string, unknown> {
+  const normalized: Record<string, unknown> = {};
+  if (isObject(obj)) {
+    const props = Object.getOwnPropertyNames(obj);
+    for (const prop of props) {
+      const objRecord = obj as Record<string, unknown>;
+      normalized[prop] = objRecord[prop];
+    }
+  }
+  return normalized;
+}
+
+export function errorToJSON(
+  err: unknown,
+  /* Enable stringifying non-primitives globally for subpaths.
+     Useful for enforcing single level error objects: */
+  stringifyObjects = false,
+) {
   if (!err) {
     return null;
   }
-  if (
-    typeof err === "object" &&
-    "toJSON" in err &&
-    typeof err.toJSON === "function"
-  ) {
+
+  /* Objects can add standard toJSON method to determine JSON.stringify output, https://mzl.la/3Gks9zu: */
+  if (isObject(err) && "toJSON" in err && typeof err.toJSON === "function") {
+    if (stringifyObjects === true) {
+      return objectToJSON(err.toJSON());
+    }
     return err.toJSON() as JSONType;
   }
 
@@ -57,7 +78,28 @@ export function errorToJSON(err: unknown) {
     return { message: err.message };
   }
 
+  return objectToJSON(err);
+}
+
+function objectToJSON(obj: unknown) {
+  const normalizedObj = normalizeObject(obj);
   return JSON.parse(
-    JSON.stringify(err, Object.getOwnPropertyNames(err)),
+    JSON.stringify(normalizedObj, (key, value: unknown) => {
+      /* Initial call passes the top level object with empty key: */
+      if (key === "") {
+        return value;
+      }
+
+      const objProps = Object.getOwnPropertyNames(normalizedObj);
+      if (!objProps.includes(key)) {
+        return undefined;
+      }
+
+      if (isObject(value)) {
+        return JSON.stringify(value);
+      }
+
+      return value;
+    }),
   ) as JSONType;
 }

package/src/utils/localStorage.ts

@@ -1,15 +1,31 @@
 import { type ConfigKeys } from "../constants/index.js";
 
 export function getLocalStorageConfigItem(key: ConfigKeys) {
-  return getLocalStorageBoolean(key);
+  const localStorageBoolean = getLocalStorageBoolean(key);
+  // If config not set, just default to false
+  if (localStorageBoolean == null) {
+    return false;
+  }
+
+  return localStorageBoolean;
 }
 
 export function getLocalStorageBoolean(key: string) {
   /* localStorage is not available in all contexts, use try/catch: */
   try {
-    return localStorage.getItem(key) === "1";
+    if (localStorage.getItem(key) === "1") {
+      return true;
+    }
+    // Key is not set
+    else if (localStorage.getItem(key) == null) {
+      return null;
+    }
+    // Key is set but not "1"
+    else {
+      return false;
+    }
   } catch (e) {
-    return false;
+    return null;
   }
 }
 

package/src/utils/typeGuards.ts

@@ -2,7 +2,16 @@ export function isUint8Array(value: unknown): value is Uint8Array {
   return value instanceof Uint8Array;
 }
 
-export function isObject(value: unknown): value is Record<string, unknown> {
+export function isObject(value: unknown): value is object {
   const type = typeof value;
   return value != null && (type == "object" || type == "function");
 }
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    Object.prototype.toString.call(value) === "[object Object]"
+  );
+}

package/src/utils/types.ts

@@ -59,7 +59,3 @@ export type Complete<T> = { [P in keyof T]-?: NonNullable<T[P]> };
 export type RequiredKeys<T> = {
   [K in keyof T]-?: Record<string, never> extends Pick<T, K> ? never : K;
 }[keyof T];
-
-export function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}