@lightsparkdev/core 1.0.9 → 1.0.11

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @lightsparkdev/core
 
+## 1.0.11
+
+### Patch Changes
+
+- 43dc882: Upgrade to Typescript 5, lint config changes
+
+## 1.0.10
+
+### Patch Changes
+
+- aefe52c: Update tsup to latest
+- 09dfcee: Prevent ts compile of test files for builds and update lint configuration
+
 ## 1.0.9
 
 ### Patch Changes

package/dist/{chunk-UU6SHVGX.js → chunk-F3XHLUGC.js}

@@ -816,39 +816,38 @@ function sleep(ms) {
 function getDefaultMaxPollsError() {
   return new Error("pollUntil: Max polls reached");
 }
-function pollUntil(asyncFn, getValue, maxPolls = 60, pollIntervalMs = 500, ignoreErrors = false, getMaxPollsError = getDefaultMaxPollsError) {
-  return new Promise((resolve, reject) => {
-    let polls = 0;
-    let stopPolling = false;
-    (async function() {
-      while (!stopPolling) {
-        polls += 1;
-        if (polls > maxPolls) {
-          stopPolling = true;
-          const maxPollsError = getMaxPollsError(maxPolls);
-          reject(maxPollsError);
-          break;
-        }
-        try {
-          const asyncResult = await asyncFn();
-          const result = getValue(asyncResult, {
-            stopPolling: false,
-            value: null
-          });
-          if (result.stopPolling) {
-            stopPolling = true;
-            resolve(result.value);
-          }
-        } catch (e) {
-          if (!ignoreErrors || isFunction_default(ignoreErrors) && !ignoreErrors(e)) {
-            stopPolling = true;
-            reject(e);
-          }
-        }
-        await sleep(pollIntervalMs);
+async function pollUntil(asyncFn, getValue, maxPolls = 60, pollIntervalMs = 500, ignoreErrors = false, getMaxPollsError = getDefaultMaxPollsError) {
+  let polls = 0;
+  let stopPolling = false;
+  let result = {
+    stopPolling: false,
+    value: null
+  };
+  while (!stopPolling) {
+    polls += 1;
+    if (polls > maxPolls) {
+      stopPolling = true;
+      const maxPollsError = getMaxPollsError(maxPolls);
+      throw maxPollsError;
+    }
+    try {
+      const asyncResult = await asyncFn();
+      result = getValue(asyncResult, {
+        stopPolling: false,
+        value: null
+      });
+      if (result.stopPolling) {
+        stopPolling = true;
       }
-    })();
-  });
+    } catch (e) {
+      if (!ignoreErrors || isFunction_default(ignoreErrors) && !ignoreErrors(e)) {
+        stopPolling = true;
+        throw e;
+      }
+    }
+    await sleep(pollIntervalMs);
+  }
+  return result.value;
 }
 
 // src/utils/types.ts
@@ -858,12 +857,12 @@ var isType = (typename) => (node) => {
 
 export {
   LightsparkException_default,
-  b64decode,
-  urlsafe_b64decode,
-  b64encode,
   isBrowser,
   isNode,
   isTest,
+  b64decode,
+  urlsafe_b64decode,
+  b64encode,
   bytesToHex,
   hexToBytes,
   createSha256Hash,

package/dist/index.cjs

@@ -99,6 +99,60 @@ var LightsparkException = class extends Error {
 };
 var LightsparkException_default = LightsparkException;
 
+// src/utils/environment.ts
+var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var isTest = isNode && process.env.NODE_ENV === "test";
+
+// src/Logger.ts
+var Logger = class {
+  context;
+  loggingEnabled = false;
+  constructor(loggerContext, getLoggingEnabled) {
+    this.context = loggerContext;
+    void this.updateLoggingEnabled(getLoggingEnabled);
+  }
+  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`);
+    }
+  }
+  info(message, ...rest) {
+    if (this.loggingEnabled) {
+      console.log(`[${this.context}] ${message}`, ...rest);
+    }
+  }
+};
+var logger = new Logger("@lightsparkdev/core");
+
+// 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;
+
 // src/auth/LightsparkAuthException.ts
 var LightsparkAuthException = class extends LightsparkException_default {
   constructor(message, extraInfo) {
@@ -109,14 +163,14 @@ var LightsparkAuthException_default = LightsparkAuthException;
 
 // src/auth/StubAuthProvider.ts
 var StubAuthProvider = class {
-  async addAuthHeaders(headers) {
-    return headers;
+  addAuthHeaders(headers) {
+    return Promise.resolve(headers);
   }
-  async isAuthorized() {
-    return false;
+  isAuthorized() {
+    return Promise.resolve(false);
   }
-  async addWsConnectionParams(params) {
-    return params;
+  addWsConnectionParams(params) {
+    return Promise.resolve(params);
   }
 };
 
@@ -133,6 +187,23 @@ var getLocalStorageConfigItem = (key) => {
   }
 };
 
+// src/crypto/KeyOrAlias.ts
+var KeyOrAlias = {
+  key: (key) => ({ key }),
+  alias: (alias) => ({ alias })
+};
+
+// src/crypto/LightsparkSigningException.ts
+var LightsparkSigningException = class extends LightsparkException_default {
+  constructor(message, extraInfo) {
+    super("SigningException", message, extraInfo);
+  }
+};
+var LightsparkSigningException_default = LightsparkSigningException;
+
+// src/crypto/NodeKeyCache.ts
+var import_auto_bind = __toESM(require("auto-bind"), 1);
+
 // src/utils/base64.ts
 var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
 var Base64 = {
@@ -176,14 +247,6 @@ var b64encode = (data) => {
   );
 };
 
-// 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;
@@ -267,7 +330,7 @@ var decrypt = async (header_json, ciphertext, password) => {
   if (header.v < 0 || header.v > 4) {
     throw new LightsparkException_default(
       "DecryptionError",
-      "Unknown version ".concat(header.v)
+      `Unknown version ${header.v}`
     );
   }
   const cryptoImpl = await getCrypto();
@@ -278,7 +341,10 @@ var decrypt = async (header_json, ciphertext, password) => {
     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(
+    const [
+      key
+      /* , _iv */
+    ] = await deriveKey(
       password,
       salt,
       header.i,
@@ -388,23 +454,9 @@ var DefaultCrypto = {
   importPrivateSigningKey
 };
 
-// src/crypto/KeyOrAlias.ts
-var KeyOrAlias = {
-  key: (key) => ({ key }),
-  alias: (alias) => ({ alias })
-};
-
-// src/crypto/NodeKeyCache.ts
-var import_auto_bind = __toESM(require("auto-bind"), 1);
-
 // src/crypto/SigningKey.ts
 var import_secp256k1 = __toESM(require("secp256k1"), 1);
 
-// src/utils/environment.ts
-var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
-var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-var isTest = isNode && process.env.NODE_ENV === "test";
-
 // src/utils/hex.ts
 var bytesToHex = (bytes) => {
   return bytes.reduce((acc, byte) => {
@@ -1161,39 +1213,38 @@ function sleep(ms) {
 function getDefaultMaxPollsError() {
   return new Error("pollUntil: Max polls reached");
 }
-function pollUntil(asyncFn, getValue, maxPolls = 60, pollIntervalMs = 500, ignoreErrors = false, getMaxPollsError = getDefaultMaxPollsError) {
-  return new Promise((resolve, reject) => {
-    let polls = 0;
-    let stopPolling = false;
-    (async function() {
-      while (!stopPolling) {
-        polls += 1;
-        if (polls > maxPolls) {
-          stopPolling = true;
-          const maxPollsError = getMaxPollsError(maxPolls);
-          reject(maxPollsError);
-          break;
-        }
-        try {
-          const asyncResult = await asyncFn();
-          const result = getValue(asyncResult, {
-            stopPolling: false,
-            value: null
-          });
-          if (result.stopPolling) {
-            stopPolling = true;
-            resolve(result.value);
-          }
-        } catch (e) {
-          if (!ignoreErrors || isFunction_default(ignoreErrors) && !ignoreErrors(e)) {
-            stopPolling = true;
-            reject(e);
-          }
-        }
-        await sleep(pollIntervalMs);
+async function pollUntil(asyncFn, getValue, maxPolls = 60, pollIntervalMs = 500, ignoreErrors = false, getMaxPollsError = getDefaultMaxPollsError) {
+  let polls = 0;
+  let stopPolling = false;
+  let result = {
+    stopPolling: false,
+    value: null
+  };
+  while (!stopPolling) {
+    polls += 1;
+    if (polls > maxPolls) {
+      stopPolling = true;
+      const maxPollsError = getMaxPollsError(maxPolls);
+      throw maxPollsError;
+    }
+    try {
+      const asyncResult = await asyncFn();
+      result = getValue(asyncResult, {
+        stopPolling: false,
+        value: null
+      });
+      if (result.stopPolling) {
+        stopPolling = true;
       }
-    })();
-  });
+    } catch (e) {
+      if (!ignoreErrors || isFunction_default(ignoreErrors) && !ignoreErrors(e)) {
+        stopPolling = true;
+        throw e;
+      }
+    }
+    await sleep(pollIntervalMs);
+  }
+  return result.value;
 }
 
 // src/utils/types.ts
@@ -1296,39 +1347,6 @@ var NodeKeyCache = class {
 };
 var NodeKeyCache_default = NodeKeyCache;
 
-// src/Logger.ts
-var Logger = class {
-  context;
-  loggingEnabled = false;
-  constructor(loggerContext, getLoggingEnabled) {
-    this.context = loggerContext;
-    this.updateLoggingEnabled(getLoggingEnabled);
-  }
-  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`);
-    }
-  }
-  info(message, ...rest) {
-    if (this.loggingEnabled) {
-      console.log(`[${this.context}] ${message}`, ...rest);
-    }
-  }
-};
-var logger = new Logger("@lightsparkdev/core");
-
 // src/requester/Requester.ts
 var import_auto_bind2 = __toESM(require("auto-bind"), 1);
 var import_dayjs = __toESM(require("dayjs"), 1);
@@ -1453,6 +1471,7 @@ var Requester = class {
     const url = `${urlWithProtocol}/${this.schemaEndpoint}`;
     logger.info(`Requester.makeRawRequest`, {
       url,
+      operationName: operation,
       variables
     });
     const response = await fetch(url, {
@@ -1500,7 +1519,7 @@ var Requester = class {
       nonce,
       expires_at: expiration
     };
-    const key = await this.nodeKeyCache.getKey(signingNodeId);
+    const key = this.nodeKeyCache.getKey(signingNodeId);
     if (!key) {
       throw new LightsparkSigningException_default(
         "Missing node of encrypted_signing_private_key"
@@ -1523,22 +1542,6 @@ var Requester = class {
   }
 };
 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;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ConfigKeys,

package/dist/index.d.cts

@@ -0,0 +1,168 @@
+import { Observable } from 'zen-observable-ts';
+export { ById, CurrencyAmountArg, CurrencyAmountObj, CurrencyAmountType, CurrencyCodes, CurrencyLocales, CurrencyMap, CurrencyUnit, DeepPartial, ExpandRecursively, Maybe, OmitTypename, abbrCurrencyUnit, b64decode, b64encode, bytesToHex, clamp, convertCurrencyAmount, convertCurrencyAmountValue, countryCodesToCurrencyCodes, createSha256Hash, defaultCurrencyCode, formatCurrencyStr, getCurrentLocale, getErrorMsg, hexToBytes, isBrowser, isCurrencyAmount, isCurrencyAmountObj, isCurrencyMap, isError, isErrorMsg, isErrorWithMessage, isNode, isNumber, isTest, isType, linearInterpolate, localeToCurrencyCode, localeToCurrencySymbol, mapCurrencyAmount, pollUntil, round, separateCurrencyStrParts, sleep, urlsafe_b64decode } from './utils/index.cjs';
+
+declare class LightsparkException extends Error {
+    code: string;
+    message: string;
+    extraInfo: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, extraInfo?: Record<string, unknown>);
+}
+
+type GetLoggingEnabled = (() => Promise<boolean> | boolean) | undefined;
+declare class Logger {
+    context: string;
+    loggingEnabled: boolean;
+    constructor(loggerContext: string, getLoggingEnabled?: GetLoggingEnabled);
+    updateLoggingEnabled(getLoggingEnabled: GetLoggingEnabled): Promise<void>;
+    info(message: string, ...rest: unknown[]): void;
+}
+
+declare enum ServerEnvironment {
+    PRODUCTION = "production",
+    DEV = "dev"
+}
+declare const apiDomainForEnvironment: (environment: ServerEnvironment) => string;
+
+type Headers = Record<string, string>;
+type WsConnectionParams = Record<string, unknown>;
+interface AuthProvider {
+    addAuthHeaders(headers: Headers): Promise<Headers>;
+    isAuthorized(): Promise<boolean>;
+    addWsConnectionParams(params: WsConnectionParams): Promise<WsConnectionParams>;
+}
+
+declare class LightsparkAuthException extends LightsparkException {
+    constructor(message: string, extraInfo?: Record<string, unknown>);
+}
+
+declare class StubAuthProvider implements AuthProvider {
+    addAuthHeaders(headers: Headers): Promise<Headers>;
+    isAuthorized(): Promise<boolean>;
+    addWsConnectionParams(params: WsConnectionParams): Promise<WsConnectionParams>;
+}
+
+declare const ConfigKeys: {
+    readonly LoggingEnabled: "lightspark-logging-enabled";
+    readonly ConsoleToolsEnabled: "lightspark-console-tools-enabled";
+};
+type ConfigKeys = (typeof ConfigKeys)[keyof typeof ConfigKeys];
+declare const getLocalStorageConfigItem: (key: ConfigKeys) => boolean;
+
+type OnlyKey = {
+    key: string;
+    alias?: never;
+};
+type OnlyAlias = {
+    key?: never;
+    alias: string;
+};
+type KeyOrAliasType = OnlyKey | OnlyAlias;
+declare const KeyOrAlias: {
+    key: (key: string) => OnlyKey;
+    alias: (alias: string) => OnlyAlias;
+};
+
+declare class LightsparkSigningException extends LightsparkException {
+    constructor(message: string, extraInfo?: Record<string, unknown>);
+}
+
+type GeneratedKeyPair = {
+    publicKey: CryptoKey | string;
+    privateKey: CryptoKey | string;
+    keyAlias?: string;
+};
+type CryptoInterface = {
+    decryptSecretWithNodePassword: (cipher: string, encryptedSecret: string, nodePassword: string) => Promise<ArrayBuffer | null>;
+    generateSigningKeyPair: () => Promise<GeneratedKeyPair>;
+    serializeSigningKey: (key: CryptoKey | string, format: "pkcs8" | "spki") => Promise<ArrayBuffer>;
+    getNonce: () => Promise<number>;
+    sign: (keyOrAlias: CryptoKey | string, data: Uint8Array) => Promise<ArrayBuffer>;
+    importPrivateSigningKey: (keyData: Uint8Array) => Promise<CryptoKey | string>;
+};
+declare function decryptSecretWithNodePassword(cipher: string, encryptedSecret: string, nodePassword: string): Promise<ArrayBuffer | null>;
+declare const DefaultCrypto: {
+    decryptSecretWithNodePassword: typeof decryptSecretWithNodePassword;
+    generateSigningKeyPair: () => Promise<GeneratedKeyPair>;
+    serializeSigningKey: (key: CryptoKey | string, format: "pkcs8" | "spki") => Promise<ArrayBuffer>;
+    getNonce: () => Promise<number>;
+    sign: (keyOrAlias: CryptoKey | string, data: Uint8Array) => Promise<ArrayBuffer>;
+    importPrivateSigningKey: (keyData: Uint8Array) => Promise<CryptoKey | string>;
+};
+
+interface Alias {
+    alias: string;
+}
+declare abstract class SigningKey {
+    readonly type: SigningKeyType;
+    constructor(type: SigningKeyType);
+    abstract sign(data: Uint8Array): Promise<ArrayBuffer>;
+}
+declare class RSASigningKey extends SigningKey {
+    private readonly privateKey;
+    private readonly cryptoImpl;
+    constructor(privateKey: CryptoKey | Alias, cryptoImpl: CryptoInterface);
+    sign(data: Uint8Array): Promise<ArrayBuffer>;
+}
+declare class Secp256k1SigningKey extends SigningKey {
+    private readonly privateKey;
+    constructor(privateKey: string);
+    sign(data: Uint8Array): Promise<Uint8Array>;
+}
+
+declare enum SigningKeyType {
+    RSASigningKey = "RSASigningKey",
+    Secp256k1SigningKey = "Secp256k1SigningKey"
+}
+
+declare class NodeKeyCache {
+    private readonly cryptoImpl;
+    private idToKey;
+    constructor(cryptoImpl?: CryptoInterface);
+    loadKey(id: string, keyOrAlias: KeyOrAliasType, signingKeyType: SigningKeyType): Promise<SigningKey | null>;
+    getKey(id: string): SigningKey | undefined;
+    hasKey(id: string): boolean;
+    private stripPemTags;
+}
+
+type Query<T> = {
+    /** The string representation of the query payload for graphQL. **/
+    queryPayload: string;
+    /** The variables that will be passed to the query. **/
+    variables?: {
+        [key: string]: unknown;
+    };
+    /**
+     * The function that will be called to construct the object from the
+     * response. *
+     */
+    constructObject: (rawData: any) => T;
+    /** The id of the node that will be used to sign the query. **/
+    signingNodeId?: string;
+    /** True if auth headers should be omitted for this query. **/
+    skipAuth?: boolean;
+};
+
+declare class Requester {
+    private readonly nodeKeyCache;
+    private readonly schemaEndpoint;
+    private readonly sdkUserAgent;
+    private readonly authProvider;
+    private readonly baseUrl;
+    private readonly cryptoImpl;
+    private readonly wsClient;
+    constructor(nodeKeyCache: NodeKeyCache, schemaEndpoint: string, sdkUserAgent: string, authProvider?: AuthProvider, baseUrl?: string, cryptoImpl?: CryptoInterface);
+    executeQuery<T>(query: Query<T>): Promise<T | null>;
+    subscribe<T>(queryPayload: string, variables?: {
+        [key: string]: unknown;
+    }): Observable<{
+        data: T;
+    }>;
+    makeRawRequest(queryPayload: string, variables?: {
+        [key: string]: unknown;
+    }, signingNodeId?: string | undefined, skipAuth?: boolean): Promise<any>;
+    private getSdkUserAgent;
+    private stripProtocol;
+    private addSigningDataIfNeeded;
+}
+
+export { AuthProvider, ConfigKeys, CryptoInterface, DefaultCrypto, GeneratedKeyPair, KeyOrAlias, KeyOrAliasType, LightsparkAuthException, LightsparkException, LightsparkSigningException, Logger, NodeKeyCache, Query, RSASigningKey, Requester, Secp256k1SigningKey, ServerEnvironment, SigningKey, SigningKeyType, StubAuthProvider, apiDomainForEnvironment, getLocalStorageConfigItem };