@umituz/react-native-subscription 1.0.6 → 1.0.7

package/LICENSE

@@ -20,3 +20,13 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
+
+
+
+
+
+
+
+
+
+

package/README.md

@@ -204,3 +204,13 @@ initializeRevenueCatService({
 
 MIT
 
+
+
+
+
+
+
+
+
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Subscription management system for React Native apps - Database-first approach with secure validation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/application/ports/ISubscriptionRepository.ts

@@ -30,3 +30,13 @@ export interface ISubscriptionRepository {
   isSubscriptionValid(status: SubscriptionStatus): boolean;
 }
 
+
+
+
+
+
+
+
+
+
+

package/src/application/ports/ISubscriptionService.ts

@@ -39,3 +39,13 @@ export interface ISubscriptionService {
   ): Promise<SubscriptionStatus>;
 }
 
+
+
+
+
+
+
+
+
+
+

package/src/domain/entities/SubscriptionStatus.ts

@@ -62,3 +62,13 @@ export function isSubscriptionValid(status: SubscriptionStatus | null): boolean
   return expirationDate.getTime() > now.getTime() - bufferMs;
 }
 
+
+
+
+
+
+
+
+
+
+

package/src/domain/errors/SubscriptionError.ts

@@ -31,3 +31,13 @@ export class SubscriptionConfigurationError extends SubscriptionError {
   }
 }
 
+
+
+
+
+
+
+
+
+
+

package/src/infrastructure/services/ActivationHandler.ts

@@ -0,0 +1,100 @@
+/**
+ * Activation Handler
+ * Handles subscription activation and deactivation
+ */
+
+import type { ISubscriptionRepository } from "../../application/ports/ISubscriptionRepository";
+import type { SubscriptionStatus } from "../../domain/entities/SubscriptionStatus";
+import { SubscriptionRepositoryError } from "../../domain/errors/SubscriptionError";
+
+export interface ActivationHandlerConfig {
+  repository: ISubscriptionRepository;
+  onStatusChanged?: (
+    userId: string,
+    status: SubscriptionStatus
+  ) => Promise<void> | void;
+  onError?: (error: Error, context: string) => Promise<void> | void;
+}
+
+/**
+ * Activate subscription for user
+ */
+export async function activateSubscription(
+  config: ActivationHandlerConfig,
+  userId: string,
+  productId: string,
+  expiresAt: string | null
+): Promise<SubscriptionStatus> {
+  try {
+    const updatedStatus = await config.repository.updateSubscriptionStatus(
+      userId,
+      {
+        isPremium: true,
+        productId,
+        expiresAt,
+        purchasedAt: new Date().toISOString(),
+        syncedAt: new Date().toISOString(),
+      }
+    );
+
+    await notifyStatusChange(config, userId, updatedStatus);
+    return updatedStatus;
+  } catch (error) {
+    await handleError(config, error, "activateSubscription");
+    throw new SubscriptionRepositoryError("Failed to activate subscription");
+  }
+}
+
+/**
+ * Deactivate subscription for user
+ */
+export async function deactivateSubscription(
+  config: ActivationHandlerConfig,
+  userId: string
+): Promise<SubscriptionStatus> {
+  try {
+    const updatedStatus = await config.repository.updateSubscriptionStatus(
+      userId,
+      {
+        isPremium: false,
+        expiresAt: null,
+        productId: null,
+      }
+    );
+
+    await notifyStatusChange(config, userId, updatedStatus);
+    return updatedStatus;
+  } catch (error) {
+    await handleError(config, error, "deactivateSubscription");
+    throw new SubscriptionRepositoryError("Failed to deactivate subscription");
+  }
+}
+
+async function notifyStatusChange(
+  config: ActivationHandlerConfig,
+  userId: string,
+  status: SubscriptionStatus
+): Promise<void> {
+  if (!config.onStatusChanged) return;
+
+  try {
+    await config.onStatusChanged(userId, status);
+  } catch (error) {
+    await handleError(config, error, "onStatusChanged");
+  }
+}
+
+async function handleError(
+  config: ActivationHandlerConfig,
+  error: unknown,
+  context: string
+): Promise<void> {
+  if (!config.onError) return;
+
+  try {
+    const err = error instanceof Error ? error : new Error("Unknown error");
+    await config.onError(err, `ActivationHandler.${context}`);
+  } catch {
+    // Ignore callback errors
+  }
+}

package/src/infrastructure/services/SubscriptionService.ts

@@ -1,51 +1,40 @@
 /**
  * Subscription Service Implementation
- * Secure subscription management with database-first approach
- *
- * SECURITY: Database-first approach ensures:
- * - 10-50x faster subscription checks
- * - Works offline (database cache)
- * - More reliable than SDK-dependent checks
- * - Server-side validation always enforced
+ * Database-first subscription management
  */
 
