enhance error logging and handling in various components for better debugging

chriscanin · chriscanin · commit f8c11235a3f1 · 2025-11-19T14:14:58.000-08:00
Issue is resolved in fraud protection, other issues with serialization were red herrings.

I am removing all code that does not contribute to the fix, but committing this here to ensure that I have a record of the error logging.
diff --git a/packages/clerk-js/src/core/clerk.ts b/packages/clerk-js/src/core/clerk.ts
@@ -2754,14 +2754,40 @@ export class Clerk implements ClerkInterface {
         Client.getOrCreateInstance().fetch({ fetchMaxTries }),
       ]);
     } catch (err) {
+      // DEBUG: Log what error was caught
+      console.error('[Clerk] Caught error during initialization:', {
+        error: err,
+        errorType: typeof err,
+        errorMessage: err instanceof Error ? err.message : String(err),
+        errorCode: (err as any)?.code,
+        isClerkRuntimeError: isClerkRuntimeError(err),
+        hasCacheFunction: !!this.__internal_getCachedResources,
+      });
+
       const isNetworkError =
         (isClerkRuntimeError(err) && err.code === 'network_error') ||
         (err instanceof Error && err.message?.includes('Network error at'));
 
+      console.error('[Clerk] Network error detection:', {
+        isNetworkError,
+        shouldFallback: this.shouldFallbackToCachedResources() && isNetworkError,
+      });
+
       const shouldFallback = this.shouldFallbackToCachedResources() && isNetworkError;
 
       if (shouldFallback) {
         const cachedResources = await this.__internal_getCachedResources?.();
+
+        // DEBUG: Log cached resources before creating Environment
+        console.error('[Clerk] Creating Environment from cached resources:', {
+          hasCachedResources: !!cachedResources,
+          hasEnvironment: !!cachedResources?.environment,
+          environmentKeys: cachedResources?.environment ? Object.keys(cachedResources.environment) : 'N/A',
+          hasProtectConfig: cachedResources?.environment ? 'protect_config' in cachedResources.environment : 'N/A',
+          protectConfigValue: cachedResources?.environment?.protect_config,
+          protectConfigType: cachedResources?.environment ? typeof cachedResources.environment.protect_config : 'N/A',
+        });
+
         environment = new Environment(cachedResources?.environment);
         Client.clearInstance();
         client = Client.getOrCreateInstance(cachedResources?.client);
diff --git a/packages/clerk-js/src/core/fraudProtection.ts b/packages/clerk-js/src/core/fraudProtection.ts
@@ -1,4 +1,4 @@
-import { ClerkRuntimeError, isClerkAPIResponseError } from '@clerk/shared/error';
+import { ClerkRuntimeError, isClerkAPIResponseError, isClerkRuntimeError } from '@clerk/shared/error';
 
 import { CaptchaChallenge } from '../utils/captcha/CaptchaChallenge';
 import type { Clerk } from './resources/internal';
@@ -26,6 +26,7 @@ export class FraudProtection {
 
   // TODO @userland-errors:
   public async execute<T extends () => Promise<any>, R = Awaited<ReturnType<T>>>(clerk: Clerk, cb: T): Promise<R> {
+    console.error('[FraudProtection] execute() called');
     // TODO @userland-errors:
     if (this.captchaAttemptsExceeded()) {
       throw new ClerkRuntimeError(
@@ -39,12 +40,28 @@ export class FraudProtection {
         await this.inflightException;
       }
 
-      return await cb();
+      console.error('[FraudProtection] About to execute callback');
+      const result = await cb();
+      console.error('[FraudProtection] Callback executed successfully');
+      return result;
     } catch (e) {
+      console.error('[FraudProtection] Callback threw error:', {
+        error: e,
+        errorType: typeof e,
+        errorMessage: e instanceof Error ? e.message : String(e),
+        isClerkAPIResponseError: isClerkAPIResponseError(e),
+      });
       if (!isClerkAPIResponseError(e)) {
         throw e;
       }
 
+      // Network errors should bypass captcha logic and be re-thrown immediately
+      // so cache fallback can be triggered
+      if (isClerkRuntimeError(e) && e.code === 'network_error') {
+        console.error('[FraudProtection] Re-throwing network error for cache fallback');
+        throw e;
+      }
+
       if (e.errors[0]?.code !== 'requires_captcha') {
         throw e;
       }
diff --git a/packages/clerk-js/src/core/resources/Environment.ts b/packages/clerk-js/src/core/resources/Environment.ts
@@ -47,15 +47,79 @@ export class Environment extends BaseResource implements EnvironmentResource {
       return this;
     }
 
-    this.authConfig = new AuthConfig(data.auth_config);
-    this.displayConfig = new DisplayConfig(data.display_config);
+    // DEBUG: Log environment data structure
+    console.error('[Environment fromJSON] Processing environment data:', {
+      hasProtectConfig: 'protect_config' in data,
+      protectConfigValue: data.protect_config,
+      protectConfigType: typeof data.protect_config,
+      dataKeys: Object.keys(data),
+    });
+
+    try {
+      console.error('[Environment fromJSON] Creating AuthConfig...');
+      this.authConfig = new AuthConfig(data.auth_config);
+      console.error('[Environment fromJSON] ✓ AuthConfig created successfully');
+    } catch (err) {
+      console.error('[Environment fromJSON] ✗ AuthConfig FAILED:', err);
+      throw err;
+    }
+
+    try {
+      console.error('[Environment fromJSON] Creating DisplayConfig...');
+      this.displayConfig = new DisplayConfig(data.display_config);
+      console.error('[Environment fromJSON] ✓ DisplayConfig created successfully');
+    } catch (err) {
+      console.error('[Environment fromJSON] ✗ DisplayConfig FAILED:', err);
+      throw err;
+    }
+
     this.maintenanceMode = this.withDefault(data.maintenance_mode, this.maintenanceMode);
     this.clientDebugMode = this.withDefault(data.client_debug_mode, this.clientDebugMode);
-    this.organizationSettings = new OrganizationSettings(data.organization_settings);
-    this.userSettings = new UserSettings(data.user_settings);
-    this.commerceSettings = new CommerceSettings(data.commerce_settings);
-    this.apiKeysSettings = new APIKeySettings(data.api_keys_settings);
-    this.protectConfig = new ProtectConfig(data.protect_config);
+
+    try {
+      console.error('[Environment fromJSON] Creating OrganizationSettings...');
+      this.organizationSettings = new OrganizationSettings(data.organization_settings);
+      console.error('[Environment fromJSON] ✓ OrganizationSettings created successfully');
+    } catch (err) {
+      console.error('[Environment fromJSON] ✗ OrganizationSettings FAILED:', err);
+      throw err;
+    }
+
+    try {
+      console.error('[Environment fromJSON] Creating UserSettings...');
+      this.userSettings = new UserSettings(data.user_settings);
+      console.error('[Environment fromJSON] ✓ UserSettings created successfully');
+    } catch (err) {
+      console.error('[Environment fromJSON] ✗ UserSettings FAILED:', err);
+      throw err;
+    }
+
+    try {
+      console.error('[Environment fromJSON] Creating CommerceSettings...');
+      this.commerceSettings = new CommerceSettings(data.commerce_settings);
+      console.error('[Environment fromJSON] ✓ CommerceSettings created successfully');
+    } catch (err) {
+      console.error('[Environment fromJSON] ✗ CommerceSettings FAILED:', err);
+      throw err;
+    }
+
+    try {
+      console.error('[Environment fromJSON] Creating APIKeySettings...');
+      this.apiKeysSettings = new APIKeySettings(data.api_keys_settings);
+      console.error('[Environment fromJSON] ✓ APIKeySettings created successfully');
+    } catch (err) {
+      console.error('[Environment fromJSON] ✗ APIKeySettings FAILED:', err);
+      throw err;
+    }
+
+    try {
+      console.error('[Environment fromJSON] Creating ProtectConfig with:', data.protect_config);
+      this.protectConfig = new ProtectConfig(data.protect_config);
+      console.error('[Environment fromJSON] ✓ ProtectConfig created successfully');
+    } catch (err) {
+      console.error('[Environment fromJSON] ✗ ProtectConfig FAILED:', err);
+      throw err;
+    }
 
     return this;
   }
diff --git a/packages/clerk-js/src/core/resources/ProtectConfig.ts b/packages/clerk-js/src/core/resources/ProtectConfig.ts
@@ -15,11 +15,24 @@ export class ProtectConfig extends BaseResource implements ProtectConfigResource
   public constructor(data: ProtectConfigJSON | ProtectConfigJSONSnapshot | null = null) {
     super();
 
+    // DEBUG: Log what data is received
+    console.error('[ProtectConfig Constructor] Received data:', {
+      data,
+      dataType: typeof data,
+      isNull: data === null,
+      isUndefined: data === undefined,
+      keys: data ? Object.keys(data) : 'N/A',
+    });
+
     this.fromJSON(data);
   }
 
   protected fromJSON(data: ProtectConfigJSON | ProtectConfigJSONSnapshot | null): this {
     if (!data) {
+      console.error('[ProtectConfig fromJSON] Data is falsy, returning early:', {
+        data,
+        dataType: typeof data,
+      });
       return this;
     }
 
diff --git a/packages/clerk-js/src/core/resources/UserSettings.ts b/packages/clerk-js/src/core/resources/UserSettings.ts
@@ -203,16 +203,37 @@ export class UserSettings extends BaseResource implements UserSettingsResource {
   }
 
   protected fromJSON(data: UserSettingsJSON | UserSettingsJSONSnapshot | null): this {
+    console.error('[UserSettings fromJSON] Called with:', {
+      hasData: !!data,
+      dataKeys: data ? Object.keys(data) : 'null',
+      hasAttributes: data ? 'attributes' in data : false,
+      attributesValue: data ? data.attributes : 'N/A',
+      attributesType: data ? typeof data.attributes : 'N/A',
+    });
+
     if (!data) {
       return this;
     }
 
-    this.attributes = this.withDefault(
-      data.attributes
-        ? (Object.fromEntries(Object.entries(data.attributes).map(a => [a[0], { ...a[1], name: a[0] }])) as Attributes)
-        : null,
-      this.attributes,
-    );
+    try {
+      console.error('[UserSettings fromJSON] About to process attributes');
+      this.attributes = this.withDefault(
+        data.attributes
+          ? (Object.fromEntries(
+              Object.entries(data.attributes).map(a => [a[0], { ...a[1], name: a[0] }]),
+            ) as Attributes)
+          : null,
+        this.attributes,
+      );
+      console.error('[UserSettings fromJSON] ✓ Attributes processed successfully');
+    } catch (err) {
+      console.error('[UserSettings fromJSON] ✗ FAILED processing attributes:', {
+        error: err,
+        errorMessage: err instanceof Error ? err.message : String(err),
+        dataAttributes: data.attributes,
+      });
+      throw err;
+    }
     this.actions = this.withDefault(data.actions, this.actions);
     this.enterpriseSSO = this.withDefault(data.enterprise_sso, this.enterpriseSSO);
     this.passkeySettings = this.withDefault(data.passkey_settings, this.passkeySettings);
diff --git a/packages/expo/src/provider/singleton/createClerkInstance.ts b/packages/expo/src/provider/singleton/createClerkInstance.ts
@@ -118,7 +118,14 @@ export function createClerkInstance(ClerkClass: typeof Clerk) {
             // @ts-expect-error - This is an internal API
             const environment = __internal_clerk?.__unstable__environment as EnvironmentResource;
             if (environment) {
-              void EnvironmentResourceCache.save(environment.__internal_toSnapshot());
+              const snapshot = environment.__internal_toSnapshot();
+              // DEBUG: Log what we're saving to cache
+              console.error('[Cache Save] Saving environment snapshot:', {
+                hasProtectConfig: 'protect_config' in snapshot,
+                protectConfigValue: snapshot.protect_config,
+                snapshotKeys: Object.keys(snapshot),
+              });
+              void EnvironmentResourceCache.save(snapshot);
             }
 
             if (client) {
@@ -141,7 +148,19 @@ export function createClerkInstance(ClerkClass: typeof Clerk) {
           }> => {
             let environment = await EnvironmentResourceCache.load();
             let client = await ClientResourceCache.load();
+
+            // DEBUG: Log cached data structure
+            console.error('[Cache Load] Loaded from cache:', {
+              hasEnvironment: !!environment,
+              hasClient: !!client,
+              environmentKeys: environment ? Object.keys(environment) : 'null',
+              hasProtectConfigInCache: environment ? 'protect_config' in environment : 'N/A',
+              protectConfigValue: environment ? environment.protect_config : 'N/A',
+              protectConfigType: environment ? typeof environment.protect_config : 'N/A',
+            });
+
             if (!environment || !client) {
+              console.error('[Cache Load] Using DUMMY data - cache was empty or incomplete');
               environment = DUMMY_CLERK_ENVIRONMENT_RESOURCE;
               client = DUMMY_CLERK_CLIENT_RESOURCE;
               setTimeout(() => void retryInitilizeResourcesFromFAPI(), 3000);
