@umituz/react-native-ai-generation-content 1.65.10 → 1.65.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.65.10",
+  "version": "1.65.12",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/domains/creations/infrastructure/repositories/CreationsFetcher.ts

@@ -1,155 +1,53 @@
-import { getDocs, getDoc, query, orderBy, onSnapshot, where } from "firebase/firestore";
 import { type FirestorePathResolver } from "@umituz/react-native-firebase";
 import type { DocumentMapper } from "../../domain/value-objects/CreationsConfig";
-import type { Creation, CreationDocument } from "../../domain/entities/Creation";
+import type { Creation } from "../../domain/entities/Creation";
 import type { CreationsSubscriptionCallback, UnsubscribeFunction } from "../../domain/repositories/ICreationsRepository";
-import { CREATION_FIELDS } from "../../domain/constants";
-
-declare const __DEV__: boolean;
+import { CreationsQuery } from "./CreationsQuery";
+import { CreationsSubscription } from "./CreationsSubscription";
 
 /**
- * Handles fetching creations from Firestore
- * Single Responsibility: Read operations
+ * CreationsFetcher
+ * Orchestrates read operations for creations
+ * Delegates to specialized classes for queries and subscriptions
+ *
+ * Architecture: Facade pattern
+ * - Query operations → CreationsQuery
+ * - Subscription operations → CreationsSubscription
  */
 export class CreationsFetcher {
+    private readonly query: CreationsQuery;
+    private readonly subscription: CreationsSubscription;
+
     constructor(
-        private readonly pathResolver: FirestorePathResolver,
-        private readonly documentMapper: DocumentMapper,
-    ) { }
+        pathResolver: FirestorePathResolver,
+        documentMapper: DocumentMapper,
+    ) {
+        this.query = new CreationsQuery(pathResolver, documentMapper);
+        this.subscription = new CreationsSubscription(pathResolver, documentMapper);
+    }
 
+    /**
+     * Get all creations for a user
+     */
     async getAll(userId: string): Promise<Creation[]> {
-        const userCollection = this.pathResolver.getUserCollection(userId);
-        if (!userCollection) return [];
-
-        try {
-            // Optimized query: Server-side filtering for non-deleted items
-            // Requires composite index: (deletedAt ASC, createdAt DESC)
-            const q = query(
-                userCollection,
-                where(CREATION_FIELDS.DELETED_AT, "==", null),
-                orderBy(CREATION_FIELDS.CREATED_AT, "desc")
-            );
-            const snapshot = await getDocs(q);
-
-            // Map documents to domain entities
-            // No client-side filtering needed - server already filtered deleted items
-            const creations = snapshot.docs.map((docSnap) => {
-                const data = docSnap.data() as CreationDocument;
-                return this.documentMapper(docSnap.id, data);
-            });
-
-            if (__DEV__) {
-                console.log("[CreationsFetcher] Fetched creations:", {
-                    count: creations.length,
-                    hasDeletedFilter: true,
-                });
-            }
-
-            return creations;
-        } catch (error) {
-            if (__DEV__) {
-                console.error("[CreationsFetcher] getAll() error:", error);
-            }
-            return [];
-        }
+        return this.query.getAll(userId);
     }
 
