@umituz/react-native-subscription 2.14.99 → 2.14.101

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.14.99",
+  "version": "2.14.101",
   "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -32,9 +32,9 @@
     "url": "git+https://github.com/umituz/react-native-subscription.git"
   },
   "dependencies": {
+    "@umituz/react-native-design-system": "latest",
     "@umituz/react-native-firebase": "latest",
-    "@umituz/react-native-storage": "latest",
-    "@umituz/react-native-timezone": "latest"
+    "@umituz/react-native-storage": "latest"
   },
   "peerDependencies": {
     "@tanstack/react-query": ">=5.0.0",

package/src/application/README.md

@@ -2,228 +2,49 @@
 
 Abonelik uygulamasının iş mantığını ve servis kontratlarını içeren katman.
 
-## Sorumluluklar
-
-- **Service Contracts**: Servis arayüzlerini tanımlama
-- **Use Cases**: İş kullanım durumlarını gerçekleştirme
-- **Business Logic**: Uygulama kurallarını yönetme
-
-## Yapı
-
-```
-application/
-├── ports/
-│   ├── ISubscriptionService.ts    # Subscription servisi kontratı
-│   └── ISubscriptionRepository.ts # Repository kontratı
-└── [future use cases]
-```
-
-## Port Interfaces
-
-### ISubscriptionService
-
-Abonelik servisi için ana kontrat:
-
-```typescript
-interface ISubscriptionService {
-  getStatus(userId: string): Promise<SubscriptionStatus | null>;
-  activateSubscription(
-    userId: string,
-    productId: string,
-    expiresAt: string | null
-  ): Promise<SubscriptionStatus>;
-  deactivateSubscription(userId: string): Promise<SubscriptionStatus>;
-  isPremium(userId: string): Promise<boolean>;
-}
-```
-
-**Kullanım:**
-
-```typescript
-import type { ISubscriptionService } from '@umituz/react-native-subscription';
-
-class MyService {
-  constructor(private subscriptionService: ISubscriptionService) {}
-
-  async checkUserAccess(userId: string) {
-    const isPremium = await this.subscriptionService.isPremium(userId);
-    return isPremium;
-  }
-}
-```
-
-### ISubscriptionRepository
-
-Abonelik verisi erişimi için kontrat:
-
-```typescript
-interface ISubscriptionRepository {
-  getSubscriptionStatus(userId: string): Promise<SubscriptionStatus | null>;
-  saveSubscriptionStatus(
-    userId: string,
-    status: SubscriptionStatus
-  ): Promise<void>;
-  deleteSubscriptionStatus(userId: string): Promise<void>;
-  isSubscriptionValid(status: SubscriptionStatus): boolean;
-}
-```
-
-**Kullanım:**
-
-```typescript
-import type { ISubscriptionRepository } from '@umituz/react-native-subscription';
-
-class FirebaseRepository implements ISubscriptionRepository {
-  async getSubscriptionStatus(userId: string) {
-    // Firebase'den abonelik durumu getir
-    const doc = await firestore().collection('subscriptions').doc(userId).get();
-    return doc.data();
-  }
-
-  async saveSubscriptionStatus(userId: string, status: SubscriptionStatus) {
-    // Firebase'e abonelik durumu kaydet
-    await firestore().collection('subscriptions').doc(userId).set(status);
-  }
-
-  isSubscriptionValid(status: SubscriptionStatus): boolean {
-    // Abonelik geçerliliğini kontrol et
-    return status.isActive && !isExpired(status.expirationDate);
-  }
-}
-```
-
-## Dependency Injection
-
-Application layer bağımlılıkları dependency injection ile alır:
-
-```typescript
-import { SubscriptionService } from '@umituz/react-native-subscription';
-
-const subscriptionService = new SubscriptionService({
-  repository: myRepository,
-  onStatusChanged: (userId, newStatus) => {
-    console.log(`User ${userId} status changed to ${newStatus.type}`);
-  },
-  onError: (error) => {
-    console.error('Subscription error:', error);
-  },
-});
-```
-
-## Repository Implementation
-
-Kendi repository'nizi oluşturun:
-
-```typescript
-import {
-  type ISubscriptionRepository,
-  SubscriptionStatus,
-} from '@umituz/react-native-subscription';
-
-class CustomRepository implements ISubscriptionRepository {
-  constructor(private db: Database) {}
-
-  async getSubscriptionStatus(userId: string): Promise<SubscriptionStatus | null> {
-    const data = await this.db.query(
-      'SELECT * FROM subscriptions WHERE user_id = ?',
-      [userId]
-    );
-    return data ? SubscriptionStatus.parse(data) : null;
-  }
-
-  async saveSubscriptionStatus(
-    userId: string,
-    status: SubscriptionStatus
-  ): Promise<void> {
-    await this.db.execute(
-      'INSERT OR REPLACE INTO subscriptions (user_id, status, expires_at) VALUES (?, ?, ?)',
-      [userId, status.type, status.expirationDate]
-    );
-  }
-
-  async deleteSubscriptionStatus(userId: string): Promise<void> {
-    await this.db.execute(
-      'DELETE FROM subscriptions WHERE user_id = ?',
-      [userId]
-    );
-  }
-
-  isSubscriptionValid(status: SubscriptionStatus): boolean {
-    if (!status.isActive) return false;
-    if (!status.expirationDate) return true; // Lifetime
-    return new Date(status.expirationDate) > new Date();
-  }
-}
-```
-
-## Best Practices
-
-1. **Interface Segregation**: Küçük, odaklanmış interface'ler tanımlayın
-2. **Dependency Inversion**: High-level modüller low-level modüllere bağımlı olmamalı
-3. **Single Responsibility**: Her service/repository tek bir sorumluluğa sahip olmalı
-4. **Error Handling**: Hataları uygun şekilde handle edin ve yukarı传播 edin
-5. **Testing**: Interface'ler mock ile kolay test edilebilir
-
-## Örnek: Service Kullanımı
-
-```typescript
-import {
-  SubscriptionService,
-  type SubscriptionConfig,
-} from '@umituz/react-native-subscription';
-
-// Konfigürasyon
-const config: SubscriptionConfig = {
-  repository: myRepository,
-  onStatusChanged: (userId, status) => {
-    // Status değiştiğinde çalışacak callback
-    analytics.track('subscription_status_changed', {
-      userId,
-      status: status.type,
-    });
-  },
-  onError: (error) => {
-    // Hata yönetimi
-    crashlytics().recordError(error);
-  },
-};
-
-// Service oluştur
-const service = new SubscriptionService(config);
-
-// Kullan
-async function manageSubscription(userId: string) {
-  // Durumu kontrol et
-  const status = await service.getSubscriptionStatus(userId);
-  console.log('Current status:', status?.type);
-
-  // Premium kontrolü
-  const isPremium = await service.isPremium(userId);
-  if (!isPremium) {
-    // Aboneliği aktifleştir
-    await service.activateSubscription(
-      userId,
-      'com.app.premium.monthly',
-      '2025-01-01T00:00:00Z'
-    );
-  }
-
-  // Aboneliği iptal et
-  // await service.deactivateSubscription(userId);
-}
-```
-
-## Type Safety
-
-Tüm interface'ler tam tip güvenliği sağlar:
-
-```typescript
-// ✓ Type-safe
-const status: SubscriptionStatus = await service.getStatus(userId);
-
-// ✗ Compile error
-const wrong = await service.getStatus(123);
-
-// ✓ Type-safe repository
-const repository: ISubscriptionRepository = new MyRepository();
-```
+## Location
+
+`src/application/`
+
+## Strategy
+
+Ortak kullanım durumlarını gerçekleştiren, servis kontratlarını tanımlayan ve uygulama kurallarını yöneten katman. Dependency injection ve test edilebilirlik sağlar.
+
+## Restrictions
+
+### REQUIRED
+
+- MUST use dependency injection pattern
+- MUST define service contracts through interfaces
+- MUST implement error handling and propagation
+- MUST ensure type safety for all operations
+- MUST support dependency inversion principle
+
+### PROHIBITED
+
+- MUST NOT contain direct infrastructure dependencies
+- MUST NOT bypass repository interfaces
+- MUST NOT leak implementation details
+- MUST NOT mix business logic with presentation
+
+### CRITICAL
+
+- Keep interfaces small and focused (Interface Segregation)
+- Maintain single responsibility for each service
+- Always handle errors appropriately and propagate upward
+- Ensure all operations are type-safe
+
+## AI Agent Guidelines
+
+When working with application layer:
+1. Interface Segregation - küçük, odaklanmış interface'ler tanımlayın
+2. Dependency Inversion - high-level modüller low-level modüllere bağımlı olmamalı
+3. Single Responsibility - her service/repository tek bir sorumluluğa sahip olmalı
+4. Error Handling - hataları uygun şekilde handle edin ve yukarı propagation edin
+5. Testing - interface'ler mock ile kolay test edilebilir
+
+## Related Documentation
+
+- [Domain Layer](../domain/README.md)
+- [Infrastructure Layer](../infrastructure/README.md)
+- [Ports](./ports/README.md)

package/src/application/ports/README.md

@@ -2,102 +2,47 @@
 
 Interfaces defining contracts between application layer and external dependencies.
 
-## Overview
-
-This directory contains port interfaces that define how the application layer interacts with external services and repositories. This enables dependency inversion and testability.
-
-## Ports
-
-### ISubscriptionService
-Port for subscription management service.
-
-```typescript
-interface ISubscriptionService {
-  getSubscriptionStatus(userId: string): Promise<SubscriptionStatus | null>;
-  activateSubscription(
-    userId: string,
-    productId: string,
-    expiresAt: string | null
-  ): Promise<SubscriptionStatus | null>;
-  deactivateSubscription(userId: string): Promise<void>;
-}
-```
-
-**Implementation:** Infrastructure services implement this interface.
-
-### ISubscriptionRepository
-Port for subscription data persistence.
-
-```typescript
-interface ISubscriptionRepository {
-  getSubscriptionStatus(userId: string): Promise<SubscriptionStatus | null>;
-  saveSubscriptionStatus(userId: string, status: SubscriptionStatus): Promise<void>;
-  deleteSubscriptionStatus(userId: string): Promise<void>;
-  isSubscriptionValid(status: SubscriptionStatus | null): boolean;
-}
-```
-
-**Implementation:** Infrastructure repositories implement this interface.
-
-### ICreditsRepository
-Port for credits data persistence.
-
-```typescript
-interface ICreditsRepository {
-  getCredits(userId: string): Promise<UserCredits | null>;
-  initializeCredits(
-    userId: string,
-    purchaseId?: string,
-    productId?: string
-  ): Promise<CreditsResult>;
-  deductCredit(userId: string, amount: number): Promise<CreditsResult>;
-  addCredits(userId: string, amount: number): Promise<CreditsResult>;
-}
-```
-
-## Usage in Application Layer
-
-```typescript
-import type { ISubscriptionService } from '../application/ports/ISubscriptionService';
-
-class SubscriptionManager {
-  constructor(private service: ISubscriptionService) {}
-
-  async manageSubscription(userId: string) {
-    // Port interface enables swapping implementations
-    const status = await this.service.getSubscriptionStatus(userId);
-    return status;
-  }
-}
-```
-
-## Testing with Mocks
-
-```typescript
-const mockService: ISubscriptionService = {
-  getSubscriptionStatus: async (userId) => ({
-    productId: 'premium',
-    isActive: true,
-    type: 'premium',
-    expirationDate: null,
-  }),
-  activateSubscription: async () => ({} as any),
-  deactivateSubscription: async () => {},
-};
-
-// Use mock in tests
-const manager = new SubscriptionManager(mockService);
-```
-
-## Best Practices
-
-1. **Interface Segregation** - Keep interfaces focused
-2. **Clear Contracts** - Document behavior thoroughly
-3. **Return Types** - Use domain entities in return types
-4. **Async Operations** - All I/O operations should be async
-
-## Related
-
-- [Application README](../README.md)
+## Location
+
+`src/application/ports/`
+
+## Strategy
+
+Port interfaces define how the application layer interacts with external services and repositories, enabling dependency inversion and testability through clear contracts.
+
+## Restrictions
+
+### REQUIRED
+
+- MUST use interface segregation (keep interfaces focused)
+- MUST document behavior thoroughly
+- MUST use domain entities in return types
+- MUST make all I/O operations async
+- MUST define clear contracts between layers
+
+### PROHIBITED
+
+- MUST NOT couple interfaces to specific implementations
+- MUST NOT include infrastructure concerns in port definitions
+- MUST NOT leak implementation details through interfaces
+
+### CRITICAL
+
+- Keep interfaces focused and segregated
+- Document all behavior thoroughly
+- Use domain entities in return types
+- Ensure all I/O operations are async
+
+## AI Agent Guidelines
+
+When working with application ports:
+1. Interface Segregation - keep interfaces focused
+2. Clear Contracts - document behavior thoroughly
+3. Return Types - use domain entities in return types
+4. Async Operations - all I/O operations should be async
+
+## Related Documentation
+
+- [Application Layer](../README.md)
 - [Infrastructure Services](../../infrastructure/services/README.md)
 - [Infrastructure Repositories](../../infrastructure/repositories/README.md)