@umituz/react-native-subscription 2.31.26 → 2.32.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.31.26",
+  "version": "2.32.1",
   "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/infrastructure/CreditsRepository.ts

@@ -1,20 +1,15 @@
-import { getDoc, setDoc } from "firebase/firestore";
-import { BaseRepository, serverTimestamp, type Firestore, type DocumentReference } from "@umituz/react-native-firebase";
+import type { Firestore, DocumentReference } from "@umituz/react-native-firebase";
+import { BaseRepository } from "@umituz/react-native-firebase";
 import type { CreditsConfig, CreditsResult, DeductCreditsResult } from "../core/Credits";
-import type { UserCreditsDocumentRead, PurchaseSource } from "../core/UserCreditsDocument";
-import { initializeCreditsTransaction } from "../application/CreditsInitializer";
-import { mapCreditsDocumentToEntity } from "../core/CreditsMapper";
+import type { PurchaseSource } from "../core/UserCreditsDocument";
 import type { RevenueCatData } from "../../revenuecat/core/types";
 import { deductCreditsOperation } from "../application/DeductCreditsCommand";
-import { calculateCreditLimit } from "../application/CreditLimitCalculator";
 import { PURCHASE_TYPE, type PurchaseType } from "../../subscription/core/SubscriptionConstants";
 import { requireFirestore, buildDocRef, type CollectionConfig } from "../../../shared/infrastructure/firestore";
-import { SUBSCRIPTION_STATUS } from "../../subscription/core/SubscriptionConstants";
+import { fetchCredits, checkHasCredits } from "./operations/CreditsFetcher";
+import { syncExpiredStatus } from "./operations/CreditsWriter";
+import { initializeCreditsWithRetry } from "./operations/CreditsInitializer";
 