+    /**
+     * Get a single creation by ID
+     */
     async getById(userId: string, id: string): Promise<Creation | null> {
-        const docRef = this.pathResolver.getDocRef(userId, id);
-        if (!docRef) return null;
-
-        try {
-            const docSnap = await getDoc(docRef);
-
-            if (!docSnap.exists()) {
-                return null;
-            }
-
-            const data = docSnap.data() as CreationDocument;
-            return this.documentMapper(docSnap.id, data);
-        } catch (error) {
-            if (__DEV__) {
-                console.error("[CreationsFetcher] getById() error:", error);
-            }
-            return null;
-        }
+        return this.query.getById(userId, id);
     }
 
     /**
-     * Subscribes to realtime updates for user's creations
-     *
-     * PERFORMANCE OPTIMIZATION:
-     * - Server-side filtering with where clause (80% data reduction)
-     * - No client-side filtering needed
-     * - Requires Firestore composite index: (deletedAt ASC, createdAt DESC)
-     *
-     * @param userId - User ID to query
-     * @param onData - Callback for data updates
-     * @param onError - Optional error callback
-     * @returns Unsubscribe function
+     * Subscribe to realtime updates for user's creations
      */
     subscribeToAll(
         userId: string,
         onData: CreationsSubscriptionCallback,
         onError?: (error: Error) => void,
     ): UnsubscribeFunction {
-        const userCollection = this.pathResolver.getUserCollection(userId);
-        if (!userCollection) {
-            const error = new Error(`[CreationsFetcher] Cannot subscribe: Invalid user collection for userId: ${userId}`);
-            if (__DEV__) {
-                console.error(error.message);
-            }
-            // Return empty array immediately
-            onData([]);
-            // Report error to callback
-            onError?.(error);
-            // Return no-op unsubscribe function (no listener was created)
-            return () => {
-                if (__DEV__) {
-                    console.log("[CreationsFetcher] No-op unsubscribe called (no listener was created)");
-                }
-            };
-        }
-
-        // Optimized query with server-side filtering
-        // This prevents downloading deleted items entirely
-        const q = query(
-            userCollection,
-            where(CREATION_FIELDS.DELETED_AT, "==", null),
-            orderBy(CREATION_FIELDS.CREATED_AT, "desc")
-        );
-
-        return onSnapshot(
-            q,
-            { includeMetadataChanges: false }, // Ignore metadata-only changes for performance
-            (snapshot) => {
-                // Map documents to domain entities
-                // Server already filtered - no client filtering needed
-                const creations = snapshot.docs.map((docSnap) => {
-                    const data = docSnap.data() as CreationDocument;
-                    return this.documentMapper(docSnap.id, data);
-                });
-
-                if (__DEV__) {
-                    console.log("[CreationsFetcher] Realtime sync:", {
-                        count: creations.length,
-                        serverFiltered: true,
-                        hasChanges: snapshot.docChanges().length,
-                    });
-                }
-
-                onData(creations);
-            },
-            (error: Error) => {
-                if (__DEV__) {
-                    console.error("[CreationsFetcher] Realtime subscription error:", {
-                        error: error.message,
-                        code: (error as { code?: string }).code,
-                        userId,
-                    });
-                }
-                onError?.(error);
-            },
-        );
+        return this.subscription.subscribeToAll(userId, onData, onError);
     }
 }

package/src/domains/creations/infrastructure/repositories/CreationsQuery.ts

@@ -0,0 +1,84 @@
+/**
+ * CreationsQuery
+ * Handles read operations (getAll, getById) for creations
+ * Single Responsibility: Firestore query operations
+ */
+
+import { getDocs, getDoc, query, orderBy, where } from "firebase/firestore";
+import { type FirestorePathResolver } from "@umituz/react-native-firebase";
+import type { DocumentMapper } from "../../domain/value-objects/CreationsConfig";
+import type { Creation, CreationDocument } from "../../domain/entities/Creation";
+import { CREATION_FIELDS } from "../../domain/constants";
+
+declare const __DEV__: boolean;
+
+/**
+ * Handles query operations for creations
+ */
+export class CreationsQuery {
+    constructor(
+        private readonly pathResolver: FirestorePathResolver,
+        private readonly documentMapper: DocumentMapper,
+    ) { }
+
+    /**
+     * Get all creations for a user
+     * Optimized query: Server-side filtering for non-deleted items
+     */
+    async getAll(userId: string): Promise<Creation[]> {
+        const userCollection = this.pathResolver.getUserCollection(userId);
+        if (!userCollection) return [];
+
+        try {
+            const q = query(
+                userCollection,
+                where(CREATION_FIELDS.DELETED_AT, "==", null),
+                orderBy(CREATION_FIELDS.CREATED_AT, "desc")
+            );
+            const snapshot = await getDocs(q);
+
+            const creations = snapshot.docs.map((docSnap) => {
+                const data = docSnap.data() as CreationDocument;
+                return this.documentMapper(docSnap.id, data);
+            });
+
+            if (__DEV__) {
+                console.log("[CreationsQuery] Fetched creations:", {
+                    count: creations.length,
+                    hasDeletedFilter: true,
+                });
+            }
+
+            return creations;
+        } catch (error) {
+            if (__DEV__) {
+                console.error("[CreationsQuery] getAll() error:", error);
+            }
+            return [];
+        }
+    }
+
+    /**
+     * Get a single creation by ID
+     */
+    async getById(userId: string, id: string): Promise<Creation | null> {
+        const docRef = this.pathResolver.getDocRef(userId, id);
+        if (!docRef) return null;
+
+        try {
+            const docSnap = await getDoc(docRef);
+
+            if (!docSnap.exists()) {
+                return null;
+            }
+
+            const data = docSnap.data() as CreationDocument;
+            return this.documentMapper(docSnap.id, data);
+        } catch (error) {
+            if (__DEV__) {
+                console.error("[CreationsQuery] getById() error:", error);
+            }
+            return null;
+        }
+    }
+}

package/src/domains/creations/infrastructure/repositories/CreationsRepository.ts

