@affectively/dash 5.2.1 → 5.3.1

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

@@ -1,418 +0,0 @@
-/**
- * Firestore query interface and SQL compiler
- */
-import { createFirebaseError } from '../errors.js';
-/**
- * Field path helper for nested fields
- */
-export class FieldPathClass {
-    _segments;
-    constructor(...segments) {
-        if (segments.length === 0) {
-            throw createFirebaseError('firestore/invalid-argument', 'Field path must contain at least one element');
-        }
-        this._segments = segments.flatMap(s => (typeof s === 'string' ? s.split('.') : s));
-    }
-    static documentId() {
-        return new FieldPathClass('__name__');
-    }
-    toString() {
-        return this._segments.join('.');
-    }
-    isEqual(other) {
-        return JSON.stringify(this._segments) === JSON.stringify(other._segments);
-    }
-}
-/**
- * Base Query class
- */
-export class QueryImpl {
-    firestore;
-    _query;
-    type;
-    constructor(firestore, constraints = []) {
-        this.firestore = firestore;
-        this._query = constraints;
-        this.type = 'query';
-    }
-    _addConstraint(constraint) {
-        return new QueryImpl(this.firestore, [...this._query, constraint]);
-    }
-    toJSON() {
-        return `Query(constraints=${this._query.length})`;
-    }
-}
-/**
- * Document reference class
- */
-export class DocumentReferenceImpl {
-    firestore;
-    _key;
-    parent;
-    id;
-    path;
-    type;
-    constructor(firestore, path, parent) {
-        this.firestore = firestore;
-        this.path = path;
-        this.parent = parent;
-        this.type = 'document';
-        // Extract document ID from path (last segment)
-        const segments = path.split('/');
-        this.id = segments[segments.length - 1];
-        this._key = path;
-    }
-    toJSON() {
-        return `DocumentReference(${this.path})`;
-    }
-}
-/**
- * Collection reference class
- */
-export class CollectionReferenceImpl {
-    firestore;
-    _key;
-    path;
-    id;
-    parent;
-    type;
-    _query = [];
-    constructor(firestore, path, parent = null) {
-        this.firestore = firestore;
-        this.path = path;
-        this.type = 'collection';
-        this.parent = parent;
-        // Extract collection ID from path (last segment)
-        const segments = path.split('/');
-        this.id = segments[segments.length - 1];
-        this._key = path;
-    }
-    _addConstraint(constraint) {
-        return new QueryImpl(this.firestore, [...this._query, constraint]);
-    }
-    toJSON() {
-        return `CollectionReference(${this.path})`;
-    }
-}
-/**
- * Create a collection reference
- */
-export function collection(firestore, path) {
-    // Validate path
-    if (!path || typeof path !== 'string') {
-        throw createFirebaseError('firestore/invalid-argument', 'Collection path must be a non-empty string');
-    }
-    // Ensure path doesn't have odd number of segments (should be a collection, not a document)
-    const segments = path.split('/').filter(s => s.length > 0);
-    if (segments.length === 0) {
-        throw createFirebaseError('firestore/invalid-argument', 'Collection path must not be empty');
-    }
-    return new CollectionReferenceImpl(firestore, path, null);
-}
-export function doc(firestoreOrReference, collectionPathOrDocId, documentId) {
-    let firestore;
-    let path;
-    let parent = null;
-    if (firestoreOrReference instanceof CollectionReferenceImpl) {
-        // Variant: doc(collectionRef, docId)
-        if (!collectionPathOrDocId) {
-            throw createFirebaseError('firestore/invalid-argument', 'Document ID is required');
-        }
-        firestore = firestoreOrReference.firestore;
-        parent = firestoreOrReference;
-        path = `${firestoreOrReference.path}/${collectionPathOrDocId}`;
-    }
-    else {
-        // Variant: doc(firestore, path) or doc(firestore, collectionPath, docId)
-        firestore = firestoreOrReference;
-        if (documentId && collectionPathOrDocId) {
-            // doc(firestore, collectionPath, docId)
-            path = `${collectionPathOrDocId}/${documentId}`;
-            parent = new CollectionReferenceImpl(firestore, collectionPathOrDocId, null);
-        }
-        else if (collectionPathOrDocId) {
-            // doc(firestore, path)
-            path = collectionPathOrDocId;
-        }
-        else {
-            throw createFirebaseError('firestore/invalid-argument', 'Document path is required');
-        }
-    }
-    const segments = path.split('/').filter(s => s.length > 0);
-    if (segments.length === 0 || segments.length % 2 === 1) {
-        throw createFirebaseError('firestore/invalid-argument', 'Document path must be even number of segments');
-    }
-    return new DocumentReferenceImpl(firestore, path, parent);
-}
-/**
- * Build a where constraint
- */
-export function where(field, operator, value) {
-    const fieldStr = typeof field === 'string' ? field : field.toString();
-    // Validate operator
-    const validOperators = [
-        '<',
-        '<=',
-        '==',
-        '!=',
-        '>=',
-        '>',
-        'array-contains',
-        'in',
-        'not-in',
-        'array-contains-any',
-    ];
-    if (!validOperators.includes(operator)) {
-        throw createFirebaseError('firestore/invalid-argument', `Invalid operator: ${operator}`);
-    }
-    return {
-        type: 'where',
-        field: fieldStr,
-        operator,
-        value,
-    };
-}
-/**
- * Build an orderBy constraint
- */
-export function orderBy(field, direction) {
-    const fieldStr = typeof field === 'string' ? field : field.toString();
-    const dir = direction || 'asc';
-    if (dir !== 'asc' && dir !== 'desc') {
-        throw createFirebaseError('firestore/invalid-argument', `Invalid direction: ${dir}`);
-    }
-    return {
-        type: 'orderBy',
-        field: fieldStr,
-        direction: dir,
-    };
-}
-/**
- * Build a limit constraint
- */
-export function limit(n) {
-    if (typeof n !== 'number' || n < 0) {
-        throw createFirebaseError('firestore/invalid-argument', 'Limit must be a non-negative number');
-    }
-    return {
-        type: 'limit',
-        count: n,
-    };
-}
-/**
- * Build a limitToLast constraint
- */
-export function limitToLast(n) {
-    if (typeof n !== 'number' || n <= 0) {
-        throw createFirebaseError('firestore/invalid-argument', 'Limit must be a positive number');
-    }
-    return {
-        type: 'limitToLast',
-        count: n,
-    };
-}
-/**
- * Build a startAt constraint
- */
-export function startAt(...values) {
-    if (values.length === 0) {
-        throw createFirebaseError('firestore/invalid-argument', 'startAt requires at least one value');
-    }
-    return {
-        type: 'startAt',
-        values,
-    };
-}
-/**
- * Build a startAfter constraint
- */
-export function startAfter(...values) {
-    if (values.length === 0) {
-        throw createFirebaseError('firestore/invalid-argument', 'startAfter requires at least one value');
-    }
-    return {
-        type: 'startAfter',
-        values,
-    };
-}
-/**
- * Build an endAt constraint
- */
-export function endAt(...values) {
-    if (values.length === 0) {
-        throw createFirebaseError('firestore/invalid-argument', 'endAt requires at least one value');
-    }
-    return {
-        type: 'endAt',
-        values,
-    };
-}
-/**
- * Build an endBefore constraint
- */
-export function endBefore(...values) {
-    if (values.length === 0) {
-        throw createFirebaseError('firestore/invalid-argument', 'endBefore requires at least one value');
-    }
-    return {
-        type: 'endBefore',
-        values,
-    };
-}
-/**
- * Build an offset constraint
- */
-export function offset(n) {
-    if (typeof n !== 'number' || n < 0) {
-        throw createFirebaseError('firestore/invalid-argument', 'Offset must be a non-negative number');
-    }
-    return {
-        type: 'offset',
-        count: n,
-    };
-}
-/**
- * Create a new query by combining base query with constraints
- */
-export function query(base, ...constraints) {
-    if (constraints.length === 0) {
-        if (base instanceof QueryImpl) {
-            return base;
-        }
-        return new QueryImpl(base.firestore, []);
-    }
-    const allConstraints = [...base._query, ...constraints];
-    return new QueryImpl(base.firestore, allConstraints);
-}
-/**
- * Get table name from path
- */
-export function getTableFromPath(path) {
-    const segments = path.split('/').filter(s => s.length > 0);
-    // For collections, return the last segment
-    // For documents, we need to find the collection name
-    return segments[segments.length - 1] || 'documents';
-}
-/**
- * Compile a query to SQL
- */
-export function compileQuery(q, collectionPath) {
-    const tableName = collectionPath ? getTableFromPath(collectionPath) : 'documents';
-    let sql = `SELECT * FROM \`${tableName}\``;
-    const params = [];
-    const whereClauses = [];
-    // Process constraints
-    for (const constraint of q._query) {
-        switch (constraint.type) {
-            case 'where': {
-                const field = constraint.field;
-                const operator = constraint.operator;
-                const value = constraint.value;
-                let clause;
-                switch (operator) {
-                    case '==':
-                        clause = `\`${field}\` = ?`;
-                        params.push(value);
-                        break;
-                    case '!=':
-                        clause = `\`${field}\` != ?`;
-                        params.push(value);
-                        break;
-                    case '<':
-                        clause = `\`${field}\` < ?`;
-                        params.push(value);
-                        break;
-                    case '<=':
-                        clause = `\`${field}\` <= ?`;
-                        params.push(value);
-                        break;
-                    case '>':
-                        clause = `\`${field}\` > ?`;
-                        params.push(value);
-                        break;
-                    case '>=':
-                        clause = `\`${field}\` >= ?`;
-                        params.push(value);
-                        break;
-                    case 'array-contains':
-                        clause = `json_extract(\`${field}\`, '$[*]') LIKE ?`;
-                        params.push(`%${JSON.stringify(value)}%`);
-                        break;
-                    case 'in':
-                        if (!Array.isArray(value)) {
-                            throw createFirebaseError('firestore/invalid-argument', '"in" operator requires array value');
-                        }
-                        const inPlaceholders = value.map(() => '?').join(', ');
-                        clause = `\`${field}\` IN (${inPlaceholders})`;
-                        params.push(...value);
-                        break;
-                    case 'not-in':
-                        if (!Array.isArray(value)) {
-                            throw createFirebaseError('firestore/invalid-argument', '"not-in" operator requires array value');
-                        }
-                        const notInPlaceholders = value.map(() => '?').join(', ');
-                        clause = `\`${field}\` NOT IN (${notInPlaceholders})`;
-                        params.push(...value);
-                        break;
-                    case 'array-contains-any':
-                        if (!Array.isArray(value)) {
-                            throw createFirebaseError('firestore/invalid-argument', '"array-contains-any" operator requires array value');
-                        }
-                        const anyPlaceholders = value.map(() => 'json_extract(?, "$[*]") LIKE ?').join(' OR ');
-                        clause = `(${anyPlaceholders})`;
-                        for (const v of value) {
-                            params.push(v);
-                            params.push(`%${JSON.stringify(v)}%`);
-                        }
-                        break;
-                    default:
-                        throw createFirebaseError('firestore/invalid-argument', `Unknown operator: ${operator}`);
-                }
-                whereClauses.push(clause);
-                break;
-            }
-            case 'orderBy': {
-                const field = constraint.field;
-                const direction = constraint.direction || 'asc';
-                sql += ` ORDER BY \`${field}\` ${direction.toUpperCase()}`;
-                break;
-            }
-            case 'limit': {
-                sql += ` LIMIT ${constraint.count}`;
-                break;
-            }
-            case 'limitToLast': {
-                // For limitToLast, we need to reverse order and take first N, then reverse again
-                // For now, implement as regular limit (TODO: full implementation)
-                sql += ` LIMIT ${constraint.count}`;
-                break;
-            }
-            case 'offset': {
-                sql += ` OFFSET ${constraint.count}`;
-                break;
-            }
-            case 'startAt':
-            case 'startAfter':
-            case 'endAt':
-            case 'endBefore':
-                // These are typically used with orderBy and would need cursor-based pagination
-                // For now, implement basic version
-                if (constraint.values && constraint.values.length > 0) {
-                    const op = constraint.type === 'startAt' || constraint.type === 'startAfter' ? '>=' : '<=';
-                    whereClauses.push(`\`__cursor\` ${op} ?`);
-                    params.push(constraint.values[0]);
-                }
-                break;
-        }
-    }
-    // Add WHERE clauses
-    if (whereClauses.length > 0) {
-        sql += ` WHERE ${whereClauses.join(' AND ')}`;
-    }
-    return {
-        table: tableName,
-        sql,
-        params,
-        constraints: q._query,
-    };
-}

