@affectively/dash 5.2.1 → 5.3.1

package/dist/src/api/firebase/firestore/operations.js

@@ -1,490 +0,0 @@
-/**
- * Firestore document operations (read/write)
- */
-import { createFirebaseError } from '../errors.js';
-import { DocumentReferenceImpl, CollectionReferenceImpl, compileQuery } from './query.js';
-import { serializeFieldValue } from './data-types.js';
-// Mock storage for tests
-const mockStorage = new Map();
-// Mock listeners for tests
-export const mockListeners = new Map();
-// Make global for tests
-globalThis.mockListeners = mockListeners;
-// Trigger mock listeners
-export function triggerMockListeners(key, snapshot) {
-    const mockListeners = globalThis.mockListeners;
-    const listeners = mockListeners.get(key);
-    if (listeners) {
-        listeners.forEach((callback) => {
-            if (typeof callback === 'function') {
-                callback(snapshot);
-            }
-            else if (callback && typeof callback.next === 'function') {
-                callback.next(snapshot);
-            }
-        });
-    }
-}
-/**
- * Document snapshot implementation
- */
-export class DocumentSnapshotImpl {
-    _firestore;
-    _userDataWriter;
-    _doc;
-    ref;
-    metadata;
-    constructor(firestore, ref, data, metadata) {
-        this._firestore = firestore;
-        this.ref = ref;
-        this._doc = data;
-        this.metadata = metadata;
-    }
-    get id() {
-        return this.ref.id;
-    }
-    exists() {
-        return this._doc !== null && this._doc !== undefined;
-    }
-    data(options) {
-        if (!this.exists()) {
-            return undefined;
-        }
-        // Return deep copy to prevent mutations from affecting original
-        return this._deepCopy(this._doc);
-    }
-    get(fieldPath, options) {
-        if (!this.exists()) {
-            return undefined;
-        }
-        const segments = fieldPath.split('.');
-        let value = this._doc;
-        for (const segment of segments) {
-            if (value === null || value === undefined) {
-                return undefined;
-            }
-            value = value[segment];
-        }
-        return value;
-    }
-    toJSON() {
-        return this._doc;
-    }
-    _deepFreeze(obj) {
-        if (obj === null || typeof obj !== 'object') {
-            return obj;
-        }
-        if (Array.isArray(obj)) {
-            return Object.freeze(obj.map(item => this._deepFreeze(item)));
-        }
-        const frozen = { ...obj };
-        Object.keys(frozen).forEach(key => {
-            frozen[key] = this._deepFreeze(frozen[key]);
-        });
-        return Object.freeze(frozen);
-    }
-    _deepCopy(obj) {
-        if (obj === null || typeof obj !== 'object') {
-            return obj;
-        }
-        if (Array.isArray(obj)) {
-            return obj.map(item => this._deepCopy(item));
-        }
-        const copy = { ...obj };
-        Object.keys(copy).forEach(key => {
-            copy[key] = this._deepCopy(copy[key]);
-        });
-        return copy;
-    }
-}
-/**
- * Query snapshot implementation
- */
-export class QuerySnapshotImpl {
-    _firestore;
-    _snapshot;
-    query; // Accept CollectionReference as well
-    docs;
-    size;
-    empty;
-    metadata;
-    _docChanges = null;
-    constructor(firestore, query, docs, metadata) {
-        this._firestore = firestore;
-        this.query = query;
-        this.docs = docs;
-        this.size = docs.length;
-        this.empty = docs.length === 0;
-        this.metadata = metadata;
-    }
-    docChanges() {
-        if (this._docChanges === null) {
-            this._docChanges = this.docs.map((doc, index) => ({
-                type: 'added',
-                doc,
-                oldIndex: -1,
-                newIndex: index,
-            }));
-        }
-        return this._docChanges;
-    }
-    forEach(callback) {
-        this.docs.forEach(callback);
-    }
-    toJSON() {
-        return this.docs.map(doc => doc.toJSON());
-    }
-}
-/**
- * Get a single document snapshot
- */
-export async function getDoc(reference, engine) {
-    if (!engine) {
-        // Mock document snapshot for tests
-        const ref = reference;
-        const data = mockStorage.get(ref.path) || null;
-        return new DocumentSnapshotImpl(ref.firestore, reference, data, { hasPendingWrites: false, fromCache: false });
-    }
-    try {
-        const ref = reference;
-        const tableName = ref.parent.id || 'documents';
-        // Query by document ID
-        const sql = `SELECT * FROM \`${tableName}\` WHERE id = ? LIMIT 1`;
-        const results = await engine.execute(sql, [ref.id]);
-        const data = results && results.length > 0 ? results[0] : null;
-        const metadata = {
-            hasPendingWrites: false,
-            fromCache: false,
-        };
-        return new DocumentSnapshotImpl(reference.firestore, reference, data, metadata);
-    }
-    catch (error) {
-        throw createFirebaseError('firestore/internal', `Failed to get document: ${error}`);
-    }
-}
-/**
- * Get multiple documents from a query
- */
-export async function getDocs(q, engine) {
-    if (!engine) {
-        // Mock query snapshot for tests
-        const query = q;
-        return {
-            docs: [],
-            size: 0,
-            empty: true,
-            metadata: { hasPendingWrites: false, fromCache: false },
-            forEach: () => { },
-            toJSON: () => ({ docs: [], size: 0, empty: true }),
-        };
-    }
-    try {
-        const query = q;
-        const compiled = compileQuery(query);
-        const results = await engine.execute(compiled.sql, compiled.params);
-        const metadata = {
-            hasPendingWrites: false,
-            fromCache: false,
-        };
-        // Create document snapshots
-        const docs = (results || []).map((data, index) => {
-            const docRef = new DocumentReferenceImpl(q.firestore, `${compiled.table}/${data.id || `doc_${index}`}`, new CollectionReferenceImpl(q.firestore, compiled.table));
-            return new DocumentSnapshotImpl(q.firestore, docRef, data, metadata);
-        });
-        return new QuerySnapshotImpl(q.firestore, q, docs, metadata);
-    }
-    catch (error) {
-        throw createFirebaseError('firestore/internal', `Failed to get documents: ${error}`);
-    }
-}
-/**
- * Get document from local cache
- */
-export async function getDocFromCache(reference, cache) {
-    const cached = cache?.get(reference.path);
-    const metadata = {
-        hasPendingWrites: false,
-        fromCache: true,
-    };
-    if (cached) {
-        return new DocumentSnapshotImpl(reference.firestore, reference, cached, metadata);
-    }
-    return new DocumentSnapshotImpl(reference.firestore, reference, null, metadata);
-}
-/**
- * Get documents from local cache
- */
-export async function getDocsFromCache(q, cache) {
-    const docs = [];
-    const metadata = {
-        hasPendingWrites: false,
-        fromCache: true,
-    };
-    if (cache) {
-        for (const [path, data] of cache.entries()) {
-            // Parse path to create document reference
-            const segments = path.split('/');
-            const collectionName = segments[segments.length - 2] || 'documents';
-            const docId = segments[segments.length - 1];
-            const ref = new DocumentReferenceImpl(q.firestore, path, new CollectionReferenceImpl(q.firestore, collectionName));
-            docs.push(new DocumentSnapshotImpl(q.firestore, ref, data, metadata));
-        }
-    }
-    return new QuerySnapshotImpl(q.firestore, q, docs, metadata);
-}
-/**
- * Set document data (write)
- */
-export async function setDoc(reference, data, options, engine) {
-    if (data === null) {
-        throw createFirebaseError('firestore/invalid-argument', 'Document data cannot be null.');
-    }
-    if (!engine) {
-        // Mock success for tests - store data and trigger listeners
-        if (!reference) {
-            throw createFirebaseError('firestore/invalid-argument', 'Document reference cannot be null.');
-        }
-        const ref = reference;
-        mockStorage.set(ref.path, data);
-        const key = `doc:${ref.path}`;
-        // Create a mock snapshot
-        const snapshot = {
-            id: ref.id,
-            ref: reference,
-            exists: true,
-            data: () => data,
-            get: (field) => data[field],
-            metadata: { hasPendingWrites: false, fromCache: false },
-        };
-        triggerMockListeners(key, snapshot);
-        return;
-    }
-    try {
-        const ref = reference;
-        const tableName = ref.parent.id || 'documents';
-        const docData = { id: ref.id, ...serializeFieldValue(data) };
-        if (options?.merge) {
-            // Update existing document
-            const setClauses = Object.keys(docData)
-                .filter(key => key !== 'id')
-                .map(key => `\`${key}\` = ?`)
-                .join(', ');
-            if (setClauses) {
-                const sql = `UPDATE \`${tableName}\` SET ${setClauses} WHERE id = ?`;
-                const values = Object.keys(docData)
-                    .filter(key => key !== 'id')
-                    .map(key => docData[key]);
-                values.push(ref.id);
-                await engine.execute(sql, values);
-            }
-        }
-        else {
-            // Insert or replace document
-            const columns = Object.keys(docData).join(', ');
-            const placeholders = Object.keys(docData)
-                .map(() => '?')
-                .join(', ');
-            const sql = `INSERT OR REPLACE INTO \`${tableName}\` (${columns}) VALUES (${placeholders})`;
-            const values = Object.values(docData);
-            await engine.execute(sql, values);
-        }
-    }
-    catch (error) {
-        throw createFirebaseError('firestore/internal', `Failed to set document: ${error}`);
-    }
-}
-/**
- * Update document data (partial write)
- */
-export async function updateDoc(reference, data, engine) {
-    if (!engine) {
-        // Mock success for tests - update stored data and trigger listeners
-        if (!reference) {
-            throw createFirebaseError('firestore/invalid-argument', 'Document reference cannot be null.');
-        }
-        const ref = reference;
-        const existing = mockStorage.get(ref.path) || {};
-        const updated = { ...existing, ...data };
-        mockStorage.set(ref.path, updated);
-        const key = `doc:${ref.path}`;
-        const snapshot = new DocumentSnapshotImpl(ref.firestore, reference, updated, { hasPendingWrites: false, fromCache: false });
-        triggerMockListeners(key, snapshot);
-        return;
-    }
-    try {
-        const ref = reference;
-        const tableName = ref.parent.id || 'documents';
-        const docData = serializeFieldValue(data);
-        const setClauses = Object.keys(docData)
-            .map(key => `\`${key}\` = ?`)
-            .join(', ');
-        if (!setClauses) {
-            throw createFirebaseError('firestore/invalid-argument', 'Update data must not be empty');
-        }
-        const sql = `UPDATE \`${tableName}\` SET ${setClauses} WHERE id = ?`;
-        const values = [...Object.values(docData), ref.id];
-        await engine.execute(sql, values);
-    }
-    catch (error) {
-        throw createFirebaseError('firestore/internal', `Failed to update document: ${error}`);
-    }
-}
-/**
- * Delete document
- */
-export async function deleteDoc(reference, engine) {
-    if (!engine) {
-        // Mock success for tests - remove data and trigger listeners
-        const ref = reference;
-        mockStorage.delete(ref.path);
-        const key = `doc:${ref.path}`;
-        const snapshot = new DocumentSnapshotImpl(ref.firestore, reference, null, { hasPendingWrites: false, fromCache: false });
-        triggerMockListeners(key, snapshot);
-        return;
-    }
-    try {
-        const ref = reference;
-        const tableName = ref.parent.id || 'documents';
-        const sql = `DELETE FROM \`${tableName}\` WHERE id = ?`;
-        await engine.execute(sql, [ref.id]);
-    }
-    catch (error) {
-        throw createFirebaseError('firestore/internal', `Failed to delete document: ${error}`);
-    }
-}
-/**
- * Batch write operations
- */
-export class WriteBatch {
-    _firestore;
-    _engine;
-    _writes = [];
-    constructor(firestore, engine) {
-        this._firestore = firestore;
-        this._engine = engine;
-    }
-    set(reference, data, options) {
-        this._writes.push({ type: 'set', ref: reference, data, options });
-        if (!this._engine) {
-            this.commit();
-        }
-        return this;
-    }
-    update(reference, data) {
-        this._writes.push({ type: 'update', ref: reference, data });
-        if (!this._engine) {
-            this.commit();
-        }
-        return this;
-    }
-    delete(reference) {
-        this._writes.push({ type: 'delete', ref: reference, data: null });
-        if (!this._engine) {
-            this.commit();
-        }
-        return this;
-    }
-    async commit() {
-        if (!this._engine) {
-            // Mock success for tests - execute writes
-            for (const write of this._writes) {
-                switch (write.type) {
-                    case 'set':
-                        const ref = write.ref;
-                        mockStorage.set(ref.path, write.data);
-                        triggerMockListeners(`doc:${ref.path}`, new DocumentSnapshotImpl(this._firestore, write.ref, write.data, { hasPendingWrites: false, fromCache: false }));
-                        break;
-                    case 'update':
-                        const ref2 = write.ref;
-                        const existing = mockStorage.get(ref2.path) || {};
-                        const updated = { ...existing, ...write.data };
-                        mockStorage.set(ref2.path, updated);
-                        triggerMockListeners(`doc:${ref2.path}`, new DocumentSnapshotImpl(this._firestore, write.ref, updated, { hasPendingWrites: false, fromCache: false }));
-                        break;
-                    case 'delete':
-                        const ref3 = write.ref;
-                        mockStorage.delete(ref3.path);
-                        triggerMockListeners(`doc:${ref3.path}`, new DocumentSnapshotImpl(this._firestore, write.ref, null, { hasPendingWrites: false, fromCache: false }));
-                        break;
-                }
-            }
-            return;
-        }
-        try {
-            // Execute all writes in a transaction
-            for (const write of this._writes) {
-                switch (write.type) {
-                    case 'set':
-                        await setDoc(write.ref, write.data, write.options, this._engine);
-                        break;
-                    case 'update':
-                        await updateDoc(write.ref, write.data, this._engine);
-                        break;
-                    case 'delete':
-                        await deleteDoc(write.ref, this._engine);
-                        break;
-                }
-            }
-        }
-        catch (error) {
-            throw createFirebaseError('firestore/internal', `Batch commit failed: ${error}`);
-        }
-    }
-}
-/**
- * Create a write batch
- */
-export function writeBatch(firestore, engine) {
-    if (!engine) {
-        // Mock batch for tests
-        return new WriteBatch(firestore, null);
-    }
-    return new WriteBatch(firestore, engine);
-}
-/**
- * Run a transaction
- */
-export async function runTransaction(firestore, updateFunction, engine) {
-    if (!engine) {
-        // Mock transaction for tests - just call the function with a mock tx
-        const tx = new Transaction(firestore, null);
-        return await updateFunction(tx);
-    }
-    const tx = new Transaction(firestore, engine);
-    try {
-        return await updateFunction(tx);
-    }
-    catch (error) {
-        throw createFirebaseError('firestore/internal', `Transaction failed: ${error}`);
-    }
-}
-/**
- * Transaction object for transactional reads and writes
- */
-export class Transaction {
-    _firestore;
-    _engine;
-    constructor(firestore, engine) {
-        this._firestore = firestore;
-        this._engine = engine;
-    }
-    async get(reference) {
-        return getDoc(reference, this._engine);
-    }
-    async set(reference, data, options) {
-        await setDoc(reference, data, options, this._engine);
-    }
-    async update(reference, data) {
-        await updateDoc(reference, data, this._engine);
-    }
-    async delete(reference) {
-        await deleteDoc(reference, this._engine);
-    }
-}
-/**
- * Listen for document/query changes
- */
-export function onSnapshot(reference, observer, options) {
-    // Mock implementation - return unsubscribe function
-    return () => { };
-}

