@zs-soft/firestore-repository-engine 0.10.0

package/README.md

@@ -0,0 +1,64 @@
+# FirestoreRepositoryEngine
+
+This project was generated using [Angular CLI](https://github.com/angular/angular-cli) version 21.0.0.
+
+## Code scaffolding
+
+Angular CLI includes powerful code scaffolding tools. To generate a new component, run:
+
+```bash
+ng generate component component-name
+```
+
+For a complete list of available schematics (such as `components`, `directives`, or `pipes`), run:
+
+```bash
+ng generate --help
+```
+
+## Building
+
+To build the library, run:
+
+```bash
+ng build firestore-repository-engine
+```
+
+This command will compile your project, and the build artifacts will be placed in the `dist/` directory.
+
+### Publishing the Library
+
+Once the project is built, you can publish your library by following these steps:
+
+1. Navigate to the `dist` directory:
+
+   ```bash
+   cd dist/firestore-repository-engine
+   ```
+
+2. Run the `npm publish` command to publish your library to the npm registry:
+   ```bash
+   npm publish
+   ```
+
+## Running unit tests
+
+To execute unit tests with the [Karma](https://karma-runner.github.io) test runner, use the following command:
+
+```bash
+ng test
+```
+
+## Running end-to-end tests
+
+For end-to-end (e2e) testing, run:
+
+```bash
+ng e2e
+```
+
+Angular CLI does not come with an end-to-end testing framework by default. You can choose one that suits your needs.
+
+## Additional Resources
+
+For more information on using the Angular CLI, including detailed command references, visit the [Angular CLI Overview and Command Reference](https://angular.dev/tools/cli) page.

package/fesm2022/zs-soft-firestore-repository-engine.mjs

@@ -0,0 +1,829 @@
+import { Observable } from 'rxjs';
+import { inject, Injector, runInInjectionContext } from '@angular/core';
+import { where, orderBy, startAfter, startAt, endBefore, endAt, limit, collection, doc, query, getCountFromServer, getDocs, setDoc, deleteDoc, docData, collectionData, Firestore } from '@angular/fire/firestore';
+import { isValidSearchTerm, normalizeSearchTerm, DEFAULT_PAGE_SIZE } from '@zs-soft/common-api';
+import { RepositoryEngine, FIRESTORE_ENGINE_CREATOR } from '@zs-soft/core-api';
+
+/**
+ * Utility for Firestore text search operations
+ * Note: Firestore doesn't support full-text search natively.
+ * This implements prefix-based search using >= and < operators.
+ */
+class SearchUtil {
+    /**
+     * Validates search options
+     * Returns true if search term meets minimum length requirement
+     */
+    static isValidSearch(search) {
+        if (!search) {
+            return false;
+        }
+        return isValidSearchTerm(search.term) && search.fields.length > 0;
+    }
+    /**
+     * Build Firestore-compatible prefix search filters for a single field
+     * Uses >= term and < term + high Unicode character for prefix matching
+     *
+     * Example: searching "John" will match "John", "Johnny", "Johnson"
+     */
+    static buildPrefixSearchFilter(field, term) {
+        const normalizedTerm = normalizeSearchTerm(term);
+        const endTerm = normalizedTerm + '\uf8ff'; // High Unicode character for range end
+        return [
+            { field, operator: '>=', value: normalizedTerm },
+            { field, operator: '<', value: endTerm },
+        ];
+    }
+    /**
+     * Build search filters for the first searchable field
+     * Note: Firestore only supports range queries on a single field,
+     * so we can only search one field at a time with prefix matching
+     */
+    static buildSearchFilters(search) {
+        if (!this.isValidSearch(search)) {
+            return [];
+        }
+        // Use the first field for prefix search (Firestore limitation)
+        const primaryField = search.fields[0];
+        return this.buildPrefixSearchFilter(primaryField, search.term);
+    }
+    /**
+     * Check if an entity matches search criteria (client-side filtering)
+     * Used for additional fields that couldn't be queried server-side
+     */
+    static matchesSearch(entity, search) {
+        if (!this.isValidSearch(search)) {
+            return true; // No valid search, include all
+        }
+        const normalizedTerm = normalizeSearchTerm(search.term);
+        return search.fields.some((field) => {
+            const value = entity[field];
+            if (typeof value !== 'string') {
+                return false;
+            }
+            return value.toLowerCase().includes(normalizedTerm);
+        });
+    }
+    /**
+     * Filter entities client-side for multi-field search
+     * Use this after fetching data when you need to search multiple fields
+     */
+    static filterBySearch(entities, search) {
+        if (!this.isValidSearch(search)) {
+            return entities;
+        }
+        return entities.filter((entity) => this.matchesSearch(entity, search));
+    }
+}
+
+/**
+ * Helper for mapping Firestore documents to entities
+ *
+ * Design Pattern: Factory Pattern
+ * - Központosított objektum létrehozás Firestore dokumentumokból
+ * - Egységes mapping logika az egész alkalmazásban
+ * - Könnyen bővíthető új mapping stratégiákkal
+ *
+ * Előnyök:
+ * - DRY: Nem ismétlődik a mapping kód minden metódusban
+ * - Tesztelhetőség: Izoláltan tesztelhető a mapping logika
+ * - Karbantarthatóság: Egy helyen módosítható a mapping
+ */
+class EntityMapperHelper {
+    /**
+     * Map a single document snapshot to an entity
+     */
+    static mapDocument(docSnapshot) {
+        return {
+            ...docSnapshot.data(),
+            uid: docSnapshot.id,
+        };
+    }
+    /**
+     * Map a single document snapshot, excluding uid from data
+     */
+    static mapDocumentWithoutUid(docSnapshot) {
+        const { uid, ...data } = docSnapshot.data();
+        return {
+            ...data,
+            uid: docSnapshot.id,
+        };
+    }
+    /**
+     * Map multiple document snapshots to entities
+     */
+    static mapDocuments(docs) {
+        return docs.map((docSnapshot) => this.mapDocument(docSnapshot));
+    }
+    /**
+     * Map multiple document snapshots, excluding uid from data
+     */
+    static mapDocumentsWithoutUid(docs) {
+        return docs.map((docSnapshot) => this.mapDocumentWithoutUid(docSnapshot));
+    }
+    /**
+     * Apply client-side search filtering if needed
+     * Only applies when search has multiple fields (first field is server-side)
+     */
+    static applySearchFilter(entities, search) {
+        if (!search || !SearchUtil.isValidSearch(search) || search.fields.length <= 1) {
+            return entities;
+        }
+        return SearchUtil.filterBySearch(entities, search);
+    }
+}
+
+/**
+ * Builds Firestore QueryConstraints from QueryOptions
+ *
+ * Design Pattern: Builder Pattern
+ * - Lépésről lépésre építi fel a komplex Firestore query-t
+ * - Elválasztja a konstrukciós logikát a reprezentációtól
+ * - Különböző constraint típusok moduláris kezelése
+ *
+ * Előnyök:
+ * - Olvashatóság: A query építés lépései világosak
+ * - Bővíthetőség: Új constraint típusok könnyen hozzáadhatók
+ * - Tesztelhetőség: Minden builder metódus külön tesztelhető
+ * - Firestore szabályok: A constraint sorrend automatikusan helyes
+ *   (where → orderBy → cursor → limit)
+ */
+class QueryConstraintBuilder {
+    /**
+     * Build all query constraints from QueryOptions
+     */
+    static build(options) {
+        const constraints = [];
+        // Add where filters
+        constraints.push(...this.buildWhereConstraints(options));
+        // Add orderBy constraints
+        constraints.push(...this.buildOrderByConstraints(options));
+        // Add cursor constraints (must come after orderBy)
+        constraints.push(...this.buildCursorConstraints(options));
+        // Add limit constraint (must come last)
+        constraints.push(...this.buildLimitConstraints(options));
+        return constraints;
+    }
+    /**
+     * Build where filter constraints
+     */
+    static buildWhereConstraints(options) {
+        if (!options.where || options.where.length === 0) {
+            return [];
+        }
+        return options.where.map((filter) => where(filter.field, filter.operator, filter.value));
+    }
+    /**
+     * Build orderBy constraints
+     */
+    static buildOrderByConstraints(options) {
+        if (!options.orderBy || options.orderBy.length === 0) {
+            return [];
+        }
+        return options.orderBy.map((sort) => orderBy(sort.field, sort.direction));
+    }
+    /**
+     * Build cursor-based pagination constraints
+     * Note: Requires orderBy to be set for proper cursor pagination
+     */
+    static buildCursorConstraints(options) {
+        const constraints = [];
+        if (options.startAfter !== undefined) {
+            constraints.push(startAfter(options.startAfter));
+        }
+        if (options.startAt !== undefined) {
+            constraints.push(startAt(options.startAt));
+        }
+        if (options.endBefore !== undefined) {
+            constraints.push(endBefore(options.endBefore));
+        }
+        if (options.endAt !== undefined) {
+            constraints.push(endAt(options.endAt));
+        }
+        return constraints;
+    }
+    /**
+     * Build limit constraints
+     */
+    static buildLimitConstraints(options) {
+        const constraints = [];
+        if (options.limit !== undefined && options.limit > 0) {
+            constraints.push(limit(options.limit));
+        }
+        return constraints;
+    }
+    /**
+     * Apply default limit if none specified
+     */
+    static applyDefaultLimit(options) {
+        if (options.limit === undefined) {
+            return { ...options, limit: DEFAULT_PAGE_SIZE };
+        }
+        return options;
+    }
+    /**
+     * Build constraints for fetching one extra item to determine hasNext
+     */
+    static buildWithExtraForPagination(options) {
+        const optionsWithExtra = {
+            ...options,
+            limit: (options.limit || DEFAULT_PAGE_SIZE) + 1,
+        };
+        return this.build(optionsWithExtra);
+    }
+}
+
+/**
+ * Helper for processing and preparing QueryOptions
+ *
+ * Design Pattern: Strategy Pattern (előkészítő)
+ * - Különböző query előkészítési stratégiák (alap, paginált)
+ * - A konkrét végrehajtás a QueryConstraintBuilder-re delegálódik
+ * - Könnyen bővíthető új stratégiákkal (pl. aggregált, real-time)
+ *
+ * Előnyök:
+ * - Szétválasztás: Query előkészítés és végrehajtás külön
+ * - Újrafelhasználhatóság: Azonos előkészítés több metódusban
+ * - Tesztelhetőség: Az előkészítési logika izoláltan tesztelhető
+ */
+class QueryOptionsHelper {
+    /**
+     * Prepare query options with defaults and search filters
+     */
+    static prepare(options) {
+        // Apply default limit
+        let prepared = QueryConstraintBuilder.applyDefaultLimit(options);
+        // Add search filters if provided
+        if (options.search && SearchUtil.isValidSearch(options.search)) {
+            const searchFilters = SearchUtil.buildSearchFilters(options.search);
+            prepared = {
+                ...prepared,
+                where: [...(prepared.where || []), ...searchFilters],
+            };
+        }
+        return prepared;
+    }
+    /**
+     * Prepare options for pagination with custom page size
+     */
+    static prepareForPagination(options, pageSize, startAfterCursor) {
+        const prepared = {
+            ...options,
+            limit: pageSize,
+            startAfter: startAfterCursor,
+        };
+        // Add search filters if provided
+        if (options.search && SearchUtil.isValidSearch(options.search)) {
+            const searchFilters = SearchUtil.buildSearchFilters(options.search);
+            prepared.where = [...(prepared.where || []), ...searchFilters];
+        }
+        return prepared;
+    }
+    /**
+     * Check if search requires client-side filtering
+     * (when multiple fields are specified, only first is server-side)
+     */
+    static requiresClientSideSearch(options) {
+        return !!(options.search &&
+            SearchUtil.isValidSearch(options.search) &&
+            options.search.fields.length > 1);
+    }
+}
+
+/**
+ * Utility functions for converting query parameters to QueryOptions
+ * Separated for better testability and reusability
+ */
+class QueryParamsUtil {
+    /**
+     * Convert path parameters and query parameters into QueryOptions
+     * This allows the list method to work with different implementations (Firestore, REST, etc.)
+     */
+    static buildQueryOptionsFromParams(pathParams, queryParams) {
+        const options = {
+            where: [],
+            orderBy: [],
+        };
+        // Process query parameters
+        if (queryParams && queryParams.length > 0) {
+            for (const param of queryParams) {
+                const { key, value } = param;
+                switch (key.toLowerCase()) {
+                    case 'limit':
+                        const limitValue = parseInt(value, 10);
+                        // Allow 0 to mean "no limit" (fetch all)
+                        if (!isNaN(limitValue) && limitValue >= 0) {
+                            options.limit = limitValue;
+                        }
+                        break;
+                    case 'offset':
+                        const offsetValue = parseInt(value, 10);
+                        if (!isNaN(offsetValue) && offsetValue >= 0) {
+                            options.offset = offsetValue;
+                        }
+                        break;
+                    case 'sort':
+                    case 'sortby':
+                    case 'orderby':
+                        // Format: field:direction (e.g., "createdAt:desc" or "name:asc")
+                        const [field, direction = 'asc'] = value.split(':');
+                        if (field) {
+                            options.orderBy = options.orderBy || [];
+                            options.orderBy.push({
+                                field: field.trim(),
+                                direction: direction.trim().toLowerCase() === 'desc' ? 'desc' : 'asc',
+                            });
+                        }
+                        break;
+                    // Handle filter parameters (e.g., status=active, type=user)
+                    default:
+                        if (key && value) {
+                            options.where = options.where || [];
+                            // Check if it's an 'in' operation (comma-separated values prefixed with 'in:')
+                            // Format: field=in:value1,value2,value3
+                            if (value.startsWith('in:')) {
+                                const valuesStr = value.slice(3); // Remove 'in:' prefix
+                                const values = valuesStr
+                                    .split(',')
+                                    .map((v) => QueryParamsUtil.parseFilterValue(v.trim()));
+                                options.where.push({
+                                    field: key,
+                                    operator: 'in',
+                                    value: values,
+                                });
+                            }
+                            // Check if it's a comparison operation (e.g., age>25, count<=10)
+                            else {
+                                const comparisonMatch = value.match(/^(>=|<=|>|<|!=)(.+)$/);
+                                if (comparisonMatch) {
+                                    const [, operator, filterValue] = comparisonMatch;
+                                    options.where.push({
+                                        field: key,
+                                        operator: operator,
+                                        value: QueryParamsUtil.parseFilterValue(filterValue),
+                                    });
+                                }
+                                else {
+                                    // Default to equality check
+                                    options.where.push({
+                                        field: key,
+                                        operator: '==',
+                                        value: QueryParamsUtil.parseFilterValue(value),
+                                    });
+                                }
+                            }
+                        }
+                        break;
+                }
+            }
+        }
+        // Process path parameters if needed (could be used for nested collections)
+        if (pathParams && pathParams.length > 0) {
+            // Path parameters could be used for filtering or collection selection
+            // For example: /users/{userId}/posts could add a filter for userId
+            // This is implementation-specific and can be extended as needed
+            console.log('Path parameters provided:', pathParams);
+        }
+        return options;
+    }
+    /**
+     * Parse filter value to appropriate type (string, number, boolean, etc.)
+     */
+    static parseFilterValue(value) {
+        // Try to parse as number (check if the entire string is a valid number)
+        const numValue = parseFloat(value);
+        if (!isNaN(numValue) && isFinite(numValue) && value.trim() === numValue.toString()) {
+            return numValue;
+        }
+        // Try to parse as boolean
+        if (value.toLowerCase() === 'true')
+            return true;
+        if (value.toLowerCase() === 'false')
+            return false;
+        // Try to parse as null/undefined
+        if (value.toLowerCase() === 'null')
+            return null;
+        if (value.toLowerCase() === 'undefined')
+            return undefined;
+        // Return as string (default)
+        return value;
+    }
+}
+
+class FirestoreRepositoryEngine extends RepositoryEngine {
+    firestore;
+    featureKey;
+    subcollectionContext;
+    injector = inject(Injector);
+    collectionPathBuilder;
+    constructor(firestore, featureKey, subcollectionContext) {
+        super();
+        this.firestore = firestore;
+        this.featureKey = featureKey;
+        this.subcollectionContext = subcollectionContext;
+        // Create path builder based on context
+        this.collectionPathBuilder = this.createPathBuilder();
+    }
+    /**
+     * Resolves the feature key, supporting both static strings and dynamic functions.
+     * Dynamic functions enable multi-tenant scenarios where the collection path
+     * depends on runtime context (e.g., active tenant ID).
+     */
+    get resolvedFeatureKey() {
+        return typeof this.featureKey === 'function' ? this.featureKey() : this.featureKey;
+    }
+    /**
+     * Lazily resolved collection reference based on the current feature key.
+     * For dynamic (function-based) feature keys, this re-evaluates on every access,
+     * enabling tenant-switching without recreating the engine.
+     */
+    get collectionRef() {
+        return collection(this.firestore, this.resolvedFeatureKey);
+    }
+    /**
+     * Creates a path builder function based on subcollection context
+     */
+    createPathBuilder() {
+        if (!this.subcollectionContext) {
+            // Flat collection: always use resolved featureKey
+            return () => this.resolvedFeatureKey;
+        }
+        // Subcollection: build path dynamically
+        return (entityData) => {
+            if (!entityData) {
+                // Fallback to flat collection if no parent ID available
+                return this.resolvedFeatureKey;
+            }
+            const parentId = entityData[this.subcollectionContext.parentIdField];
+            if (!parentId) {
+                throw new Error(`Cannot resolve subcollection path: ${this.subcollectionContext.parentIdField} is required`);
+            }
+            const parentCollConfig = this.subcollectionContext.parentCollection;
+            const parentColl = typeof parentCollConfig === 'function' ? parentCollConfig() : parentCollConfig;
+            return `${parentColl}/${parentId}/${this.subcollectionContext.subcollection}`;
+        };
+    }
+    /**
+     * Gets collection reference for specific entity data
+     */
+    getCollectionRef(entityData) {
+        const path = this.collectionPathBuilder(entityData);
+        return collection(this.firestore, path);
+    }
+    batch(operations) {
+        return new Observable((subscriber) => {
+            const batch = this.firestore.batch();
+            for (const op of operations) {
+                if (!op.uid)
+                    continue; // Skip operations without uid
+                const ref = doc(this.collectionRef, op.uid);
+                switch (op.type) {
+                    case 'create':
+                        if (op.data) {
+                            batch.set(ref, op.data);
+                        }
+                        break;
+                    case 'update':
+                        if (op.data) {
+                            batch.update(ref, op.data);
+                        }
+                        break;
+                    case 'delete':
+                        batch.delete(ref);
+                        break;
+                }
+            }
+            batch
+                .commit()
+                .then(() => {
+                subscriber.next();
+                subscriber.complete();
+            })
+                .catch((error) => subscriber.error(error));
+        });
+    }
+    count(options) {
+        return new Observable((subscriber) => {
+            const constraints = [];
+            if (options?.where) {
+                for (const filter of options.where) {
+                    constraints.push(where(filter.field, filter.operator, filter.value));
+                }
+            }
+            const entitiesQuery = query(this.collectionRef, ...constraints);
+            // Use getCountFromServer for efficient counting without downloading documents
+            getCountFromServer(entitiesQuery)
+                .then((snapshot) => {
+                subscriber.next(snapshot.data().count);
+                subscriber.complete();
+            })
+                .catch((error) => {
+                // Fallback to the old method if getCountFromServer is not available
+                console.warn('getCountFromServer failed, falling back to getDocs:', error);
+                getDocs(entitiesQuery)
+                    .then((docSnapshot) => {
+                    subscriber.next(docSnapshot.size);
+                    subscriber.complete();
+                })
+                    .catch((fallbackError) => subscriber.error(fallbackError));
+            });
+        });
+    }
+    create$(entityAdd) {
+        return runInInjectionContext(this.injector, () => {
+            const uid = doc(collection(this.firestore, 'id')).id;
+            const newEntity = {
+                ...entityAdd,
+                uid,
+            };
+            // Use entity data to resolve collection path
+            const collectionRef = this.getCollectionRef(newEntity);
+            return new Observable((subscriber) => {
+                setDoc(doc(collectionRef, uid), newEntity)
+                    .then(() => {
+                    subscriber.next({ ...newEntity });
+                    subscriber.complete();
+                })
+                    .catch((error) => {
+                    subscriber.error(error);
+                });
+            });
+        });
+    }
+    delete$(entity) {
+        return runInInjectionContext(this.injector, () => {
+            // Use entity data to resolve collection path
+            const collectionRef = this.getCollectionRef(entity);
+            return new Observable((subscriber) => {
+                deleteDoc(doc(collectionRef, entity.uid))
+                    .then(() => {
+                    subscriber.next(entity);
+                    subscriber.complete();
+                })
+                    .catch((error) => subscriber.error(error));
+            });
+        });
+    }
+    exists(uid) {
+        return new Observable((subscriber) => {
+            getDocs(query(this.collectionRef, where('uid', '==', uid)))
+                .then((snapshot) => {
+                subscriber.next(!snapshot.empty);
+                subscriber.complete();
+            })
+                .catch((error) => subscriber.error(error));
+        });
+    }
+    list$(pathParams, queryParams) {
+        // Convert path and query parameters to QueryOptions for abstraction
+        const queryOptions = QueryParamsUtil.buildQueryOptionsFromParams(pathParams, queryParams);
+        // Delegate to the abstract query method for implementation flexibility
+        return this.query(queryOptions);
+    }
+    listByIds$(ids) {
+        return runInInjectionContext(this.injector, () => {
+            if (ids.length === 0) {
+                return new Observable((subscriber) => {
+                    subscriber.next([]);
+                    subscriber.complete();
+                });
+            }
+            const entitiesQuery = query(this.collectionRef, where('uid', 'in', ids));
+            return new Observable((subscriber) => {
+                getDocs(entitiesQuery)
+                    .then((snapshot) => {
+                    const entities = EntityMapperHelper.mapDocumentsWithoutUid(snapshot.docs);
+                    subscriber.next(entities);
+                    subscriber.complete();
+                })
+                    .catch((error) => subscriber.error(error));
+            });
+        });
+    }
+    load$(uid) {
+        return runInInjectionContext(this.injector, () => {
+            const entityDocument = doc(this.firestore, `${this.resolvedFeatureKey}/${uid}`);
+            return docData(entityDocument, {
+                idField: 'uid',
+            });
+        });
+    }
+    query(options) {
+        return new Observable((subscriber) => {
+            // Prepare options with defaults and search filters
+            const queryOptions = QueryOptionsHelper.prepare(options);
+            // Build all constraints using the builder
+            const constraints = QueryConstraintBuilder.build(queryOptions);
+            const entitiesQuery = query(this.collectionRef, ...constraints);
+            getDocs(entitiesQuery)
+                .then((snapshot) => {
+                let entities = EntityMapperHelper.mapDocuments(snapshot.docs);
+                // Apply client-side search filtering for additional fields
+                entities = EntityMapperHelper.applySearchFilter(entities, options.search);
+                subscriber.next(entities);
+                subscriber.complete();
+            })
+                .catch((error) => {
+                console.error(error);
+                subscriber.error(error);
+            });
+        });
+    }
+    queryPaginated(options, pageSize, lastDocument) {
+        return new Observable((subscriber) => {
+            // Prepare options for pagination
+            const paginatedOptions = QueryOptionsHelper.prepareForPagination(options, pageSize, lastDocument?.uid);
+            // Build constraints and execute query
+            const constraints = QueryConstraintBuilder.build(paginatedOptions);
+            const entitiesQuery = query(this.collectionRef, ...constraints);
+            getDocs(entitiesQuery)
+                .then((snapshot) => {
+                let entities = EntityMapperHelper.mapDocuments(snapshot.docs);
+                entities = EntityMapperHelper.applySearchFilter(entities, options.search);
+                subscriber.next({
+                    items: entities,
+                    totalItems: entities.length,
+                    totalPages: Math.ceil(entities.length / pageSize),
+                    currentPage: 1,
+                    hasNext: entities.length === pageSize,
+                    hasPrevious: !!lastDocument,
+                });
+                subscriber.complete();
+            })
+                .catch((error) => subscriber.error(error));
+        });
+    }
+    /**
+     * Query with cursor-based pagination (more efficient for Firestore)
+     * Returns cursor information for next/previous page navigation
+     */
+    queryCursorPaginated(options) {
+        return new Observable((subscriber) => {
+            const pageSize = options.limit || DEFAULT_PAGE_SIZE;
+            // Prepare options with search filters
+            const queryOptions = QueryOptionsHelper.prepare(options);
+            // Fetch one extra to determine hasNext
+            const constraints = QueryConstraintBuilder.buildWithExtraForPagination(queryOptions);
+            const entitiesQuery = query(this.collectionRef, ...constraints);
+            getDocs(entitiesQuery)
+                .then((snapshot) => {
+                let entities = EntityMapperHelper.mapDocuments(snapshot.docs);
+                entities = EntityMapperHelper.applySearchFilter(entities, options.search);
+                // Check if there are more results
+                const hasNext = entities.length > pageSize;
+                if (hasNext) {
+                    entities = entities.slice(0, pageSize);
+                }
+                subscriber.next({
+                    items: entities,
+                    hasNext,
+                    hasPrevious: !!options.startAfter,
+                    firstCursor: entities.length > 0 ? entities[0].uid : undefined,
+                    lastCursor: entities.length > 0 ? entities[entities.length - 1].uid : undefined,
+                });
+                subscriber.complete();
+            })
+                .catch((error) => subscriber.error(error));
+        });
+    }
+    search$(params) {
+        return runInInjectionContext(this.injector, () => {
+            if (!params || params.length === 0) {
+                return new Observable((subscriber) => {
+                    subscriber.next([]);
+                    subscriber.complete();
+                });
+            }
+            const queries = params.map((param) => where(param.query.field, param.query.operation, param.query.value));
+            const entityQuery = query(this.collectionRef, ...queries);
+            return new Observable((subscriber) => {
+                getDocs(entityQuery)
+                    .then((snapshot) => {
+                    const entities = EntityMapperHelper.mapDocumentsWithoutUid(snapshot.docs);
+                    subscriber.next(entities);
+                    subscriber.complete();
+                })
+                    .catch((error) => subscriber.error(error));
+            });
+        });
+    }
+    update$(entityUpdate) {
+        return runInInjectionContext(this.injector, () => {
+            const newEntity = {
+                ...entityUpdate,
+            };
+            // Use entity data to resolve collection path
+            const collectionRef = this.getCollectionRef(newEntity);
+            return new Observable((subscriber) => {
+                // Use merge: true to only update the provided fields, not replace the entire document
+                setDoc(doc(collectionRef, entityUpdate.uid), newEntity, { merge: true })
+                    .then(() => {
+                    subscriber.next(newEntity);
+                    subscriber.complete();
+                })
+                    .catch((error) => {
+                    subscriber.error(error);
+                });
+            });
+        });
+    }
+    /**
+     * Query entities by parent ID (for subcollections)
+     * @param parentId The ID of the parent entity
+     * @param options Optional query options for filtering/sorting
+     */
+    queryByParentId$(parentId, options) {
+        if (!this.subcollectionContext) {
+            throw new Error('queryByParentId$ requires subcollectionContext');
+        }
+        const parentContext = { [this.subcollectionContext.parentIdField]: parentId };
+        const collectionRef = this.getCollectionRef(parentContext);
+        return new Observable((subscriber) => {
+            // Prepare options and build constraints
+            const queryOptions = options ? QueryOptionsHelper.prepare(options) : {};
+            const constraints = QueryConstraintBuilder.build(queryOptions);
+            const entitiesQuery = query(collectionRef, ...constraints);
+            getDocs(entitiesQuery)
+                .then((snapshot) => {
+                let entities = EntityMapperHelper.mapDocuments(snapshot.docs);
+                entities = EntityMapperHelper.applySearchFilter(entities, options?.search);
+                subscriber.next(entities);
+                subscriber.complete();
+            })
+                .catch((error) => subscriber.error(error));
+        });
+    }
+    /**
+     * Real-time query with snapshot listener (continuous updates)
+     * Use this when you need live updates from Firestore
+     * Note: This creates a persistent connection and incurs read costs on every change
+     */
+    queryRealtime$(options) {
+        return runInInjectionContext(this.injector, () => {
+            // Prepare options with defaults and search filters
+            const queryOptions = QueryOptionsHelper.prepare(options);
+            // Build constraints and create query
+            const constraints = QueryConstraintBuilder.build(queryOptions);
+            const entitiesQuery = query(this.collectionRef, ...constraints);
+            // Use collectionData for real-time updates
+            return collectionData(entitiesQuery, { idField: 'uid' });
+        });
+    }
+    /**
+     * Real-time load with snapshot listener (continuous updates for single document)
+     * Use this when you need live updates for a single entity
+     * Note: This creates a persistent connection and incurs read costs on every change
+     */
+    loadRealtime$(uid) {
+        return runInInjectionContext(this.injector, () => {
+            const entityDocument = doc(this.firestore, `${this.resolvedFeatureKey}/${uid}`);
+            return docData(entityDocument, {
+                idField: 'uid',
+            });
+        });
+    }
+}
+
+/**
+ * Factory function that creates a Firestore repository engine
+ * This is injected via FIRESTORE_ENGINE_CREATOR token
+ */
+function createFirestoreEngineCreator(firestore) {
+    return (featureKey, subcollectionContext) => {
+        return new FirestoreRepositoryEngine(firestore, featureKey, subcollectionContext);
+    };
+}
+/**
+ * Provides the FIRESTORE_ENGINE_CREATOR for use with RepositoryEngineFactory
+ * Add this to your app.config.ts providers array
+ *
+ * @example
+ * ```typescript
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideFirestoreEngine(),
+ *     // ... other providers
+ *   ],
+ * };
+ * ```
+ */
+function provideFirestoreEngine() {
+    return {
+        provide: FIRESTORE_ENGINE_CREATOR,
+        useFactory: () => {
+            const firestore = inject(Firestore);
+            return createFirestoreEngineCreator(firestore);
+        },
+    };
+}
+
+/*
+ * Public API Surface of firestore-repository-engine
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { EntityMapperHelper, FirestoreRepositoryEngine, QueryConstraintBuilder, QueryOptionsHelper, QueryParamsUtil, SearchUtil, provideFirestoreEngine };
+//# sourceMappingURL=zs-soft-firestore-repository-engine.mjs.map

package/fesm2022/zs-soft-firestore-repository-engine.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"zs-soft-firestore-repository-engine.mjs","sources":["../../../projects/firestore-repository-engine/src/lib/utils/search.util.ts","../../../projects/firestore-repository-engine/src/lib/helpers/entity-mapper.helper.ts","../../../projects/firestore-repository-engine/src/lib/utils/query-constraint.builder.ts","../../../projects/firestore-repository-engine/src/lib/helpers/query-options.helper.ts","../../../projects/firestore-repository-engine/src/lib/utils/query-params.util.ts","../../../projects/firestore-repository-engine/src/lib/firestore-repository.engine.ts","../../../projects/firestore-repository-engine/src/lib/firestore-engine.provider.ts","../../../projects/firestore-repository-engine/src/public-api.ts","../../../projects/firestore-repository-engine/src/zs-soft-firestore-repository-engine.ts"],"sourcesContent":["import {\n  isValidSearchTerm,\n  normalizeSearchTerm,\n  QueryFilter,\n  SearchOptions,\n} from '@zs-soft/common-api';\n\n/**\n * Utility for Firestore text search operations\n * Note: Firestore doesn't support full-text search natively.\n * This implements prefix-based search using >= and < operators.\n */\nexport class SearchUtil {\n  /**\n   * Validates search options\n   * Returns true if search term meets minimum length requirement\n   */\n  static isValidSearch(search: SearchOptions | undefined): boolean {\n    if (!search) {\n      return false;\n    }\n    return isValidSearchTerm(search.term) && search.fields.length > 0;\n  }\n\n  /**\n   * Build Firestore-compatible prefix search filters for a single field\n   * Uses >= term and < term + high Unicode character for prefix matching\n   *\n   * Example: searching \"John\" will match \"John\", \"Johnny\", \"Johnson\"\n   */\n  static buildPrefixSearchFilter(field: string, term: string): QueryFilter[] {\n    const normalizedTerm = normalizeSearchTerm(term);\n    const endTerm = normalizedTerm + '\\uf8ff'; // High Unicode character for range end\n\n    return [\n      { field, operator: '>=', value: normalizedTerm },\n      { field, operator: '<', value: endTerm },\n    ];\n  }\n\n  /**\n   * Build search filters for the first searchable field\n   * Note: Firestore only supports range queries on a single field,\n   * so we can only search one field at a time with prefix matching\n   */\n  static buildSearchFilters(search: SearchOptions): QueryFilter[] {\n    if (!this.isValidSearch(search)) {\n      return [];\n    }\n\n    // Use the first field for prefix search (Firestore limitation)\n    const primaryField = search.fields[0];\n    return this.buildPrefixSearchFilter(primaryField, search.term);\n  }\n\n  /**\n   * Check if an entity matches search criteria (client-side filtering)\n   * Used for additional fields that couldn't be queried server-side\n   */\n  static matchesSearch(entity: Record<string, unknown>, search: SearchOptions): boolean {\n    if (!this.isValidSearch(search)) {\n      return true; // No valid search, include all\n    }\n\n    const normalizedTerm = normalizeSearchTerm(search.term);\n\n    return search.fields.some((field) => {\n      const value = entity[field];\n      if (typeof value !== 'string') {\n        return false;\n      }\n      return value.toLowerCase().includes(normalizedTerm);\n    });\n  }\n\n  /**\n   * Filter entities client-side for multi-field search\n   * Use this after fetching data when you need to search multiple fields\n   */\n  static filterBySearch<T extends Record<string, unknown>>(\n    entities: T[],\n    search: SearchOptions,\n  ): T[] {\n    if (!this.isValidSearch(search)) {\n      return entities;\n    }\n\n    return entities.filter((entity) => this.matchesSearch(entity, search));\n  }\n}\n","import { DocumentData, QueryDocumentSnapshot } from '@angular/fire/firestore';\nimport { SearchOptions } from '@zs-soft/common-api';\nimport { Entity, EntityModel } from '@zs-soft/core-api';\n\nimport { SearchUtil } from '../utils/search.util';\n\n/**\n * Helper for mapping Firestore documents to entities\n *\n * Design Pattern: Factory Pattern\n * - Központosított objektum létrehozás Firestore dokumentumokból\n * - Egységes mapping logika az egész alkalmazásban\n * - Könnyen bővíthető új mapping stratégiákkal\n *\n * Előnyök:\n * - DRY: Nem ismétlődik a mapping kód minden metódusban\n * - Tesztelhetőség: Izoláltan tesztelhető a mapping logika\n * - Karbantarthatóság: Egy helyen módosítható a mapping\n */\nexport class EntityMapperHelper {\n  /**\n   * Map a single document snapshot to an entity\n   */\n  static mapDocument<T extends Entity>(docSnapshot: QueryDocumentSnapshot<DocumentData>): T {\n    return {\n      ...docSnapshot.data(),\n      uid: docSnapshot.id,\n    } as T;\n  }\n\n  /**\n   * Map a single document snapshot, excluding uid from data\n   */\n  static mapDocumentWithoutUid<T extends EntityModel>(\n    docSnapshot: QueryDocumentSnapshot<DocumentData>,\n  ): T {\n    const { uid, ...data } = docSnapshot.data() as EntityModel;\n    return {\n      ...data,\n      uid: docSnapshot.id,\n    } as T;\n  }\n\n  /**\n   * Map multiple document snapshots to entities\n   */\n  static mapDocuments<T extends Entity>(docs: QueryDocumentSnapshot<DocumentData>[]): T[] {\n    return docs.map((docSnapshot) => this.mapDocument<T>(docSnapshot));\n  }\n\n  /**\n   * Map multiple document snapshots, excluding uid from data\n   */\n  static mapDocumentsWithoutUid<T extends EntityModel>(\n    docs: QueryDocumentSnapshot<DocumentData>[],\n  ): T[] {\n    return docs.map((docSnapshot) => this.mapDocumentWithoutUid<T>(docSnapshot));\n  }\n\n  /**\n   * Apply client-side search filtering if needed\n   * Only applies when search has multiple fields (first field is server-side)\n   */\n  static applySearchFilter<T extends Entity>(entities: T[], search?: SearchOptions): T[] {\n    if (!search || !SearchUtil.isValidSearch(search) || search.fields.length <= 1) {\n      return entities;\n    }\n\n    return SearchUtil.filterBySearch(\n      entities as unknown as Record<string, unknown>[],\n      search,\n    ) as unknown as T[];\n  }\n}\n","import {\n  limit,\n  orderBy,\n  QueryConstraint,\n  startAfter,\n  startAt,\n  endAt,\n  endBefore,\n  where,\n} from '@angular/fire/firestore';\nimport { DEFAULT_PAGE_SIZE, QueryOptions } from '@zs-soft/common-api';\n\n/**\n * Builds Firestore QueryConstraints from QueryOptions\n *\n * Design Pattern: Builder Pattern\n * - Lépésről lépésre építi fel a komplex Firestore query-t\n * - Elválasztja a konstrukciós logikát a reprezentációtól\n * - Különböző constraint típusok moduláris kezelése\n *\n * Előnyök:\n * - Olvashatóság: A query építés lépései világosak\n * - Bővíthetőség: Új constraint típusok könnyen hozzáadhatók\n * - Tesztelhetőség: Minden builder metódus külön tesztelhető\n * - Firestore szabályok: A constraint sorrend automatikusan helyes\n *   (where → orderBy → cursor → limit)\n */\nexport class QueryConstraintBuilder {\n  /**\n   * Build all query constraints from QueryOptions\n   */\n  static build(options: QueryOptions): QueryConstraint[] {\n    const constraints: QueryConstraint[] = [];\n\n    // Add where filters\n    constraints.push(...this.buildWhereConstraints(options));\n\n    // Add orderBy constraints\n    constraints.push(...this.buildOrderByConstraints(options));\n\n    // Add cursor constraints (must come after orderBy)\n    constraints.push(...this.buildCursorConstraints(options));\n\n    // Add limit constraint (must come last)\n    constraints.push(...this.buildLimitConstraints(options));\n\n    return constraints;\n  }\n\n  /**\n   * Build where filter constraints\n   */\n  static buildWhereConstraints(options: QueryOptions): QueryConstraint[] {\n    if (!options.where || options.where.length === 0) {\n      return [];\n    }\n\n    return options.where.map((filter) => where(filter.field, filter.operator, filter.value));\n  }\n\n  /**\n   * Build orderBy constraints\n   */\n  static buildOrderByConstraints(options: QueryOptions): QueryConstraint[] {\n    if (!options.orderBy || options.orderBy.length === 0) {\n      return [];\n    }\n\n    return options.orderBy.map((sort) => orderBy(sort.field, sort.direction));\n  }\n\n  /**\n   * Build cursor-based pagination constraints\n   * Note: Requires orderBy to be set for proper cursor pagination\n   */\n  static buildCursorConstraints(options: QueryOptions): QueryConstraint[] {\n    const constraints: QueryConstraint[] = [];\n\n    if (options.startAfter !== undefined) {\n      constraints.push(startAfter(options.startAfter));\n    }\n\n    if (options.startAt !== undefined) {\n      constraints.push(startAt(options.startAt));\n    }\n\n    if (options.endBefore !== undefined) {\n      constraints.push(endBefore(options.endBefore));\n    }\n\n    if (options.endAt !== undefined) {\n      constraints.push(endAt(options.endAt));\n    }\n\n    return constraints;\n  }\n\n  /**\n   * Build limit constraints\n   */\n  static buildLimitConstraints(options: QueryOptions): QueryConstraint[] {\n    const constraints: QueryConstraint[] = [];\n\n    if (options.limit !== undefined && options.limit > 0) {\n      constraints.push(limit(options.limit));\n    }\n\n    return constraints;\n  }\n\n  /**\n   * Apply default limit if none specified\n   */\n  static applyDefaultLimit(options: QueryOptions): QueryOptions {\n    if (options.limit === undefined) {\n      return { ...options, limit: DEFAULT_PAGE_SIZE };\n    }\n    return options;\n  }\n\n  /**\n   * Build constraints for fetching one extra item to determine hasNext\n   */\n  static buildWithExtraForPagination(options: QueryOptions): QueryConstraint[] {\n    const optionsWithExtra = {\n      ...options,\n      limit: (options.limit || DEFAULT_PAGE_SIZE) + 1,\n    };\n    return this.build(optionsWithExtra);\n  }\n}\n","import { QueryOptions } from '@zs-soft/common-api';\n\nimport { QueryConstraintBuilder } from '../utils/query-constraint.builder';\nimport { SearchUtil } from '../utils/search.util';\n\n/**\n * Helper for processing and preparing QueryOptions\n *\n * Design Pattern: Strategy Pattern (előkészítő)\n * - Különböző query előkészítési stratégiák (alap, paginált)\n * - A konkrét végrehajtás a QueryConstraintBuilder-re delegálódik\n * - Könnyen bővíthető új stratégiákkal (pl. aggregált, real-time)\n *\n * Előnyök:\n * - Szétválasztás: Query előkészítés és végrehajtás külön\n * - Újrafelhasználhatóság: Azonos előkészítés több metódusban\n * - Tesztelhetőség: Az előkészítési logika izoláltan tesztelhető\n */\nexport class QueryOptionsHelper {\n  /**\n   * Prepare query options with defaults and search filters\n   */\n  static prepare(options: QueryOptions): QueryOptions {\n    // Apply default limit\n    let prepared = QueryConstraintBuilder.applyDefaultLimit(options);\n\n    // Add search filters if provided\n    if (options.search && SearchUtil.isValidSearch(options.search)) {\n      const searchFilters = SearchUtil.buildSearchFilters(options.search);\n      prepared = {\n        ...prepared,\n        where: [...(prepared.where || []), ...searchFilters],\n      };\n    }\n\n    return prepared;\n  }\n\n  /**\n   * Prepare options for pagination with custom page size\n   */\n  static prepareForPagination(\n    options: QueryOptions,\n    pageSize: number,\n    startAfterCursor?: string,\n  ): QueryOptions {\n    const prepared: QueryOptions = {\n      ...options,\n      limit: pageSize,\n      startAfter: startAfterCursor,\n    };\n\n    // Add search filters if provided\n    if (options.search && SearchUtil.isValidSearch(options.search)) {\n      const searchFilters = SearchUtil.buildSearchFilters(options.search);\n      prepared.where = [...(prepared.where || []), ...searchFilters];\n    }\n\n    return prepared;\n  }\n\n  /**\n   * Check if search requires client-side filtering\n   * (when multiple fields are specified, only first is server-side)\n   */\n  static requiresClientSideSearch(options: QueryOptions): boolean {\n    return !!(\n      options.search &&\n      SearchUtil.isValidSearch(options.search) &&\n      options.search.fields.length > 1\n    );\n  }\n}\n","import { KeyValue } from '@angular/common';\nimport { QueryOptions } from '@zs-soft/common-api';\n\n/**\n * Utility functions for converting query parameters to QueryOptions\n * Separated for better testability and reusability\n */\nexport class QueryParamsUtil {\n  /**\n   * Convert path parameters and query parameters into QueryOptions\n   * This allows the list method to work with different implementations (Firestore, REST, etc.)\n   */\n  static buildQueryOptionsFromParams(\n    pathParams: string[],\n    queryParams: KeyValue<string, string>[],\n  ): QueryOptions {\n    const options: QueryOptions = {\n      where: [],\n      orderBy: [],\n    };\n\n    // Process query parameters\n    if (queryParams && queryParams.length > 0) {\n      for (const param of queryParams) {\n        const { key, value } = param;\n\n        switch (key.toLowerCase()) {\n          case 'limit':\n            const limitValue = parseInt(value, 10);\n            // Allow 0 to mean \"no limit\" (fetch all)\n            if (!isNaN(limitValue) && limitValue >= 0) {\n              options.limit = limitValue;\n            }\n            break;\n\n          case 'offset':\n            const offsetValue = parseInt(value, 10);\n            if (!isNaN(offsetValue) && offsetValue >= 0) {\n              options.offset = offsetValue;\n            }\n            break;\n\n          case 'sort':\n          case 'sortby':\n          case 'orderby':\n            // Format: field:direction (e.g., \"createdAt:desc\" or \"name:asc\")\n            const [field, direction = 'asc'] = value.split(':');\n            if (field) {\n              options.orderBy = options.orderBy || [];\n              options.orderBy.push({\n                field: field.trim(),\n                direction: direction.trim().toLowerCase() === 'desc' ? 'desc' : 'asc',\n              });\n            }\n            break;\n\n          // Handle filter parameters (e.g., status=active, type=user)\n          default:\n            if (key && value) {\n              options.where = options.where || [];\n\n              // Check if it's an 'in' operation (comma-separated values prefixed with 'in:')\n              // Format: field=in:value1,value2,value3\n              if (value.startsWith('in:')) {\n                const valuesStr = value.slice(3); // Remove 'in:' prefix\n                const values = valuesStr\n                  .split(',')\n                  .map((v) => QueryParamsUtil.parseFilterValue(v.trim()));\n                options.where.push({\n                  field: key,\n                  operator: 'in',\n                  value: values,\n                });\n              }\n              // Check if it's a comparison operation (e.g., age>25, count<=10)\n              else {\n                const comparisonMatch = value.match(/^(>=|<=|>|<|!=)(.+)$/);\n                if (comparisonMatch) {\n                  const [, operator, filterValue] = comparisonMatch;\n                  options.where.push({\n                    field: key,\n                    operator: operator as any,\n                    value: QueryParamsUtil.parseFilterValue(filterValue),\n                  });\n                } else {\n                  // Default to equality check\n                  options.where.push({\n                    field: key,\n                    operator: '==',\n                    value: QueryParamsUtil.parseFilterValue(value),\n                  });\n                }\n              }\n            }\n            break;\n        }\n      }\n    }\n\n    // Process path parameters if needed (could be used for nested collections)\n    if (pathParams && pathParams.length > 0) {\n      // Path parameters could be used for filtering or collection selection\n      // For example: /users/{userId}/posts could add a filter for userId\n      // This is implementation-specific and can be extended as needed\n      console.log('Path parameters provided:', pathParams);\n    }\n\n    return options;\n  }\n\n  /**\n   * Parse filter value to appropriate type (string, number, boolean, etc.)\n   */\n  static parseFilterValue(value: string): any {\n    // Try to parse as number (check if the entire string is a valid number)\n    const numValue = parseFloat(value);\n    if (!isNaN(numValue) && isFinite(numValue) && value.trim() === numValue.toString()) {\n      return numValue;\n    }\n\n    // Try to parse as boolean\n    if (value.toLowerCase() === 'true') return true;\n    if (value.toLowerCase() === 'false') return false;\n\n    // Try to parse as null/undefined\n    if (value.toLowerCase() === 'null') return null;\n    if (value.toLowerCase() === 'undefined') return undefined;\n\n    // Return as string (default)\n    return value;\n  }\n}\n","import { Observable } from 'rxjs';\n\nimport { KeyValue } from '@angular/common';\nimport { inject, Injector, runInInjectionContext } from '@angular/core';\nimport {\n  collection,\n  collectionData,\n  CollectionReference,\n  deleteDoc,\n  doc,\n  docData,\n  Firestore,\n  getCountFromServer,\n  getDocs,\n  query,\n  QueryConstraint,\n  setDoc,\n  where,\n} from '@angular/fire/firestore';\nimport {\n  CursorPaginatedResult,\n  DEFAULT_PAGE_SIZE,\n  PaginatedResult,\n  QueryOptions,\n  SearchParams,\n} from '@zs-soft/common-api';\nimport {\n  BatchOperation,\n  CollectionPathBuilder,\n  Entity,\n  EntityModel,\n  EntityModelAdd,\n  EntityModelUpdate,\n  RepositoryEngine,\n  SubcollectionContext,\n} from '@zs-soft/core-api';\n\nimport { EntityMapperHelper } from './helpers/entity-mapper.helper';\nimport { QueryOptionsHelper } from './helpers/query-options.helper';\nimport { QueryConstraintBuilder } from './utils/query-constraint.builder';\nimport { QueryParamsUtil } from './utils/query-params.util';\n\nexport class FirestoreRepositoryEngine extends RepositoryEngine<\n  EntityModel,\n  EntityModelAdd,\n  EntityModelUpdate\n> {\n  private injector = inject(Injector);\n\n  protected collectionPathBuilder: CollectionPathBuilder;\n\n  public constructor(\n    protected firestore: Firestore,\n    protected featureKey: string | (() => string),\n    protected subcollectionContext?: SubcollectionContext,\n  ) {\n    super();\n\n    // Create path builder based on context\n    this.collectionPathBuilder = this.createPathBuilder();\n  }\n\n  /**\n   * Resolves the feature key, supporting both static strings and dynamic functions.\n   * Dynamic functions enable multi-tenant scenarios where the collection path\n   * depends on runtime context (e.g., active tenant ID).\n   */\n  protected get resolvedFeatureKey(): string {\n    return typeof this.featureKey === 'function' ? this.featureKey() : this.featureKey;\n  }\n\n  /**\n   * Lazily resolved collection reference based on the current feature key.\n   * For dynamic (function-based) feature keys, this re-evaluates on every access,\n   * enabling tenant-switching without recreating the engine.\n   */\n  protected get collectionRef(): CollectionReference<EntityModel> {\n    return collection(this.firestore, this.resolvedFeatureKey) as CollectionReference<EntityModel>;\n  }\n\n  /**\n   * Creates a path builder function based on subcollection context\n   */\n  private createPathBuilder(): CollectionPathBuilder {\n    if (!this.subcollectionContext) {\n      // Flat collection: always use resolved featureKey\n      return () => this.resolvedFeatureKey;\n    }\n\n    // Subcollection: build path dynamically\n    return (entityData?: Partial<EntityModel>) => {\n      if (!entityData) {\n        // Fallback to flat collection if no parent ID available\n        return this.resolvedFeatureKey;\n      }\n\n      const parentId = (entityData as any)[this.subcollectionContext!.parentIdField];\n      if (!parentId) {\n        throw new Error(\n          `Cannot resolve subcollection path: ${this.subcollectionContext!.parentIdField} is required`,\n        );\n      }\n\n      const parentCollConfig = this.subcollectionContext!.parentCollection;\n      const parentColl =\n        typeof parentCollConfig === 'function' ? parentCollConfig() : parentCollConfig;\n\n      return `${parentColl}/${parentId}/${this.subcollectionContext!.subcollection}`;\n    };\n  }\n\n  /**\n   * Gets collection reference for specific entity data\n   */\n  private getCollectionRef(entityData?: Partial<EntityModel>): CollectionReference<EntityModel> {\n    const path = this.collectionPathBuilder(entityData);\n    return collection(this.firestore, path) as CollectionReference<EntityModel>;\n  }\n\n  public override batch(operations: BatchOperation<Entity>[]): Observable<void> {\n    return new Observable<void>((subscriber) => {\n      const batch = (this.firestore as any).batch();\n      for (const op of operations) {\n        if (!op.uid) continue; // Skip operations without uid\n        const ref = doc(this.collectionRef, op.uid);\n        switch (op.type) {\n          case 'create':\n            if (op.data) {\n              batch.set(ref, op.data);\n            }\n            break;\n          case 'update':\n            if (op.data) {\n              batch.update(ref, op.data);\n            }\n            break;\n          case 'delete':\n            batch.delete(ref);\n            break;\n        }\n      }\n      batch\n        .commit()\n        .then(() => {\n          subscriber.next();\n          subscriber.complete();\n        })\n        .catch((error: unknown) => subscriber.error(error));\n    });\n  }\n\n  public override count(options?: QueryOptions): Observable<number> {\n    return new Observable<number>((subscriber) => {\n      const constraints: QueryConstraint[] = [];\n      if (options?.where) {\n        for (const filter of options.where) {\n          constraints.push(where(filter.field, filter.operator, filter.value));\n        }\n      }\n      const entitiesQuery = query(this.collectionRef, ...constraints);\n\n      // Use getCountFromServer for efficient counting without downloading documents\n      getCountFromServer(entitiesQuery)\n        .then((snapshot) => {\n          subscriber.next(snapshot.data().count);\n          subscriber.complete();\n        })\n        .catch((error) => {\n          // Fallback to the old method if getCountFromServer is not available\n          console.warn('getCountFromServer failed, falling back to getDocs:', error);\n          getDocs(entitiesQuery)\n            .then((docSnapshot) => {\n              subscriber.next(docSnapshot.size);\n              subscriber.complete();\n            })\n            .catch((fallbackError) => subscriber.error(fallbackError));\n        });\n    });\n  }\n\n  public override create$(entityAdd: EntityModelAdd): Observable<EntityModel> {\n    return runInInjectionContext(this.injector, () => {\n      const uid = doc(collection(this.firestore, 'id')).id;\n      const newEntity = {\n        ...entityAdd,\n        uid,\n      };\n\n      // Use entity data to resolve collection path\n      const collectionRef = this.getCollectionRef(newEntity);\n\n      return new Observable<EntityModel>((subscriber) => {\n        setDoc(doc(collectionRef, uid), newEntity)\n          .then(() => {\n            subscriber.next({ ...newEntity } as EntityModel);\n            subscriber.complete();\n          })\n          .catch((error) => {\n            subscriber.error(error);\n          });\n      });\n    });\n  }\n\n  public override delete$(entity: EntityModel): Observable<EntityModel> {\n    return runInInjectionContext(this.injector, () => {\n      // Use entity data to resolve collection path\n      const collectionRef = this.getCollectionRef(entity);\n\n      return new Observable<EntityModel>((subscriber) => {\n        deleteDoc(doc(collectionRef, entity.uid))\n          .then(() => {\n            subscriber.next(entity);\n            subscriber.complete();\n          })\n          .catch((error) => subscriber.error(error));\n      });\n    });\n  }\n\n  public override exists(uid: string): Observable<boolean> {\n    return new Observable<boolean>((subscriber) => {\n      getDocs(query(this.collectionRef, where('uid', '==', uid)))\n        .then((snapshot) => {\n          subscriber.next(!snapshot.empty);\n          subscriber.complete();\n        })\n        .catch((error) => subscriber.error(error));\n    });\n  }\n\n  public override list$(\n    pathParams: string[],\n    queryParams: KeyValue<string, string>[],\n  ): Observable<EntityModel[]> {\n    // Convert path and query parameters to QueryOptions for abstraction\n    const queryOptions = QueryParamsUtil.buildQueryOptionsFromParams(pathParams, queryParams);\n\n    // Delegate to the abstract query method for implementation flexibility\n    return this.query(queryOptions);\n  }\n\n  public listByIds$(ids: string[]): Observable<EntityModel[]> {\n    return runInInjectionContext(this.injector, () => {\n      if (ids.length === 0) {\n        return new Observable<EntityModel[]>((subscriber) => {\n          subscriber.next([]);\n          subscriber.complete();\n        });\n      }\n\n      const entitiesQuery = query(this.collectionRef, where('uid', 'in', ids));\n\n      return new Observable<EntityModel[]>((subscriber) => {\n        getDocs(entitiesQuery)\n          .then((snapshot) => {\n            const entities = EntityMapperHelper.mapDocumentsWithoutUid<EntityModel>(snapshot.docs);\n            subscriber.next(entities);\n            subscriber.complete();\n          })\n          .catch((error) => subscriber.error(error));\n      });\n    });\n  }\n\n  public override load$(uid: string): Observable<EntityModel | undefined> {\n    return runInInjectionContext(this.injector, () => {\n      const entityDocument = doc(this.firestore, `${this.resolvedFeatureKey}/${uid}`);\n\n      return docData(entityDocument, {\n        idField: 'uid',\n      }) as Observable<EntityModel>;\n    });\n  }\n\n  public override query(options: QueryOptions): Observable<Entity[]> {\n    return new Observable<Entity[]>((subscriber) => {\n      // Prepare options with defaults and search filters\n      const queryOptions = QueryOptionsHelper.prepare(options);\n\n      // Build all constraints using the builder\n      const constraints = QueryConstraintBuilder.build(queryOptions);\n      const entitiesQuery = query(this.collectionRef, ...constraints);\n\n      getDocs(entitiesQuery)\n        .then((snapshot) => {\n          let entities = EntityMapperHelper.mapDocuments<Entity>(snapshot.docs);\n\n          // Apply client-side search filtering for additional fields\n          entities = EntityMapperHelper.applySearchFilter(entities, options.search);\n\n          subscriber.next(entities);\n          subscriber.complete();\n        })\n        .catch((error) => {\n          console.error(error);\n          subscriber.error(error);\n        });\n    });\n  }\n\n  public override queryPaginated(\n    options: QueryOptions,\n    pageSize: number,\n    lastDocument?: Entity,\n  ): Observable<PaginatedResult<Entity>> {\n    return new Observable<PaginatedResult<Entity>>((subscriber) => {\n      // Prepare options for pagination\n      const paginatedOptions = QueryOptionsHelper.prepareForPagination(\n        options,\n        pageSize,\n        lastDocument?.uid,\n      );\n\n      // Build constraints and execute query\n      const constraints = QueryConstraintBuilder.build(paginatedOptions);\n      const entitiesQuery = query(this.collectionRef, ...constraints);\n\n      getDocs(entitiesQuery)\n        .then((snapshot) => {\n          let entities = EntityMapperHelper.mapDocuments<Entity>(snapshot.docs);\n          entities = EntityMapperHelper.applySearchFilter(entities, options.search);\n\n          subscriber.next({\n            items: entities,\n            totalItems: entities.length,\n            totalPages: Math.ceil(entities.length / pageSize),\n            currentPage: 1,\n            hasNext: entities.length === pageSize,\n            hasPrevious: !!lastDocument,\n          });\n          subscriber.complete();\n        })\n        .catch((error) => subscriber.error(error));\n    });\n  }\n\n  /**\n   * Query with cursor-based pagination (more efficient for Firestore)\n   * Returns cursor information for next/previous page navigation\n   */\n  public queryCursorPaginated(options: QueryOptions): Observable<CursorPaginatedResult<Entity>> {\n    return new Observable<CursorPaginatedResult<Entity>>((subscriber) => {\n      const pageSize = options.limit || DEFAULT_PAGE_SIZE;\n\n      // Prepare options with search filters\n      const queryOptions = QueryOptionsHelper.prepare(options);\n\n      // Fetch one extra to determine hasNext\n      const constraints = QueryConstraintBuilder.buildWithExtraForPagination(queryOptions);\n      const entitiesQuery = query(this.collectionRef, ...constraints);\n\n      getDocs(entitiesQuery)\n        .then((snapshot) => {\n          let entities = EntityMapperHelper.mapDocuments<Entity>(snapshot.docs);\n          entities = EntityMapperHelper.applySearchFilter(entities, options.search);\n\n          // Check if there are more results\n          const hasNext = entities.length > pageSize;\n          if (hasNext) {\n            entities = entities.slice(0, pageSize);\n          }\n\n          subscriber.next({\n            items: entities,\n            hasNext,\n            hasPrevious: !!options.startAfter,\n            firstCursor: entities.length > 0 ? entities[0].uid : undefined,\n            lastCursor: entities.length > 0 ? entities[entities.length - 1].uid : undefined,\n          });\n          subscriber.complete();\n        })\n        .catch((error) => subscriber.error(error));\n    });\n  }\n\n  public search$(params: SearchParams): Observable<EntityModel[]> {\n    return runInInjectionContext(this.injector, () => {\n      if (!params || params.length === 0) {\n        return new Observable<EntityModel[]>((subscriber) => {\n          subscriber.next([]);\n          subscriber.complete();\n        });\n      }\n\n      const queries: QueryConstraint[] = params.map((param: any) =>\n        where(param.query.field, param.query.operation, param.query.value),\n      );\n\n      const entityQuery = query(this.collectionRef, ...queries);\n\n      return new Observable<EntityModel[]>((subscriber) => {\n        getDocs(entityQuery)\n          .then((snapshot) => {\n            const entities = EntityMapperHelper.mapDocumentsWithoutUid<EntityModel>(snapshot.docs);\n            subscriber.next(entities);\n            subscriber.complete();\n          })\n          .catch((error) => subscriber.error(error));\n      });\n    });\n  }\n\n  public override update$(entityUpdate: EntityModelUpdate): Observable<EntityModelUpdate> {\n    return runInInjectionContext(this.injector, () => {\n      const newEntity: EntityModel = {\n        ...entityUpdate,\n      } as EntityModel;\n\n      // Use entity data to resolve collection path\n      const collectionRef = this.getCollectionRef(newEntity);\n\n      return new Observable<EntityModelUpdate>((subscriber) => {\n        // Use merge: true to only update the provided fields, not replace the entire document\n        setDoc(doc(collectionRef, entityUpdate.uid), newEntity, { merge: true })\n          .then(() => {\n            subscriber.next(newEntity as EntityModelUpdate);\n            subscriber.complete();\n          })\n          .catch((error) => {\n            subscriber.error(error);\n          });\n      });\n    });\n  }\n\n  /**\n   * Query entities by parent ID (for subcollections)\n   * @param parentId The ID of the parent entity\n   * @param options Optional query options for filtering/sorting\n   */\n  public queryByParentId$(parentId: string, options?: QueryOptions): Observable<EntityModel[]> {\n    if (!this.subcollectionContext) {\n      throw new Error('queryByParentId$ requires subcollectionContext');\n    }\n\n    const parentContext = { [this.subcollectionContext.parentIdField]: parentId };\n    const collectionRef = this.getCollectionRef(parentContext);\n\n    return new Observable<EntityModel[]>((subscriber) => {\n      // Prepare options and build constraints\n      const queryOptions = options ? QueryOptionsHelper.prepare(options) : {};\n      const constraints = QueryConstraintBuilder.build(queryOptions);\n      const entitiesQuery = query(collectionRef, ...constraints);\n\n      getDocs(entitiesQuery)\n        .then((snapshot) => {\n          let entities = EntityMapperHelper.mapDocuments<EntityModel>(snapshot.docs);\n          entities = EntityMapperHelper.applySearchFilter(entities, options?.search);\n          subscriber.next(entities);\n          subscriber.complete();\n        })\n        .catch((error) => subscriber.error(error));\n    });\n  }\n\n  /**\n   * Real-time query with snapshot listener (continuous updates)\n   * Use this when you need live updates from Firestore\n   * Note: This creates a persistent connection and incurs read costs on every change\n   */\n  public queryRealtime$(options: QueryOptions): Observable<Entity[]> {\n    return runInInjectionContext(this.injector, () => {\n      // Prepare options with defaults and search filters\n      const queryOptions = QueryOptionsHelper.prepare(options);\n\n      // Build constraints and create query\n      const constraints = QueryConstraintBuilder.build(queryOptions);\n      const entitiesQuery = query(this.collectionRef, ...constraints);\n\n      // Use collectionData for real-time updates\n      return collectionData(entitiesQuery, { idField: 'uid' }) as Observable<Entity[]>;\n    });\n  }\n\n  /**\n   * Real-time load with snapshot listener (continuous updates for single document)\n   * Use this when you need live updates for a single entity\n   * Note: This creates a persistent connection and incurs read costs on every change\n   */\n  public loadRealtime$(uid: string): Observable<EntityModel | undefined> {\n    return runInInjectionContext(this.injector, () => {\n      const entityDocument = doc(this.firestore, `${this.resolvedFeatureKey}/${uid}`);\n\n      return docData(entityDocument, {\n        idField: 'uid',\n      }) as Observable<EntityModel>;\n    });\n  }\n}\n","import { inject, Provider } from '@angular/core';\nimport { Firestore } from '@angular/fire/firestore';\nimport {\n  EntityModel,\n  EntityModelAdd,\n  EntityModelUpdate,\n  FIRESTORE_ENGINE_CREATOR,\n  RepositoryEngine,\n  RepositoryEngineCreator,\n  SubcollectionContext,\n} from '@zs-soft/core-api';\n\nimport { FirestoreRepositoryEngine } from './firestore-repository.engine';\n\n/**\n * Factory function that creates a Firestore repository engine\n * This is injected via FIRESTORE_ENGINE_CREATOR token\n */\nfunction createFirestoreEngineCreator(firestore: Firestore): RepositoryEngineCreator {\n  return <R extends EntityModel, S extends EntityModelAdd, T extends EntityModelUpdate>(\n    featureKey: string | (() => string),\n    subcollectionContext?: SubcollectionContext,\n  ): RepositoryEngine<R, S, T> => {\n    return new FirestoreRepositoryEngine(\n      firestore,\n      featureKey,\n      subcollectionContext,\n    ) as unknown as RepositoryEngine<R, S, T>;\n  };\n}\n\n/**\n * Provides the FIRESTORE_ENGINE_CREATOR for use with RepositoryEngineFactory\n * Add this to your app.config.ts providers array\n *\n * @example\n * ```typescript\n * export const appConfig: ApplicationConfig = {\n *   providers: [\n *     provideFirestoreEngine(),\n *     // ... other providers\n *   ],\n * };\n * ```\n */\nexport function provideFirestoreEngine(): Provider {\n  return {\n    provide: FIRESTORE_ENGINE_CREATOR,\n    useFactory: () => {\n      const firestore = inject(Firestore);\n      return createFirestoreEngineCreator(firestore);\n    },\n  };\n}\n","/*\n * Public API Surface of firestore-repository-engine\n */\n\nexport * from './lib/firestore-repository.engine';\nexport * from './lib/firestore-engine.provider';\nexport * from './lib/helpers/entity-mapper.helper';\nexport * from './lib/helpers/query-options.helper';\nexport * from './lib/utils/query-constraint.builder';\nexport * from './lib/utils/query-params.util';\nexport * from './lib/utils/search.util';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@zs-soft/firestore-repository-engine",
+  "version": "0.10.0",
+  "description": "Firestore repository engine for Angular applications",
+  "author": "zssz-soft",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zssz-soft/libraries.git",
+    "directory": "projects/firestore-repository-engine"
+  },
+  "homepage": "https://github.com/zssz-soft/libraries/tree/main/projects/firestore-repository-engine",
+  "bugs": {
+    "url": "https://github.com/zssz-soft/libraries/issues"
+  },
+  "keywords": [
+    "angular",
+    "firestore",
+    "repository",
+    "firebase"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@angular/common": "^21.2.0",
+    "@angular/core": "^21.2.0",
+    "@angular/fire": "^21.2.0",
+    "@zs-soft/common-api": "^0.10.0",
+    "@zs-soft/core-api": "^0.10.0",
+    "rxjs": "^7.0.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "tags": [
+    "type:engine",
+    "scope:shared"
+  ],
+  "module": "fesm2022/zs-soft-firestore-repository-engine.mjs",
+  "typings": "types/zs-soft-firestore-repository-engine.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/zs-soft-firestore-repository-engine.d.ts",
+      "default": "./fesm2022/zs-soft-firestore-repository-engine.mjs"
+    }
+  }
+}

package/types/zs-soft-firestore-repository-engine.d.ts

@@ -0,0 +1,253 @@
+import { Observable } from 'rxjs';
+import { KeyValue } from '@angular/common';
+import { Firestore, CollectionReference, QueryDocumentSnapshot, DocumentData, QueryConstraint } from '@angular/fire/firestore';
+import { QueryOptions, PaginatedResult, CursorPaginatedResult, SearchParams, SearchOptions, QueryFilter } from '@zs-soft/common-api';
+import { RepositoryEngine, EntityModel, EntityModelAdd, EntityModelUpdate, SubcollectionContext, CollectionPathBuilder, BatchOperation, Entity } from '@zs-soft/core-api';
+import { Provider } from '@angular/core';
+
+declare class FirestoreRepositoryEngine extends RepositoryEngine<EntityModel, EntityModelAdd, EntityModelUpdate> {
+    protected firestore: Firestore;
+    protected featureKey: string | (() => string);
+    protected subcollectionContext?: SubcollectionContext | undefined;
+    private injector;
+    protected collectionPathBuilder: CollectionPathBuilder;
+    constructor(firestore: Firestore, featureKey: string | (() => string), subcollectionContext?: SubcollectionContext | undefined);
+    /**
+     * Resolves the feature key, supporting both static strings and dynamic functions.
+     * Dynamic functions enable multi-tenant scenarios where the collection path
+     * depends on runtime context (e.g., active tenant ID).
+     */
+    protected get resolvedFeatureKey(): string;
+    /**
+     * Lazily resolved collection reference based on the current feature key.
+     * For dynamic (function-based) feature keys, this re-evaluates on every access,
+     * enabling tenant-switching without recreating the engine.
+     */
+    protected get collectionRef(): CollectionReference<EntityModel>;
+    /**
+     * Creates a path builder function based on subcollection context
+     */
+    private createPathBuilder;
+    /**
+     * Gets collection reference for specific entity data
+     */
+    private getCollectionRef;
+    batch(operations: BatchOperation<Entity>[]): Observable<void>;
+    count(options?: QueryOptions): Observable<number>;
+    create$(entityAdd: EntityModelAdd): Observable<EntityModel>;
+    delete$(entity: EntityModel): Observable<EntityModel>;
+    exists(uid: string): Observable<boolean>;
+    list$(pathParams: string[], queryParams: KeyValue<string, string>[]): Observable<EntityModel[]>;
+    listByIds$(ids: string[]): Observable<EntityModel[]>;
+    load$(uid: string): Observable<EntityModel | undefined>;
+    query(options: QueryOptions): Observable<Entity[]>;
+    queryPaginated(options: QueryOptions, pageSize: number, lastDocument?: Entity): Observable<PaginatedResult<Entity>>;
+    /**
+     * Query with cursor-based pagination (more efficient for Firestore)
+     * Returns cursor information for next/previous page navigation
+     */
+    queryCursorPaginated(options: QueryOptions): Observable<CursorPaginatedResult<Entity>>;
+    search$(params: SearchParams): Observable<EntityModel[]>;
+    update$(entityUpdate: EntityModelUpdate): Observable<EntityModelUpdate>;
+    /**
+     * Query entities by parent ID (for subcollections)
+     * @param parentId The ID of the parent entity
+     * @param options Optional query options for filtering/sorting
+     */
+    queryByParentId$(parentId: string, options?: QueryOptions): Observable<EntityModel[]>;
+    /**
+     * Real-time query with snapshot listener (continuous updates)
+     * Use this when you need live updates from Firestore
+     * Note: This creates a persistent connection and incurs read costs on every change
+     */
+    queryRealtime$(options: QueryOptions): Observable<Entity[]>;
+    /**
+     * Real-time load with snapshot listener (continuous updates for single document)
+     * Use this when you need live updates for a single entity
+     * Note: This creates a persistent connection and incurs read costs on every change
+     */
+    loadRealtime$(uid: string): Observable<EntityModel | undefined>;
+}
+
+/**
+ * Provides the FIRESTORE_ENGINE_CREATOR for use with RepositoryEngineFactory
+ * Add this to your app.config.ts providers array
+ *
+ * @example
+ * ```typescript
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideFirestoreEngine(),
+ *     // ... other providers
+ *   ],
+ * };
+ * ```
+ */
+declare function provideFirestoreEngine(): Provider;
+
+/**
+ * Helper for mapping Firestore documents to entities
+ *
+ * Design Pattern: Factory Pattern
+ * - Központosított objektum létrehozás Firestore dokumentumokból
+ * - Egységes mapping logika az egész alkalmazásban
+ * - Könnyen bővíthető új mapping stratégiákkal
+ *
+ * Előnyök:
+ * - DRY: Nem ismétlődik a mapping kód minden metódusban
+ * - Tesztelhetőség: Izoláltan tesztelhető a mapping logika
+ * - Karbantarthatóság: Egy helyen módosítható a mapping
+ */
+declare class EntityMapperHelper {
+    /**
+     * Map a single document snapshot to an entity
+     */
+    static mapDocument<T extends Entity>(docSnapshot: QueryDocumentSnapshot<DocumentData>): T;
+    /**
+     * Map a single document snapshot, excluding uid from data
+     */
+    static mapDocumentWithoutUid<T extends EntityModel>(docSnapshot: QueryDocumentSnapshot<DocumentData>): T;
+    /**
+     * Map multiple document snapshots to entities
+     */
+    static mapDocuments<T extends Entity>(docs: QueryDocumentSnapshot<DocumentData>[]): T[];
+    /**
+     * Map multiple document snapshots, excluding uid from data
+     */
+    static mapDocumentsWithoutUid<T extends EntityModel>(docs: QueryDocumentSnapshot<DocumentData>[]): T[];
+    /**
+     * Apply client-side search filtering if needed
+     * Only applies when search has multiple fields (first field is server-side)
+     */
+    static applySearchFilter<T extends Entity>(entities: T[], search?: SearchOptions): T[];
+}
+
+/**
+ * Helper for processing and preparing QueryOptions
+ *
+ * Design Pattern: Strategy Pattern (előkészítő)
+ * - Különböző query előkészítési stratégiák (alap, paginált)
+ * - A konkrét végrehajtás a QueryConstraintBuilder-re delegálódik
+ * - Könnyen bővíthető új stratégiákkal (pl. aggregált, real-time)
+ *
+ * Előnyök:
+ * - Szétválasztás: Query előkészítés és végrehajtás külön
+ * - Újrafelhasználhatóság: Azonos előkészítés több metódusban
+ * - Tesztelhetőség: Az előkészítési logika izoláltan tesztelhető
+ */
+declare class QueryOptionsHelper {
+    /**
+     * Prepare query options with defaults and search filters
+     */
+    static prepare(options: QueryOptions): QueryOptions;
+    /**
+     * Prepare options for pagination with custom page size
+     */
+    static prepareForPagination(options: QueryOptions, pageSize: number, startAfterCursor?: string): QueryOptions;
+    /**
+     * Check if search requires client-side filtering
+     * (when multiple fields are specified, only first is server-side)
+     */
+    static requiresClientSideSearch(options: QueryOptions): boolean;
+}
+
+/**
+ * Builds Firestore QueryConstraints from QueryOptions
+ *
+ * Design Pattern: Builder Pattern
+ * - Lépésről lépésre építi fel a komplex Firestore query-t
+ * - Elválasztja a konstrukciós logikát a reprezentációtól
+ * - Különböző constraint típusok moduláris kezelése
+ *
+ * Előnyök:
+ * - Olvashatóság: A query építés lépései világosak
+ * - Bővíthetőség: Új constraint típusok könnyen hozzáadhatók
+ * - Tesztelhetőség: Minden builder metódus külön tesztelhető
+ * - Firestore szabályok: A constraint sorrend automatikusan helyes
+ *   (where → orderBy → cursor → limit)
+ */
+declare class QueryConstraintBuilder {
+    /**
+     * Build all query constraints from QueryOptions
+     */
+    static build(options: QueryOptions): QueryConstraint[];
+    /**
+     * Build where filter constraints
+     */
+    static buildWhereConstraints(options: QueryOptions): QueryConstraint[];
+    /**
+     * Build orderBy constraints
+     */
+    static buildOrderByConstraints(options: QueryOptions): QueryConstraint[];
+    /**
+     * Build cursor-based pagination constraints
+     * Note: Requires orderBy to be set for proper cursor pagination
+     */
+    static buildCursorConstraints(options: QueryOptions): QueryConstraint[];
+    /**
+     * Build limit constraints
+     */
+    static buildLimitConstraints(options: QueryOptions): QueryConstraint[];
+    /**
+     * Apply default limit if none specified
+     */
+    static applyDefaultLimit(options: QueryOptions): QueryOptions;
+    /**
+     * Build constraints for fetching one extra item to determine hasNext
+     */
+    static buildWithExtraForPagination(options: QueryOptions): QueryConstraint[];
+}
+
+/**
+ * Utility functions for converting query parameters to QueryOptions
+ * Separated for better testability and reusability
+ */
+declare class QueryParamsUtil {
+    /**
+     * Convert path parameters and query parameters into QueryOptions
+     * This allows the list method to work with different implementations (Firestore, REST, etc.)
+     */
+    static buildQueryOptionsFromParams(pathParams: string[], queryParams: KeyValue<string, string>[]): QueryOptions;
+    /**
+     * Parse filter value to appropriate type (string, number, boolean, etc.)
+     */
+    static parseFilterValue(value: string): any;
+}
+
+/**
+ * Utility for Firestore text search operations
+ * Note: Firestore doesn't support full-text search natively.
+ * This implements prefix-based search using >= and < operators.
+ */
+declare class SearchUtil {
+    /**
+     * Validates search options
+     * Returns true if search term meets minimum length requirement
+     */
+    static isValidSearch(search: SearchOptions | undefined): boolean;
+    /**
+     * Build Firestore-compatible prefix search filters for a single field
+     * Uses >= term and < term + high Unicode character for prefix matching
+     *
+     * Example: searching "John" will match "John", "Johnny", "Johnson"
+     */
+    static buildPrefixSearchFilter(field: string, term: string): QueryFilter[];
+    /**
+     * Build search filters for the first searchable field
+     * Note: Firestore only supports range queries on a single field,
+     * so we can only search one field at a time with prefix matching
+     */
+    static buildSearchFilters(search: SearchOptions): QueryFilter[];
+    /**
+     * Check if an entity matches search criteria (client-side filtering)
+     * Used for additional fields that couldn't be queried server-side
+     */
+    static matchesSearch(entity: Record<string, unknown>, search: SearchOptions): boolean;
+    /**
+     * Filter entities client-side for multi-field search
+     * Use this after fetching data when you need to search multiple fields
+     */
+    static filterBySearch<T extends Record<string, unknown>>(entities: T[], search: SearchOptions): T[];
+}
+
+export { EntityMapperHelper, FirestoreRepositoryEngine, QueryConstraintBuilder, QueryOptionsHelper, QueryParamsUtil, SearchUtil, provideFirestoreEngine };