@affectively/dash 5.1.0 → 5.2.0

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

@@ -0,0 +1,418 @@
+/**
+ * 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

@@ -0,0 +1,11 @@
+/**
+ * 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

@@ -0,0 +1,17 @@
+/**
+ * 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

@@ -0,0 +1,100 @@
+/**
+ * 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>;