@lightsparkdev/core 0.2.1 → 0.2.2

package/src/requester/Requester.ts

@@ -12,8 +12,8 @@ import Query from "./Query.js";
 import AuthProvider from "../auth/AuthProvider.js";
 import StubAuthProvider from "../auth/StubAuthProvider.js";
 import {
-  getCrypto,
-  getNonce,
+  CryptoInterface,
+  DefaultCrypto,
   LightsparkSigningException,
 } from "../crypto/crypto.js";
 import NodeKeyCache from "../crypto/NodeKeyCache.js";
@@ -34,7 +34,8 @@ class Requester {
     private readonly schemaEndpoint: string,
     private readonly sdkUserAgent: string,
     private readonly authProvider: AuthProvider = new StubAuthProvider(),
-    private readonly baseUrl: string = DEFAULT_BASE_URL
+    private readonly baseUrl: string = DEFAULT_BASE_URL,
+    private readonly cryptoImpl: CryptoInterface = DefaultCrypto
   ) {
     let websocketImpl;
     if (typeof WebSocket === "undefined" && typeof window === "undefined") {
@@ -183,7 +184,7 @@ class Requester {
     const variables = queryPayload.variables;
     const operationName = queryPayload.operationName;
 
-    const nonce = await getNonce();
+    const nonce = await this.cryptoImpl.getNonce();
     const expiration = dayjs.utc().add(1, "hour").format();
 
     const payload = {
@@ -201,16 +202,11 @@ class Requester {
       );
     }
 
+    if (typeof TextEncoder === "undefined") {
+      const TextEncoder = (await import("text-encoding")).TextEncoder;
+    }
     const encodedPayload = new TextEncoder().encode(JSON.stringify(payload));
-    const cryptoImpl = await getCrypto();
-    const signedPayload = await cryptoImpl.subtle.sign(
-      {
-        name: "RSA-PSS",
-        saltLength: 32,
-      },
-      key,
-      encodedPayload
-    );
+    const signedPayload = await this.cryptoImpl.sign(key, encodedPayload);
     const encodedSignedPayload = b64encode(signedPayload);
 
     headers["X-Lightspark-Signing"] = JSON.stringify({

package/src/utils/base64.ts

@@ -1,7 +1,56 @@
 // Copyright  ©, 2023, Lightspark Group, Inc. - All Rights Reserved
 
+const chars =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+const Base64 = {
+  btoa: (input: string = "") => {
+    let str = input;
+    let output = "";
+
+    for (
+      let block = 0, charCode, i = 0, map = chars;
+      str.charAt(i | 0) || ((map = "="), i % 1);
+      output += map.charAt(63 & (block >> (8 - (i % 1) * 8)))
+    ) {
+      charCode = str.charCodeAt((i += 3 / 4));
+
+      if (charCode > 0xff) {
+        throw new Error(
+          "'btoa' failed: The string to be encoded contains characters outside of the Latin1 range."
+        );
+      }
+
+      block = (block << 8) | charCode;
+    }
+
+    return output;
+  },
+
+  atob: (input: string = "") => {
+    let str = input.replace(/=+$/, "");
+    let output = "";
+
+    if (str.length % 4 == 1) {
+      throw new Error(
+        "'atob' failed: The string to be decoded is not correctly encoded."
+      );
+    }
+    for (
+      let bc = 0, bs = 0, buffer, i = 0;
+      (buffer = str.charAt(i++));
+      ~buffer && ((bs = bc % 4 ? bs * 64 + buffer : buffer), bc++ % 4)
+        ? (output += String.fromCharCode(255 & (bs >> ((-2 * bc) & 6))))
+        : 0
+    ) {
+      buffer = chars.indexOf(buffer);
+    }
+
+    return output;
+  },
+};
+
 export const b64decode = (encoded: string): Uint8Array => {
-  return Uint8Array.from(atob(encoded), (c) => c.charCodeAt(0));
+  return Uint8Array.from(Base64.atob(encoded), (c) => c.charCodeAt(0));
 };
 
 export const urlsafe_b64decode = (encoded: string): Uint8Array => {
@@ -9,7 +58,7 @@ export const urlsafe_b64decode = (encoded: string): Uint8Array => {
 };
 
 export const b64encode = (data: ArrayBuffer): string => {
-  return btoa(
+  return Base64.btoa(
     String.fromCharCode.apply(null, Array.from(new Uint8Array(data)))
   );
 };