@lightsparkdev/core 1.4.3 → 1.4.5

package/dist/index.js

@@ -1,3 +1,22 @@
+import {
+  ConfigKeys,
+  DefaultCrypto,
+  KeyOrAlias,
+  LightsparkAuthException_default,
+  LightsparkSigningException_default,
+  Logger,
+  LoggingLevel,
+  NodeKeyCache_default,
+  RSASigningKey,
+  Requester_default,
+  Secp256k1SigningKey,
+  ServerEnvironment_default,
+  SigningKey,
+  SigningKeyType,
+  StubAuthProvider,
+  apiDomainForEnvironment,
+  logger
+} from "./chunk-L5YREN7B.js";
 import {
   CurrencyUnit,
   LightsparkException_default,
@@ -35,6 +54,7 @@ import {
   isNode,
   isNumber,
   isObject,
+  isReactNative,
   isRecord,
   isSDKCurrencyAmount,
   isTest,
@@ -55,463 +75,10 @@ import {
   urlsafe_b64decode,
   zipcodeToState,
   zipcodeToStateCode
-} from "./chunk-36QHRQJC.js";
-
-// src/auth/LightsparkAuthException.ts
-var LightsparkAuthException = class extends LightsparkException_default {
-  constructor(message, extraInfo) {
-    super("AuthException", message, extraInfo);
-  }
-};
-var LightsparkAuthException_default = LightsparkAuthException;
-
-// src/auth/StubAuthProvider.ts
-var StubAuthProvider = class {
-  addAuthHeaders(headers) {
-    return Promise.resolve(headers);
-  }
-  isAuthorized() {
-    return Promise.resolve(false);
-  }
-  addWsConnectionParams(params) {
-    return Promise.resolve(params);
-  }
-};
-
-// src/constants/index.ts
-var ConfigKeys = {
-  LoggingEnabled: "lightspark-logging-enabled",
-  ConsoleToolsEnabled: "lightspark-console-tools-enabled"
-};
-
-// src/crypto/LightsparkSigningException.ts
-var LightsparkSigningException = class extends LightsparkException_default {
-  constructor(message, extraInfo) {
-    super("SigningException", message, extraInfo);
-  }
-};
-var LightsparkSigningException_default = LightsparkSigningException;
-
-// src/crypto/crypto.ts
-var getCrypto = () => {
-  let cryptoImplPromise;
-  if (typeof crypto !== "undefined") {
-    cryptoImplPromise = Promise.resolve(crypto);
-  } else {
-    cryptoImplPromise = import("crypto").then((nodeCrypto) => {
-      let cryptoModule = nodeCrypto;
-      if (!nodeCrypto.subtle) {
-        cryptoModule = Object.assign({}, cryptoModule, {
-          subtle: nodeCrypto.webcrypto.subtle
-        });
-      }
-      if (!nodeCrypto.getRandomValues) {
-        cryptoModule = Object.assign({}, cryptoModule, {
-          getRandomValues: (array) => {
-            if (!array) {
-              return array;
-            }
-            const buffer = Buffer.from(array.buffer);
-            const view = new Uint8Array(buffer);
-            nodeCrypto.randomFillSync(view);
-            return array;
-          }
-        });
-      }
-      return cryptoModule;
-    });
-  }
-  return cryptoImplPromise;
-};
-var getRandomValues32 = async (arr) => {
-  if (typeof crypto !== "undefined") {
-    return crypto.getRandomValues(arr);
-  } else {
-    const cryptoImpl = await getCrypto();
-    return cryptoImpl.getRandomValues(arr);
-  }
-};
-var deriveKey = async (password, salt, iterations, algorithm, bit_len) => {
-  const enc = new TextEncoder();
-  const cryptoImpl = await getCrypto();
-  const password_key = await cryptoImpl.subtle.importKey(
-    "raw",
-    enc.encode(password),
-    "PBKDF2",
-    false,
-    ["deriveBits", "deriveKey"]
-  );
-  const derived = await cryptoImpl.subtle.deriveBits(
-    {
-      name: "PBKDF2",
-      salt,
-      iterations,
-      hash: "SHA-256"
-    },
-    password_key,
-    bit_len
-  );
-  const key = await cryptoImpl.subtle.importKey(
-    "raw",
-    derived.slice(0, 32),
-    { name: algorithm, length: 256 },
-    false,
-    ["encrypt", "decrypt"]
-  );
-  const iv = derived.slice(32);
-  return [key, iv];
-};
-var decrypt = async (header_json, ciphertext, password) => {
-  let decoded = b64decode(ciphertext);
-  let header;
-  if (header_json === "AES_256_CBC_PBKDF2_5000_SHA256") {
-    header = {
-      v: 0,
-      i: 5e3
-    };
-    decoded = decoded.slice(8);
-  } else {
-    header = JSON.parse(header_json);
-  }
-  if (header.v < 0 || header.v > 4) {
-    throw new LightsparkException_default(
-      "DecryptionError",
-      `Unknown version ${header.v}`
-    );
-  }
-  const cryptoImpl = await getCrypto();
-  const algorithm = header.v < 2 ? "AES-CBC" : "AES-GCM";
-  const bit_len = header.v < 4 ? 384 : 352;
-  const salt_len = header.v < 4 ? 8 : 16;
-  if (header.lsv === 2 || header.v === 3) {
-    const salt = decoded.slice(decoded.length - 8, decoded.length);
-    const nonce = decoded.slice(0, 12);
-    const cipherText = decoded.slice(12, decoded.length - 8);
-    const [
-      key
-      /* , _iv */
-    ] = await deriveKey(
-      password,
-      salt,
-      header.i,
-      algorithm,
-      256
-    );
-    return await cryptoImpl.subtle.decrypt(
-      { name: algorithm, iv: nonce.buffer },
-      key,
-      cipherText
-    );
-  } else {
-    const salt = decoded.slice(0, salt_len);
-    const encrypted = decoded.slice(salt_len);
-    const [key, iv] = await deriveKey(
-      password,
-      salt,
-      header.i,
-      algorithm,
-      bit_len
-    );
-    return await cryptoImpl.subtle.decrypt(
-      { name: algorithm, iv },
-      key,
-      encrypted
-    );
-  }
-};
-async function decryptSecretWithNodePassword(cipher, encryptedSecret, nodePassword) {
-  let decryptedValue = null;
-  try {
-    decryptedValue = await decrypt(cipher, encryptedSecret, nodePassword);
-  } catch (ex) {
-    console.error(ex);
-  }
-  return decryptedValue;
-}
-var generateSigningKeyPair = async () => {
-  const cryptoImpl = await getCrypto();
-  return await cryptoImpl.subtle.generateKey(
-    /*algorithm:*/
-    {
-      name: "RSA-PSS",
-      modulusLength: 4096,
-      publicExponent: new Uint8Array([1, 0, 1]),
-      hash: "SHA-256"
-    },
-    /*extractable*/
-    true,
-    /*keyUsages*/
-    ["sign", "verify"]
-  );
-};
-var serializeSigningKey = async (key, format) => {
-  const cryptoImpl = await getCrypto();
-  return await cryptoImpl.subtle.exportKey(
-    /*format*/
-    format,
-    /*key*/
-    key
-  );
-};
-var getNonce = async () => {
-  const nonceSt = await getRandomValues32(new Uint32Array(2));
-  const [upper, lower] = nonceSt;
-  const nonce = BigInt(upper) << 32n | BigInt(lower);
-  return Number(nonce);
-};
-var sign = async (keyOrAlias, data) => {
-  if (typeof keyOrAlias === "string") {
-    throw new LightsparkSigningException_default(
-      "Key alias not supported for default crypto."
-    );
-  }
-  const cryptoImpl = await getCrypto();
-  return await cryptoImpl.subtle.sign(
-    {
-      name: "RSA-PSS",
-      saltLength: 32
-    },
-    keyOrAlias,
-    data
-  );
-};
-var importPrivateSigningKey = async (keyData) => {
-  const cryptoImpl = await getCrypto();
-  return await cryptoImpl.subtle.importKey(
-    /*format*/
-    "pkcs8",
-    /*keyData*/
-    keyData,
-    /*algorithm*/
-    {
-      name: "RSA-PSS",
-      hash: "SHA-256"
-    },
-    /*extractable*/
-    true,
-    /*keyUsages*/
-    ["sign"]
-  );
-};
-var DefaultCrypto = {
-  decryptSecretWithNodePassword,
-  generateSigningKeyPair,
-  serializeSigningKey,
-  getNonce,
-  sign,
-  importPrivateSigningKey
-};
-
-// src/crypto/KeyOrAlias.ts
-var KeyOrAlias = {
-  key: (key) => ({ key }),
-  alias: (alias) => ({ alias })
-};
-
-// ../../node_modules/auto-bind/index.js
-var getAllProperties = (object) => {
-  const properties = /* @__PURE__ */ new Set();
-  do {
-    for (const key of Reflect.ownKeys(object)) {
-      properties.add([object, key]);
-    }
-  } while ((object = Reflect.getPrototypeOf(object)) && object !== Object.prototype);
-  return properties;
-};
-function autoBind(self, { include, exclude } = {}) {
-  const filter = (key) => {
-    const match = (pattern) => typeof pattern === "string" ? key === pattern : pattern.test(key);
-    if (include) {
-      return include.some(match);
-    }
-    if (exclude) {
-      return !exclude.some(match);
-    }
-    return true;
-  };
-  for (const [object, key] of getAllProperties(self.constructor.prototype)) {
-    if (key === "constructor" || !filter(key)) {
-      continue;
-    }
-    const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
-    if (descriptor && typeof descriptor.value === "function") {
-      self[key] = self[key].bind(self);
-    }
-  }
-  return self;
-}
-
-// src/crypto/SigningKey.ts
-import secp256k1 from "secp256k1";
-function isAlias(key) {
-  return "alias" in key;
-}
-var SigningKey = class {
-  type;
-  constructor(type) {
-    this.type = type;
-  }
-};
-var RSASigningKey = class extends SigningKey {
-  constructor(privateKey, cryptoImpl) {
-    super("RSASigningKey" /* RSASigningKey */);
-    this.privateKey = privateKey;
-    this.cryptoImpl = cryptoImpl;
-  }
-  async sign(data) {
-    const key = isAlias(this.privateKey) ? this.privateKey.alias : this.privateKey;
-    return this.cryptoImpl.sign(key, data);
-  }
-};
-var Secp256k1SigningKey = class extends SigningKey {
-  constructor(privateKey) {
-    super("Secp256k1SigningKey" /* Secp256k1SigningKey */);
-    this.privateKey = privateKey;
-  }
-  async sign(data) {
-    const keyBytes = new Uint8Array(hexToBytes(this.privateKey));
-    const hash = await createSha256Hash(data);
-    const signResult = secp256k1.ecdsaSign(hash, keyBytes);
-    return secp256k1.signatureExport(signResult.signature);
-  }
-};
+} from "./chunk-IWYMQNIA.js";
 
-// src/crypto/types.ts
-var SigningKeyType = /* @__PURE__ */ ((SigningKeyType2) => {
-  SigningKeyType2["RSASigningKey"] = "RSASigningKey";
-  SigningKeyType2["Secp256k1SigningKey"] = "Secp256k1SigningKey";
-  return SigningKeyType2;
-})(SigningKeyType || {});
-
-// src/crypto/NodeKeyCache.ts
-var NodeKeyCache = class {
-  constructor(cryptoImpl = DefaultCrypto) {
-    this.cryptoImpl = cryptoImpl;
-    this.idToKey = /* @__PURE__ */ new Map();
-    autoBind(this);
-  }
-  idToKey;
-  async loadKey(id, keyOrAlias, signingKeyType) {
-    let signingKey;
-    if (keyOrAlias.alias !== void 0) {
-      switch (signingKeyType) {
-        case "RSASigningKey" /* RSASigningKey */:
-          signingKey = new RSASigningKey(
-            { alias: keyOrAlias.alias },
-            this.cryptoImpl
-          );
-          break;
-        default:
-          throw new LightsparkSigningException_default(
-            `Aliases are not supported for signing key type ${signingKeyType}`
-          );
-      }
-      this.idToKey.set(id, signingKey);
-      return signingKey;
-    }
-    try {
-      if (signingKeyType === "Secp256k1SigningKey" /* Secp256k1SigningKey */) {
-        signingKey = new Secp256k1SigningKey(keyOrAlias.key);
-      } else {
-        const decoded = b64decode(this.stripPemTags(keyOrAlias.key));
-        const cryptoKeyOrAlias = await this.cryptoImpl.importPrivateSigningKey(decoded);
-        const key = typeof cryptoKeyOrAlias === "string" ? { alias: cryptoKeyOrAlias } : cryptoKeyOrAlias;
-        signingKey = new RSASigningKey(key, this.cryptoImpl);
-      }
-      this.idToKey.set(id, signingKey);
-      return signingKey;
-    } catch (e) {
-      console.log("Error importing key: ", e);
-    }
-    return null;
-  }
-  getKey(id) {
-    return this.idToKey.get(id);
-  }
-  hasKey(id) {
-    return this.idToKey.has(id);
-  }
-  stripPemTags(pem) {
-    return pem.replace(/-----BEGIN (.*)-----/, "").replace(/-----END (.*)----/, "");
-  }
-};
-var NodeKeyCache_default = NodeKeyCache;
-
-// src/Logger.ts
-var LoggingLevel = /* @__PURE__ */ ((LoggingLevel2) => {
-  LoggingLevel2[LoggingLevel2["Trace"] = 0] = "Trace";
-  LoggingLevel2[LoggingLevel2["Info"] = 1] = "Info";
-  return LoggingLevel2;
-})(LoggingLevel || {});
-var Logger = class {
-  context;
-  loggingEnabled = false;
-  loggingLevel = 1 /* Info */;
-  constructor(loggerContext, getLoggingEnabled) {
-    this.context = loggerContext;
-    void this.updateLoggingEnabled(getLoggingEnabled);
-  }
-  setLevel(level) {
-    this.loggingLevel = level;
-  }
-  setEnabled(enabled, level = 1 /* Info */) {
-    this.loggingEnabled = enabled;
-    this.loggingLevel = level;
-  }
-  async updateLoggingEnabled(getLoggingEnabled) {
-    if (getLoggingEnabled) {
-      this.loggingEnabled = await getLoggingEnabled();
-    } else if (isTest) {
-      this.loggingEnabled = true;
-    } else if (isBrowser) {
-      try {
-        this.loggingEnabled = getLocalStorageConfigItem(
-          ConfigKeys.LoggingEnabled
-        );
-      } catch (e) {
-      }
-    }
-    if (this.loggingEnabled) {
-      console.log(`[${this.context}] Logging enabled`);
-    }
-  }
-  trace(message, ...rest) {
-    if (this.loggingEnabled && this.loggingLevel === 0 /* Trace */) {
-      console.log(`[${this.context}] ${message}`, ...rest);
-    }
-  }
-  info(message, ...rest) {
-    if (this.loggingEnabled && this.loggingLevel <= 1 /* Info */) {
-      console.log(`[${this.context}] ${message}`, ...rest);
-    }
-  }
-};
-var logger = new Logger("@lightsparkdev/core");
-
-// src/requester/Requester.ts
-import dayjs from "dayjs";
-import utc from "dayjs/plugin/utc.js";
-import { Observable } from "zen-observable-ts";
-var DEFAULT_BASE_URL = "api.lightspark.com";
-dayjs.extend(utc);
-var Requester = class {
-  constructor(nodeKeyCache, schemaEndpoint, sdkUserAgent, authProvider = new StubAuthProvider(), baseUrl = DEFAULT_BASE_URL, cryptoImpl = DefaultCrypto, signingKey, fetchImpl = fetch) {
-    this.nodeKeyCache = nodeKeyCache;
-    this.schemaEndpoint = schemaEndpoint;
-    this.sdkUserAgent = sdkUserAgent;
-    this.authProvider = authProvider;
-    this.baseUrl = baseUrl;
-    this.cryptoImpl = cryptoImpl;
-    this.signingKey = signingKey;
-    this.fetchImpl = fetchImpl;
-    this.wsClient = new Promise((resolve) => {
-      this.resolveWsClient = resolve;
-    });
-    void this.initWsClient(baseUrl, authProvider);
-    autoBind(this);
-  }
-  wsClient;
-  resolveWsClient = null;
+// src/requester/DefaultRequester.ts
+var DefaultRequester = class extends Requester_default {
   async initWsClient(baseUrl, authProvider) {
     if (!this.resolveWsClient) {
       return this.wsClient;
@@ -541,229 +108,7 @@ var Requester = class {
     }
     return wsClient;
   }
-  async executeQuery(query) {
-    const data = await this.makeRawRequest(
-      query.queryPayload,
-      query.variables || {},
-      query.signingNodeId,
-      !!query.skipAuth
-    );
-    return query.constructObject(data);
-  }
-  subscribe(queryPayload, variables = {}) {
-    logger.trace(`Requester.subscribe variables`, variables);
-    const operationNameRegex = /^\s*(query|mutation|subscription)\s+(\w+)/i;
-    const operationMatch = queryPayload.match(operationNameRegex);
-    if (!operationMatch || operationMatch.length < 3) {
-      throw new LightsparkException_default("InvalidQuery", "Invalid query payload");
-    }
-    const operationType = operationMatch[1];
-    logger.trace(`Requester.subscribe operationType`, operationType);
-    if (operationType == "mutation") {
-      throw new LightsparkException_default(
-        "InvalidQuery",
-        "Mutation queries should call makeRawRequest instead"
-      );
-    }
-    for (const key in variables) {
-      if (variables[key] === void 0) {
-        variables[key] = null;
-      }
-    }
-    const operation = operationMatch[2];
-    const bodyData = {
-      query: queryPayload,
-      variables,
-      operationName: operation
-    };
-    return new Observable((observer) => {
-      logger.trace(`Requester.subscribe observer`, observer);
-      let cleanup = null;
-      let canceled = false;
-      void (async () => {
-        try {
-          const wsClient = await this.wsClient;
-          if (!wsClient) {
-            throw new LightsparkException_default(
-              "WebSocketNotInitialized",
-              "WebSocket client is not initialized or is not available in the current environment."
-            );
-          }
-          if (!canceled) {
-            cleanup = wsClient.subscribe(bodyData, {
-              next: (data) => observer.next(data),
-              error: (err) => observer.error(err),
-              complete: () => observer.complete()
-            });
-          }
-        } catch (err) {
-          observer.error(err);
-        }
-      })();
-      return () => {
-        canceled = true;
-        if (cleanup) {
-          cleanup();
-        }
-      };
-    });
-  }
-  async makeRawRequest(queryPayload, variables = {}, signingNodeId = void 0, skipAuth = false) {
-    logger.trace(`Requester.makeRawRequest args`, {
-      queryPayload,
-      variables,
-      signingNodeId,
-      skipAuth
-    });
-    const operationNameRegex = /^\s*(query|mutation|subscription)\s+(\w+)/i;
-    const operationMatch = queryPayload.match(operationNameRegex);
-    if (!operationMatch || operationMatch.length < 3) {
-      throw new LightsparkException_default("InvalidQuery", "Invalid query payload");
-    }
-    const operationType = operationMatch[1];
-    if (operationType == "subscription") {
-      throw new LightsparkException_default(
-        "InvalidQuery",
-        "Subscription queries should call subscribe instead"
-      );
-    }
-    for (const key in variables) {
-      if (variables[key] === void 0) {
-        variables[key] = null;
-      }
-    }
-    const operation = operationMatch[2];
-    const payload = {
-      query: queryPayload,
-      variables,
-      operationName: operation
-    };
-    const browserUserAgent = typeof navigator !== "undefined" ? navigator.userAgent : "";
-    const sdkUserAgent = this.getSdkUserAgent();
-    const baseHeaders = {
-      "Content-Type": "application/json",
-      "X-Lightspark-SDK": sdkUserAgent,
-      "User-Agent": browserUserAgent || sdkUserAgent,
-      "X-GraphQL-Operation": operation
-    };
-    const headers = skipAuth ? baseHeaders : await this.authProvider.addAuthHeaders(baseHeaders);
-    let bodyData = await this.addSigningDataIfNeeded(
-      payload,
-      headers,
-      signingNodeId
-    );
-    if (bodyData.length > 1024 && typeof CompressionStream != "undefined") {
-      bodyData = await compress(bodyData);
-      headers["Content-Encoding"] = "deflate";
-    }
-    let urlWithProtocol = this.baseUrl;
-    if (!urlWithProtocol.startsWith("https://") && !urlWithProtocol.startsWith("http://")) {
-      urlWithProtocol = `https://${urlWithProtocol}`;
-    }
-    const url = `${urlWithProtocol}/${this.schemaEndpoint}`;
-    logger.trace(`Requester.makeRawRequest`, {
-      url,
-      operationName: operation,
-      variables,
-      headers
-    });
-    const response = await this.fetchImpl(url, {
-      method: "POST",
-      headers,
-      body: bodyData
-    });
-    if (!response.ok) {
-      throw new LightsparkException_default(
-        "RequestFailed",
-        `Request ${operation} failed. ${response.statusText}`
-      );
-    }
-    const responseJson = await response.json();
-    const data = responseJson.data;
-    if (!data) {
-      let firstErrorName = void 0;
-      if (Array.isArray(responseJson.errors) && responseJson.errors.length > 0) {
-        const firstError = responseJson.errors[0];
-        firstErrorName = firstError["extensions"]?.["error_name"];
-      }
-      throw new LightsparkException_default(
-        "RequestFailed",
-        `Request ${operation} failed. ${JSON.stringify(responseJson.errors)}`,
-        { errorName: firstErrorName }
-      );
-    }
-    return data;
-  }
-  getSdkUserAgent() {
-    const platform = isNode ? "NodeJS" : "Browser";
-    const platformVersion = isNode ? process.version : "";
-    return `${this.sdkUserAgent} ${platform}/${platformVersion}`;
-  }
-  stripProtocol(url) {
-    return url.replace(/.*?:\/\//g, "");
-  }
-  async addSigningDataIfNeeded(queryPayload, headers, signingNodeId) {
-    if (!signingNodeId) {
-      return new TextEncoder().encode(JSON.stringify(queryPayload));
-    }
-    const query = queryPayload.query;
-    const variables = queryPayload.variables;
-    const operationName = queryPayload.operationName;
-    const nonce = await this.cryptoImpl.getNonce();
-    const expiration = dayjs.utc().add(1, "hour").format();
-    const payload = {
-      query,
-      variables,
-      operationName,
-      nonce,
-      expires_at: expiration
-    };
-    const key = this.signingKey ?? this.nodeKeyCache.getKey(signingNodeId);
-    if (!key) {
-      throw new LightsparkSigningException_default(
-        "Missing node of encrypted_signing_private_key"
-      );
-    }
-    const encodedPayload = new TextEncoder().encode(JSON.stringify(payload));
-    const signedPayload = await key.sign(encodedPayload);
-    const encodedSignedPayload = b64encode(signedPayload);
-    headers["X-Lightspark-Signing"] = JSON.stringify({
-      v: "1",
-      signature: encodedSignedPayload
-    });
-    return encodedPayload;
-  }
-};
-async function compress(data) {
-  const stream = new Blob([data]).stream();
-  const compressedStream = stream.pipeThrough(new CompressionStream("deflate"));
-  const reader = compressedStream.getReader();
-  const chunks = [];
-  let done, value;
-  while (!done) {
-    ({ done, value } = await reader.read());
-    chunks.push(value);
-  }
-  const blob = new Blob(chunks);
-  return new Uint8Array(await blob.arrayBuffer());
-}
-var Requester_default = Requester;
-
-// src/ServerEnvironment.ts
-var ServerEnvironment = /* @__PURE__ */ ((ServerEnvironment2) => {
-  ServerEnvironment2["PRODUCTION"] = "production";
-  ServerEnvironment2["DEV"] = "dev";
-  return ServerEnvironment2;
-})(ServerEnvironment || {});
-var apiDomainForEnvironment = (environment) => {
-  switch (environment) {
-    case "dev" /* DEV */:
-      return "api.dev.dev.sparkinfra.net";
-    case "production" /* PRODUCTION */:
-      return "api.lightspark.com";
-  }
 };
-var ServerEnvironment_default = ServerEnvironment;
 export {
   ConfigKeys,
   CurrencyUnit,
@@ -776,7 +121,7 @@ export {
   LoggingLevel,
   NodeKeyCache_default as NodeKeyCache,
   RSASigningKey,
-  Requester_default as Requester,
+  DefaultRequester as Requester,
   Secp256k1SigningKey,
   ServerEnvironment_default as ServerEnvironment,
   SigningKey,
@@ -817,6 +162,7 @@ export {
   isNode,
   isNumber,
   isObject,
+  isReactNative,
   isRecord,
   isSDKCurrencyAmount,
   isTest,