create-stackr 0.2.0

package/templates/integrations/mobile/att/services/attService.ts

@@ -0,0 +1,84 @@
+import { trackingPermissions, TrackingPermissionResult } from './trackingPermissions';
+import { logger } from '../utils/logger';
+
+class ATTService {
+  /**
+   * Initialize ATT permissions service
+   */
+  async initialize(): Promise<TrackingPermissionResult> {
+    try {
+      logger.debug('ATTService: Initializing ATT permissions');
+      const result = await trackingPermissions.initialize();
+      logger.debug('ATTService: ATT permissions initialized', {
+        status: result.status,
+        canTrack: result.canTrack
+      });
+      return result;
+    } catch (error) {
+      logger.error('ATTService: Failed to initialize ATT permissions', { error });
+      throw error;
+    }
+  }
+
+  /**
+   * Request ATT permissions from user
+   */
+  async requestPermissions(): Promise<TrackingPermissionResult> {
+    try {
+      logger.debug('ATTService: Requesting ATT permissions');
+      const result = await trackingPermissions.requestPermissions();
+      logger.debug('ATTService: ATT permissions request completed', {
+        status: result.status,
+        canTrack: result.canTrack
+      });
+      return result;
+    } catch (error) {
+      logger.error('ATTService: Failed to request ATT permissions', { error });
+      throw error;
+    }
+  }
+
+  /**
+   * Get current permission status
+   */
+  getCurrentStatus() {
+    return trackingPermissions.currentStatus;
+  }
+
+  /**
+   * Check if tracking is supported on this platform
+   */
+  isTrackingSupported(): boolean {
+    return trackingPermissions.isTrackingSupported;
+  }
+
+  /**
+   * Check if user can be tracked
+   */
+  canTrack(): boolean {
+    return trackingPermissions.canTrack;
+  }
+
+  /**
+   * Get advertising ID if available
+   */
+  async getAdvertisingId(): Promise<string | null> {
+    try {
+      return await trackingPermissions.getAdvertisingId();
+    } catch (error) {
+      logger.error('ATTService: Failed to get advertising ID', { error });
+      return null;
+    }
+  }
+
+  /**
+   * Reset ATT service state
+   */
+  reset(): void {
+    trackingPermissions.reset();
+    logger.debug('ATTService: Service reset');
+  }
+}
+
+// Export singleton instance
+export const attService = new ATTService();

package/templates/integrations/mobile/att/services/trackingPermissions.ts