-/**
- * Credits Repository
- * Provides domain-specific database operations for credits system.
- */
 export class CreditsRepository extends BaseRepository {
   constructor(private config: CreditsConfig) {
     super(config.collectionName);
@@ -34,14 +29,7 @@ export class CreditsRepository extends BaseRepository {
 
   async getCredits(userId: string): Promise<CreditsResult> {
     const db = requireFirestore();
-    const snap = await getDoc(this.getRef(db, userId));
-
-    if (!snap.exists()) {
-      return { success: true, data: null, error: null };
-    }
-
-    const entity = mapCreditsDocumentToEntity(snap.data() as UserCreditsDocumentRead);
-    return { success: true, data: entity, error: null };
+    return fetchCredits(this.getRef(db, userId));
   }
 
   async initializeCredits(
@@ -53,101 +41,32 @@ export class CreditsRepository extends BaseRepository {
     type: PurchaseType = PURCHASE_TYPE.INITIAL
   ): Promise<CreditsResult> {
     const db = requireFirestore();
-    const creditLimit = calculateCreditLimit(productId, this.config);
-    const cfg = { ...this.config, creditLimit };
-
-    const maxRetries = 3;
-    let lastError: any;
-
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-      try {
-        const result = await initializeCreditsTransaction(
-          db,
-          this.getRef(db, userId),
-          cfg,
-          purchaseId,
-          {
-            productId,
-            source,
-            expirationDate: revenueCatData.expirationDate,
-            willRenew: revenueCatData.willRenew,
-            originalTransactionId: revenueCatData.originalTransactionId,
-            isPremium: revenueCatData.isPremium,
-            periodType: revenueCatData.periodType,
-            unsubscribeDetectedAt: revenueCatData.unsubscribeDetectedAt,
-            billingIssueDetectedAt: revenueCatData.billingIssueDetectedAt,
-            store: revenueCatData.store,
-            ownershipType: revenueCatData.ownershipType,
-            type,
-          }
-        );
-
-        return {
-          success: true,
-          data: result.finalData ? mapCreditsDocumentToEntity(result.finalData) : null,
-          error: null,
-        };
-      } catch (error: any) {
-        lastError = error;
-
-        const isTransientError =
-          error?.code === 'already-exists' ||
-          error?.code === 'DEADLINE_EXCEEDED' ||
-          error?.code === 'UNAVAILABLE' ||
-          error?.code === 'RESOURCE_EXHAUSTED' ||
-          error?.message?.includes('already-exists') ||
-          error?.message?.includes('timeout') ||
-          error?.message?.includes('unavailable');
-
-        if (isTransientError && attempt < maxRetries - 1) {
-          await new Promise(resolve => setTimeout(resolve, 100 * (attempt + 1)));
-          continue;
-        }
-        break;
-      }
-    }
-
-    const errorMessage = lastError instanceof Error
-      ? lastError.message
-      : typeof lastError === 'string'
-        ? lastError
-        : 'Unknown error during credit initialization';
-
-    const errorCode = lastError?.code ?? 'UNKNOWN_ERROR';
-
-    return {
-      success: false,
-      data: null,
-      error: {
-        message: errorMessage,
-        code: errorCode,
-      },
-    };
+    return initializeCreditsWithRetry({
+      db,
+      ref: this.getRef(db, userId),
+      config: this.config,
+      userId,
+      purchaseId,
+      productId,
+      source,
+      revenueCatData,
+      type,
+    });
   }
 
-  /**
-   * Deducts credits using atomic transaction logic.
-   */
   async deductCredit(userId: string, cost: number): Promise<DeductCreditsResult> {
     const db = requireFirestore();
     return deductCreditsOperation(db, this.getRef(db, userId), cost, userId);
   }
 
   async hasCredits(userId: string, cost: number): Promise<boolean> {
-    const result = await this.getCredits(userId);
-    if (!result.success || !result.data) return false;
-    return result.data.credits >= cost;
+    const db = requireFirestore();
+    return checkHasCredits(this.getRef(db, userId), cost);
   }
 
   async syncExpiredStatus(userId: string): Promise<void> {
     const db = requireFirestore();
-    const ref = this.getRef(db, userId);
-    await setDoc(ref, {
-      isPremium: false,
-      status: SUBSCRIPTION_STATUS.EXPIRED,
-      willRenew: false,
-      expirationDate: serverTimestamp(),
-    }, { merge: true });
+    await syncExpiredStatus(this.getRef(db, userId));
   }
 }
 

package/src/domains/credits/infrastructure/operations/CreditsFetcher.ts

@@ -0,0 +1,23 @@
+import { getDoc } from "firebase/firestore";
+import type { Firestore, DocumentReference } from "@umituz/react-native-firebase";
+import type { CreditsResult } from "../../core/Credits";
+import type { UserCreditsDocumentRead } from "../../core/UserCreditsDocument";
+import { mapCreditsDocumentToEntity } from "../../core/CreditsMapper";
+import { requireFirestore } from "../../../../shared/infrastructure/firestore";
+
+export async function fetchCredits(ref: DocumentReference): Promise<CreditsResult> {
+  const snap = await getDoc(ref);
+
+  if (!snap.exists()) {
+    return { success: true, data: null, error: null };
+  }
+
+  const entity = mapCreditsDocumentToEntity(snap.data() as UserCreditsDocumentRead);
+  return { success: true, data: entity, error: null };
+}
+
+export async function checkHasCredits(ref: DocumentReference, cost: number): Promise<boolean> {
+  const result = await fetchCredits(ref);
+  if (!result.success || !result.data) return false;
+  return result.data.credits >= cost;
+}

package/src/domains/credits/infrastructure/operations/CreditsInitializer.ts

@@ -0,0 +1,98 @@
+import type { Firestore, DocumentReference } from "@umituz/react-native-firebase";
+import type { CreditsConfig, CreditsResult } from "../../core/Credits";
+import type { UserCreditsDocumentRead, PurchaseSource } from "../../core/UserCreditsDocument";
+import { initializeCreditsTransaction } from "../../application/CreditsInitializer";
+import { mapCreditsDocumentToEntity } from "../../core/CreditsMapper";
+import type { RevenueCatData } from "../../../revenuecat/core/types";
+import { calculateCreditLimit } from "../../application/CreditLimitCalculator";
+import { PURCHASE_TYPE, type PurchaseType } from "../../../subscription/core/SubscriptionConstants";
+
+interface InitializeCreditsParams {
+  db: Firestore;
+  ref: DocumentReference;
+  config: CreditsConfig;
+  userId: string;
+  purchaseId: string;
+  productId: string;
+  source: PurchaseSource;
+  revenueCatData: RevenueCatData;
+  type?: PurchaseType;
+}
+
+function isTransientError(error: any): boolean {
+  return (
+    error?.code === 'already-exists' ||
+    error?.code === 'DEADLINE_EXCEEDED' ||
+    error?.code === 'UNAVAILABLE' ||
+    error?.code === 'RESOURCE_EXHAUSTED' ||
+    error?.message?.includes('already-exists') ||
+    error?.message?.includes('timeout') ||
+    error?.message?.includes('unavailable')
+  );
+}
+
+export async function initializeCreditsWithRetry(params: InitializeCreditsParams): Promise<CreditsResult> {
+  const { db, ref, config, purchaseId, productId, source, revenueCatData, type = PURCHASE_TYPE.INITIAL } = params;
+
+  const creditLimit = calculateCreditLimit(productId, config);
+  const cfg = { ...config, creditLimit };
+
+  const maxRetries = 3;
+  let lastError: any;
+
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      const result = await initializeCreditsTransaction(
+        db,
+        ref,
+        cfg,
+        purchaseId,
+        {
+          productId,
+          source,
+          expirationDate: revenueCatData.expirationDate,
+          willRenew: revenueCatData.willRenew,
+          originalTransactionId: revenueCatData.originalTransactionId,
+          isPremium: revenueCatData.isPremium,
+          periodType: revenueCatData.periodType,
+          unsubscribeDetectedAt: revenueCatData.unsubscribeDetectedAt,
+          billingIssueDetectedAt: revenueCatData.billingIssueDetectedAt,
+          store: revenueCatData.store,
+          ownershipType: revenueCatData.ownershipType,
+          type,
+        }
+      );
+
+      return {
+        success: true,
+        data: result.finalData ? mapCreditsDocumentToEntity(result.finalData) : null,
+        error: null,
+      };
+    } catch (error: any) {
+      lastError = error;
+
+      if (isTransientError(error) && attempt < maxRetries - 1) {
+        await new Promise(resolve => setTimeout(resolve, 100 * (attempt + 1)));
+        continue;
+      }
+      break;
+    }
+  }
+
+  const errorMessage = lastError instanceof Error
+    ? lastError.message
+    : typeof lastError === 'string'
+      ? lastError
+      : 'Unknown error during credit initialization';
+
+  const errorCode = lastError?.code ?? 'UNKNOWN_ERROR';
+
+  return {
+    success: false,
+    data: null,
+    error: {
+      message: errorMessage,
+      code: errorCode,
+    },
+  };
+}

