@umituz/react-native-subscription 2.27.113 → 2.27.114

package/src/init/createSubscriptionInitModule.ts

@@ -18,15 +18,12 @@ export function createSubscriptionInitModule(config: SubscriptionInitModuleConfi
       try {
         const apiKey = getApiKey();
         if (!apiKey) {
-          if (__DEV__) console.log('[SubscriptionInit] No API key - skipping');
           return true;
         }
 
         await initializeSubscription({ apiKey, ...subscriptionConfig });
-        if (__DEV__) console.log('[SubscriptionInit] Initialized');
         return true;
-      } catch (error) {
-        if (__DEV__) console.error('[SubscriptionInit] Error:', error);
+      } catch {
         return false;
       }
     },

package/src/presentation/hooks/feedback/useFeedbackSubmit.ts

@@ -27,13 +27,6 @@ export function usePaywallFeedbackSubmit(
 
   const submit = useCallback(
     async (reason: string) => {
-      if (__DEV__) {
-        console.log("[usePaywallFeedbackSubmit] Submitting:", {
-          userId: user?.uid?.slice(0, 8),
-          reason: reason.slice(0, 20),
-        });
-      }
-
       try {
         const result = await submitPaywallFeedback(
           user?.uid ?? null,
@@ -81,13 +74,6 @@ export function useSettingsFeedbackSubmit(
 
   const submit = useCallback(
     async (data: SettingsFeedbackData) => {
-      if (__DEV__) {
-        console.log("[useSettingsFeedbackSubmit] Submitting:", {
-          userId: user?.uid?.slice(0, 8),
-          type: data.type,
-        });
-      }
-
       try {
         const result = await submitSettingsFeedback(
           user?.uid ?? null,

package/src/shared/application/FeedbackService.ts

@@ -32,30 +32,16 @@ export async function submitFeedback(
   const db = getFirestore();
 
   if (!db) {
-    if (__DEV__) {
-      console.warn("[FeedbackService] Firestore not available");
-    }
     return { success: false, error: new Error("Firestore not available") };
   }
 
   if (!data.userId) {
-    if (__DEV__) {
-      console.warn("[FeedbackService] User ID is required for feedback");
-    }
     return { success: false, error: new Error("User ID is required") };
   }
 
   try {
-    if (__DEV__) {
-      console.log("[FeedbackService] Submitting feedback:", {
-        type: data.type,
-        userId: data.userId?.slice(0, 8),
-      });
-    }
-
     const now = new Date().toISOString();
 
-    // Store under users/{userId}/feedback
     const userDocRef = doc(db, "users", data.userId);
     const feedbackCollectionRef = collection(userDocRef, "feedback");
 
@@ -70,15 +56,8 @@ export async function submitFeedback(
       updatedAt: now,
     });
 
-    if (__DEV__) {
-      console.log("[FeedbackService] Feedback submitted successfully");
-    }
-
     return { success: true };
   } catch (error) {
-    if (__DEV__) {
-      console.error("[FeedbackService] Submit error:", error);
-    }
     return {
       success: false,
       error: error instanceof Error ? error : new Error("Unknown error"),

package/src/shared/infrastructure/SubscriptionEventBus.ts

@@ -42,8 +42,7 @@ export class SubscriptionEventBus {
     this.listeners[event].forEach(callback => {
       try {
         callback(data);
-      } catch (error) {
-        if (__DEV__) console.error(`[SubscriptionEventBus] Error in listener for ${event}:`, error);
+      } catch {
       }
     });
   }

package/src/shared/types/CommonTypes.ts

@@ -0,0 +1,65 @@
+/**
+ * Common Type Definitions
+ * Shared types used across multiple domains
+ */
+
+/**
+ * Purchase result from any purchase operation
+ */
+export interface PurchaseResult {
+  success: boolean;
+  productId?: string;
+  error?: Error;
+}
+
+/**
+ * Transaction result for repository operations
+ */
+export interface TransactionResult<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: Error;
+}
+
+/**
+ * Subscription status information
+ */
+export interface SubscriptionStatusInfo {
+  isActive: boolean;
+  isExpired: boolean;
+  isTrial: boolean;
+  willRenew: boolean;
+  expirationDate?: Date;
+  productId?: string;
+}
+
+/**
+ * Credits information
+ */
+export interface CreditsInfo {
+  credits: number;
+  creditLimit: number;
+  isPremium: boolean;
+  status: string;
+}
+
+/**
+ * Transaction metadata for any transaction type
+ */
+export interface TransactionMetadata {
+  productId: string;
+  amount: number;
+  currency?: string;
+  timestamp: Date;
+  type: 'purchase' | 'renewal' | 'restore' | 'credit_purchase';
+}
+
+/**
+ * Platform information
+ */
+export type Platform = 'ios' | 'android';
+
+/**
+ * Purchase source tracking
+ */
+export type PurchaseSource = 'settings' | 'paywall' | 'upgrade_prompt' | 'auto-execution' | 'manual';

package/src/shared/utils/BaseError.ts

@@ -0,0 +1,26 @@
+/**
+ * Base Error Class
+ * Common base error for all domain errors
+ */
+
+export abstract class BaseError extends Error {
+    public readonly code: string;
+    public readonly cause?: Error;
+
+    constructor(message: string, code: string, cause?: Error) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.cause = cause;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            cause: this.cause?.message,
+        };
+    }
+}

package/src/shared/utils/Logger.ts

@@ -1,7 +1,7 @@
 /**
  * Subscription Logger
  * Centralized logging utility for the subscription package.
- * All logs are dev-only and automatically stripped in production.
+ * All logs are disabled - no logging.
  */
 
 export type LogLevel = "debug" | "info" | "warn" | "error";
@@ -25,86 +25,55 @@ export type LogCategory = (typeof LOG_CATEGORY)[keyof typeof LOG_CATEGORY];
 
 /**
  * Development-only logger that automatically respects __DEV__ flag.
- * All methods are no-ops in production builds.
+ * All methods are no-ops - logging is disabled.
  */
 class SubscriptionLogger {
-  private enabled: boolean = true;
-  private categories: Set<LogCategory> = new Set();
-
   /** Enable or disable all logging */
-  setEnabled(enabled: boolean): void {
-    this.enabled = enabled;
+  setEnabled(_enabled: boolean): void {
   }
 
   /** Enable logging for specific categories only */
-  setCategories(categories: LogCategory[]): void {
-    this.categories = new Set(categories);
+  setCategories(_categories: LogCategory[]): void {
   }
 
   /** Clear category filter (log all categories) */
   clearCategories(): void {
-    this.categories.clear();
-  }
-
-  private shouldLog(category?: LogCategory): boolean {
-    if (typeof __DEV__ === "undefined" || !__DEV__) return false;
-    if (!this.enabled) return false;
-    if (this.categories.size > 0 && category && !this.categories.has(category)) return false;
-    return true;
-  }
-
-  private formatMessage(category: LogCategory | string, message: string): string {
-    return `[${category}] ${message}`;
   }
 
-  debug(category: LogCategory, message: string, metadata?: LogMetadata): void {
-    if (!this.shouldLog(category)) return;
-    console.log(this.formatMessage(category, message), metadata ?? "");
+  debug(_category: LogCategory, _message: string, _metadata?: LogMetadata): void {
   }
 
-  info(category: LogCategory, message: string, metadata?: LogMetadata): void {
-    if (!this.shouldLog(category)) return;
-    console.log(this.formatMessage(category, message), metadata ?? "");
+  info(_category: LogCategory, _message: string, _metadata?: LogMetadata): void {
   }
 
-  warn(category: LogCategory, message: string, metadata?: LogMetadata): void {
-    if (!this.shouldLog(category)) return;
-    console.warn(this.formatMessage(category, message), metadata ?? "");
+  warn(_category: LogCategory, _message: string, _metadata?: LogMetadata): void {
   }
 
-  error(category: LogCategory, message: string, error?: unknown, metadata?: LogMetadata): void {
-    if (!this.shouldLog(category)) return;
-    console.error(this.formatMessage(category, message), { error, ...metadata });
+  error(_category: LogCategory, _message: string, _error?: unknown, _metadata?: LogMetadata): void {
   }
 
   /** Log purchase flow events */
-  purchase(message: string, metadata?: LogMetadata): void {
-    this.debug(LOG_CATEGORY.PURCHASE, message, metadata);
+  purchase(_message: string, _metadata?: LogMetadata): void {
   }
 
   /** Log credits-related events */
-  credits(message: string, metadata?: LogMetadata): void {
-    this.debug(LOG_CATEGORY.CREDITS, message, metadata);
+  credits(_message: string, _metadata?: LogMetadata): void {
   }
 
   /** Log trial-related events */
-  trial(message: string, metadata?: LogMetadata): void {
-    this.debug(LOG_CATEGORY.TRIAL, message, metadata);
+  trial(_message: string, _metadata?: LogMetadata): void {
   }
 
   /** Log RevenueCat SDK events */
-  revenueCat(message: string, metadata?: LogMetadata): void {
-    this.debug(LOG_CATEGORY.REVENUECAT, message, metadata);
+  revenueCat(_message: string, _metadata?: LogMetadata): void {
   }
 
   /** Log feature gate events */
-  featureGate(message: string, metadata?: LogMetadata): void {
-    this.debug(LOG_CATEGORY.FEATURE_GATE, message, metadata);
+  featureGate(_message: string, _metadata?: LogMetadata): void {
   }
 
   /** Log sync operations */
-  sync(message: string, metadata?: LogMetadata): void {
-    this.debug(LOG_CATEGORY.SYNC, message, metadata);
+  sync(_message: string, _metadata?: LogMetadata): void {
   }
 }
 

package/src/shared/utils/Result.ts

@@ -114,6 +114,22 @@ export function tryCatchSync<T>(
     return failure(mappedError);
   }
 }
+export function tryCatchSync<T>(
+  fn: () => T,
+  errorMapper?: (error: unknown) => Error
+): Result<T, Error> {
+  try {
+    const data = fn();
+    return success(data);
+  } catch {
+    const mappedError = errorMapper
+      ? errorMapper(error)
+      : error instanceof Error
+        ? error
+        : new Error(String(error));
+    return failure(mappedError);
+  }
+}
 
 /** Combine multiple results into one */
 export function combine<T, E>(results: Result<T, E>[]): Result<T[], E> {

package/src/shared/utils/SubscriptionError.ts

@@ -3,55 +3,45 @@
  * Custom error class for subscription-related errors
  */
 
-export class SubscriptionError extends Error {
-    public readonly code: string;
+import { BaseError } from "./BaseError";
 
-    constructor(message: string, code: string = 'SUBSCRIPTION_ERROR') {
-        super(message);
+export class SubscriptionError extends BaseError {
+    constructor(message: string, code: string = 'SUBSCRIPTION_ERROR', cause?: Error) {
+        super(message, code, cause);
         this.name = 'SubscriptionError';
-        this.code = code;
-        Object.setPrototypeOf(this, SubscriptionError.prototype);
     }
 
-    static notFound(message: string = 'Subscription not found'): SubscriptionError {
-        return new SubscriptionError(message, 'SUBSCRIPTION_NOT_FOUND');
+    static notFound(message: string = 'Subscription not found', cause?: Error): SubscriptionError {
+        return new SubscriptionError(message, 'SUBSCRIPTION_NOT_FOUND', cause);
     }
 
-    static expired(message: string = 'Subscription has expired'): SubscriptionError {
-        return new SubscriptionError(message, 'SUBSCRIPTION_EXPIRED');
+    static expired(message: string = 'Subscription has expired', cause?: Error): SubscriptionError {
+        return new SubscriptionError(message, 'SUBSCRIPTION_EXPIRED', cause);
     }
 
-    static purchaseFailed(message: string = 'Purchase failed'): SubscriptionError {
-        return new SubscriptionError(message, 'PURCHASE_FAILED');
+    static purchaseFailed(message: string = 'Purchase failed', cause?: Error): SubscriptionError {
+        return new SubscriptionError(message, 'PURCHASE_FAILED', cause);
     }
 
-    static restoreFailed(message: string = 'Restore failed'): SubscriptionError {
-        return new SubscriptionError(message, 'RESTORE_FAILED');
+    static restoreFailed(message: string = 'Restore failed', cause?: Error): SubscriptionError {
+        return new SubscriptionError(message, 'RESTORE_FAILED', cause);
     }
 
-    static networkError(message: string = 'Network error'): SubscriptionError {
-        return new SubscriptionError(message, 'NETWORK_ERROR');
+    static networkError(message: string = 'Network error', cause?: Error): SubscriptionError {
+        return new SubscriptionError(message, 'NETWORK_ERROR', cause);
     }
 }
 
-export class SubscriptionRepositoryError extends Error {
-    public readonly code: string;
-
-    constructor(message: string, code: string = 'REPOSITORY_ERROR') {
-        super(message);
+export class SubscriptionRepositoryError extends BaseError {
+    constructor(message: string, code: string = 'REPOSITORY_ERROR', cause?: Error) {
+        super(message, code, cause);
         this.name = 'SubscriptionRepositoryError';
-        this.code = code;
-        Object.setPrototypeOf(this, SubscriptionRepositoryError.prototype);
     }
 }
 
-export class SubscriptionValidationError extends Error {
-    public readonly code: string;
-
-    constructor(message: string, code: string = 'VALIDATION_ERROR') {
-        super(message);
+export class SubscriptionValidationError extends BaseError {
+    constructor(message: string, code: string = 'VALIDATION_ERROR', cause?: Error) {
+        super(message, code, cause);
         this.name = 'SubscriptionValidationError';
-        this.code = code;
-        Object.setPrototypeOf(this, SubscriptionValidationError.prototype);
     }
 }

package/src/utils/packageTypeDetector.ts

@@ -54,9 +54,5 @@ export function detectPackageType(productIdentifier: string): SubscriptionPackag
       return PACKAGE_TYPE.LIFETIME;
   }
 
-  if (__DEV__ && productIdentifier !== 'no_subscription') {
-    console.warn("[PackageTypeDetector] Unknown package type for:", productIdentifier);
-  }
-
   return PACKAGE_TYPE.UNKNOWN;
 }