@docstack/pouchdb-adapter-googledrive 0.0.8 → 0.0.9

package/lib/drive.js

@@ -0,0 +1,737 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveHandler = void 0;
+const cache_1 = require("./cache");
+const client_1 = require("./client");
+const DEFAULT_COMPACTION_THRESHOLD = 100; // entries
+const DEFAULT_SIZE_THRESHOLD = 1024 * 1024; // 1MB
+const DEFAULT_CACHE_SIZE = 1000; // Number of docs
+/**
+ * DriveHandler - Lazy Loading Implementation
+ *
+ * Storage structure:
+ * /db-folder/
+ *   ├── _meta.json
+ *   ├── snapshot-index.json  # Map<DocId, IndexEntry>
+ *   ├── snapshot-data.json   # Map<DocId, DocBody>
+ *   └── changes-*.ndjson     # Append logs
+ */
+class DriveHandler {
+    log(...args) {
+        console.log(`[googledrive-drive] [${this.meta.dbName}]`, ...args);
+    }
+    constructor(options, dbName) {
+        this.folderId = null;
+        this.meta = {
+            seq: 0,
+            changeLogIds: [],
+            snapshotIndexId: null,
+            lastCompaction: null,
+            dbName: ''
+        };
+        this.metaEtag = null;
+        this.metaModifiedTime = null;
+        // In-Memory Index: ID -> Metadata/Pointer
+        this.index = {};
+        this.pendingChanges = [];
+        this.currentLogSizeEstimate = 0;
+        this.listeners = [];
+        this.pollingInterval = null;
+        this.loadingPromise = null;
+        this.isPollingActive = false;
+        this.processedLogIds = new Set();
+        this.currentSnapshotIndexId = null;
+        this.debug = false;
+        this.isCompacting = false;
+        const clientOptions = { ...options };
+        if (options.testMode) {
+            const serverUrl = options.testServerUrl || 'http://localhost:3000';
+            // @ts-ignore - baseUrl/uploadUrl might not be in the strict type if we didn't update types.ts definition for DriveClientOptions in client.ts yet? 
+            // We did update DriveClientOptions in client.ts.
+            // But GoogleDriveAdapterOptions extends DriveClientOptions?
+            // types.ts: export interface GoogleDriveAdapterOptions extends DriveClientOptions
+            // client.ts: export interface DriveClientOptions { accessToken: ...; baseUrl?: string; uploadUrl?: string; }
+            // So typescript should be happy.
+            // Using /drive/v3/files as base for the test server if simplified?
+            // The TestServer mounts at /drive/v3/files.
+            // But the client appends /drive/v3/files to BASE_URL? 
+            // In client.ts default is `https://www.googleapis.com/drive/v3/files`.
+            // Our TestServer mounts `/drive/v3/files`.
+            // So testUrl should be `http://localhost:3000/drive/v3/files`.
+            const testBase = `${serverUrl}/drive/v3/files`;
+            const testUpload = `${serverUrl}/upload/drive/v3/files`;
+            // @ts-ignore
+            clientOptions.baseUrl = testBase;
+            // @ts-ignore
+            clientOptions.uploadUrl = testUpload;
+        }
+        this.client = new client_1.GoogleDriveClient(clientOptions);
+        this.options = options;
+        this.folderId = options.folderId || null;
+        this.folderName = options.folderName || dbName;
+        this.parents = options.parents || [];
+        this.compactionThreshold = options.compactionThreshold || DEFAULT_COMPACTION_THRESHOLD;
+        this.compactionSizeThreshold = options.compactionSizeThreshold || DEFAULT_SIZE_THRESHOLD;
+        this.meta.dbName = dbName;
+        this.debug = !!options.debug;
+        this.docCache = new cache_1.LRUCache(options.cacheSize || DEFAULT_CACHE_SIZE);
+        this.fileCache = new cache_1.LRUCache(100); // Cache for last 100 files
+        // Polling will be started in load() after folderId is resolved
+    }
+    // Public getter for Sequence (used by adapter)
+    get seq() {
+        return this.meta.seq;
+    }
+    /** Load the database (Index Only) */
+    async load() {
+        if (this.loadingPromise)
+            return this.loadingPromise;
+        this.loadingPromise = (async () => {
+            try {
+                this.log('Loading database, options', { options: this.options });
+                if (!this.folderId) {
+                    this.folderId = await this.findOrCreateFolder();
+                    this.log('Retrieved folder', { folderId: this.folderId });
+                }
+                const metaFile = await this.findFile('_meta.json');
+                if (metaFile) {
+                    this.log('Retrieved meta file', { fileId: metaFile.id });
+                    this.meta = await this.downloadJson(metaFile.id, true); // No cache for meta
+                    this.metaEtag = metaFile.etag || null;
+                    this.metaModifiedTime = metaFile.modifiedTime || null;
+                }
+                else {
+                    this.log('Meta file not found, creating new');
+                    await this.saveMeta(this.meta);
+                }
+                if (this.meta.snapshotIndexId !== this.currentSnapshotIndexId) {
+                    this.log('Snapshot index changed, loading index', {
+                        snapshotIndexId: this.meta.snapshotIndexId,
+                        currentSnapshotIndexId: this.currentSnapshotIndexId
+                    });
+                    // Compaction occurred or initial load
+                    this.index = {};
+                    this.processedLogIds.clear();
+                    this.currentSnapshotIndexId = this.meta.snapshotIndexId;
+                    if (this.meta.snapshotIndexId) {
+                        try {
+                            const snapshotIdx = await this.downloadJson(this.meta.snapshotIndexId);
+                            if (snapshotIdx.docs) {
+                                this.filesFromLegacySnapshot(snapshotIdx);
+                            }
+                            else {
+                                this.index = snapshotIdx.entries || {};
+                            }
+                        }
+                        catch (e) {
+                            console.warn('Failed to load snapshot index', e);
+                        }
+                    }
+                    else if (this.meta.snapshotId) {
+                        this.log('Legacy snapshot found, loading index', {
+                            snapshotId: this.meta.snapshotId
+                        });
+                        try {
+                            const legacySnapshot = await this.downloadJson(this.meta.snapshotId);
+                            this.filesFromLegacySnapshot(legacySnapshot);
+                        }
+                        catch (e) {
+                            console.warn('Failed to load legacy snapshot', e);
+                        }
+                    }
+                }
+                // 2. Replay NEW Change Logs (Metadata only updates)
+                this.log('Replaying change logs');
+                for (const logId of this.meta.changeLogIds) {
+                    if (this.processedLogIds.has(logId))
+                        continue;
+                    this.log('Replaying change log', logId);
+                    let changes = await this.downloadNdjson(logId);
+                    if (!Array.isArray(changes)) {
+                        this.log("Unexpected changes", { changes, logId });
+                        this.log('Downloaded changes not an array, wrapping/ignoring', typeof changes);
+                        changes = changes ? [changes] : []; // Fallback
+                    }
+                    this.currentLogSizeEstimate += 100 * changes.length;
+                    this.log('Replayed change log', logId);
+                    for (const change of changes) {
+                        this.log('Processing change, sequence', change.seq);
+                        this.updateIndex(change, logId);
+                        if (this.docCache.get(change.id)) {
+                            this.docCache.remove(change.id);
+                        }
+                    }
+                    this.processedLogIds.add(logId);
+                    this.log('Processed log', logId);
+                }
+                // 3. Start Polling (if enabled)
+                if (this.options.pollingIntervalMs) {
+                    this.log('Starting polling with interval', this.options.pollingIntervalMs);
+                    this.startPolling(Number(this.options.pollingIntervalMs));
+                }
+                else {
+                    this.log('Polling disabled (no interval provided)');
+                }
+            }
+            catch (e) {
+                console.error('Failed to load database', e);
+                throw e;
+            }
+            finally {
+                this.loadingPromise = null;
+            }
+        })();
+        return this.loadingPromise;
+    }
+    // Migration helper
+    filesFromLegacySnapshot(snapshot) {
+        // Convert Legacy Snapshot (Docs in memory) to Index
+        // Since we don't have a separate file pointer for each doc in legacy snapshot,
+        // we say they are in the snapshot file itself.
+        // BUT, lazy loading requires being able to fetch them. 
+        // We will cache them ALL now (since we downloaded them) and index them.
+        for (const [id, doc] of Object.entries(snapshot.docs)) {
+            this.index[id] = {
+                rev: doc._rev,
+                seq: snapshot.seq, // Approximate
+                location: { fileId: 'LEGACY_MEMORY' } // Special validity marker
+            };
+            this.docCache.put(id, doc);
+        }
+    }
+    /**
+     * Get a document body.
+     * Index -> Cache -> Fetch
+     */
+    async get(id) {
+        const entry = this.index[id];
+        if (!entry)
+            return null;
+        if (entry.deleted)
+            return null;
+        // 1. Check Doc Cache
+        const cachedDoc = this.docCache.get(id);
+        if (cachedDoc)
+            return cachedDoc;
+        // 2. Fetch from Drive (via File Cache)
+        if (entry.location.fileId === 'LEGACY_MEMORY') {
+            if (this.meta.snapshotId) {
+                const legacy = await this.downloadJson(this.meta.snapshotId);
+                if (legacy.docs[id]) {
+                    this.docCache.put(id, legacy.docs[id]);
+                    return legacy.docs[id];
+                }
+            }
+            return null;
+        }
+        const fileId = entry.location.fileId;
+        const content = await this.fetchFile(fileId);
+        let doc = null;
+        if (Array.isArray(content)) {
+            // It's a change log (NDJSON parsed as array)
+            const match = [...content].reverse().find((c) => c.id === id);
+            doc = match ? match.doc : null;
+        }
+        else if (content && content.docs) {
+            // It's a snapshot-data chunk
+            doc = content.docs[id];
+        }
+        else if (content && content.id === id && content.doc) {
+            // It's a single ChangeEntry object (parsed from single-line NDJSON)
+            doc = content.doc;
+        }
+        else if (content && (content._id === id || content.id === id)) {
+            // Single doc file or raw doc body
+            doc = content;
+        }
+        if (doc) {
+            this.docCache.put(id, doc);
+            doc._rev = entry.rev;
+        }
+        return doc;
+    }
+    /** Generic Download with Caching and Parsing */
+    async fetchFile(fileId, skipCache = false) {
+        if (!skipCache) {
+            const cached = this.fileCache.get(fileId);
+            if (cached) {
+                this.log('fetchFile cache hit', fileId);
+                return cached;
+            }
+        }
+        this.log('fetchFile downloading', fileId);
+        const data = await this.client.getFile(fileId);
+        let parsed;
+        if (typeof data === 'string') {
+            const trimmed = data.trim();
+            if (trimmed.startsWith('{')) {
+                // Could be JSON or NDJSON
+                if (trimmed.includes('\n')) {
+                    // Definitely NDJSON (multiple lines)
+                    try {
+                        const lines = trimmed.split('\n').filter(l => l);
+                        parsed = lines.map(line => JSON.parse(line));
+                    }
+                    catch (e) {
+                        parsed = data;
+                    }
+                }
+                else {
+                    // Single line. Try regular JSON first.
+                    try {
+                        parsed = JSON.parse(trimmed);
+                        // Optional: if we know it was supposed to be NDJSON? 
+                        // Our change files are always NDJSON. 
+                        // But _meta.json and snapshot-*.json are regular JSON.
+                    }
+                    catch (e) {
+                        parsed = data;
+                    }
+                }
+            }
+            else {
+                parsed = data;
+            }
+        }
+        else {
+            parsed = data;
+        }
+        this.fileCache.put(fileId, parsed);
+        return parsed;
+    }
+    /** Get multiple docs (Atomic-ish) used for _allDocs */
+    async getMulti(ids) {
+        // Naive parallel fetch
+        // Optimization: Group by fileID to reduce requests
+        const byFile = {};
+        const results = {};
+        for (const id of ids) {
+            const entry = this.index[id];
+            if (!entry || entry.deleted) {
+                results[id] = null;
+                continue;
+            }
+            // Check cache
+            const cached = this.docCache.get(id);
+            if (cached) {
+                results[id] = cached;
+                continue;
+            }
+            // Group by file
+            if (entry.location.fileId === 'LEGACY_MEMORY') {
+                // Handle legacy separately
+                const doc = await this.get(id); // fallback
+                results[id] = doc;
+            }
+            else {
+                if (!byFile[entry.location.fileId])
+                    byFile[entry.location.fileId] = [];
+                byFile[entry.location.fileId].push(id);
+            }
+        }
+        // Fetch files
+        for (const [fileId, docIds] of Object.entries(byFile)) {
+            try {
+                const content = await this.fetchFile(fileId);
+                for (const docId of docIds) {
+                    let doc = null;
+                    if (Array.isArray(content)) {
+                        const match = [...content].reverse().find((c) => c.id === docId);
+                        doc = match ? match.doc : null;
+                    }
+                    else if (content && content.docs) {
+                        doc = content.docs[docId];
+                    }
+                    else if (content && content.id === docId && content.doc) {
+                        // Single ChangeEntry object
+                        doc = content.doc;
+                    }
+                    if (doc) {
+                        // Add entry.rev to doc just in case
+                        if (this.index[docId])
+                            doc._rev = this.index[docId].rev;
+                        this.docCache.put(docId, doc);
+                        results[docId] = doc;
+                    }
+                    else {
+                        results[docId] = null;
+                    }
+                }
+            }
+            catch (e) {
+                console.error(`Failed to fetch file ${fileId} for docs ${docIds}`, e);
+                // Return nulls
+                docIds.forEach(id => results[id] = null);
+            }
+        }
+        return ids.map(id => results[id]);
+    }
+    /** Return all keys in Index */
+    async getIndexKeys() {
+        if (this.loadingPromise)
+            await this.loadingPromise;
+        return Object.keys(this.index);
+    }
+    /** Get metadata for a specific ID from Index */
+    getIndexEntry(id) {
+        return this.index[id];
+    }
+    /** Single change wrapper */
+    async appendChange(change) {
+        return this.appendChanges([change]);
+    }
+    /** Append changes with OCC */
+    async appendChanges(changes) {
+        const MAX_RETRIES = 5;
+        let attempt = 0;
+        while (attempt < MAX_RETRIES) {
+            try {
+                return await this.tryAppendChanges(changes);
+            }
+            catch (err) {
+                if (err.status === 412 || err.status === 409) {
+                    // Reload and RETRY
+                    await this.load();
+                    // Check conflicts against Index (Metadata sufficient)
+                    this.checkConflicts(changes);
+                    // Reseq
+                    let currentSeq = this.meta.seq;
+                    for (const change of changes) {
+                        currentSeq++;
+                        change.seq = currentSeq;
+                    }
+                    attempt++;
+                    await new Promise(r => setTimeout(r, Math.random() * 500 + 100));
+                    continue;
+                }
+                throw err;
+            }
+        }
+        throw new Error('Failed to append changes');
+    }
+    async tryAppendChanges(changes) {
+        // 1. Write Log File (Upload Data)
+        const fileId = await this.writeChangeFile(changes);
+        try {
+            // 2. Prepare speculative meta update
+            const nextMeta = { ...this.meta };
+            nextMeta.changeLogIds = [...nextMeta.changeLogIds, fileId];
+            nextMeta.seq = changes[changes.length - 1].seq;
+            // 3. Commit Lock
+            await this.saveMeta(nextMeta, this.metaEtag);
+            // 4. Update Local State
+            this.meta = nextMeta;
+            for (const change of changes) {
+                this.updateIndex(change, fileId);
+                if (change.doc) {
+                    this.docCache.put(change.id, change.doc);
+                }
+                else if (change.deleted) {
+                    this.docCache.remove(change.id);
+                }
+            }
+            // Notify local changes feed listeners about our own write
+            this.notifyListeners();
+            // 5. Compaction Check
+            const totalChanges = await this.countTotalChanges();
+            if (totalChanges >= this.compactionThreshold ||
+                this.currentLogSizeEstimate >= this.compactionSizeThreshold) {
+                this.compact().catch(e => console.error('Compaction failed', e));
+            }
+        }
+        catch (err) {
+            // Cleanup orphaned log file on metadata update failure
+            this.client.deleteFile(fileId).catch(e => this.log('Failed to cleanup orphaned log', fileId, e));
+            throw err;
+        }
+    }
+    /** Update Index with a new change */
+    updateIndex(change, fileId) {
+        this.index[change.id] = {
+            rev: change.rev,
+            seq: change.seq,
+            deleted: !!change.deleted,
+            location: { fileId }
+        };
+    }
+    checkConflicts(changes) {
+        for (const change of changes) {
+            const docId = change.id;
+            const newRevNum = parseInt(change.rev.split('-')[0], 10);
+            const existing = this.index[docId];
+            if (existing) {
+                const currentRevNum = parseInt(existing.rev.split('-')[0], 10);
+                if (currentRevNum >= newRevNum) {
+                    const err = new Error('Document update conflict');
+                    err.status = 409;
+                    err.name = 'conflict'; // PouchDB expectation
+                    throw err;
+                }
+            }
+        }
+    }
+    /** Compact: Create SnapshotIndex + SnapshotData */
+    async compact() {
+        if (this.isCompacting)
+            return;
+        this.isCompacting = true;
+        try {
+            this.log('Starting compaction');
+            const snapshotSeq = this.meta.seq;
+            const oldLogIds = [...this.meta.changeLogIds];
+            const oldIndexId = this.meta.snapshotIndexId;
+            // 1. Fetch ALL active documents
+            // We need them to build the new large snapshot-data file
+            // This is the one time we download everything if not cached. 
+            // Optimization: We could reuse existing `snapshot-data` chunks and only append new data 
+            // to a new chunk, but for simplicity: Merge All.
+            const allIds = Object.keys(this.index).filter(id => !this.index[id].deleted);
+            const allDocs = await this.getMulti(allIds);
+            const snapshotData = { docs: {} };
+            allIds.forEach((id, i) => {
+                if (allDocs[i])
+                    snapshotData.docs[id] = allDocs[i];
+            });
+            // 2. Upload Data File
+            const dataContent = JSON.stringify(snapshotData);
+            const dataRes = await this.client.createFile(`snapshot-data-${Date.now()}.json`, [this.folderId], 'application/json', dataContent);
+            const dataFileId = dataRes.id;
+            // 3. Create Index pointing to this Data File
+            const newIndexEntries = {};
+            for (const id of Object.keys(snapshotData.docs)) {
+                newIndexEntries[id] = {
+                    rev: this.index[id].rev,
+                    seq: this.index[id].seq,
+                    location: { fileId: dataFileId }
+                };
+            }
+            const snapshotIndex = {
+                entries: newIndexEntries,
+                seq: snapshotSeq,
+                createdAt: Date.now()
+            };
+            const indexContent = JSON.stringify(snapshotIndex);
+            const indexRes = await this.client.createFile(`snapshot-index-${Date.now()}.json`, [this.folderId], 'application/json', indexContent);
+            const newIndexId = indexRes.id;
+            // 4. Update Meta
+            let filesToDelete = [];
+            await this.atomicUpdateMeta((latest) => {
+                const remainingLogs = latest.changeLogIds.filter(id => !oldLogIds.includes(id));
+                // Only delete files that were in oldLogIds but not in remainingLogs
+                filesToDelete = oldLogIds.filter(id => !remainingLogs.includes(id));
+                return {
+                    ...latest,
+                    snapshotIndexId: newIndexId,
+                    changeLogIds: remainingLogs,
+                    lastCompaction: Date.now()
+                };
+            });
+            // 5. Cleanup - Only delete files that were confirmed removed from metadata
+            await this.cleanupOldFiles(oldIndexId, filesToDelete);
+            this.currentLogSizeEstimate = 0;
+        }
+        finally {
+            this.isCompacting = false;
+        }
+    }
+    // ... Helpers (atomicUpdateMeta, saveMeta, writeChangeFile same as before) ...
+    async atomicUpdateMeta(modifier) {
+        const MAX_RETRIES = 5;
+        let attempt = 0;
+        while (attempt < MAX_RETRIES) {
+            try {
+                const metaFile = await this.findFile('_meta.json');
+                if (!metaFile)
+                    throw new Error('Meta missing');
+                const validMeta = await this.downloadJson(metaFile.id, true); // No cache
+                const newMeta = modifier(validMeta);
+                await this.saveMeta(newMeta, metaFile.etag);
+                this.meta = newMeta;
+                return;
+            }
+            catch (err) {
+                if (err.status === 412 || err.status === 409) {
+                    attempt++;
+                    await new Promise(r => setTimeout(r, Math.random() * 500 + 100));
+                    continue;
+                }
+                throw err;
+            }
+        }
+    }
+    // Reused helpers
+    async findOrCreateFolder() {
+        const safeName = this.escapeQuery(this.folderName);
+        const q = `name = '${safeName}' and mimeType = 'application/vnd.google-apps.folder' and trashed = false`;
+        const files = await this.client.listFiles(q);
+        if (files.length > 0)
+            return files[0].id;
+        const createRes = await this.client.createFile(this.folderName, this.parents.length ? this.parents : undefined, 'application/vnd.google-apps.folder', '');
+        return createRes.id;
+    }
+    async findFile(name) {
+        if (!this.folderId)
+            return null;
+        const safeName = this.escapeQuery(name);
+        const q = `name = '${safeName}' and '${this.folderId}' in parents and trashed = false`;
+        const files = await this.client.listFiles(q);
+        if (files.length > 0) {
+            let file = files[0];
+            if (!file.etag) {
+                // Robustness: Fetch metadata for the file if etag is missing from list
+                try {
+                    file = await this.client.getFileMetadata(file.id);
+                }
+                catch (e) {
+                    this.log('Failed to fetch file metadata for etag', file.id, e);
+                }
+            }
+            return {
+                id: file.id,
+                etag: file.etag,
+                modifiedTime: file.modifiedTime
+            };
+        }
+        return null;
+    }
+    async downloadJson(fileId, skipCache = false) {
+        return await this.fetchFile(fileId, skipCache);
+    }
+    async downloadFileAny(fileId) {
+        return await this.fetchFile(fileId);
+    }
+    async downloadNdjson(fileId) {
+        return await this.fetchFile(fileId);
+    }
+    async writeChangeFile(changes) {
+        const lines = changes.map(c => JSON.stringify(c)).join('\n') + '\n';
+        const startSeq = changes[0].seq;
+        const name = `changes-${startSeq}-${Math.random().toString(36).substring(7)}.ndjson`;
+        const res = await this.client.createFile(name, [this.folderId], 'application/x-ndjson', lines);
+        this.currentLogSizeEstimate += new Blob([lines]).size;
+        return res.id;
+    }
+    async saveMeta(meta, expectedEtag = null) {
+        const content = JSON.stringify(meta);
+        const metaFile = await this.findFile('_meta.json');
+        if (metaFile) {
+            const res = await this.client.updateFile(metaFile.id, content, expectedEtag || undefined);
+            this.metaEtag = res.etag;
+            this.metaModifiedTime = res.modifiedTime;
+            this.fileCache.remove(metaFile.id); // Invalidate cache
+        }
+        else {
+            const res = await this.client.createFile('_meta.json', [this.folderId], 'application/json', content);
+            this.metaEtag = res.etag;
+            this.metaModifiedTime = res.modifiedTime;
+        }
+    }
+    async countTotalChanges() {
+        // If no snapshot exists yet, total changes = meta.seq (all changes)
+        if (!this.meta.snapshotIndexId) {
+            return this.meta.seq;
+        }
+        // Each log file ID in changeLogIds represents some number of changes.
+        // For simplicity and to trigger compaction based on file count (which is what matters for Drive),
+        // we can return the number of log files. 
+        // But since compactionThreshold is usually in ENTRIES, let's keep a rough estimate
+        // or just return the log file count if that's what the user expects.
+        // The previous "* 5" was too aggressive. 
+        // Let's assume on average 1 change per log file in tests (worst case).
+        return this.meta.changeLogIds.length + this.pendingChanges.length;
+    }
+    async cleanupOldFiles(oldIndexId, oldLogIds) {
+        const deleteFile = async (fileId) => {
+            try {
+                await this.client.deleteFile(fileId);
+                this.log('Deleted file', fileId);
+            }
+            catch (err) {
+                // 404 is ok - file already deleted or doesn't exist
+                if (err.status === 404 || err.code === 404) {
+                    this.log('File already deleted or not found', fileId);
+                    return;
+                }
+                // Log other errors but don't fail
+                this.log('Failed to delete file', fileId, err);
+            }
+        };
+        if (oldIndexId) {
+            await deleteFile(oldIndexId);
+        }
+        for (const id of oldLogIds) {
+            await deleteFile(id);
+        }
+    }
+    startPolling(intervalMs) {
+        this.log('Starting polling with interval', { intervalMs });
+        if (isNaN(intervalMs) || intervalMs <= 0)
+            return;
+        if (this.pollingInterval)
+            clearInterval(this.pollingInterval);
+        this.pollingInterval = setInterval(async () => {
+            this.log('Polling tick...');
+            if (this.isPollingActive) {
+                this.log('Polling already in progress, skipping tick');
+                return;
+            }
+            this.isPollingActive = true;
+            try {
+                const metaFile = await this.findFile('_meta.json');
+                if (!metaFile) {
+                    this.log('Polling: _meta.json not found');
+                    return;
+                }
+                // Compare etags, falling back to modifiedTime
+                this.log('Polling: comparing etag', metaFile.etag, 'with', this.metaEtag);
+                if ((metaFile.etag && this.metaEtag && metaFile.etag !== this.metaEtag) ||
+                    (!metaFile.etag && metaFile.modifiedTime !== this.metaModifiedTime)) {
+                    this.log('Polling detected change!', metaFile.etag || metaFile.modifiedTime);
+                    await this.load();
+                    this.notifyListeners();
+                }
+            }
+            catch (err) {
+                this.log('Polling error', err);
+            }
+            finally {
+                this.isPollingActive = false;
+            }
+        }, intervalMs);
+    }
+    notifyListeners() {
+        // Observers expecting 'docs' object might be broken if they expect FULL body.
+        // We can pass empty object or partials?
+        // Real PouchDB changes feed calls `db.changes()`. 
+        // Our `adapter.js` uses `db.onChange` effectively.
+        // We should pass a map of { ID: { _rev, ... } } (Index entries)
+        // Adapter needs to handle this.
+        const changes = {};
+        for (const [id, entry] of Object.entries(this.index)) {
+            changes[id] = {
+                _id: id,
+                _rev: entry.rev,
+                _deleted: !!entry.deleted,
+                seq: entry.seq // IMPORTANT: Missing previously, preventing filtered changes from working
+            };
+        }
+        for (const cb of this.listeners)
+            cb(changes);
+    }
+    // For tests/debug
+    onChange(cb) {
+        this.listeners.push(cb);
+        return () => {
+            this.listeners = this.listeners.filter(l => l !== cb);
+        };
+    }
+    stopPolling() { if (this.pollingInterval)
+        clearInterval(this.pollingInterval); }
+    escapeQuery(value) {
+        return value.replace(/'/g, "\\'");
+    }
+    async deleteFolder() { if (this.folderId)
+        await this.client.deleteFile(this.folderId); }
+    getNextSeq() { return this.meta.seq + 1; }
+}
+exports.DriveHandler = DriveHandler;