@quiltt/core 3.5.5 → 3.6.0

package/dist/index.js

@@ -1,55 +1,12 @@
-import { G as GlobalStorage, e as endpointGraphQL, v as version, d as debugging, S as SubscriptionLink, a as endpointAuth } from './SubscriptionLink-client-B5Tmyqw7.js';
-export { L as LocalStorage, M as MemoryStorage, O as Observable, f as Storage, c as cdnBase, b as endpointWebsockets } from './SubscriptionLink-client-B5Tmyqw7.js';
 import { ApolloLink, ApolloClient } from '@apollo/client/index.js';
 export { InMemoryCache, gql, useMutation, useQuery, useSubscription } from '@apollo/client/index.js';
+import { G as GlobalStorage, e as endpointGraphQL, v as version, d as debugging, S as SubscriptionLink, a as endpointAuth } from './SubscriptionLink-client-Bf6n9gzT.js';
+export { L as LocalStorage, M as MemoryStorage, O as Observable, b as Storage, c as cdnBase, f as endpointWebsockets, g as getEnv } from './SubscriptionLink-client-Bf6n9gzT.js';
 import { BatchHttpLink as BatchHttpLink$1 } from '@apollo/client/link/batch-http/index.js';
-import fetch from 'cross-fetch';
+import crossfetch from 'cross-fetch';
 import { onError } from '@apollo/client/link/error/index.js';
 import { HttpLink as HttpLink$1 } from '@apollo/client/link/http/index.js';
 import { RetryLink as RetryLink$1 } from '@apollo/client/link/retry/index.js';
-import Axios from 'axios';
-
-const MATCHER = /^(?:[\w-]+\.){2}[\w-]+$/;
-const JsonWebTokenParse = (token)=>{
-    if (typeof token === 'undefined' || token === null) return token;
-    if (!MATCHER.test(token)) {
-        console.error(`Invalid Session Token: ${token}`);
-        return;
-    }
-    const [_header, payload, _signature] = token.split('.');
-    try {
-        return {
-            token: token,
-            claims: JSON.parse(atob(payload))
-        };
-    } catch (error) {
-        console.error(`Invalid Session Token: ${error}`);
-    }
-};
-
-/**
- * This is designed to support singletons to timeouts that can broadcast
- * to any observers, preventing race conditions with multiple timeouts.
- */ class Timeoutable {
-    constructor(){
-        this.observers = [];
-        this.set = (callback, delay)=>{
-            if (this.timeout) {
-                clearTimeout(this.timeout);
-            }
-            this.observers.push(callback);
-            this.timeout = setTimeout(this.broadcast.bind(this), delay);
-        };
-        this.clear = (observer)=>{
-            this.observers = this.observers.filter((callback)=>callback !== observer);
-        };
-        // Only sends to the 1st listener, but ensures that someone is notified
-        this.broadcast = ()=>{
-            if (this.observers.length === 0) return;
-            this.observers[0](undefined);
-        };
-    }
-}
 
 var ConnectorSDKEventType;
 (function(ConnectorSDKEventType) {
@@ -81,9 +38,11 @@ var ConnectorSDKEventType;
     }
 }
 