package/dist/src/api/firebase/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Firebase Compatibility API
- * Complete drop-in replacement for Firebase SDK
- */
-export * from './firestore/index.js';
-export * from './firestore/index.js';
-export * from './database/index.js';
-export * from './auth/index.js';
-export * as storage from './storage/index.js';
-export { FirebaseError, createFirebaseError } from './errors.js';
-export type { Firestore, RealtimeDatabase, FirebaseAuth, FirebaseStorage, FirebaseApp, FirebaseConfig, DocumentReference, CollectionReference, Query, DocumentSnapshot, QuerySnapshot, DatabaseReference, DataSnapshot, OnDisconnect, DocumentChange, SnapshotMetadata, SnapshotOptions, QueryConstraint, WhereFilterOp, FieldPath, FieldValue, Timestamp, GeoPoint, User, UserCredential, AuthProvider, AuthCredential, StorageReference, UploadMetadata, FullMetadata, ListResult, UploadTask, UploadTaskSnapshot, } from './types.js';

package/dist/src/api/firebase/index.js

@@ -1,17 +0,0 @@
-/**
- * Firebase Compatibility API
- * Complete drop-in replacement for Firebase SDK
- */
-// Re-export all Firestore APIs
-export * from './firestore/index.js';
-// Re-export all Firestore listener APIs
-// Re-export Firestore APIs
-export * from './firestore/index.js';
-// Re-export Realtime Database APIs
-export * from './database/index.js';
-// Re-export all Authentication APIs
-export * from './auth/index.js';
-// Re-export Storage APIs with namespacing to avoid conflicts
-export * as storage from './storage/index.js';
-// Re-export error types
-export { FirebaseError, createFirebaseError } from './errors.js';