@@ -45,8 +45,8 @@ export class CreationsRepository
 
     const documentMapper = options?.documentMapper ?? mapDocumentToCreation;
 
-    // Initialize with default database (will be resolved by FirestorePathResolver)
-    this.pathResolver = new FirestorePathResolver(collectionName, null);
+    // Initialize with Firestore database instance from BaseRepository
+    this.pathResolver = new FirestorePathResolver(collectionName, this.getDb());
     this.fetcher = new CreationsFetcher(this.pathResolver, documentMapper);
     this.writer = new CreationsWriter(this.pathResolver);
   }

package/src/domains/creations/infrastructure/repositories/CreationsSubscription.ts

@@ -0,0 +1,125 @@
+/**
+ * CreationsSubscription
+ * Handles realtime subscription operations for creations
+ * Single Responsibility: Firestore realtime listeners
+ */
+
+import { query, orderBy, onSnapshot, where } from "firebase/firestore";
+import { type FirestorePathResolver } from "@umituz/react-native-firebase";
+import type { DocumentMapper } from "../../domain/value-objects/CreationsConfig";
+import type { Creation, CreationDocument } from "../../domain/entities/Creation";
+import type { CreationsSubscriptionCallback, UnsubscribeFunction } from "../../domain/repositories/ICreationsRepository";
+import { CREATION_FIELDS } from "../../domain/constants";
+
+declare const __DEV__: boolean;
+
+/**
+ * Handles realtime subscriptions for creations
+ */
+export class CreationsSubscription {
+    constructor(
+        private readonly pathResolver: FirestorePathResolver,
+        private readonly documentMapper: DocumentMapper,
+    ) { }
+
+    /**
+     * Subscribes to realtime updates for user's creations
+     *
+     * PERFORMANCE OPTIMIZATION:
+     * - Server-side filtering with where clause (80% data reduction)
+     * - No client-side filtering needed
+     * - Requires Firestore composite index: (deletedAt ASC, createdAt DESC)
+     *
+     * @param userId - User ID to query
+     * @param onData - Callback for data updates
+     * @param onError - Optional error callback
+     * @returns Unsubscribe function
+     */
+    subscribeToAll(
+        userId: string,
+        onData: CreationsSubscriptionCallback,
+        onError?: (error: Error) => void,
+    ): UnsubscribeFunction {
+        const userCollection = this.pathResolver.getUserCollection(userId);
+
+        if (!userCollection) {
+            return this.handleInvalidCollection(userId, onData, onError);
+        }
+
+        return this.createRealtimeListener(userCollection, onData, onError);
+    }
+
+    /**
+     * Handles case when user collection is invalid
+     */
+    private handleInvalidCollection(
+        userId: string,
+        onData: CreationsSubscriptionCallback,
+        onError?: (error: Error) => void,
+    ): UnsubscribeFunction {
+        const error = new Error(`[CreationsSubscription] Cannot subscribe: Invalid user collection for userId: ${userId}`);
+
+        if (__DEV__) {
+            console.error(error.message);
+        }
+
+        // Return empty array immediately
+        onData([]);
+
+        // Report error to callback
+        onError?.(error);
+
+        // Return no-op unsubscribe function
+        return () => {
+            if (__DEV__) {
+                console.log("[CreationsSubscription] No-op unsubscribe called (no listener was created)");
+            }
+        };
+    }
+
+    /**
+     * Creates the realtime listener with optimized query
+     */
+    private createRealtimeListener(
+        userCollection: any,
+        onData: CreationsSubscriptionCallback,
+        onError?: (error: Error) => void,
+    ): UnsubscribeFunction {
+        const q = query(
+            userCollection,
+            where(CREATION_FIELDS.DELETED_AT, "==", null),
+            orderBy(CREATION_FIELDS.CREATED_AT, "desc")
+        );
+
+        return onSnapshot(
+            q,
+            { includeMetadataChanges: false },
+            (snapshot) => {
+                const creations = snapshot.docs.map((docSnap) => {
+                    const data = docSnap.data() as CreationDocument;
+                    return this.documentMapper(docSnap.id, data);
+                });
+
+                if (__DEV__) {
+                    console.log("[CreationsSubscription] Realtime sync:", {
+                        count: creations.length,
+                        serverFiltered: true,
+                        hasChanges: snapshot.docChanges().length,
+                    });
+                }
+
+                onData(creations);
+            },
+            (error: Error) => {
+                if (__DEV__) {
+                    console.error("[CreationsSubscription] Realtime subscription error:", {
+                        error: error.message,
+                        code: (error as { code?: string }).code,
+                        userId,
+                    });
+                }
+                onError?.(error);
+            },
+        );
+    }
+}