-import type { ISubscriptionService } from '../../application/ports/ISubscriptionService';
-import type { ISubscriptionRepository } from '../../application/ports/ISubscriptionRepository';
-import type { SubscriptionStatus } from '../../domain/entities/SubscriptionStatus';
-import {
-  createDefaultSubscriptionStatus,
-  isSubscriptionValid,
-} from '../../domain/entities/SubscriptionStatus';
+import type { ISubscriptionService } from "../../application/ports/ISubscriptionService";
+import type { ISubscriptionRepository } from "../../application/ports/ISubscriptionRepository";
+import type { SubscriptionStatus } from "../../domain/entities/SubscriptionStatus";
+import { createDefaultSubscriptionStatus } from "../../domain/entities/SubscriptionStatus";
 import {
   SubscriptionRepositoryError,
   SubscriptionValidationError,
-} from '../../domain/errors/SubscriptionError';
-import type { SubscriptionConfig } from '../../domain/value-objects/SubscriptionConfig';
+} from "../../domain/errors/SubscriptionError";
+import type { SubscriptionConfig } from "../../domain/value-objects/SubscriptionConfig";
+import {
+  activateSubscription,
+  deactivateSubscription,
+  type ActivationHandlerConfig,
+} from "./ActivationHandler";
 
 export class SubscriptionService implements ISubscriptionService {
   private repository: ISubscriptionRepository;
-  private onStatusChanged?: (
-    userId: string,
-    status: SubscriptionStatus,
-  ) => Promise<void> | void;
-  private onError?: (error: Error, context: string) => Promise<void> | void;
+  private handlerConfig: ActivationHandlerConfig;
 
   constructor(config: SubscriptionConfig) {
     if (!config.repository) {
-      throw new SubscriptionValidationError(
-        'Repository is required for SubscriptionService',
-      );
+      throw new SubscriptionValidationError("Repository is required");
     }
 
     this.repository = config.repository;
-    this.onStatusChanged = config.onStatusChanged;
-    this.onError = config.onError;
+    this.handlerConfig = {
+      repository: config.repository,
+      onStatusChanged: config.onStatusChanged,
+      onError: config.onError,
+    };
   }
 
-  /**
-   * Get subscription status for a user
-   * Returns default (free) status if user not found
-   */
   async getSubscriptionStatus(userId: string): Promise<SubscriptionStatus> {
     try {
       const status = await this.repository.getSubscriptionStatus(userId);
@@ -53,131 +42,45 @@ export class SubscriptionService implements ISubscriptionService {
         return createDefaultSubscriptionStatus();
       }
 
-      // Validate subscription status (check expiration)
       const isValid = this.repository.isSubscriptionValid(status);
       if (!isValid && status.isPremium) {
-        // Subscription expired, update status
-        const updatedStatus = await this.deactivateSubscription(userId);
-        return updatedStatus;
+        return await this.deactivateSubscription(userId);
       }
 
       return status;
     } catch (error) {
-      await this.handleError(
-        error instanceof Error
-          ? error
-          : new Error('Error getting subscription status'),
-        'SubscriptionService.getSubscriptionStatus',
-      );
+      await this.handleError(error, "getSubscriptionStatus");
       return createDefaultSubscriptionStatus();
     }
   }
 
-  /**
-   * Check if user has active subscription
-   */
   async isPremium(userId: string): Promise<boolean> {
     const status = await this.getSubscriptionStatus(userId);
     return this.repository.isSubscriptionValid(status);
   }
 
-  /**
-   * Activate subscription
-   */
   async activateSubscription(
     userId: string,
     productId: string,
-    expiresAt: string | null,
+    expiresAt: string | null
   ): Promise<SubscriptionStatus> {
-    try {
-      const updatedStatus = await this.repository.updateSubscriptionStatus(
-        userId,
-        {
-          isPremium: true,
-          productId,
-          expiresAt,
-          purchasedAt: new Date().toISOString(),
-          syncedAt: new Date().toISOString(),
-        },
-      );
-
-      // Call callback if provided
-      if (this.onStatusChanged) {
-        try {
-          await this.onStatusChanged(userId, updatedStatus);
-        } catch (error) {
-          // Don't fail activation if callback fails
-          await this.handleError(
-            error instanceof Error ? error : new Error('Callback failed'),
-            'SubscriptionService.activateSubscription.onStatusChanged',
-          );
-        }
-      }
-
-      return updatedStatus;
-    } catch (error) {
-      await this.handleError(
-        error instanceof Error
-          ? error
-          : new Error('Error activating subscription'),
-        'SubscriptionService.activateSubscription',
-      );
-      throw new SubscriptionRepositoryError(
-        'Failed to activate subscription',
-      );
-    }
+    return activateSubscription(
+      this.handlerConfig,
+      userId,
+      productId,
+      expiresAt
+    );
   }
 
-  /**
-   * Deactivate subscription
-   */
   async deactivateSubscription(userId: string): Promise<SubscriptionStatus> {
-    try {
-      const updatedStatus = await this.repository.updateSubscriptionStatus(
-        userId,
-        {
-          isPremium: false,
-          expiresAt: null,
-          productId: null,
-        },
-      );
-
-      // Call callback if provided
-      if (this.onStatusChanged) {
-        try {
-          await this.onStatusChanged(userId, updatedStatus);
-        } catch (error) {
-          // Don't fail deactivation if callback fails
-          await this.handleError(
-            error instanceof Error ? error : new Error('Callback failed'),
-            'SubscriptionService.deactivateSubscription.onStatusChanged',
-          );
-        }
-      }
-
-      return updatedStatus;
-    } catch (error) {
-      await this.handleError(
-        error instanceof Error
-          ? error
-          : new Error('Error deactivating subscription'),
-        'SubscriptionService.deactivateSubscription',
-      );
-      throw new SubscriptionRepositoryError(
-        'Failed to deactivate subscription',
-      );
-    }
+    return deactivateSubscription(this.handlerConfig, userId);
   }
 
-  /**
-   * Update subscription status
-   */
   async updateSubscriptionStatus(
     userId: string,
-    updates: Partial<SubscriptionStatus>,
+    updates: Partial<SubscriptionStatus>
   ): Promise<SubscriptionStatus> {
     try {
-      // Add syncedAt timestamp
       const updatesWithSync = {
         ...updates,
         syncedAt: new Date().toISOString(),
@@ -185,61 +88,40 @@ export class SubscriptionService implements ISubscriptionService {
 
       const updatedStatus = await this.repository.updateSubscriptionStatus(
         userId,
-        updatesWithSync,
+        updatesWithSync
       );
 
-      // Call callback if provided
-      if (this.onStatusChanged) {
+      if (this.handlerConfig.onStatusChanged) {
         try {
-          await this.onStatusChanged(userId, updatedStatus);
+          await this.handlerConfig.onStatusChanged(userId, updatedStatus);
         } catch (error) {
-          // Don't fail update if callback fails
-          await this.handleError(
-            error instanceof Error ? error : new Error('Callback failed'),
-            'SubscriptionService.updateSubscriptionStatus.onStatusChanged',
-          );
+          await this.handleError(error, "updateSubscriptionStatus.callback");
         }
       }
 
       return updatedStatus;
     } catch (error) {
-      await this.handleError(
-        error instanceof Error
-          ? error
-          : new Error('Error updating subscription status'),
-        'SubscriptionService.updateSubscriptionStatus',
-      );
-      throw new SubscriptionRepositoryError(
-        'Failed to update subscription status',
-      );
+      await this.handleError(error, "updateSubscriptionStatus");
+      throw new SubscriptionRepositoryError("Failed to update subscription");
     }
   }
 
-  /**
-   * Handle errors with optional callback
-   */
-  private async handleError(error: Error, context: string): Promise<void> {
-    if (this.onError) {
-      try {
-        await this.onError(error, context);
-      } catch {
-        // Ignore callback errors
-      }
+  private async handleError(error: unknown, context: string): Promise<void> {
+    if (!this.handlerConfig.onError) return;
+
+    try {
+      const err = error instanceof Error ? error : new Error("Unknown error");
+      await this.handlerConfig.onError(err, `SubscriptionService.${context}`);
+    } catch {
+      // Ignore callback errors
     }
   }
 }
 
-/**
- * Singleton instance
- * Apps should use initializeSubscriptionService() to set up with their config
- */
 let subscriptionServiceInstance: SubscriptionService | null = null;
 
-/**
- * Initialize Subscription service with configuration
- */
 export function initializeSubscriptionService(
-  config: SubscriptionConfig,
+  config: SubscriptionConfig
 ): SubscriptionService {
   if (!subscriptionServiceInstance) {
     subscriptionServiceInstance = new SubscriptionService(config);
@@ -247,27 +129,14 @@ export function initializeSubscriptionService(
   return subscriptionServiceInstance;
 }
 
-/**
- * Get Subscription service instance
- * Returns null if service is not initialized (graceful degradation)
- */
 export function getSubscriptionService(): SubscriptionService | null {
-  if (!subscriptionServiceInstance) {
-    /* eslint-disable-next-line no-console */
-    if (__DEV__) {
-      console.warn(
-        'Subscription service is not initialized. Call initializeSubscriptionService() first.',
-      );
-    }
-    return null;
+  if (!subscriptionServiceInstance && typeof __DEV__ !== "undefined" && __DEV__) {
+    // eslint-disable-next-line no-console
+    console.warn("[Subscription] Service not initialized");
   }
   return subscriptionServiceInstance;
 }
 
-/**
- * Reset Subscription service (useful for testing)
- */
 export function resetSubscriptionService(): void {
   subscriptionServiceInstance = null;
 }
-