@@ -0,0 +1,208 @@
+import * as TrackingTransparency from 'expo-tracking-transparency';
+import { logger } from '../utils/logger';
+
+export enum TrackingStatus {
+  NOT_DETERMINED = 'not-determined',
+  RESTRICTED = 'restricted', 
+  DENIED = 'denied',
+  GRANTED = 'granted',
+  UNSUPPORTED = 'unsupported' // For non-iOS platforms
+}
+
+export interface TrackingPermissionResult {
+  status: TrackingStatus;
+  canTrack: boolean;
+  advertisingId?: string;
+}
+
+class TrackingPermissionsService {
+  private _currentStatus: TrackingStatus = TrackingStatus.NOT_DETERMINED;
+  private _isInitialized: boolean = false;
+
+  /**
+   * Get current tracking permission status
+   */
+  get currentStatus(): TrackingStatus {
+    return this._currentStatus;
+  }
+
+  /**
+   * Check if tracking is supported on this platform
+   */
+  get isTrackingSupported(): boolean {
+    return TrackingTransparency.isAvailable();
+  }
+
+  /**
+   * Check if user can be tracked
+   */
+  get canTrack(): boolean {
+    return this._currentStatus === TrackingStatus.GRANTED;
+  }
+
+  /**
+   * Initialize the service and get current permission status
+   */
+  async initialize(): Promise<TrackingPermissionResult> {
+    logger.debug('TrackingPermissions: Initializing...');
+
+    if (!this.isTrackingSupported) {
+      logger.info('TrackingPermissions: ATT not available on this platform/version');
+      this._currentStatus = TrackingStatus.UNSUPPORTED;
+      this._isInitialized = true;
+      return {
+        status: this._currentStatus,
+        canTrack: true // Allow tracking when ATT is not required
+      };
+    }
+
+    try {
+      // Get current permissions without requesting
+      const { status } = await TrackingTransparency.getTrackingPermissionsAsync();
+      this._currentStatus = this._mapExpoStatusToOurStatus(status);
+      this._isInitialized = true;
+
+      logger.debug('TrackingPermissions: Current status retrieved', {
+        status: this._currentStatus,
+        canTrack: this.canTrack
+      });
+
+      return await this._buildResult();
+    } catch (error) {
+      logger.error('TrackingPermissions: Failed to get current status', { error });
+      this._currentStatus = TrackingStatus.NOT_DETERMINED;
+      this._isInitialized = true;
+      return {
+        status: this._currentStatus,
+        canTrack: false
+      };
+    }
+  }
+
+  /**
+   * Request tracking permissions from the user
+   */
+  async requestPermissions(): Promise<TrackingPermissionResult> {
+    logger.debug('TrackingPermissions: Requesting permissions...');
+
+    if (!this.isTrackingSupported) {
+      logger.info('TrackingPermissions: ATT not available, returning unsupported');
+      return {
+        status: TrackingStatus.UNSUPPORTED,
+        canTrack: true
+      };
+    }
+
+    try {
+      // Check current status first
+      if (!this._isInitialized) {
+        await this.initialize();
+      }
+
+      // If already determined, don't request again
+      if (this._currentStatus === TrackingStatus.GRANTED ||
+          this._currentStatus === TrackingStatus.DENIED ||
+          this._currentStatus === TrackingStatus.RESTRICTED) {
+        logger.info('TrackingPermissions: Status already determined', {
+          status: this._currentStatus
+        });
+        return await this._buildResult();
+      }
+
+      // Request permissions
+      const { status } = await TrackingTransparency.requestTrackingPermissionsAsync();
+      this._currentStatus = this._mapExpoStatusToOurStatus(status);
+
+      logger.debug('TrackingPermissions: Permission request completed', {
+        status: this._currentStatus,
+        canTrack: this.canTrack
+      });
+
+      return await this._buildResult();
+    } catch (error) {
+      logger.error('TrackingPermissions: Failed to request permissions', { error });
+      this._currentStatus = TrackingStatus.DENIED;
+      return {
+        status: this._currentStatus,
+        canTrack: false
+      };
+    }
+  }
+
+  /**
+   * Get advertising ID if tracking is allowed
+   */
+  async getAdvertisingId(): Promise<string | null> {
+    if (!this.isTrackingSupported) {
+      logger.info('TrackingPermissions: ATT not available, cannot get advertising ID from this API');
+      return null; // Let Adjust SDK handle ADID when ATT is not available
+    }
+
+    if (!this.canTrack) {
+      logger.info('TrackingPermissions: Cannot get advertising ID - tracking not granted');
+      return null;
+    }
+
+    try {
+      const advertisingId = TrackingTransparency.getAdvertisingId();
+      logger.info('TrackingPermissions: Retrieved advertising ID', {
+        hasId: !!advertisingId
+      });
+      return advertisingId;
+    } catch (error) {
+      logger.error('TrackingPermissions: Failed to get advertising ID', { error });
+      return null;
+    }
+  }
+
+  /**
+   * Reset the service state (useful for testing)
+   */
+  reset(): void {
+    this._currentStatus = TrackingStatus.NOT_DETERMINED;
+    this._isInitialized = false;
+    logger.debug('TrackingPermissions: Service reset');
+  }
+
+  /**
+   * Map Expo's tracking status to our internal status
+   */
+  private _mapExpoStatusToOurStatus(expoStatus: string): TrackingStatus {
+    switch (expoStatus) {
+      case 'granted':
+        return TrackingStatus.GRANTED;
+      case 'denied':
+        return TrackingStatus.DENIED;
+      case 'restricted':
+        return TrackingStatus.RESTRICTED;
+      case 'not-determined':
+      case 'undetermined': // Handle both possible values
+      default:
+        return TrackingStatus.NOT_DETERMINED;
+    }
+  }
+
+  /**
+   * Build a complete result object
+   */
+  private async _buildResult(): Promise<TrackingPermissionResult> {
+    const result: TrackingPermissionResult = {
+      status: this._currentStatus,
+      canTrack: this.canTrack
+    };
+
+    // Try to get advertising ID if tracking is allowed
+    if (this.canTrack && this.isTrackingSupported) {
+      try {
+        result.advertisingId = (await this.getAdvertisingId()) || undefined;
+      } catch (error) {
+        logger.error('TrackingPermissions: Failed to get advertising ID for result', { error });
+      }
+    }
+
+    return result;
+  }
+}
+
+// Export singleton instance
+export const trackingPermissions = new TrackingPermissionsService();

package/templates/integrations/mobile/att/store/att.store.ts