+// Use `cross-fetch` only if `fetch` is not available on the `globalThis` object
+const effectiveFetch$2 = typeof fetch === 'undefined' ? crossfetch : fetch;
 const BatchHttpLink = new BatchHttpLink$1({
     uri: endpointGraphQL,
-    fetch
+    fetch: effectiveFetch$2
 });
 
 const ErrorLink = onError(({ graphQLErrors, networkError })=>{
@@ -104,9 +63,11 @@ const ErrorLink = onError(({ graphQLErrors, networkError })=>{
 
 const ForwardableLink = new ApolloLink((operation, forward)=>forward(operation));
 
+// Use `cross-fetch` only if `fetch` is not available on the `globalThis` object
+const effectiveFetch$1 = typeof fetch === 'undefined' ? crossfetch : fetch;
 const HttpLink = new HttpLink$1({
     uri: endpointGraphQL,
-    fetch
+    fetch: effectiveFetch$1
 });
 
 const RetryLink = new RetryLink$1({
@@ -152,35 +113,51 @@ class QuilttClient extends ApolloClient {
     }
 }
 
+// Use `cross-fetch` only if `fetch` is not available on the `globalThis` object
+const effectiveFetch = typeof fetch === 'undefined' ? crossfetch : fetch;
 const RETRY_DELAY = 150 // ms
 ;
 const RETRIES = 10 // 150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500 = 8.250s
 ;
-// Create an axios singleton for Quiltt, to prevent mutating other instances
-const axios = Axios.create();
-// Example: axios.get(url, { retry: true })
-axios.interceptors.response.use(undefined, (error)=>{
-    const { config, message, response } = error;
-    const messageLower = message.toLowerCase();
-    if (!config || !config.retry) {
-        return Promise.reject(error);
-    }
-    // Retry Network timeout, Network errors, and Too Many Requests
-    if (!(messageLower.includes('timeout') || messageLower.includes('network error') || response?.status === 429)) {
-        return Promise.reject(error);
-    }
-    if (config.retriesRemaining === undefined) {
-        config.retriesRemaining = RETRIES - 1;
-    } else if (config.retriesRemaining === 1) {
+/**
+ * A wrapper around the native `fetch` function that adds automatic retries on failure, including network errors and HTTP 429 responses.
+ * Now treats any response with status < 500 as valid.
+ */ const fetchWithRetry = async (url, options = {
+    retry: false
+})=>{
+    const { retry, retriesRemaining, validateStatus = (status)=>status >= 200 && status < 300, ...fetchOptions } = options;
+    try {
+        const response = await effectiveFetch(url, fetchOptions);
+        const isResponseOk = validateStatus(response.status);
+        if (isResponseOk) {
+            return {
+                data: await response.json().catch(()=>null),
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                ok: isResponseOk
+            };
+        }
+        // If validateStatus fails, and retry is enabled, prepare to retry for eligible status codes
+        if (retry && (response.status >= 500 || response.status === 429)) {
+            throw new Error('Retryable failure');
+        }
+        throw new Error('HTTP error with status ' + response.status);
+    } catch (error) {
+        if (retry) {
+            const currentRetriesRemaining = retriesRemaining !== undefined ? retriesRemaining : RETRIES;
+            if (currentRetriesRemaining > 0) {
+                const delayTime = RETRY_DELAY * (RETRIES - currentRetriesRemaining);
+                await new Promise((resolve)=>setTimeout(resolve, delayTime));
+                return fetchWithRetry(url, {
+                    ...options,
+                    retriesRemaining: currentRetriesRemaining - 1
+                });
+            }
+        }
         return Promise.reject(error);
-    } else {
-        config.retriesRemaining -= 1;
     }
-    const delay = new Promise((resolve)=>{
-        setTimeout(()=>resolve(), RETRY_DELAY * (RETRIES - config.retriesRemaining));
-    });
-    return delay.then(()=>axios(config));
-});
+};
 
 var AuthStrategies;
 (function(AuthStrategies) {
@@ -194,47 +171,64 @@ class AuthAPI {
    * Response Statuses:
    *  - 200: OK           -> Session is Valid
    *  - 401: Unauthorized -> Session is Invalid
-   */ this.ping = (token)=>{
-            return axios.get(endpointAuth, this.config(token));
+   */ this.ping = async (token)=>{
+            const response = await fetchWithRetry(endpointAuth, {
+                method: 'GET',
+                ...this.config(token)
+            });
+            return response;
         };
         /**
    * Response Statuses:
    *  - 201: Created              -> Profile Created, New Session Returned
    *  - 202: Accepted             -> Profile Found, MFA Code Sent for `authenticate`
    *  - 422: Unprocessable Entity -> Invalid Payload
-   */ this.identify = (payload)=>{
-            return axios.post(endpointAuth, this.body(payload), this.config());
+   */ this.identify = async (payload)=>{
+            const response = await fetchWithRetry(endpointAuth, {
+                method: 'POST',
+                body: JSON.stringify(this.body(payload)),
+                ...this.config()
+            });
+            return response;
         };
         /**
    * Response Statuses:
    *  - 201: Created              -> MFA Validated, New Session Returned
    *  - 401: Unauthorized         -> MFA Invalid
    *  - 422: Unprocessable Entity -> Invalid Payload
-   */ this.authenticate = (payload)=>{
-            return axios.put(endpointAuth, this.body(payload), this.config());
+   */ this.authenticate = async (payload)=>{
+            const response = await fetchWithRetry(endpointAuth, {
+                method: 'PUT',
+                body: JSON.stringify(this.body(payload)),
+                ...this.config()
+            });
+            return response;
         };
         /**
    * Response Statuses:
    *  - 204: No Content   -> Session Revoked
    *  - 401: Unauthorized -> Session Not Found
-   */ this.revoke = (token)=>{
-            return axios.delete(endpointAuth, this.config(token));
+   */ this.revoke = async (token)=>{
+            const response = await fetchWithRetry(endpointAuth, {
+                method: 'DELETE',
+                ...this.config(token)
+            });
+            return response;
         };
         this.config = (token)=>{
-            const headers = {
-                'Content-Type': 'application/json',
-                Accept: 'application/json'
-            };
+            const headers = new Headers();
+            headers.set('Content-Type', 'application/json');
+            headers.set('Accept', 'application/json');
             if (token) {
-                headers.Authorization = `Bearer ${token}`;
+                headers.set('Authorization', `Bearer ${token}`);
             }
             return {
-                headers: headers,
+                headers,
                 validateStatus: this.validateStatus,
                 retry: true
             };
         };
-        this.validateStatus = (status)=>status < 500;
+        this.validateStatus = (status)=>status < 500 && status !== 429;
         this.body = (payload)=>{
             if (!this.clientId) {
                 console.error('Quiltt Client ID is not set. Unable to identify & authenticate');
@@ -250,4 +244,46 @@ class AuthAPI {
     }
 }
 
+const MATCHER = /^(?:[\w-]+\.){2}[\w-]+$/;
+const JsonWebTokenParse = (token)=>{
+    if (typeof token === 'undefined' || token === null) return token;
+    if (!MATCHER.test(token)) {
+        console.error(`Invalid Session Token: ${token}`);
+        return;
+    }
+    const [_header, payload, _signature] = token.split('.');
+    try {
+        return {
+            token: token,
+            claims: JSON.parse(atob(payload))
+        };
+    } catch (error) {
+        console.error(`Invalid Session Token: ${error}`);
+    }
+};
+
+/**
+ * This is designed to support singletons to timeouts that can broadcast
+ * to any observers, preventing race conditions with multiple timeouts.
+ */ class Timeoutable {
+    constructor(){
+        this.observers = [];
+        this.set = (callback, delay)=>{
+            if (this.timeout) {
+                clearTimeout(this.timeout);
+            }
+            this.observers.push(callback);
+            this.timeout = setTimeout(this.broadcast.bind(this), delay);
+        };
+        this.clear = (observer)=>{
+            this.observers = this.observers.filter((callback)=>callback !== observer);
+        };
+        // Only sends to the 1st listener, but ensures that someone is notified
+        this.broadcast = ()=>{
+            if (this.observers.length === 0) return;
+            this.observers[0](undefined);
+        };
+    }
+}
+
 export { AuthAPI, AuthLink, AuthStrategies, BatchHttpLink, ConnectorSDKEventType, ErrorLink, ForwardableLink, GlobalStorage, HttpLink, JsonWebTokenParse, QuilttClient, RetryLink, SubscriptionLink, TerminatingLink, Timeoutable, VersionLink, debugging, endpointAuth, endpointGraphQL, version };

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@quiltt/core",
-  "version": "3.5.5",
+  "version": "3.6.0",
   "description": "Javascript API client and utilities for Quiltt",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/quiltt/quiltt-public.git",
-    "directory": "packages/core"
-  },
-  "homepage": "https://github.com/quiltt/quiltt-public/tree/main/packages/core#readme",
   "keywords": [
     "quiltt",
     "typescript"
   ],
+  "homepage": "https://github.com/quiltt/quiltt-js/tree/main/packages/core#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/quiltt/quiltt-js.git",
+    "directory": "packages/core"
+  },
   "license": "MIT",
   "sideEffects": [
     "./src/Storage/Local.ts",
@@ -33,16 +33,15 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@apollo/client": "^3.7.16",
-    "axios": "^1.6.0",
-    "cross-fetch": "^3.1.8",
+    "@apollo/client": "^3.9.9",
+    "cross-fetch": "^4.0.0",
     "graphql": "^16.8.1",
-    "graphql-ruby-client": "^1.11.8"
+    "graphql-ruby-client": "^1.13.3"
   },
   "devDependencies": {
     "@trivago/prettier-plugin-sort-imports": "4.1.1",
-    "@types/node": "20.11.25",
-    "@types/react": "18.2.64",
+    "@types/node": "20.12.2",
+    "@types/react": "18.2.73",
     "@typescript-eslint/eslint-plugin": "5.60.1",
     "@typescript-eslint/parser": "5.60.1",
     "bunchee": "4.4.8",
@@ -51,7 +50,7 @@
     "eslint-plugin-prettier": "4.2.1",
     "prettier": "2.8.8",
     "rimraf": "5.0.5",
-    "typescript": "5.4.2"
+    "typescript": "5.4.3"
   },
   "publishConfig": {
     "access": "public"

package/src/api/graphql/links/ActionCableLink.ts

@@ -1,4 +1,4 @@
-import { GlobalStorage } from '@/Storage'
+import { GlobalStorage } from '@/storage'
 import type { FetchResult, NextLink, Operation } from '@apollo/client/core/index.js'
 import { ApolloLink, Observable } from '@apollo/client/core/index.js'
 import { print } from 'graphql'

package/src/api/graphql/links/AuthLink.ts

@@ -1,7 +1,7 @@
 import type { FetchResult, NextLink, Observable, Operation } from '@apollo/client/index.js'
 import { ApolloLink } from '@apollo/client/index.js'
 
-import { GlobalStorage } from '@/Storage'
+import { GlobalStorage } from '@/storage'
 
 /**
  * unauthorizedCallback only triggers in the event the token is present, and

package/src/api/graphql/links/BatchHttpLink.ts

@@ -1,12 +1,14 @@
 import { BatchHttpLink as ApolloHttpLink } from '@apollo/client/link/batch-http/index.js'
+import crossfetch from 'cross-fetch'
 
-import fetch from 'cross-fetch'
+// Use `cross-fetch` only if `fetch` is not available on the `globalThis` object
+const effectiveFetch = typeof fetch === 'undefined' ? crossfetch : fetch
 
 import { endpointGraphQL } from '../../../configuration'
 
 export const BatchHttpLink = new ApolloHttpLink({
   uri: endpointGraphQL,
-  fetch,
+  fetch: effectiveFetch,
 })
 
 export default BatchHttpLink

package/src/api/graphql/links/ErrorLink.ts

@@ -1,4 +1,4 @@
-import { GlobalStorage } from '@/Storage'
+import { GlobalStorage } from '@/storage'
 
 import type { ServerError } from '@apollo/client/index.js'
 import { onError } from '@apollo/client/link/error/index.js'

package/src/api/graphql/links/HttpLink.ts

@@ -1,12 +1,14 @@
 import { HttpLink as ApolloHttpLink } from '@apollo/client/link/http/index.js'
+import crossfetch from 'cross-fetch'
 
-import fetch from 'cross-fetch'
+// Use `cross-fetch` only if `fetch` is not available on the `globalThis` object
+const effectiveFetch = typeof fetch === 'undefined' ? crossfetch : fetch
 
 import { endpointGraphQL } from '../../../configuration'
 
 export const HttpLink = new ApolloHttpLink({
   uri: endpointGraphQL,
-  fetch,
+  fetch: effectiveFetch,
 })
 
 export default HttpLink

package/src/api/rest/{AuthAPI.ts → auth.ts}

@@ -1,7 +1,6 @@
-import type { AxiosRequestConfig, AxiosResponse } from './axios'
-import { axios } from './axios'
-
-import { endpointAuth } from '../../configuration'
+import { endpointAuth } from '@/configuration'
+import type { FetchResponse } from './fetchWithRetry'
+import { fetchWithRetry } from './fetchWithRetry'
 
 export enum AuthStrategies {
   Email = 'email',
@@ -22,7 +21,7 @@ export type UsernamePayload = EmailInput | PhoneInput
 export type PasscodePayload = UsernamePayload & { passcode: string }
 
 type SessionData = { token: string }
-type NoContentData = void
+type NoContentData = null
 type UnauthorizedData = { message: string; instruction: string }
 export type UnprocessableData = { [attribute: string]: Array<string> }
 
@@ -31,8 +30,8 @@ type Identify = SessionData | NoContentData | UnprocessableData
 type Authenticate = SessionData | UnauthorizedData | UnprocessableData
 type Revoke = NoContentData | UnauthorizedData
 
-export type SessionResponse = AxiosResponse<SessionData>
-export type UnprocessableResponse = AxiosResponse<UnprocessableData>
+export type SessionResponse = FetchResponse<SessionData>
+export type UnprocessableResponse = FetchResponse<UnprocessableData>
 
 // https://www.quiltt.dev/api-reference/rest/auth#
 export class AuthAPI {
@@ -47,8 +46,12 @@ export class AuthAPI {
    *  - 200: OK           -> Session is Valid
    *  - 401: Unauthorized -> Session is Invalid
    */
-  ping = (token: string) => {
-    return axios.get<Ping>(endpointAuth, this.config(token))
+  ping = async (token: string) => {
+    const response = await fetchWithRetry<Ping>(endpointAuth, {
+      method: 'GET',
+      ...this.config(token),
+    })
+    return response
   }
 
   /**
@@ -57,8 +60,13 @@ export class AuthAPI {
    *  - 202: Accepted             -> Profile Found, MFA Code Sent for `authenticate`
    *  - 422: Unprocessable Entity -> Invalid Payload
    */
-  identify = (payload: UsernamePayload) => {
-    return axios.post<Identify>(endpointAuth, this.body(payload), this.config())
+  identify = async (payload: UsernamePayload) => {
+    const response = await fetchWithRetry<Identify>(endpointAuth, {
+      method: 'POST',
+      body: JSON.stringify(this.body(payload)),
+      ...this.config(),
+    })
+    return response
   }
 
   /**
@@ -67,8 +75,13 @@ export class AuthAPI {
    *  - 401: Unauthorized         -> MFA Invalid
    *  - 422: Unprocessable Entity -> Invalid Payload
    */
-  authenticate = (payload: PasscodePayload) => {
-    return axios.put<Authenticate>(endpointAuth, this.body(payload), this.config())
+  authenticate = async (payload: PasscodePayload): Promise<FetchResponse<Authenticate>> => {
+    const response = await fetchWithRetry<Authenticate>(endpointAuth, {
+      method: 'PUT',
+      body: JSON.stringify(this.body(payload)),
+      ...this.config(),
+    })
+    return response
   }
 
   /**
@@ -76,28 +89,30 @@ export class AuthAPI {
    *  - 204: No Content   -> Session Revoked
    *  - 401: Unauthorized -> Session Not Found
    */
-  revoke = (token: string) => {
-    return axios.delete<Revoke>(endpointAuth, this.config(token))
+  revoke = async (token: string): Promise<FetchResponse<Revoke>> => {
+    const response = await fetchWithRetry<Revoke>(endpointAuth, {
+      method: 'DELETE',
+      ...this.config(token),
+    })
+    return response
   }
 
-  private config = (token?: string): AxiosRequestConfig => {
-    const headers: { [id: string]: string } = {
-      'Content-Type': 'application/json',
-      Accept: 'application/json',
-    }
+  private config = (token?: string) => {
+    const headers = new Headers()
+    headers.set('Content-Type', 'application/json')
+    headers.set('Accept', 'application/json')
 
     if (token) {
-      headers.Authorization = `Bearer ${token}`
+      headers.set('Authorization', `Bearer ${token}`)
     }
 
     return {
-      headers: headers,
+      headers,
       validateStatus: this.validateStatus,
       retry: true,
     }
   }
-
-  private validateStatus = (status: number) => status < 500
+  private validateStatus = (status: number) => status < 500 && status !== 429
 
   private body = (payload: any) => {
     if (!this.clientId) {
@@ -112,5 +127,3 @@ export class AuthAPI {
     }
   }
 }
-
-export default AuthAPI

package/src/api/rest/fetchWithRetry.ts

@@ -0,0 +1,73 @@
+import crossfetch from 'cross-fetch'
+
+// Use `cross-fetch` only if `fetch` is not available on the `globalThis` object
+const effectiveFetch = typeof fetch === 'undefined' ? crossfetch : fetch
+
+type FetchWithRetryOptions = RequestInit & {
+  retry?: boolean
+  retriesRemaining?: number
+  validateStatus?: (status: number) => boolean
+}
+
+export type FetchResponse<T> = {
+  data: T
+  status: number
+  statusText: string
+  headers: Headers
+  ok: boolean
+}
+
+const RETRY_DELAY = 150 // ms
+const RETRIES = 10 // 150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500 = 8.250s
+
+/**
+ * A wrapper around the native `fetch` function that adds automatic retries on failure, including network errors and HTTP 429 responses.
+ * Now treats any response with status < 500 as valid.
+ */
+export const fetchWithRetry = async <T>(
+  url: RequestInfo,
+  options: FetchWithRetryOptions = { retry: false }
+): Promise<FetchResponse<T>> => {
+  const {
+    retry,
+    retriesRemaining,
+    validateStatus = (status) => status >= 200 && status < 300, // Default to success for 2xx responses
+    ...fetchOptions
+  } = options
+
+  try {
+    const response = await effectiveFetch(url, fetchOptions)
+
+    const isResponseOk = validateStatus(response.status)
+
+    if (isResponseOk) {
+      return {
+        data: await response.json().catch(() => null),
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        ok: isResponseOk,
+      }
+    }
+
+    // If validateStatus fails, and retry is enabled, prepare to retry for eligible status codes
+    if (retry && (response.status >= 500 || response.status === 429)) {
+      throw new Error('Retryable failure')
+    }
+
+    throw new Error('HTTP error with status ' + response.status)
+  } catch (error) {
+    if (retry) {
+      const currentRetriesRemaining = retriesRemaining !== undefined ? retriesRemaining : RETRIES
+      if (currentRetriesRemaining > 0) {
+        const delayTime = RETRY_DELAY * (RETRIES - currentRetriesRemaining)
+        await new Promise((resolve) => setTimeout(resolve, delayTime))
+        return fetchWithRetry(url, {
+          ...options,
+          retriesRemaining: currentRetriesRemaining - 1,
+        })
+      }
+    }
+    return Promise.reject(error)
+  }
+}

package/src/api/rest/index.ts

@@ -1 +1 @@
-export * from './AuthAPI'
+export * from './auth'

package/src/configuration.ts

@@ -1,32 +1,46 @@
 import { name as packageName, version as packageVersion } from '../package.json'
 
-const QUILTT_API_INSECURE = (() => {
+/**
+ * Retrieves the environment variable by key, with fallback and type conversion,
+ * supporting Node.js, Vite, and potentially other runtime environments.
+ */
+export const getEnv = (key: string, fallback: any = undefined): any => {
   try {
-    return process.env.QUILTT_API_INSECURE
-  } catch {
-    return undefined
-  }
-})()
+    let value: string | undefined
 
-const QUILTT_API_DOMAIN = (() => {
-  try {
-    return process.env.QUILTT_API_DOMAIN
-  } catch {
+    // Check if running under Node.js and use process.env
+    if (typeof process !== 'undefined' && process.env) {
+      value = process.env[key]
+    }
+
+    // Return the value after type conversion if necessary or use fallback
+    if (value === undefined || value === null) {
+      return fallback
+    }
+
+    // Convert to boolean if the value is 'true' or 'false'
+    if (value === 'true' || value === 'false') {
+      return value === 'true'
+    }
+
+    // Convert to number if it's numeric
+    if (!isNaN(Number(value))) {
+      return Number(value)
+    }
+
+    return value
+  } catch (error) {
     return undefined
   }
-})()
+}
 
-const QUILTT_DEBUG = (() => {
-  try {
-    return !!process.env.QUILTT_DEBUG || process.env.NODE_ENV !== 'production'
-  } catch {
-    return false
-  }
-})()
+const QUILTT_API_INSECURE = getEnv('QUILTT_API_INSECURE', false)
+const QUILTT_API_DOMAIN = getEnv('QUILTT_API_DOMAIN', 'quiltt.io')
+const QUILTT_DEBUG = getEnv('QUILTT_DEBUG', process?.env?.NODE_ENV !== 'production')
 
 const domain = QUILTT_API_DOMAIN || 'quiltt.io'
 const protocolHttp = `http${QUILTT_API_INSECURE ? '' : 's'}`
-const protocolWebsockets = `ws${QUILTT_API_DOMAIN ? '' : 's'}`
+const protocolWebsockets = `ws${QUILTT_API_INSECURE ? '' : 's'}`
 
 export const debugging = QUILTT_DEBUG
 export const version = `${packageName}: v${packageVersion}`