package/src/domains/credits/infrastructure/operations/CreditsWriter.ts

@@ -0,0 +1,13 @@
+import { setDoc } from "firebase/firestore";
+import type { DocumentReference } from "@umituz/react-native-firebase";
+import { serverTimestamp } from "@umituz/react-native-firebase";
+import { SUBSCRIPTION_STATUS } from "../../../subscription/core/SubscriptionConstants";
+
+export async function syncExpiredStatus(ref: DocumentReference): Promise<void> {
+  await setDoc(ref, {
+    isPremium: false,
+    status: SUBSCRIPTION_STATUS.EXPIRED,
+    willRenew: false,
+    expirationDate: serverTimestamp(),
+  }, { merge: true });
+}

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

@@ -0,0 +1,49 @@
+import type { InitializeResult } from "../../../../shared/application/ports/IRevenueCatService";
+
+export class ConfigurationStateManager {
+  private _isPurchasesConfigured = false;
+  private _configurationPromise: Promise<InitializeResult> | null = null;
+  private _resolveConfiguration: ((value: InitializeResult) => void) | null = null;
+
+  get isPurchasesConfigured(): boolean {
+    return this._isPurchasesConfigured;
+  }
+
+  get configurationPromise(): Promise<InitializeResult> | null {
+    return this._configurationPromise;
+  }
+
+  get isConfiguring(): boolean {
+    return this._configurationPromise !== null;
+  }
+
+  startConfiguration(): (value: InitializeResult) => void {
+    if (this._configurationPromise) {
+      throw new Error('Configuration already in progress');
+    }
+
+    this._configurationPromise = new Promise((resolve) => {
+      this._resolveConfiguration = resolve;
+    });
+
+    return (value: InitializeResult) => {
+      if (this._resolveConfiguration) {
+        this._resolveConfiguration(value);
+      }
+    };
+  }
+
+  completeConfiguration(success: boolean): void {
+    this._isPurchasesConfigured = success;
+    this._configurationPromise = null;
+    this._resolveConfiguration = null;
+  }
+
+  reset(): void {
+    this._isPurchasesConfigured = false;
+    this._configurationPromise = null;
+    this._resolveConfiguration = null;
+  }
+}
+
+export const configState = new ConfigurationStateManager();

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

