@umituz/react-native-subscription 3.1.33 → 3.1.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "3.1.33",
+  "version": "3.1.35",
   "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domains/credits/application/CreditsInitializer.ts

@@ -9,6 +9,9 @@ import { calculateNewCredits, buildCreditsData } from "./creditOperationUtils";
 import { CreditLimitService } from "../domain/services/CreditLimitService";
 import { generatePurchaseMetadata } from "./PurchaseMetadataGenerator";
 import { PURCHASE_ID_PREFIXES } from "../core/CreditsConstants";
+import { createLogger } from "../../../shared/utils/logger";
+
+const logger = createLogger("CreditsInitializer");
 
 export async function initializeCreditsTransaction(
     _db: Firestore,
@@ -19,19 +22,17 @@ export async function initializeCreditsTransaction(
     userId: string
 ): Promise<InitializationResult> {
 
-    if (__DEV__) {
-        console.log('[CreditsInitializer] 🔵 initializeCreditsTransaction: START', {
-            userId,
-            purchaseId,
-            productId: metadata.productId,
-            source: metadata.source,
-            type: metadata.type,
-            isPremium: metadata.isPremium,
-            willRenew: metadata.willRenew,
-            storeTransactionId: metadata.storeTransactionId,
-            timestamp: new Date().toISOString(),
-        });
-    }
+    logger.debug("initializeCreditsTransaction: START", {
+        userId,
+        purchaseId,
+        productId: metadata.productId,
+        source: metadata.source,
+        type: metadata.type,
+        isPremium: metadata.isPremium,
+        willRenew: metadata.willRenew,
+        storeTransactionId: metadata.storeTransactionId,
+        timestamp: new Date().toISOString(),
+    });
 
     if (!purchaseId.startsWith(PURCHASE_ID_PREFIXES.PURCHASE) && !purchaseId.startsWith(PURCHASE_ID_PREFIXES.RENEWAL)) {
         throw new Error(`[CreditsInitializer] Only purchase and renewal operations can allocate credits. Received: ${purchaseId}`);
@@ -46,14 +47,12 @@ export async function initializeCreditsTransaction(
         const existingData = getCreditDocumentOrDefault(creditsDoc, platform);
 
         if (existingData.processedPurchases.includes(purchaseId)) {
-            if (__DEV__) {
-                console.log('[CreditsInitializer] 🟡 Transaction already processed, skipping', {
-                    userId,
-                    purchaseId,
-                    existingCredits: existingData.credits,
-                    processedPurchasesCount: existingData.processedPurchases.length,
-                });
-            }
+            logger.debug("Transaction already processed, skipping", {
+                userId,
+                purchaseId,
+                existingCredits: existingData.credits,
+                processedPurchasesCount: existingData.processedPurchases.length,
+            });
             return {
                 credits: existingData.credits,
                 alreadyProcessed: true,
@@ -61,14 +60,12 @@ export async function initializeCreditsTransaction(
             };
         }
 
-        if (__DEV__) {
-            console.log('[CreditsInitializer] 🔵 Processing credit allocation', {
-                userId,
-                purchaseId,
-                existingCredits: existingData.credits,
-                productId: metadata.productId,
-            });
-        }
+        logger.debug("Processing credit allocation", {
+            userId,
+            purchaseId,
+            existingCredits: existingData.credits,
+            productId: metadata.productId,
+        });
 
         const creditLimitService = new CreditLimitService(config);
         const creditLimit = creditLimitService.calculate(metadata.productId);
@@ -100,16 +97,14 @@ export async function initializeCreditsTransaction(
 
         transaction.set(creditsRef, creditsData, { merge: true });
 
-        if (__DEV__) {
-            console.log('[CreditsInitializer] 🟢 Credit allocation successful', {
-                userId,
-                purchaseId,
-                previousCredits: existingData.credits,
-                newCredits,
-                creditLimit,
-                productId: metadata.productId,
-            });
-        }
+        logger.debug("Credit allocation successful", {
+            userId,
+            purchaseId,
+            previousCredits: existingData.credits,
+            newCredits,
+            creditLimit,
+            productId: metadata.productId,
+        });
 
         return {
             credits: newCredits,

package/src/domains/credits/application/DeductCreditsCommand.ts

@@ -2,6 +2,9 @@ import { runTransaction, serverTimestamp, type DocumentReference } from "firebas
 import type { Firestore } from "@umituz/react-native-firebase";
 import type { DeductCreditsResult } from "../core/Credits";
 import { CREDIT_ERROR_CODES, MAX_SINGLE_DEDUCTION } from "../core/CreditsConstants";
+import { createLogger } from "../../../shared/utils/logger";
+
+const logger = createLogger("DeductCreditsCommand");
 
 export async function deductCreditsOperation(
   _db: Firestore,
@@ -32,12 +35,12 @@ export async function deductCreditsOperation(
   }
 
   try {
-    if (__DEV__) console.log('[DeductCreditsCommand] >>> starting transaction', { userId, cost, creditsRefPath: creditsRef.path });
+    logger.debug(">>> starting transaction", { userId, cost, creditsRefPath: creditsRef.path });
 
     const remaining = await runTransaction(_db, async (tx) => {
       const docSnap = await tx.get(creditsRef);
 
-      if (__DEV__) console.log('[DeductCreditsCommand] doc exists:', docSnap.exists());
+      logger.debug("doc exists", { exists: docSnap.exists() });
 
       if (!docSnap.exists()) {
         throw new Error(CREDIT_ERROR_CODES.NO_CREDITS);
@@ -46,7 +49,7 @@ export async function deductCreditsOperation(
       const rawCredits = docSnap.data().credits;
       const current = typeof rawCredits === "number" && Number.isFinite(rawCredits) ? rawCredits : 0;
 
-      if (__DEV__) console.log('[DeductCreditsCommand] current credits:', current, 'cost:', cost);
+      logger.debug("current credits", { current, cost });
 
       if (current < cost) {
         throw new Error(CREDIT_ERROR_CODES.CREDITS_EXHAUSTED);
@@ -58,12 +61,12 @@ export async function deductCreditsOperation(
         lastUpdatedAt: serverTimestamp()
       });
 
-      if (__DEV__) console.log('[DeductCreditsCommand] updated credits to:', updated);
+      logger.debug("updated credits to", { updated });
 
       return updated;
     });
 
-    if (__DEV__) console.log('[DeductCreditsCommand] transaction SUCCESS, remaining:', remaining);
+    logger.debug("transaction SUCCESS", { remaining });
 
     return {
       success: true,
@@ -76,13 +79,11 @@ export async function deductCreditsOperation(
       ? message
       : CREDIT_ERROR_CODES.DEDUCT_ERR;
 
-    // Use console.warn instead of console.error for "no credits" - this is expected behavior, not a system error
-    if (__DEV__) {
-      if (code === CREDIT_ERROR_CODES.NO_CREDITS || code === CREDIT_ERROR_CODES.CREDITS_EXHAUSTED) {
-        console.warn('[DeductCreditsCommand] ⚠️ User has no credits - paywall should open', { code, message });
-      } else {
-        console.error('[DeductCreditsCommand] ❌ Unexpected transaction error:', { code, message });
-      }
+    // Use logger.warn instead of logger.error for "no credits" - this is expected behavior, not a system error
+    if (code === CREDIT_ERROR_CODES.NO_CREDITS || code === CREDIT_ERROR_CODES.CREDITS_EXHAUSTED) {
+      logger.warn("User has no credits - paywall should open", { code, message });
+    } else {
+      logger.error("Unexpected transaction error", e, { code, message });
     }
 
     return {

package/src/domains/credits/presentation/deduct-credit/useDeductCredit.ts

@@ -1,7 +1,10 @@
 import { useCallback, useState } from "react";
 import { getCreditsRepository } from "../../infrastructure/CreditsRepositoryManager";
+import { createLogger } from "../../../../shared/utils/logger";
 import type { UseDeductCreditParams, UseDeductCreditResult } from "./types";
 
+const logger = createLogger("useDeductCredit");
+
 export const useDeductCredit = ({
   userId,
   onCreditsExhausted,
@@ -15,26 +18,22 @@ export const useDeductCredit = ({
     setIsDeducting(true);
     try {
       const res = await repository.deductCredit(userId, cost);
-      if (__DEV__) console.log('[useDeductCredit] deduction result:', JSON.stringify(res));
+      logger.debug("Deduction result", { result: res });
 
       if (!res.success) {
-        if (__DEV__) console.log('[useDeductCredit] deduction FAILED:', res.error?.code, res.error?.message);
+        logger.warn("Deduction failed", { code: res.error?.code, message: res.error?.message });
 
         if (res.error?.code === "CREDITS_EXHAUSTED" || res.error?.code === "DEDUCT_ERR" || res.error?.code === "NO_CREDITS") {
-          if (__DEV__) console.log('[useDeductCredit] Credits exhausted, calling onCreditsExhausted callback');
+          logger.info("Credits exhausted, calling onCreditsExhausted callback");
           onCreditsExhausted?.();
         }
         return false;
       }
 
-      if (__DEV__) console.log('[useDeductCredit] deduction SUCCESS, remaining:', res.remainingCredits);
+      logger.debug("Deduction success", { remainingCredits: res.remainingCredits });
       return true;
     } catch (error) {
-      if (__DEV__) console.error('[useDeductCredit] UNEXPECTED ERROR during credit deduction', {
-        cost,
-        userId,
-        error: error instanceof Error ? error.message : String(error)
-      });
+      logger.error("Unexpected error during credit deduction", error, { cost, userId });
       return false;
     } finally {
       setIsDeducting(false);
@@ -52,13 +51,7 @@ export const useDeductCredit = ({
       const result = await repository.refundCredit(userId, amount);
       return result.success;
     } catch (error) {
-      if (__DEV__) {
-        console.error('[useDeductCredit] Unexpected error during credit refund', {
-          amount,
-          userId,
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
+      logger.error("Unexpected error during credit refund", error, { amount, userId });
       return false;
     }
   }, [userId, repository]);

package/src/domains/credits/presentation/useCredits.ts

@@ -28,7 +28,7 @@ export const useCredits = (): UseCreditsResult => {
   const hasUser = isAuthenticated(userId);
   const queryEnabled = hasUser && isConfigured;
 
-  const { credits, isLoading, error } = useCreditsRealTime(userId);
+  const { credits, isLoading, error, refetch } = useCreditsRealTime(userId);
 
   const derivedValues = useMemo(() => {
     const has = (credits?.credits ?? 0) > 0;
@@ -53,7 +53,7 @@ export const useCredits = (): UseCreditsResult => {
     error,
     hasCredits: derivedValues.hasCredits,
     creditsPercent: derivedValues.creditsPercent,
-    refetch: async () => {},
+    refetch,
     canAfford,
   };
 };

package/src/domains/credits/presentation/useCredits.types.ts

@@ -10,6 +10,6 @@ export interface UseCreditsResult {
   error: Error | null;
   hasCredits: boolean;
   creditsPercent: number;
-  refetch: () => Promise<any>;
+  refetch: () => void;
   canAfford: (cost: number) => boolean;
 }

package/src/domains/paywall/components/PaywallScreen.tsx

@@ -29,6 +29,9 @@ import {
 } from "../utils/paywallLayoutUtils";
 import { hasItems } from "../../../shared/utils/arrayUtils";
 import { PaywallRenderItem } from "./PaywallScreen.renderItem";
+import { createLogger } from "../../../../shared/utils/logger";
+
+const logger = createLogger("PaywallScreen");
 
 // Paywall layout constants
 const PAYWALL_HEADER_HEIGHT = 60; // Close button + spacing
@@ -37,13 +40,11 @@ const PAYWALL_FOOTER_HEIGHT_BASE = 280; // Base footer height
 export const PaywallScreen: React.FC<PaywallScreenProps> = React.memo((props) => {
   const navigation = useNavigation();
 
-  if (__DEV__) {
-    console.log('[PaywallScreen] 📱 Rendering PaywallScreen', {
-      hasPackages: !!props.packages?.length,
-      packagesCount: props.packages?.length || 0,
-      isPremium: props.isPremium,
-    });
-  }
+  logger.debug("Rendering PaywallScreen", {
+    hasPackages: !!props.packages?.length,
+    packagesCount: props.packages?.length || 0,
+    isPremium: props.isPremium,
+  });
 
   const {
     translations,
@@ -69,7 +70,7 @@ export const PaywallScreen: React.FC<PaywallScreenProps> = React.memo((props) =>
   const responsive = useResponsive();
 
   const handleClose = useCallback(() => {
-    if (__DEV__) console.log('[PaywallScreen] 🔙 Closing paywall');
+    logger.debug("Closing paywall");
     if (onClose) {
       onClose();
     } else if (navigation.canGoBack()) {
@@ -98,7 +99,7 @@ export const PaywallScreen: React.FC<PaywallScreenProps> = React.memo((props) =>
   // Cleanup on unmount only - resetState is stable from useCallback
   useEffect(() => {
     return () => {
-      if (__DEV__) console.log('[PaywallScreen] 🧹 Cleanup: resetting state');
+      logger.debug("Cleanup: resetting state");
       resetState();
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -118,7 +119,7 @@ export const PaywallScreen: React.FC<PaywallScreenProps> = React.memo((props) =>
     try {
       if (await Linking.canOpenURL(url)) await Linking.openURL(url);
     } catch (error) {
-      console.error('[PaywallScreen] Failed to open URL:', error);
+      logger.error("Failed to open URL", error);
     }
   }, []);
 
@@ -176,7 +177,7 @@ export const PaywallScreen: React.FC<PaywallScreenProps> = React.memo((props) =>
 
   // Defensive check for translations
   if (!translations) {
-    if (__DEV__) console.warn("[PaywallScreen] Translations prop is missing");
+    logger.warn("Translations prop is missing");
     return null;
   }
 

package/src/domains/paywall/hooks/usePaywallActions.ts

@@ -9,6 +9,9 @@ import { useState, useRef, useMemo, useCallback } from "react";
 import type { UsePaywallActionsParams } from "./usePaywallActions.types";
 import { usePurchaseHandler } from "./usePaywallPurchase";
 import { useRestoreHandler } from "./usePaywallRestore";
+import { createLogger } from "../../../../shared/utils/logger";
+
+const logger = createLogger("usePaywallActions");
 
 export function usePaywallActions({
   packages = [],
@@ -61,9 +64,7 @@ export function usePaywallActions({
 
   // Reset state - memoized with useCallback to prevent infinite loops
   const resetState = useCallback(() => {
-    if (__DEV__) {
-      console.log('[usePaywallActions] 🧹 Resetting state');
-    }
+    logger.debug("Resetting state");
     setSelectedPlanId(null);
     setIsProcessing(false);
   }, []);

package/src/domains/paywall/hooks/usePaywallActions.utils.ts

@@ -5,32 +5,27 @@
 
 import { useSubscriptionStatus } from "../../subscription/presentation/useSubscriptionStatus";
 import { useCredits } from "../../credits/presentation/useCredits";
+import { createLogger } from "../../../../shared/utils/logger";
+
+const logger = createLogger("PremiumVerification");
 
 export function usePremiumVerification() {
-  const { refetch: refetchStatus } = useSubscriptionStatus();
-  const { refetch: refetchCredits } = useCredits();
+  const { isPremium: isSubscriptionPremium } = useSubscriptionStatus();
+  const { credits } = useCredits();
 
   const verifyPremiumStatus = async (): Promise<boolean> => {
-    if (__DEV__) {
-      console.log('[PremiumVerification] 🔍 Checking premium status as fallback...');
-    }
-
-    const [statusResult, creditsResult] = await Promise.all([
-      refetchStatus(),
-      refetchCredits()
-    ]);
+    logger.debug("Checking premium status as fallback...");
 
-    const isSubscriptionPremium = statusResult.data?.isPremium ?? false;
-    const isCreditsPremium = creditsResult.data?.isPremium ?? false;
+    // With real-time sync, data is already up-to-date via onSnapshot
+    // No need to manually refetch - just check current state
+    const isCreditsPremium = credits?.isPremium ?? false;
     const isActuallySuccessful = isSubscriptionPremium || isCreditsPremium;
 
-    if (__DEV__) {
-      console.log('[PremiumVerification] 📊 Fallback check result:', {
-        isSubscriptionPremium,
-        isCreditsPremium,
-        isActuallySuccessful
-      });
-    }
+    logger.debug("Fallback check result", {
+      isSubscriptionPremium,
+      isCreditsPremium,
+      isActuallySuccessful
+    });
 
     return isActuallySuccessful;
   };

package/src/domains/paywall/hooks/usePaywallPurchase.ts

@@ -7,6 +7,9 @@
 import { useCallback } from "react";
 import type { UsePaywallActionsParams } from "./usePaywallActions.types";
 import { usePremiumVerification } from "./usePaywallActions.utils";
+import { createLogger } from "../../../../shared/utils/logger";
+
+const logger = createLogger("usePurchaseHandler");
 
 interface UsePurchaseHandlerParams {
   selectedPlanId: string | null;
@@ -36,18 +39,14 @@ export function usePurchaseHandler({
       return;
     }
 
-    if (__DEV__) {
-      console.log('[usePurchaseHandler] 🛒 Starting purchase', {
-        productId: pkg.product.identifier,
-      });
-    }
+    logger.debug("Starting purchase", {
+      productId: pkg.product.identifier,
+    });
 
     try {
       const success = await callbacksRef.current.purchasePackage(pkg);
 
-      if (__DEV__) {
-        console.log('[usePurchaseHandler] ✅ Purchase completed', { success });
-      }
+      logger.debug("Purchase completed", { success });
 
       let isActuallySuccessful = success === true;
 
@@ -56,20 +55,14 @@ export function usePurchaseHandler({
       }
 
       if (isActuallySuccessful) {
-        if (__DEV__) {
-          console.log('[usePurchaseHandler] 🎉 Purchase successful, closing paywall');
-        }
+        logger.debug("Purchase successful, closing paywall");
         callbacksRef.current.onPurchaseSuccess?.();
         callbacksRef.current.onClose?.();
       } else {
-        if (__DEV__) {
-          console.warn('[usePurchaseHandler] ⚠️ Purchase did not indicate success');
-        }
+        logger.warn("Purchase did not indicate success");
       }
     } catch (error) {
-      if (__DEV__) {
-        console.error('[usePurchaseHandler] ❌ Purchase error:', error);
-      }
+      logger.error("Purchase error", error);
       callbacksRef.current.onPurchaseError?.(error instanceof Error ? error : new Error(String(error)));
     }
   }, [selectedPlanId, verifyPremiumStatus, callbacksRef, isProcessingRef]);

package/src/domains/paywall/hooks/usePaywallRestore.ts

@@ -7,6 +7,9 @@
 import { useCallback } from "react";
 import type { UsePaywallActionsParams } from "./usePaywallActions.types";
 import { usePremiumVerification } from "./usePaywallActions.utils";
+import { createLogger } from "../../../../shared/utils/logger";
+
+const logger = createLogger("useRestoreHandler");
 
 interface UseRestoreHandlerParams {
   isProcessingRef: React.MutableRefObject<boolean>;
@@ -26,16 +29,12 @@ export function useRestoreHandler({
   const handleRestore = useCallback(async () => {
     if (isProcessingRef.current) return;
 
-    if (__DEV__) {
-      console.log('[useRestoreHandler] 🔄 Starting restore');
-    }
+    logger.debug("Starting restore");
 
     try {
       const success = await callbacksRef.current.restorePurchase();
 
-      if (__DEV__) {
-        console.log('[useRestoreHandler] ✅ Restore completed', { success });
-      }
+      logger.debug("Restore completed", { success });
 
       let isActuallySuccessful = success === true;
 
@@ -44,20 +43,14 @@ export function useRestoreHandler({
       }
 
       if (isActuallySuccessful) {
-        if (__DEV__) {
-          console.log('[useRestoreHandler] 🎉 Restore successful, closing paywall');
-        }
+        logger.debug("Restore successful, closing paywall");
         callbacksRef.current.onPurchaseSuccess?.();
         callbacksRef.current.onClose?.();
       } else {
-        if (__DEV__) {
-          console.warn('[useRestoreHandler] ⚠️ Restore did not indicate success');
-        }
+        logger.warn("Restore did not indicate success");
       }
     } catch (error) {
-      if (__DEV__) {
-        console.error('[useRestoreHandler] ❌ Restore error:', error);
-      }
+      logger.error("Restore error", error);
       callbacksRef.current.onPurchaseError?.(error instanceof Error ? error : new Error(String(error)));
     }
   }, [verifyPremiumStatus, callbacksRef, isProcessingRef]);

package/src/domains/revenuecat/infrastructure/services/RevenueCatInitializer.ts

@@ -3,6 +3,9 @@ import type { InitializerDeps } from "./RevenueCatInitializer.types";
 import { FAILED_INITIALIZATION_RESULT, CONFIGURATION_RETRY_DELAY_MS, MAX_INIT_RETRIES } from "./initializerConstants";
 import { configState } from "./ConfigurationStateManager";
 import { handleUserSwitch, handleInitialConfiguration, fetchCurrentUserData } from "./userSwitchHandler";
+import { createLogger } from "../../../../../shared/utils/logger";
+
+const logger = createLogger("RevenueCatInitializer");
 
 const MAX_CONFIG_START_RETRIES = 3;
 
@@ -32,7 +35,7 @@ export async function initializeSDK(
     }
 
     if (configState.isConfiguring) {
-      console.error('[RevenueCatInitializer] Max retry attempts reached', { userId });
+      logger.error("Max retry attempts reached", undefined, { userId });
       return FAILED_INITIALIZATION_RESULT;
     }
 
@@ -49,18 +52,16 @@ export async function initializeSDK(
     resolveConfig = configState.startConfiguration();
   } catch (error) {
     if (configStartRetryCount >= MAX_CONFIG_START_RETRIES) {
-      console.error('[RevenueCatInitializer] Max configuration start retries reached', {
+      logger.error("Max configuration start retries reached", error, {
         userId,
         retryCount: configStartRetryCount,
-        error
       });
       return FAILED_INITIALIZATION_RESULT;
     }
 
-    console.error('[RevenueCatInitializer] Failed to start configuration, retrying', {
+    logger.error("Failed to start configuration, retrying", error, {
       userId,
       retryCount: configStartRetryCount,
-      error
     });
     await new Promise<void>(resolve => setTimeout(() => resolve(), CONFIGURATION_RETRY_DELAY_MS));
     return initializeSDK(deps, userId, apiKey, configStartRetryCount + 1);

package/src/domains/revenuecat/infrastructure/services/UserSwitchMutex.ts

@@ -1,3 +1,7 @@
+import { createLogger } from "../../../../../shared/utils/logger";
+
+const logger = createLogger("UserSwitchMutex");
+
 class UserSwitchMutexImpl {
   private activeSwitchPromise: Promise<unknown> | null = null;
   private activeUserId: string | null = null;
@@ -6,30 +10,24 @@ class UserSwitchMutexImpl {
 
   async acquire(userId: string): Promise<{ shouldProceed: boolean; existingPromise?: Promise<unknown> }> {
     if (this.activeSwitchPromise && this.activeUserId === userId) {
-      if (typeof __DEV__ !== 'undefined' && __DEV__) {
-        console.log('[UserSwitchMutex] Switch already in progress for this user, returning existing promise');
-      }
+      logger.debug("Switch already in progress for this user, returning existing promise");
       return { shouldProceed: false, existingPromise: this.activeSwitchPromise };
     }
 
     if (this.activeSwitchPromise) {
-      if (typeof __DEV__ !== 'undefined' && __DEV__) {
-        console.log('[UserSwitchMutex] Waiting for active switch to complete...');
-      }
+      logger.debug("Waiting for active switch to complete...");
       try {
         await this.activeSwitchPromise;
       } catch (error) {
         // Previous switch failed — this is non-fatal for the current switch,
         // but worth logging so the failure is visible in diagnostics.
-        console.warn('[UserSwitchMutex] Previous user switch failed:', error instanceof Error ? error.message : String(error));
+        logger.warn("Previous user switch failed", error);
       }
 
       const timeSinceLastSwitch = Date.now() - this.lastSwitchTime;
       if (timeSinceLastSwitch < this.MIN_SWITCH_INTERVAL_MS) {
         const delayNeeded = this.MIN_SWITCH_INTERVAL_MS - timeSinceLastSwitch;
-        if (typeof __DEV__ !== 'undefined' && __DEV__) {
-          console.log(`[UserSwitchMutex] Rate limiting: waiting ${delayNeeded}ms`);
-        }
+        logger.debug(`Rate limiting: waiting ${delayNeeded}ms`);
         await new Promise<void>(resolve => setTimeout(() => resolve(), delayNeeded));
       }