package/dist/src/api/firebase/storage/index.d.ts

@@ -1,100 +0,0 @@
-/**
- * Firebase Cloud Storage API
- */
-import type { StorageReference, FirebaseStorage, UploadMetadata, FullMetadata, ListResult, UploadTask, UploadTaskSnapshot } from '../types.js';
-/**
- * Storage reference implementation
- */
-export declare class StorageReferenceImpl implements StorageReference {
-    storage: FirebaseStorage;
-    _location: {
-        bucket: string;
-        path: string;
-    };
-    bucket: string;
-    fullPath: string;
-    name: string;
-    parent: StorageReferenceImpl | null;
-    root: StorageReferenceImpl;
-    constructor(storage: FirebaseStorage, bucket: string, path: string);
-    toString(): string;
-}
-/**
- * Upload task implementation
- */
-export declare class UploadTaskImpl implements UploadTask {
-    private _ref;
-    private _data;
-    private _metadata;
-    private _paused;
-    private _cancelled;
-    private _progress;
-    private _listeners;
-    private _errorListeners;
-    private _completeListeners;
-    constructor(ref: StorageReferenceImpl, data: Blob | ArrayBuffer | string, metadata?: UploadMetadata);
-    on(event: string, nextOrObserver?: any, error?: (error: Error) => void, complete?: () => void): () => void;
-    then(onFulfilled?: (snapshot: UploadTaskSnapshot) => any, onRejected?: (error: Error) => any): Promise<any>;
-    catch(onRejected: (error: Error) => any): Promise<any>;
-    pause(): boolean;
-    resume(): boolean;
-    cancel(): boolean;
-    private _performUpload;
-    private _createSnapshot;
-    private _notifyProgress;
-}
-/**
- * Get storage reference
- */
-export declare function ref(storage: FirebaseStorage, path?: string): StorageReferenceImpl;
-/**
- * Get reference from URL
- */
-export declare function refFromURL(storage: FirebaseStorage, url: string): StorageReferenceImpl;
-/**
- * Get child reference
- */
-export declare function child(parent: StorageReferenceImpl, path: string): StorageReferenceImpl;
-/**
- * Upload bytes
- */
-export declare function uploadBytes(reference: StorageReferenceImpl, data: Blob | ArrayBuffer | Uint8Array, metadata?: UploadMetadata): Promise<UploadTaskSnapshot>;
-/**
- * Upload resumable (with progress tracking)
- */
-export declare function uploadBytesResumable(reference: StorageReferenceImpl, data: Blob | ArrayBuffer | Uint8Array, metadata?: UploadMetadata): UploadTask;
-/**
- * Upload string
- */
-export declare function uploadString(reference: StorageReferenceImpl, value: string, format?: 'raw' | 'base64' | 'base64url' | 'data_url', metadata?: UploadMetadata): Promise<UploadTaskSnapshot>;
-/**
- * Download bytes
- */
-export declare function getBytes(reference: StorageReferenceImpl, maxDownloadSizeBytes?: number): Promise<ArrayBuffer>;
-/**
- * Get download URL
- */
-export declare function getDownloadURL(reference: StorageReferenceImpl): Promise<string>;
-/**
- * Get metadata
- */
-export declare function getMetadata(reference: StorageReferenceImpl): Promise<FullMetadata>;
-/**
- * Update metadata
- */
-export declare function updateMetadata(reference: StorageReferenceImpl, metadata: UploadMetadata): Promise<FullMetadata>;
-/**
- * Delete object
- */
-export declare function deleteObject(reference: StorageReferenceImpl): Promise<void>;
-/**
- * List files (with pagination)
- */
-export declare function list(reference: StorageReferenceImpl, options?: {
-    maxResults?: number;
-    pageToken?: string;
-}): Promise<ListResult>;
-/**
- * List all files
- */
-export declare function listAll(reference: StorageReferenceImpl): Promise<ListResult>;