@@ -1,133 +1,25 @@
-import Purchases, { type CustomerInfo, type PurchasesOfferings } from "react-native-purchases";
 import type { InitializeResult } from "../../../../shared/application/ports/IRevenueCatService";
 import { resolveApiKey } from "../utils/ApiKeyResolver";
 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";
 
 export type { InitializerDeps } from "./RevenueCatInitializer.types";
 
-/**
- * Thread-safe configuration state manager
- * Prevents race conditions during concurrent initialization attempts
- */
-class ConfigurationStateManager {
-  private _isPurchasesConfigured = false;
-  private _configurationPromise: Promise<InitializeResult> | null = null;
-  private _resolveConfiguration: ((value: InitializeResult) => void) | null = null;
-
-  get isPurchasesConfigured(): boolean {
-    return this._isPurchasesConfigured;
-  }
-
-  get configurationPromise(): Promise<InitializeResult> | null {
-    return this._configurationPromise;
-  }
-
-  get isConfiguring(): boolean {
-    return this._configurationPromise !== null;
-  }
-
-  /**
-   * Starts a new configuration process
-   * @throws Error if configuration is already in progress
-   */
-  startConfiguration(): (value: InitializeResult) => void {
-    if (this._configurationPromise) {
-      throw new Error('Configuration already in progress');
-    }
-
-    this._configurationPromise = new Promise((resolve) => {
-      this._resolveConfiguration = resolve;
-    });
-
-    return (value: InitializeResult) => {
-      if (this._resolveConfiguration) {
-        this._resolveConfiguration(value);
-      }
-    };
-  }
-
-  /**
-   * Completes the configuration process
-   */
-  completeConfiguration(success: boolean): void {
-    this._isPurchasesConfigured = success;
-    this._configurationPromise = null;
-    this._resolveConfiguration = null;
-  }
-
-  /**
-   * Resets the configuration state
-   */
-  reset(): void {
-    this._isPurchasesConfigured = false;
-    this._configurationPromise = null;
-    this._resolveConfiguration = null;
-  }
-}
-
-const configState = new ConfigurationStateManager();
-
-function buildSuccessResult(deps: InitializerDeps, customerInfo: CustomerInfo, offerings: PurchasesOfferings): InitializeResult {
-  const isPremium = !!customerInfo.entitlements.active[deps.config.entitlementIdentifier];
-  return { success: true, offering: offerings.current, isPremium };
-}
-
 export async function initializeSDK(
   deps: InitializerDeps,
   userId: string,
   apiKey?: string
 ): Promise<InitializeResult> {
   if (deps.isInitialized() && deps.getCurrentUserId() === userId) {
-    try {
-      const [customerInfo, offerings] = await Promise.all([
-        Purchases.getCustomerInfo(),
-        Purchases.getOfferings(),
-      ]);
-      return buildSuccessResult(deps, customerInfo, offerings);
-    } catch (error) {
-      console.error('[RevenueCatInitializer] Failed to fetch customer info/offerings for initialized user', {
-        userId,
-        error
-      });
-      return FAILED_INITIALIZATION_RESULT;
-    }
+    return fetchCurrentUserData(deps);
   }
 
   if (configState.isPurchasesConfigured) {
-    try {
-      const currentAppUserId = await Purchases.getAppUserID();
-      let customerInfo;
-
-      // Handle user switching
-      if (currentAppUserId !== userId) {
-        if (userId) {
-          // Switch to authenticated user
-          const result = await Purchases.logIn(userId);
-          customerInfo = result.customerInfo;
-        } else {
-          // User logged out - switch to anonymous
-          customerInfo = await Purchases.logOut();
-        }
-      } else {
-        customerInfo = await Purchases.getCustomerInfo();
-      }
-
-      deps.setInitialized(true);
-      deps.setCurrentUserId(userId ?? null);
-      const offerings = await Purchases.getOfferings();
-      return buildSuccessResult(deps, customerInfo, offerings);
-    } catch (error) {
-      console.error('[RevenueCatInitializer] Failed during user switch or fetch', {
-        userId,
-        currentAppUserId: await Purchases.getAppUserID().catch(() => 'unknown'),
-        error
-      });
-      return FAILED_INITIALIZATION_RESULT;
-    }
+    return handleUserSwitch(deps, userId);
   }
 
-  // Wait for ongoing configuration with retry limit
   if (configState.isConfiguring) {
     let retryCount = 0;
     while (configState.isConfiguring && retryCount < MAX_INIT_RETRIES) {
@@ -144,7 +36,6 @@ export async function initializeSDK(
       return FAILED_INITIALIZATION_RESULT;
     }
 
-    // Configuration completed, try again
     return initializeSDK(deps, userId, apiKey);
   }
 
@@ -161,36 +52,12 @@ export async function initializeSDK(
       userId,
       error
     });
-    // Configuration already in progress, wait and retry
     await new Promise(resolve => setTimeout(resolve, CONFIGURATION_RETRY_DELAY_MS));
     return initializeSDK(deps, userId, apiKey);
   }
 
