svelte-firekit 0.0.25 → 0.1.0

package/dist/services/collection.svelte.js

@@ -0,0 +1,871 @@
+/**
+ * @fileoverview FirekitCollection - Optimized collection management for Svelte applications
+ * @module FirekitCollection
+ * @version 1.0.0
+ */
+import { collection, collectionGroup, query, onSnapshot, getDocs, where, orderBy, limit, startAt, startAfter, endAt, endBefore } from 'firebase/firestore';
+import { firebaseService } from '../firebase.js';
+import { browser } from '$app/environment';
+import { CollectionErrorCode, CollectionError } from '../types/collection.js';
+/**
+ * Query builder implementation for type-safe query construction
+ */
+class FirekitQueryBuilder {
+    constraints = [];
+    where(field, operator, value) {
+        this.constraints.push(where(field, operator, value));
+        return this;
+    }
+    orderBy(field, direction = 'asc') {
+        this.constraints.push(orderBy(field, direction));
+        return this;
+    }
+    limit(count) {
+        this.constraints.push(limit(count));
+        return this;
+    }
+    startAt(...values) {
+        this.constraints.push(startAt(...values));
+        return this;
+    }
+    startAfter(...values) {
+        this.constraints.push(startAfter(...values));
+        return this;
+    }
+    endAt(...values) {
+        this.constraints.push(endAt(...values));
+        return this;
+    }
+    endBefore(...values) {
+        this.constraints.push(endBefore(...values));
+        return this;
+    }
+    build() {
+        return [...this.constraints];
+    }
+}
+/**
+ * Comprehensive Firestore collection management with real-time updates and advanced features.
+ * Uses Svelte 5 runes for optimal reactivity and performance.
+ *
+ * @class FirekitCollection
+ * @template T Document data type
+ *
+ * @example
+ * ```typescript
+ * interface User {
+ *   id: string;
+ *   name: string;
+ *   email: string;
+ *   active: boolean;
+ * }
+ *
+ * // Simple collection subscription
+ * const users = firekitCollection<User>('users');
+ *
+ * // With query constraints
+ * const activeUsers = firekitCollection<User>('users',
+ *   where('active', '==', true),
+ *   orderBy('name'),
+ *   limit(10)
+ * );
+ *
+ * // With advanced options
+ * const paginatedUsers = firekitCollection<User>('users', {
+ *   pagination: { enabled: true, pageSize: 20 },
+ *   cache: { enabled: true, ttl: 300000 },
+ *   transform: (doc) => ({ ...doc, displayName: doc.name.toUpperCase() })
+ * });
+ *
+ * // Access reactive state
+ * $: if (users.loading) {
+ *   console.log('Loading...');
+ * } else if (users.error) {
+ *   console.error('Error:', users.error);
+ * } else {
+ *   console.log('Users:', users.data);
+ * }
+ * ```
+ */
+class FirekitCollection {
+    // Reactive state using Svelte 5 runes
+    _data = $state([]);
+    _loading = $state(true);
+    _initialized = $state(false);
+    _error = $state(null);
+    _lastUpdated = $state(null);
+    // Internal state
+    collectionRef = null;
+    queryRef = null;
+    unsubscribe = null;
+    eventListeners = new Set();
+    options;
+    stats = this.initializeStats();
+    cache = new Map();
+    collectionPath;
+    /**
+     * Creates a collection subscription
+     *
+     * @param path Collection path
+     * @param constraintsOrOptions Query constraints or collection options
+     * @param additionalConstraints Additional constraints if options were provided
+     */
+    constructor(path, constraintsOrOptions, ...additionalConstraints) {
+        this.collectionPath = path;
+        // Parse constructor arguments
+        if (Array.isArray(constraintsOrOptions)) {
+            // Old style: path, ...constraints
+            this.options = {};
+            this.initializeCollection([...constraintsOrOptions, ...additionalConstraints]);
+        }
+        else {
+            // New style: path, options, ...constraints
+            this.options = constraintsOrOptions || {};
+            // Only use additionalConstraints since options object doesn't contain constraints
+            this.initializeCollection(additionalConstraints);
+        }
+    }
+    /**
+     * Initialize statistics object
+     */
+    initializeStats() {
+        return {
+            totalDocuments: 0,
+            readCount: 0,
+            writeCount: 0,
+            cacheHitRate: 0,
+            averageQueryTime: 0,
+            lastActivity: new Date(),
+            memoryUsage: 0
+        };
+    }
+    /**
+     * Initialize collection subscription
+     */
+    async initializeCollection(constraints) {
+        if (!browser)
+            return;
+        try {
+            const firestore = firebaseService.getDbInstance();
+            if (!firestore) {
+                throw new CollectionError(CollectionErrorCode.COLLECTION_UNAVAILABLE, 'Firestore instance not available', this.collectionPath);
+            }
+            // Check cache first
+            const cacheKey = this.getCacheKey(constraints);
+            if (this.options.cache?.enabled && this.isCacheValid(cacheKey)) {
+                const cached = this.cache.get(cacheKey);
+                this._data = cached.data;
+                this._loading = false;
+                this._initialized = true;
+                this._lastUpdated = cached.timestamp;
+                this.emitEvent({
+                    type: 'cache_hit',
+                    data: cached.data,
+                    timestamp: new Date(),
+                    path: this.collectionPath
+                });
+                this.stats.cacheHitRate = (this.stats.cacheHitRate + 1) / 2;
+            }
+            // Create collection reference
+            this.collectionRef = collection(firestore, this.collectionPath);
+            // Create query with constraints
+            this.queryRef =
+                constraints.length > 0 ? query(this.collectionRef, ...constraints) : this.collectionRef;
+            // Set up real-time listener or one-time fetch
+            if (this.options.realtime !== false) {
+                this.setupRealtimeListener();
+            }
+            else {
+                await this.fetchOnce();
+            }
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Set up real-time document listener
+     */
+    setupRealtimeListener() {
+        if (!this.queryRef)
+            return;
+        this.emitEvent({
+            type: 'loading_started',
+            timestamp: new Date(),
+            path: this.collectionPath
+        });
+        const options = {
+            includeMetadataChanges: this.options.includeMetadata || false
+        };
+        this.unsubscribe = onSnapshot(this.queryRef, options, (snapshot) => {
+            this.processSnapshot(snapshot);
+        }, (error) => {
+            this.handleError(error);
+        });
+    }
+    /**
+     * Fetch collection data once (no real-time updates)
+     */
+    async fetchOnce() {
+        if (!this.queryRef)
+            return;
+        try {
+            this._loading = true;
+            this.emitEvent({
+                type: 'loading_started',
+                timestamp: new Date(),
+                path: this.collectionPath
+            });
+            const startTime = Date.now();
+            const snapshot = await getDocs(this.queryRef);
+            const queryTime = Date.now() - startTime;
+            this.stats.averageQueryTime = (this.stats.averageQueryTime + queryTime) / 2;
+            this.processSnapshot(snapshot);
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Process query snapshot and update state
+     */
+    processSnapshot(snapshot) {
+        try {
+            const startTime = Date.now();
+            // Extract documents with ID
+            let documents = snapshot.docs.map((doc) => {
+                const data = doc.data();
+                return { id: doc.id, ...data };
+            });
+            // Apply transform function if provided
+            if (this.options.transform) {
+                documents = documents.map(this.options.transform);
+            }
+            // Apply filter function if provided
+            if (this.options.filter) {
+                documents = documents.filter(this.options.filter);
+            }
+            // Apply sort function if provided
+            if (this.options.sort) {
+                documents = documents.sort(this.options.sort);
+            }
+            // Track document changes for events
+            const changes = this.calculateChanges(this._data, documents);
+            // Update reactive state
+            this._data = documents;
+            this._loading = false;
+            this._initialized = true;
+            this._error = null;
+            this._lastUpdated = new Date();
+            // Update statistics
+            this.stats.totalDocuments = documents.length;
+            this.stats.readCount++;
+            this.stats.lastActivity = new Date();
+            this.stats.memoryUsage = this.calculateMemoryUsage(documents);
+            // Update cache if enabled
+            if (this.options.cache?.enabled) {
+                const cacheKey = this.getCacheKey([]);
+                this.cache.set(cacheKey, {
+                    data: documents,
+                    timestamp: new Date()
+                });
+                this.cleanupCache();
+            }
+            // Emit events
+            this.emitEvent({
+                type: 'data_changed',
+                data: documents,
+                changes,
+                timestamp: new Date(),
+                path: this.collectionPath
+            });
+            this.emitEvent({
+                type: 'loading_finished',
+                data: {
+                    documentCount: documents.length,
+                    processingTime: Date.now() - startTime
+                },
+                timestamp: new Date(),
+                path: this.collectionPath
+            });
+            // Emit individual change events
+            changes.forEach((change) => {
+                this.emitEvent({
+                    type: `document_${change.type}`,
+                    data: change.doc,
+                    changes: [change],
+                    timestamp: new Date(),
+                    path: this.collectionPath
+                });
+            });
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Calculate changes between old and new document arrays
+     */
+    calculateChanges(oldDocs, newDocs) {
+        const changes = [];
+        const oldMap = new Map(oldDocs.map((doc, index) => [doc.id, { doc, index }]));
+        const newMap = new Map(newDocs.map((doc, index) => [doc.id, { doc, index }]));
+        // Find added and modified documents
+        newDocs.forEach((newDoc, newIndex) => {
+            const id = newDoc.id;
+            const oldEntry = oldMap.get(id);
+            if (!oldEntry) {
+                // Document was added
+                changes.push({
+                    type: 'added',
+                    doc: newDoc,
+                    oldIndex: -1,
+                    newIndex,
+                    timestamp: new Date()
+                });
+            }
+            else if (JSON.stringify(oldEntry.doc) !== JSON.stringify(newDoc)) {
+                // Document was modified
+                changes.push({
+                    type: 'modified',
+                    doc: newDoc,
+                    oldIndex: oldEntry.index,
+                    newIndex,
+                    timestamp: new Date()
+                });
+            }
+        });
+        // Find removed documents
+        oldDocs.forEach((oldDoc, oldIndex) => {
+            const id = oldDoc.id;
+            if (!newMap.has(id)) {
+                changes.push({
+                    type: 'removed',
+                    doc: oldDoc,
+                    oldIndex,
+                    newIndex: -1,
+                    timestamp: new Date()
+                });
+            }
+        });
+        return changes;
+    }
+    /**
+     * Handle and process errors
+     */
+    handleError(error) {
+        let collectionError;
+        if (error instanceof CollectionError) {
+            collectionError = error;
+        }
+        else {
+            // Map Firestore errors to CollectionError
+            const code = this.mapFirestoreErrorCode(error.code);
+            collectionError = new CollectionError(code, error.message || 'An unknown error occurred', this.collectionPath, [], error);
+        }
+        this._error = collectionError;
+        this._loading = false;
+        this.emitEvent({
+            type: 'error',
+            error: collectionError,
+            timestamp: new Date(),
+            path: this.collectionPath
+        });
+        console.error('FirekitCollection error:', collectionError);
+    }
+    /**
+     * Map Firestore error codes to CollectionErrorCode
+     */
+    mapFirestoreErrorCode(firestoreCode) {
+        switch (firestoreCode) {
+            case 'permission-denied':
+                return CollectionErrorCode.PERMISSION_DENIED;
+            case 'not-found':
+                return CollectionErrorCode.NOT_FOUND;
+            case 'unavailable':
+                return CollectionErrorCode.UNAVAILABLE;
+            case 'deadline-exceeded':
+                return CollectionErrorCode.DEADLINE_EXCEEDED;
+            case 'unauthenticated':
+                return CollectionErrorCode.UNAUTHENTICATED;
+            case 'resource-exhausted':
+                return CollectionErrorCode.RESOURCE_EXHAUSTED;
+            case 'failed-precondition':
+                return CollectionErrorCode.FAILED_PRECONDITION;
+            case 'aborted':
+                return CollectionErrorCode.ABORTED;
+            case 'out-of-range':
+                return CollectionErrorCode.OUT_OF_RANGE;
+            case 'unimplemented':
+                return CollectionErrorCode.UNIMPLEMENTED;
+            case 'internal':
+                return CollectionErrorCode.INTERNAL_ERROR;
+            case 'data-loss':
+                return CollectionErrorCode.DATA_LOSS;
+            case 'cancelled':
+                return CollectionErrorCode.CANCELLED;
+            default:
+                return CollectionErrorCode.UNKNOWN;
+        }
+    }
+    /**
+     * Generate cache key for query
+     */
+    getCacheKey(constraints) {
+        if (this.options.cache?.customKey) {
+            return this.options.cache.customKey(this.collectionPath, constraints);
+        }
+        // More reliable constraint serialization
+        const constraintString = constraints
+            .map((c) => {
+            try {
+                return JSON.stringify(c);
+            }
+            catch {
+                return c.toString();
+            }
+        })
+            .join('|');
+        return `${this.collectionPath}:${constraintString}`;
+    }
+    /**
+     * Check if cache entry is still valid
+     */
+    isCacheValid(cacheKey) {
+        const cached = this.cache.get(cacheKey);
+        if (!cached)
+            return false;
+        const ttl = this.options.cache?.ttl || 300000; // 5 minutes default
+        return Date.now() - cached.timestamp.getTime() < ttl;
+    }
+    /**
+     * Clean up expired cache entries
+     */
+    cleanupCache() {
+        const maxSize = this.options.cache?.maxSize || 100;
+        const ttl = this.options.cache?.ttl || 300000;
+        const now = Date.now();
+        // Remove expired entries
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp.getTime() > ttl) {
+                this.cache.delete(key);
+            }
+        }
+        // Remove oldest entries if cache is too large
+        if (this.cache.size > maxSize) {
+            const entries = Array.from(this.cache.entries()).sort((a, b) => a[1].timestamp.getTime() - b[1].timestamp.getTime());
+            const toRemove = entries.slice(0, this.cache.size - maxSize);
+            toRemove.forEach(([key]) => this.cache.delete(key));
+        }
+    }
+    /**
+     * Calculate memory usage of documents
+     */
+    calculateMemoryUsage(documents) {
+        try {
+            return JSON.stringify(documents).length * 2; // Rough estimate
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * Emit event to all listeners
+     */
+    emitEvent(event) {
+        this.eventListeners.forEach((callback) => {
+            try {
+                callback(event);
+            }
+            catch (error) {
+                console.error('Error in collection event listener:', error);
+            }
+        });
+    }
+    // ========================================
+    // REACTIVE GETTERS (Public API)
+    // ========================================
+    /**
+     * Get current collection data
+     */
+    get data() {
+        return this._data;
+    }
+    /**
+     * Get loading state
+     */
+    get loading() {
+        return this._loading;
+    }
+    /**
+     * Get initialization state
+     */
+    get initialized() {
+        return this._initialized;
+    }
+    /**
+     * Get error state
+     */
+    get error() {
+        return this._error;
+    }
+    /**
+     * Check if collection is empty
+     */
+    get empty() {
+        return this._data.length === 0;
+    }
+    /**
+     * Get number of documents
+     */
+    get size() {
+        return this._data.length;
+    }
+    /**
+     * Get last update timestamp
+     */
+    get lastUpdated() {
+        return this._lastUpdated;
+    }
+    /**
+     * Get collection reference
+     */
+    get ref() {
+        if (!this.collectionRef) {
+            throw new CollectionError(CollectionErrorCode.REFERENCE_UNAVAILABLE, 'Collection reference not available', this.collectionPath);
+        }
+        return this.collectionRef;
+    }
+    /**
+     * Get query reference
+     */
+    get queryReference() {
+        if (!this.queryRef) {
+            throw new CollectionError(CollectionErrorCode.REFERENCE_UNAVAILABLE, 'Query reference not available', this.collectionPath);
+        }
+        return this.queryRef;
+    }
+    /**
+     * Get collection path
+     */
+    get path() {
+        return this.collectionPath;
+    }
+    /**
+     * Get collection state summary
+     */
+    get state() {
+        return {
+            data: this._data,
+            loading: this._loading,
+            initialized: this._initialized,
+            error: this._error,
+            empty: this.empty,
+            size: this.size,
+            lastUpdated: this._lastUpdated
+        };
+    }
+    // ========================================
+    // PUBLIC METHODS
+    // ========================================
+    /**
+     * Manually refresh collection data
+     */
+    async refresh() {
+        if (!this.queryRef) {
+            throw new CollectionError(CollectionErrorCode.REFERENCE_UNAVAILABLE, 'Cannot refresh: query reference not available', this.collectionPath);
+        }
+        try {
+            this._loading = true;
+            const snapshot = await getDocs(this.queryRef);
+            this.processSnapshot(snapshot);
+        }
+        catch (error) {
+            this.handleError(error);
+            throw error;
+        }
+    }
+    /**
+     * Get fresh data from server (bypassing cache)
+     */
+    async getFromServer() {
+        if (!this.queryRef) {
+            throw new CollectionError(CollectionErrorCode.REFERENCE_UNAVAILABLE, 'Cannot fetch: query reference not available', this.collectionPath);
+        }
+        try {
+            const snapshot = await getDocs(this.queryRef);
+            return snapshot.docs.map((doc) => {
+                const data = doc.data();
+                return { id: doc.id, ...data };
+            });
+        }
+        catch (error) {
+            this.handleError(error);
+            throw error;
+        }
+    }
+    /**
+     * Add query constraints to existing query
+     */
+    addConstraints(...constraints) {
+        if (!this.collectionRef) {
+            throw new CollectionError(CollectionErrorCode.REFERENCE_UNAVAILABLE, 'Cannot add constraints: collection reference not available', this.collectionPath);
+        }
+        const newQuery = query(this.queryRef || this.collectionRef, ...constraints);
+        const newCollection = new FirekitCollection(this.collectionPath, this.options);
+        newCollection.queryRef = newQuery;
+        newCollection.initializeCollection([]);
+        return newCollection;
+    }
+    /**
+     * Create a new query builder for this collection
+     */
+    createQuery() {
+        return new FirekitQueryBuilder();
+    }
+    /**
+     * Apply new query constraints
+     */
+    withQuery(builder) {
+        return this.addConstraints(...builder.build());
+    }
+    /**
+     * Filter documents by predicate
+     */
+    filter(predicate) {
+        return this._data.filter(predicate);
+    }
+    /**
+     * Find first document matching predicate
+     */
+    find(predicate) {
+        return this._data.find(predicate);
+    }
+    /**
+     * Find document by ID
+     */
+    findById(id) {
+        return this._data.find((doc) => doc.id === id);
+    }
+    /**
+     * Sort documents by field or custom function
+     */
+    sort(compareFn) {
+        return [...this._data].sort(compareFn);
+    }
+    /**
+     * Get paginated subset of documents
+     */
+    paginate(page, pageSize) {
+        const startIndex = (page - 1) * pageSize;
+        const endIndex = startIndex + pageSize;
+        return this._data.slice(startIndex, endIndex);
+    }
+    /**
+     * Group documents by field value
+     */
+    groupBy(field) {
+        const groups = new Map();
+        this._data.forEach((doc) => {
+            const key = doc[field];
+            if (!groups.has(key)) {
+                groups.set(key, []);
+            }
+            groups.get(key).push(doc);
+        });
+        return groups;
+    }
+    /**
+     * Get unique values for a field
+     */
+    unique(field) {
+        const values = this._data.map((doc) => doc[field]);
+        return Array.from(new Set(values));
+    }
+    /**
+     * Count documents matching predicate
+     */
+    count(predicate) {
+        return predicate ? this._data.filter(predicate).length : this._data.length;
+    }
+    /**
+     * Check if any document matches predicate
+     */
+    some(predicate) {
+        return this._data.some(predicate);
+    }
+    /**
+     * Check if all documents match predicate
+     */
+    every(predicate) {
+        return this._data.every(predicate);
+    }
+    /**
+     * Switch between realtime and one-time fetch modes
+     */
+    setRealtimeMode(realtime) {
+        if (this.options.realtime === realtime)
+            return;
+        this.options.realtime = realtime;
+        // Clean up existing listener
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+        // Set up new mode
+        if (realtime) {
+            this.setupRealtimeListener();
+        }
+    }
+    /**
+     * Clear cache for this collection
+     */
+    clearCache() {
+        const cacheKey = this.getCacheKey([]);
+        this.cache.delete(cacheKey);
+    }
+    /**
+     * Get collection statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats = this.initializeStats();
+    }
+    // ========================================
+    // EVENT MANAGEMENT
+    // ========================================
+    /**
+     * Add event listener
+     */
+    addEventListener(callback) {
+        this.eventListeners.add(callback);
+        return () => this.eventListeners.delete(callback);
+    }
+    /**
+     * Remove all event listeners
+     */
+    clearEventListeners() {
+        this.eventListeners.clear();
+    }
+    /**
+     * Wait for collection to initialize
+     */
+    async waitForInitialization() {
+        return new Promise((resolve) => {
+            if (this._initialized) {
+                resolve(this._data);
+                return;
+            }
+            const unsubscribe = this.addEventListener((event) => {
+                if (event.type === 'data_changed' || event.type === 'error') {
+                    unsubscribe();
+                    resolve(this._data);
+                }
+            });
+        });
+    }
+    // ========================================
+    // CLEANUP
+    // ========================================
+    /**
+     * Dispose of all resources and cleanup
+     */
+    dispose() {
+        // Unsubscribe from real-time updates
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+        // Clear cache
+        this.cache.clear();
+        // Clear event listeners
+        this.eventListeners.clear();
+        // Reset state
+        this._data = [];
+        this._loading = false;
+        this._initialized = false;
+        this._error = null;
+        this._lastUpdated = null;
+    }
+}
+/**
+ * Collection Group implementation for querying across multiple collections
+ */
+class FirekitCollectionGroup extends FirekitCollection {
+    constructor(collectionId, constraintsOrOptions, ...additionalConstraints) {
+        // Initialize with empty options to avoid parent constructor issues
+        super(`__collection_group__${collectionId}`, {});
+        // Parse constructor arguments properly
+        if (Array.isArray(constraintsOrOptions)) {
+            this.options = {};
+            this.initializeCollectionGroup(collectionId, [
+                ...constraintsOrOptions,
+                ...additionalConstraints
+            ]);
+        }
+        else {
+            this.options = constraintsOrOptions || {};
+            this.initializeCollectionGroup(collectionId, additionalConstraints);
+        }
+    }
+    /**
+     * Initialize collection group subscription
+     */
+    async initializeCollectionGroup(collectionId, constraints) {
+        if (!browser)
+            return;
+        try {
+            const firestore = firebaseService.getDbInstance();
+            if (!firestore) {
+                throw new CollectionError(CollectionErrorCode.COLLECTION_UNAVAILABLE, 'Firestore instance not available', collectionId);
+            }
+            // Create collection group reference
+            const groupRef = collectionGroup(firestore, collectionId);
+            // Create query with constraints
+            this.queryRef =
+                constraints.length > 0
+                    ? query(groupRef, ...constraints)
+                    : groupRef;
+            // Set up real-time listener or one-time fetch
+            if (this.options.realtime !== false) {
+                this.setupRealtimeListener();
+            }
+            else {
+                await this.fetchOnce();
+            }
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+}
+export function firekitCollection(path, constraintsOrOptions, ...additionalConstraints) {
+    if (Array.isArray(constraintsOrOptions)) {
+        return new FirekitCollection(path, [...constraintsOrOptions, ...additionalConstraints]);
+    }
+    else {
+        return new FirekitCollection(path, constraintsOrOptions, ...additionalConstraints);
+    }
+}
+/**
+ * Creates a one-time collection fetch (no real-time updates)
+ */
+export function firekitCollectionOnce(path, ...constraints) {
+    return new FirekitCollection(path, { realtime: false }, ...constraints);
+}
+export function firekitCollectionGroup(collectionId, constraintsOrOptions, ...additionalConstraints) {
+    if (Array.isArray(constraintsOrOptions)) {
+        return new FirekitCollectionGroup(collectionId, [
+            ...constraintsOrOptions,
+            ...additionalConstraints
+        ]);
+    }
+    else {
+        return new FirekitCollectionGroup(collectionId, constraintsOrOptions, ...additionalConstraints);
+    }
+}