@@ -0,0 +1,162 @@
+import { create } from 'zustand';
+import { attService } from '../services/attService';
+import { TrackingStatus, TrackingPermissionResult } from '../services/trackingPermissions';
+import { logger } from '../utils/logger';
+
+interface ATTState {
+  // State
+  permissionStatus: TrackingStatus;
+  isPermissionRequested: boolean;
+  isLoading: boolean;
+  error: string | null;
+
+  // Actions
+  initialize: () => Promise<void>;
+  requestPermissions: () => Promise<TrackingPermissionResult>;
+  setLoading: (loading: boolean) => void;
+  setError: (error: string | null) => void;
+  reset: () => void;
+
+  // Computed values
+  canTrack: boolean;
+  isTrackingSupported: boolean;
+}
+
+export const useATTStore = create<ATTState>((set, get) => ({
+  // Initial state
+  permissionStatus: TrackingStatus.NOT_DETERMINED,
+  isPermissionRequested: false,
+  isLoading: false,
+  error: null,
+
+  // Actions
+  initialize: async () => {
+    const state = get();
+    if (state.isLoading) {
+      logger.info('ATTStore: Already initializing, skipping');
+      return;
+    }
+
+    try {
+      set({ isLoading: true, error: null });
+      logger.info('ATTStore: Initializing ATT permissions...');
+
+      const result = await attService.initialize();
+      
+      set({
+        permissionStatus: result.status,
+        isLoading: false,
+        error: null
+      });
+
+      logger.info('ATTStore: ATT permissions initialized', { 
+        status: result.status,
+        canTrack: result.canTrack 
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to initialize ATT permissions';
+      logger.error('ATTStore: Failed to initialize ATT permissions', { error });
+      set({
+        error: errorMessage,
+        isLoading: false,
+        permissionStatus: TrackingStatus.DENIED
+      });
+    }
+  },
+
+  requestPermissions: async () => {
+    const state = get();
+    if (state.isLoading) {
+      logger.info('ATTStore: Permission request already in progress');
+      return { status: state.permissionStatus, canTrack: state.canTrack };
+    }
+
+    try {
+      set({ isLoading: true, error: null });
+      logger.info('ATTStore: Requesting ATT permissions...');
+
+      const result = await attService.requestPermissions();
+      
+      set({
+        permissionStatus: result.status,
+        isPermissionRequested: true,
+        isLoading: false,
+        error: null
+      });
+
+      logger.info('ATTStore: ATT permissions requested', { 
+        status: result.status,
+        canTrack: result.canTrack 
+      });
+
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to request ATT permissions';
+      logger.error('ATTStore: Failed to request ATT permissions', { error });
+      
+      const result = {
+        status: TrackingStatus.DENIED,
+        canTrack: false
+      };
+
+      set({
+        error: errorMessage,
+        isLoading: false,
+        permissionStatus: TrackingStatus.DENIED,
+        isPermissionRequested: true
+      });
+
+      return result;
+    }
+  },
+
+  setLoading: (isLoading) => set({ isLoading }),
+  
+  setError: (error) => set({ error }),
+
+  reset: () => {
+    set({
+      permissionStatus: TrackingStatus.NOT_DETERMINED,
+      isPermissionRequested: false,
+      isLoading: false,
+      error: null
+    });
+    attService.reset();
+    logger.info('ATTStore: Store reset');
+  },
+
+  // Computed values
+  get canTrack() {
+    const state = get();
+    return state.permissionStatus === TrackingStatus.GRANTED || 
+           state.permissionStatus === TrackingStatus.UNSUPPORTED;
+  },
+
+  get isTrackingSupported() {
+    return attService.isTrackingSupported();
+  },
+}));
+
+// Selectors for commonly used ATT state
+export const useATT = () => {
+  const state = useATTStore();
+  return {
+    permissionStatus: state.permissionStatus,
+    isPermissionRequested: state.isPermissionRequested,
+    isLoading: state.isLoading,
+    error: state.error,
+    canTrack: state.canTrack,
+    isTrackingSupported: state.isTrackingSupported,
+  };
+};
+
+export const useATTActions = () => {
+  const state = useATTStore();
+  return {
+    initialize: state.initialize,
+    requestPermissions: state.requestPermissions,
+    setLoading: state.setLoading,
+    setError: state.setError,
+    reset: state.reset,
+  };
+};

package/templates/integrations/mobile/revenuecat/services/revenuecatService.ts.ejs

@@ -0,0 +1,174 @@
+import { Platform } from 'react-native';
+import Purchases, { CustomerInfo, PurchasesPackage, PurchasesOfferings } from 'react-native-purchases';
+import Constants from 'expo-constants';
+import { logger } from '../utils/logger';
+
+class RevenueCatService {
+  private static readonly IOS_API_KEY = Constants.expoConfig?.extra?.revenueCat?.iosKey || '';
+  private static readonly ANDROID_API_KEY = Constants.expoConfig?.extra?.revenueCat?.androidKey || '';
+
+  private _isInitialized: boolean = false;
+
+  /**
+   * Check if RevenueCat is initialized
+   */
+  get isInitialized(): boolean {
+    return this._isInitialized;
+  }
+
+  /**
+   * Initialize RevenueCat SDK
+   */
+  initialize(): void {
+    if (this._isInitialized) {
+      logger.info('RevenueCatService: Already initialized, skipping');
+      return;
+    }
+
+    try {
+      logger.info('RevenueCatService: Initializing RevenueCat...');
+      
+      // Set log level for debugging
+      Purchases.setLogLevel(Purchases.LOG_LEVEL.DEBUG);
+
+      // Configure with platform-specific API key
+      if (Platform.OS === 'ios') {
+        Purchases.configure({ apiKey: RevenueCatService.IOS_API_KEY });
+      } else if (Platform.OS === 'android') {
+        Purchases.configure({ apiKey: RevenueCatService.ANDROID_API_KEY });
+      }
+
+      this._isInitialized = true;
+      logger.info('RevenueCatService: RevenueCat initialized successfully');
+    } catch (error) {
+      logger.error('RevenueCatService: Failed to initialize RevenueCat', { error });
+      throw error;
+    }
+  }
+
+  /**
+   * Set Adjust ID for attribution
+   */
+  setAdjustId(adjustId: string): void {
+    try {
+      logger.info('RevenueCatService: Setting Adjust ID', { adjustId });
+      Purchases.setAdjustID(adjustId);
+      logger.info('RevenueCatService: Adjust ID set successfully');
+    } catch (error) {
+      logger.error('RevenueCatService: Failed to set Adjust ID', { error });
+      throw error;
+    }
+  }
+
+  /**
+   * Get customer info
+   */
+  async getCustomerInfo(): Promise<CustomerInfo> {
+    try {
+      logger.info('RevenueCatService: Getting customer info');
+      const customerInfo = await Purchases.getCustomerInfo();
+      logger.info('RevenueCatService: Customer info retrieved successfully');
+      return customerInfo;
+    } catch (error) {
+      logger.error('RevenueCatService: Failed to get customer info', { error });
+      throw error;
+    }
+  }
+
+  /**
+   * Get available offerings
+   */
+  async getOfferings(): Promise<PurchasesOfferings> {
+    try {
+      logger.info('RevenueCatService: Getting offerings');
+      const offerings = await Purchases.getOfferings();
+      logger.info('RevenueCatService: Offerings retrieved successfully', {
+        offeringsCount: Object.keys(offerings.all).length,
+        hasCurrent: !!offerings.current,
+      });
+      return offerings;
+    } catch (error) {
+      logger.error('RevenueCatService: Failed to get offerings', { error });
+      throw error;
+    }
+  }
+
+  /**
+   * Purchase a package
+   */
+  async purchasePackage(pkg: PurchasesPackage): Promise<{
+    customerInfo: CustomerInfo;
+    userCancelled: boolean;
+  }> {
+    try {
+      logger.info('RevenueCatService: Purchasing package', { packageId: pkg.identifier });
+      const result = await Purchases.purchasePackage(pkg);
+      logger.info('RevenueCatService: Package purchased successfully');
+      return { ...result, userCancelled: false };
+    } catch (error: any) {
+      if (error.userCancelled) {
+        logger.info('RevenueCatService: Purchase cancelled by user');
+        return { 
+          customerInfo: await this.getCustomerInfo(), 
+          userCancelled: true 
+        };
+      }
+      logger.error('RevenueCatService: Failed to purchase package', { error });
+      throw error;
+    }
+  }
+
+  /**
+   * Restore purchases
+   */
+  async restorePurchases(): Promise<CustomerInfo> {
+    try {
+      logger.info('RevenueCatService: Restoring purchases');
+      const customerInfo = await Purchases.restorePurchases();
+      logger.info('RevenueCatService: Purchases restored successfully');
+      return customerInfo;
+    } catch (error) {
+      logger.error('RevenueCatService: Failed to restore purchases', { error });
+      throw error;
+    }
+  }
+
+  /**
+   * Check if user has active entitlement
+   */
+  hasActiveEntitlement(customerInfo: CustomerInfo, entitlementId: string): boolean {
+    return customerInfo.entitlements.active[entitlementId] !== undefined;
+  }
+
+  /**
+   * Get entitlement info
+   */
+  getEntitlementInfo(customerInfo: CustomerInfo, entitlementId: string) {
+    return customerInfo.entitlements.active[entitlementId];
+  }
+
+  /**
+   * Add customer info update listener
+   */
+  addCustomerInfoUpdateListener(callback: (customerInfo: CustomerInfo) => void): void {
+    Purchases.addCustomerInfoUpdateListener(callback);
+  }
+
+  /**
+   * Remove customer info update listener
+   */
+  removeCustomerInfoUpdateListener(callback: (customerInfo: CustomerInfo) => void): void {
+    Purchases.removeCustomerInfoUpdateListener(callback);
+  }
+
+  /**
+   * Reset RevenueCat state (useful for testing)
+   */
+  reset(): void {
+    this._isInitialized = false;
+    logger.info('RevenueCatService: Service reset');
+  }
+}
+
+// Export singleton instance
+export const revenueCatService = new RevenueCatService();