-  try {
-    // Configure with null appUserID for anonymous users (generates RevenueCat anonymous ID)
-    // For authenticated users, use their userId
-    await Purchases.configure({ apiKey: key, appUserID: userId ?? null });
-    deps.setInitialized(true);
-    deps.setCurrentUserId(userId ?? null);
-
-    const [customerInfo, offerings] = await Promise.all([
-      Purchases.getCustomerInfo(),
-      Purchases.getOfferings(),
-    ]);
-
-    const result = buildSuccessResult(deps, customerInfo, offerings);
-    configState.completeConfiguration(true);
-    resolveConfig(result);
-    return result;
-  } catch (error) {
-    console.error('[RevenueCatInitializer] SDK configuration failed', {
-      userId,
-      apiKey: apiKey ? 'provided' : 'from config',
-      error
-    });
-    configState.completeConfiguration(false);
-    resolveConfig(FAILED_INITIALIZATION_RESULT);
-    return FAILED_INITIALIZATION_RESULT;
-  }
+  const result = await handleInitialConfiguration(deps, userId, key);
+  configState.completeConfiguration(result.success);
+  resolveConfig(result);
+  return result;
 }
-

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

@@ -0,0 +1,94 @@
+import Purchases, { type CustomerInfo } from "react-native-purchases";
+import type { InitializeResult } from "../../../../shared/application/ports/IRevenueCatService";
+import type { InitializerDeps } from "./RevenueCatInitializer.types";
+import { FAILED_INITIALIZATION_RESULT } from "./initializerConstants";
+
+function buildSuccessResult(deps: InitializerDeps, customerInfo: CustomerInfo, offerings: any): InitializeResult {
+  const isPremium = !!customerInfo.entitlements.active[deps.config.entitlementIdentifier];
+  return { success: true, offering: offerings.current, isPremium };
+}
+
+function normalizeUserId(userId: string): string | null {
+  return (userId && userId.length > 0) ? userId : null;
+}
+
+function isAnonymousId(userId: string): boolean {
+  return userId.startsWith('$RCAnonymous');
+}
+
+export async function handleUserSwitch(
+  deps: InitializerDeps,
+  userId: string
+): Promise<InitializeResult> {
+  try {
+    const currentAppUserId = await Purchases.getAppUserID();
+    let customerInfo;
+
+    const normalizedUserId = normalizeUserId(userId);
+    const normalizedCurrentUserId = isAnonymousId(currentAppUserId) ? null : currentAppUserId;
+
+    if (normalizedCurrentUserId !== normalizedUserId) {
+      if (normalizedUserId) {
+        const result = await Purchases.logIn(normalizedUserId);
+        customerInfo = result.customerInfo;
+      } else {
+        customerInfo = await Purchases.getCustomerInfo();
+      }
+    } else {
+      customerInfo = await Purchases.getCustomerInfo();
+    }
+
+    deps.setInitialized(true);
+    deps.setCurrentUserId(normalizedUserId);
+    const offerings = await Purchases.getOfferings();
+    return buildSuccessResult(deps, customerInfo, offerings);
+  } catch (error) {
+    console.error('[UserSwitchHandler] Failed during user switch or fetch', {
+      userId,
+      currentAppUserId: await Purchases.getAppUserID().catch(() => 'unknown'),
+      error
+    });
+    return FAILED_INITIALIZATION_RESULT;
+  }
+}
+
+export async function handleInitialConfiguration(
+  deps: InitializerDeps,
+  userId: string,
+  apiKey: string
+): Promise<InitializeResult> {
+  try {
+    const normalizedUserId = normalizeUserId(userId);
+    await Purchases.configure({ apiKey, appUserID: normalizedUserId });
+    deps.setInitialized(true);
+    deps.setCurrentUserId(normalizedUserId);
+
+    const [customerInfo, offerings] = await Promise.all([
+      Purchases.getCustomerInfo(),
+      Purchases.getOfferings(),
+    ]);
+
+    return buildSuccessResult(deps, customerInfo, offerings);
+  } catch (error) {
+    console.error('[UserSwitchHandler] SDK configuration failed', {
+      userId,
+      error
+    });
+    return FAILED_INITIALIZATION_RESULT;
+  }
+}
+
+export async function fetchCurrentUserData(deps: InitializerDeps): Promise<InitializeResult> {
+  try {
+    const [customerInfo, offerings] = await Promise.all([
+      Purchases.getCustomerInfo(),
+      Purchases.getOfferings(),
+    ]);
+    return buildSuccessResult(deps, customerInfo, offerings);
+  } catch (error) {
+    console.error('[UserSwitchHandler] Failed to fetch customer info/offerings for initialized user', {
+      error
+    });
+    return FAILED_INITIALIZATION_RESULT;
+  }
+}