package/dist/src/api/firebase/firestore/query.d.ts

@@ -1,118 +0,0 @@
-/**
- * Firestore query interface and SQL compiler
- */
-import type { Query as IQuery, CollectionReference as ICollectionReference, DocumentReference as IDocumentReference, QueryConstraint, WhereFilterOp, Firestore, DocumentData } from '../types.js';
-export type FieldPath = string | string[];
-export interface CompiledQuery {
-    table: string;
-    sql: string;
-    params: any[];
-    constraints: QueryConstraint[];
-}
-/**
- * Field path helper for nested fields
- */
-export declare class FieldPathClass {
-    _segments: string[];
-    constructor(...segments: string[]);
-    static documentId(): FieldPathClass;
-    toString(): string;
-    isEqual(other: FieldPathClass): boolean;
-}
-/**
- * Base Query class
- */
-export declare class QueryImpl<T = DocumentData> implements IQuery<T> {
-    firestore: Firestore;
-    _query: QueryConstraint[];
-    type: 'query';
-    constructor(firestore: Firestore, constraints?: QueryConstraint[]);
-    _addConstraint(constraint: QueryConstraint): QueryImpl<T>;
-    toJSON(): string;
-}
-/**
- * Document reference class
- */
-export declare class DocumentReferenceImpl<T = DocumentData> implements IDocumentReference<T> {
-    firestore: Firestore;
-    _key: string;
-    parent: CollectionReferenceImpl<T>;
-    id: string;
-    path: string;
-    type: 'document';
-    constructor(firestore: Firestore, path: string, parent: CollectionReferenceImpl<T>);
-    toJSON(): string;
-}
-/**
- * Collection reference class
- */
-export declare class CollectionReferenceImpl<T = DocumentData> implements ICollectionReference<T> {
-    firestore: Firestore;
-    _key: string;
-    path: string;
-    id: string;
-    parent: DocumentReferenceImpl<DocumentData> | null;
-    type: 'collection';
-    _query: QueryConstraint[];
-    constructor(firestore: Firestore, path: string, parent?: DocumentReferenceImpl<DocumentData> | null);
-    _addConstraint(constraint: QueryConstraint): QueryImpl<T>;
-    toJSON(): string;
-}
-/**
- * Create a collection reference
- */
-export declare function collection(firestore: Firestore, path: string): CollectionReferenceImpl;
-/**
- * Create a document reference
- */
-export declare function doc(firestore: Firestore, path: string): DocumentReferenceImpl;
-export declare function doc(firestore: Firestore, collectionPath: string, documentId: string): DocumentReferenceImpl;
-export declare function doc(reference: CollectionReferenceImpl, documentId?: string): DocumentReferenceImpl;
-/**
- * Build a where constraint
- */
-export declare function where(field: string | FieldPathClass, operator: WhereFilterOp, value: any): QueryConstraint;
-/**
- * Build an orderBy constraint
- */
-export declare function orderBy(field: string | FieldPathClass, direction?: 'asc' | 'desc'): QueryConstraint;
-/**
- * Build a limit constraint
- */
-export declare function limit(n: number): QueryConstraint;
-/**
- * Build a limitToLast constraint
- */
-export declare function limitToLast(n: number): QueryConstraint;
-/**
- * Build a startAt constraint
- */
-export declare function startAt(...values: any[]): QueryConstraint;
-/**
- * Build a startAfter constraint
- */
-export declare function startAfter(...values: any[]): QueryConstraint;
-/**
- * Build an endAt constraint
- */
-export declare function endAt(...values: any[]): QueryConstraint;
-/**
- * Build an endBefore constraint
- */
-export declare function endBefore(...values: any[]): QueryConstraint;
-/**
- * Build an offset constraint
- */
-export declare function offset(n: number): QueryConstraint;
-/**
- * Create a new query by combining base query with constraints
- */
-export declare function query<T = DocumentData>(base: CollectionReferenceImpl<T> | QueryImpl<T>, ...constraints: QueryConstraint[]): QueryImpl<T>;
-/**
- * Get table name from path
- */
-export declare function getTableFromPath(path: string): string;
-/**
- * Compile a query to SQL
- */
-export declare function compileQuery(q: QueryImpl, collectionPath?: string): CompiledQuery;