package/src/domains/subscription/infrastructure/managers/SubscriptionManager.ts

@@ -34,21 +34,30 @@ class SubscriptionManagerImpl {
   async initialize(userId?: string): Promise<boolean> {
     this.ensureConfigured();
 
-    const actualUserId = userId ?? (await this.managerConfig.getAnonymousUserId()) ?? '';
-    const { shouldInit, existingPromise } = this.state.initCache.tryAcquireInitialization(actualUserId);
+    let actualUserId: string | null = null;
+
+    if (userId && userId.length > 0) {
+      actualUserId = userId;
+    } else {
+      const anonymousId = await this.managerConfig.getAnonymousUserId();
+      actualUserId = (anonymousId && anonymousId.length > 0) ? anonymousId : null;
+    }
+
+    const cacheKey = actualUserId ?? '__anonymous__';
+    const { shouldInit, existingPromise } = this.state.initCache.tryAcquireInitialization(cacheKey);
 
     if (!shouldInit && existingPromise) {
       return existingPromise;
     }
 
     const promise = this.performInitialization(actualUserId);
-    this.state.initCache.setPromise(promise, actualUserId);
+    this.state.initCache.setPromise(promise, cacheKey);
     return promise;
   }
 
-  private async performInitialization(userId: string): Promise<boolean> {
+  private async performInitialization(userId: string | null): Promise<boolean> {
     this.ensureConfigured();
-    const { service, success } = await performServiceInitialization(this.managerConfig.config, userId);
+    const { service, success } = await performServiceInitialization(this.managerConfig.config, userId ?? '');
     this.serviceInstance = service ?? null;
     this.ensurePackageHandlerInitialized();
     return success;