@docstack/pouchdb-adapter-googledrive 0.0.6 → 0.0.9

package/lib/adapter.js

@@ -6,8 +6,13 @@ const drive_1 = require("./drive");
  * Schedule a function to run asynchronously.
  */
 function nextTick(fn) {
-    queueMicrotask(fn);
+    if (typeof fn === 'function') {
+        queueMicrotask(fn);
+    }
 }
+/**
+ * TODO: Implement dynamic method signature, since PouchDB CRUD methods can be called as promise, callback or (?)
+ */
 /**
  * GoogleDriveAdapter - PouchDB adapter for Google Drive storage.
  * Updated for Lazy Loading (Async Access).
@@ -22,20 +27,73 @@ function GoogleDriveAdapter(PouchDB) {
         let instanceId;
         let db;
         // Initialize DriveHandler
+        console.log('Initializing DriveHandler with options:', adapterOpts);
         db = new drive_1.DriveHandler(adapterOpts, name);
-        // After database is initialized
-        function afterDBCreated() {
-            instanceId = 'gdrive-' + name + '-' + Date.now().toString(36);
-            nextTick(function () {
-                callback(null, api);
-            });
+        // Initialize instanceId synchronously to avoid race conditions during replication setup
+        instanceId = 'gdrive-' + name + '-' + Date.now().toString(36);
+        // Polyfill activeTasks to ensure replication works even if PouchDB core doesn't attach it
+        if (!api.activeTasks) {
+            class ActiveTasks {
+                constructor() {
+                    this._tasks = {};
+                }
+                add(task) {
+                    const id = Date.now().toString(36) + Math.random().toString(36).substring(2, 5);
+                    this._tasks[id] = task;
+                    this._tasks[id].created_at = new Date().toISOString();
+                    this._tasks[id].updated_at = new Date().toISOString();
+                    return id;
+                }
+                remove(id, err) {
+                    delete this._tasks[id];
+                }
+                update(id, update) {
+                    if (this._tasks[id]) {
+                        Object.assign(this._tasks[id], update);
+                        this._tasks[id].updated_at = new Date().toISOString();
+                    }
+                }
+                get(id) {
+                    return this._tasks[id];
+                }
+                list() {
+                    return Object.values(this._tasks);
+                }
+            }
+            // @ts-ignore
+            api.activeTasks = new ActiveTasks();
         }
+        // Wrap callback to ensure it's only called once
+        let callbackCalled = false;
+        const onceCallback = (err, api) => {
+            if (callbackCalled)
+                return;
+            callbackCalled = true;
+            callback(err, api);
+        };
+        const debug = adapterOpts.debug;
+        const log = (...args) => { if (debug)
+            console.log(`[googledrive-adapter] [${name}]`, ...args); };
+        log('Initializing with options:', {
+            folderId: adapterOpts.folderId,
+            folderName: adapterOpts.folderName,
+            pollingIntervalMs: adapterOpts.pollingIntervalMs,
+            debug: adapterOpts.debug
+        });
         // Load data from Drive and initialize
         db.load().then(() => {
+            log('Database loaded');
             afterDBCreated();
         }).catch((err) => {
-            callback(err);
+            log('Load error', err);
+            onceCallback(err);
         });
+        // After database is initialized
+        function afterDBCreated() {
+            nextTick(function () {
+                onceCallback(null, api);
+            });
+        }
         // ============ PouchDB Adapter API Methods ============
         api._remote = false;
         api.type = function () {
@@ -46,77 +104,115 @@ function GoogleDriveAdapter(PouchDB) {
         };
         // Info now must be async-ish (calculated from Index)
         api._info = function (callback) {
-            const keys = db.getIndexKeys();
-            const docCount = keys.length; // Approximate (doesn't account for deleted unless filtered)
-            // Filter deleted for accurate count
-            let alive = 0;
-            for (const k of keys) {
-                const entry = db.getIndexEntry(k);
-                if (entry && !entry.deleted)
-                    alive++;
-            }
-            const res = {
-                doc_count: alive,
-                update_seq: db.seq,
-                backend_adapter: 'googledrive'
-            };
-            nextTick(function () {
-                callback(null, res);
+            // Need to handle promise if it returns one
+            const promise = Promise.resolve().then(async () => {
+                const keys = await db.getIndexKeys();
+                const docCount = keys.length; // Approximate (doesn't account for deleted unless filtered)
+                // Filter deleted for accurate count
+                let alive = 0;
+                for (const k of keys) {
+                    const entry = db.getIndexEntry(k);
+                    if (entry && !entry.deleted)
+                        alive++;
+                }
+                return {
+                    db_name: name,
+                    doc_count: alive,
+                    update_seq: db.seq,
+                    backend_adapter: 'googledrive'
+                };
             });
+            if (callback) {
+                promise.then(res => callback(null, res)).catch(err => callback(err));
+            }
+            else {
+                return promise;
+            }
         };
+        api.info = api._info;
         // Get a single document by ID (Async fetch)
         api._get = function (id, opts, callback) {
             if (typeof opts === 'function') {
                 callback = opts;
                 opts = {};
             }
-            db.get(id).then(doc => {
+            // Ensure opts is always an object
+            if (!opts || typeof opts !== 'object') {
+                opts = {};
+            }
+            // PouchDB sometimes asks for metadata only (revs, revs_info) 
+            log('_get id:', id, 'opts:', JSON.stringify(opts));
+            const promise = db.get(id).then(doc => {
                 if (!doc) {
-                    return callback({
+                    log('_get missing', id);
+                    const err = {
                         status: 404,
                         error: true,
                         name: 'not_found',
-                        message: 'missing',
-                        reason: 'missing'
-                    });
+                        message: 'missing'
+                    };
+                    if (callback)
+                        callback(err);
+                    throw err;
                 }
-                const metadata = {
-                    id: doc._id,
-                    rev: doc._rev,
-                    winningRev: doc._rev,
-                    deleted: !!doc._deleted
-                };
-                callback(null, { doc, metadata });
-            }).catch(err => {
-                callback(err);
+                // Support open_revs for bulkGet shim compatibility
+                if (opts.open_revs) {
+                    log('_get handling open_revs for:', id);
+                    // We currently only store the winning revision.
+                    // If open_revs='all' or includes our rev, return it.
+                    // TODO: Robust conflict support would check exact rev matching.
+                    const result = [{ ok: doc }];
+                    if (callback)
+                        callback(null, result);
+                    return result;
+                }
+                log('_get returning standard doc for:', id);
+                // If only rev was requested? (Internal optimization)
+                // PouchDB core handles this if we return the full doc.
+                const response = doc;
+                if (callback)
+                    callback(null, response);
+                return response;
+            }).catch(e => {
+                log('_get error', e);
+                if (callback)
+                    callback(e);
+                throw e;
             });
+            return promise;
         };
+        api.get = api._get;
         // Get all documents (Lazy stream or fetch)
         api._allDocs = function (opts, callback) {
             if (typeof opts === 'function') {
                 callback = opts;
                 opts = {};
             }
-            const keys = db.getIndexKeys();
-            const total = keys.length; // Total keys (including deleted?)
-            let startIndex = opts.skip || 0;
-            let limit = typeof opts.limit === 'number' ? opts.limit : keys.length;
-            let filteredKeys = keys;
-            if (opts.startkey)
-                filteredKeys = filteredKeys.filter(k => k >= opts.startkey);
-            if (opts.endkey)
-                filteredKeys = filteredKeys.filter(k => k <= opts.endkey);
-            if (opts.key)
-                filteredKeys = filteredKeys.filter(k => k === opts.key);
-            if (opts.keys)
-                filteredKeys = opts.keys;
-            filteredKeys.sort();
-            if (opts.descending)
-                filteredKeys.reverse();
-            const sliced = filteredKeys.slice(startIndex, startIndex + limit);
-            // Fetch actual docs if needed
-            if (opts.include_docs) {
-                db.getMulti(sliced).then(docs => {
+            // Ensure opts is always an object
+            if (!opts || typeof opts !== 'object') {
+                opts = {};
+            }
+            const promise = (async () => {
+                const keys = await db.getIndexKeys();
+                const total = keys.length; // Total keys (including deleted?)
+                let startIndex = opts.skip || 0;
+                let limit = typeof opts.limit === 'number' ? opts.limit : keys.length;
+                let filteredKeys = keys;
+                if (opts.startkey)
+                    filteredKeys = filteredKeys.filter(k => k >= opts.startkey);
+                if (opts.endkey)
+                    filteredKeys = filteredKeys.filter(k => k <= opts.endkey);
+                if (opts.key)
+                    filteredKeys = filteredKeys.filter(k => k === opts.key);
+                if (opts.keys)
+                    filteredKeys = opts.keys;
+                filteredKeys.sort();
+                if (opts.descending)
+                    filteredKeys.reverse();
+                const sliced = filteredKeys.slice(startIndex, startIndex + limit);
+                // Fetch actual docs if needed
+                if (opts.include_docs) {
+                    const docs = await db.getMulti(sliced);
                     const rows = sliced.map((id, i) => {
                         const doc = docs[i];
                         const entry = db.getIndexEntry(id);
@@ -142,31 +238,78 @@ function GoogleDriveAdapter(PouchDB) {
                     };
                     if (opts.update_seq)
                         result.update_seq = db.seq;
-                    callback(null, result);
-                }).catch(err => callback(err));
+                    return result;
+                }
+                else {
+                    // Index only (Fast!)
+                    const rows = sliced.map(id => {
+                        const entry = db.getIndexEntry(id);
+                        if (!entry || entry.deleted)
+                            return { key: id, error: 'not_found' };
+                        return {
+                            id,
+                            key: id,
+                            value: { rev: entry.rev }
+                        };
+                    });
+                    const result = {
+                        total_rows: total,
+                        offset: startIndex,
+                        rows
+                    };
+                    if (opts.update_seq)
+                        result.update_seq = db.seq;
+                    return result;
+                }
+            })();
+            if (callback) {
+                promise.then(res => callback(null, res)).catch(err => callback(err));
             }
             else {
-                // Index only (Fast!)
-                const rows = sliced.map(id => {
-                    const entry = db.getIndexEntry(id);
-                    if (!entry || entry.deleted)
-                        return { key: id, error: 'not_found' };
-                    return {
-                        id,
-                        key: id,
-                        value: { rev: entry.rev }
-                    };
-                });
-                const result = {
-                    total_rows: total,
-                    offset: startIndex,
-                    rows
-                };
-                if (opts.update_seq)
-                    result.update_seq = db.seq;
-                nextTick(() => callback(null, result));
+                return promise;
             }
         };
+        api.allDocs = api._allDocs;
+        // Bulk Get optimization for Replication
+        api._bulkGet = function (opts, callback) {
+            const docs = opts.docs;
+            const ids = docs.map((d) => d.id);
+            return db.getMulti(ids).then(results => {
+                const response = {
+                    results: ids.map((id, i) => {
+                        const doc = results[i];
+                        const requestedRev = docs[i].rev;
+                        const entry = db.getIndexEntry(id);
+                        let docResult;
+                        if (!doc || (requestedRev && doc._rev !== requestedRev)) {
+                            docResult = {
+                                error: {
+                                    status: 404,
+                                    error: true,
+                                    name: 'not_found',
+                                    message: 'missing'
+                                }
+                            };
+                        }
+                        else {
+                            docResult = { ok: doc };
+                        }
+                        return {
+                            id,
+                            docs: [docResult]
+                        };
+                    })
+                };
+                if (callback)
+                    callback(null, response);
+                return response;
+            }).catch((err) => {
+                if (callback)
+                    callback(err);
+                throw err;
+            });
+        };
+        api.bulkGet = api._bulkGet;
         // Bulk document operations
         api._bulkDocs = function (req, opts, callback) {
             const docs = req.docs;
@@ -226,13 +369,21 @@ function GoogleDriveAdapter(PouchDB) {
                     results.push({ ok: true, id, rev: newRev });
                 }
             }
+            log('_bulkDocs flushing', changes.length, 'changes');
             // Append changes to log
-            db.appendChanges(changes).then(() => {
-                nextTick(() => callback(null, results));
+            const promise = db.appendChanges(changes).then(() => {
+                if (callback)
+                    nextTick(() => callback(null, results));
+                return results;
             }).catch((err) => {
-                callback(err);
+                log('_bulkDocs error', err);
+                if (callback)
+                    callback(err);
+                throw err;
             });
+            return promise;
         };
+        api.bulkDocs = api._bulkDocs;
         // Changes feed
         api._changes = function (opts) {
             opts = Object.assign({}, opts);
@@ -242,50 +393,52 @@ function GoogleDriveAdapter(PouchDB) {
             const results = [];
             let lastSeq = since;
             let complete = false;
-            // Should we iterate Index or Logs?
-            // "Index" only has LATEST state. _changes usually wants history if `since` is old.
-            // But this adapter is an "Index + Log" adapter.
-            // If `since` is 0, we can walk the Index.
-            // If `since` is recent, we can maybe walk pending changes?
-            // Correct implementation of `_changes` with Append-Only Log requires reading the log files essentially.
-            // BUT, standard PouchDB `_changes` often just iterates all docs if it can't stream.
-            // For now, let's iterate the INDEX (Winning Revisions) which implies "since=0" behavior effectively (State of the World).
-            function processChanges() {
-                const keys = db.getIndexKeys(); // IDs
-                let processed = 0;
-                // Index-based iteration
-                for (const id of keys) {
-                    if (complete || processed >= limit)
-                        break;
-                    const entry = db.getIndexEntry(id);
-                    if (!entry)
-                        continue;
-                    // Filter by seq?
-                    if (entry.seq <= since)
-                        continue; // Already seen
-                    const change = {
-                        id: id,
-                        seq: entry.seq,
-                        changes: [{ rev: entry.rev }],
-                    };
-                    if (opts.include_docs) {
-                        // We need to fetch it!
-                        // This makes _changes with include_docs SLOW.
-                        // We can't do this synchronously here easily because `processChanges` is sync in original code?
-                        // Wait, original was `nextTick(processChanges)`.
-                        // We need to be async here.
+            // Setup live listener FIRST (before emitting changes)
+            let cancelLive;
+            let liveListener;
+            if (opts.live) {
+                log('_changes setting up live listener');
+                liveListener = (changedDocs) => {
+                    if (complete)
+                        return;
+                    for (const id of Object.keys(changedDocs)) {
+                        if (id.startsWith('_local/'))
+                            continue;
+                        const entry = db.getIndexEntry(id);
+                        if (entry && entry.seq > lastSeq) {
+                            const change = {
+                                id: id,
+                                seq: entry.seq,
+                                changes: [{ rev: entry.rev }]
+                            };
+                            if (opts.include_docs) {
+                                db.get(id).then(doc => {
+                                    change.doc = doc;
+                                    if (opts.onChange)
+                                        opts.onChange(change);
+                                    lastSeq = Math.max(lastSeq, change.seq);
+                                }).catch(e => log('Live change body fetch error', e));
+                            }
+                            else {
+                                if (opts.onChange)
+                                    opts.onChange(change);
+                                lastSeq = Math.max(lastSeq, change.seq);
+                            }
+                        }
                     }
-                    // Supporting async processChanges is cleaner.
-                }
-                // ... This requires rewrite for async iteration ...
+                };
+                cancelLive = db.onChange(liveListener);
             }
-            // Simplified Async Version
+            // Process initial changes
             async function processChangesAsync() {
-                const keys = db.getIndexKeys();
+                log('_changes processing since', since, 'limit', limit, 'live', !!opts.live);
+                const keys = await db.getIndexKeys();
                 let processed = 0;
                 for (const id of keys) {
                     if (complete || processed >= limit)
                         break;
+                    if (id.startsWith('_local/'))
+                        continue;
                     const entry = db.getIndexEntry(id);
                     if (!entry || entry.seq <= since)
                         continue;
@@ -295,7 +448,12 @@ function GoogleDriveAdapter(PouchDB) {
                         changes: [{ rev: entry.rev }]
                     };
                     if (opts.include_docs) {
-                        change.doc = await db.get(id);
+                        try {
+                            change.doc = await db.get(id);
+                        }
+                        catch (e) {
+                            log('_changes include_docs error', e);
+                        }
                     }
                     if (opts.onChange)
                         opts.onChange(change);
@@ -304,53 +462,67 @@ function GoogleDriveAdapter(PouchDB) {
                     processed++;
                     lastSeq = Math.max(lastSeq, entry.seq);
                 }
-                if (opts.complete && !complete) {
+                // ✅ Call opts.complete() ONLY for non-live modes
+                // PouchDB replication will infinite-loop reconnect if we call complete() on a live feed
+                if (opts.complete && !complete && !opts.live) {
+                    log('_changes calling complete callback with', { results_count: results.length, last_seq: lastSeq });
                     opts.complete(null, { results, last_seq: lastSeq });
                 }
             }
-            if (opts.live) {
-                db.onChange((changes) => {
-                    // Update feed
-                    // ...
-                });
-            }
-            nextTick(() => {
-                processChangesAsync().catch(err => {
-                    console.error('Changes feed error', err);
-                    if (opts.complete)
-                        opts.complete(err);
-                });
+            // Start processing (async) which will wait for load() via getIndexKeys()
+            processChangesAsync().catch(err => {
+                log('_changes error', err);
+                complete = true;
+                if (opts.complete)
+                    opts.complete(err);
             });
             return {
                 cancel() {
+                    log('_changes cancel');
                     complete = true;
+                    if (cancelLive)
+                        cancelLive();
                 }
             };
         };
         // Manual compaction trigger
         api._compact = function (callback) {
-            db.compact().then(() => {
-                callback(null, { ok: true });
+            const promise = db.compact().then(() => {
+                const result = { ok: true };
+                if (callback)
+                    callback(null, result);
+                return result;
             }).catch((err) => {
-                callback(err);
+                if (callback)
+                    callback(err);
+                throw err;
             });
+            return promise;
         };
         api._getRevisionTree = function (docId, callback) {
-            db.get(docId).then(doc => {
-                if (!doc) {
-                    return callback({ status: 404, error: true, name: 'not_found', message: 'missing' });
-                }
-                const revTree = [{
-                        pos: 1,
-                        ids: [doc._rev.split('-')[1], { status: 'available' }, []]
-                    }];
-                callback(null, revTree);
-            }).catch(callback);
+            const entry = db.getIndexEntry(docId);
+            if (!entry) {
+                return callback({ status: 404, error: true, name: 'not_found', message: 'missing' });
+            }
+            // Return a minimal tree based on the known winning revision
+            const revNum = parseInt(entry.rev.split('-')[0], 10);
+            const revHash = entry.rev.split('-')[1];
+            const revTree = [{
+                    pos: revNum,
+                    ids: [revHash, { status: 'available' }, []]
+                }];
+            callback(null, revTree);
         };
         api._close = function (callback) {
             db.stopPolling();
-            nextTick(callback);
+            if (typeof callback === 'function') {
+                nextTick(callback);
+            }
+            else {
+                return Promise.resolve();
+            }
         };
+        api.close = api._close;
         api._destroy = function (opts, callback) {
             if (typeof opts === 'function') {
                 callback = opts;
@@ -358,16 +530,28 @@ function GoogleDriveAdapter(PouchDB) {
             }
             db.stopPolling();
             if (opts.deleteFolder) {
-                db.deleteFolder().then(() => {
-                    callback(null, { ok: true });
+                return db.deleteFolder().then(() => {
+                    if (typeof callback === 'function') {
+                        callback(null, { ok: true });
+                    }
+                    return { ok: true };
                 }).catch((err) => {
-                    callback(err);
+                    if (typeof callback === 'function') {
+                        callback(err);
+                    }
+                    throw err;
                 });
             }
             else {
-                nextTick(() => callback(null, { ok: true }));
+                if (typeof callback === 'function') {
+                    nextTick(() => callback(null, { ok: true }));
+                }
+                else {
+                    return Promise.resolve({ ok: true });
+                }
             }
         };
+        api.destroy = api._destroy;
         api._putLocal = function (doc, opts, callback) {
             if (typeof opts === 'function') {
                 callback = opts;
@@ -383,18 +567,35 @@ function GoogleDriveAdapter(PouchDB) {
                 doc: savedDoc,
                 timestamp: Date.now()
             };
-            db.appendChanges([change]).then(() => {
-                callback(null, { ok: true, id, rev });
+            const promise = db.appendChanges([change]).then(() => {
+                const result = { ok: true, id, rev };
+                if (callback)
+                    callback(null, result);
+                return result;
             }).catch((err) => {
-                callback(err);
+                if (callback)
+                    callback(err);
+                throw err;
             });
+            return promise;
         };
         api._getLocal = function (id, callback) {
-            db.get(id).then(doc => {
-                if (!doc)
-                    return callback({ status: 404, error: true, name: 'not_found' });
-                callback(null, doc);
-            }).catch(callback);
+            const promise = db.get(id).then(doc => {
+                if (!doc) {
+                    const err = { status: 404, error: true, name: 'not_found' };
+                    if (callback)
+                        callback(err);
+                    throw err;
+                }
+                if (callback)
+                    callback(null, doc);
+                return doc;
+            }).catch(err => {
+                if (callback)
+                    callback(err);
+                throw err;
+            });
+            return promise;
         };
         api._removeLocal = function (doc, opts, callback) {
             // ... Similar async update ...
@@ -405,7 +606,10 @@ function GoogleDriveAdapter(PouchDB) {
             const id = doc._id;
             // Check existence async if we want to be strict, but index check is ok
             if (!db.getIndexEntry(id)) {
-                return callback({ status: 404, error: true, name: 'not_found' });
+                const err = { status: 404, error: true, name: 'not_found' };
+                if (callback)
+                    callback(err);
+                return Promise.reject(err);
             }
             // ...
             // Simplified removeLocal
@@ -416,11 +620,17 @@ function GoogleDriveAdapter(PouchDB) {
                 deleted: true,
                 timestamp: Date.now()
             };
-            db.appendChanges([change]).then(() => {
-                callback(null, { ok: true, id, rev: '0-0' });
+            const promise = db.appendChanges([change]).then(() => {
+                const result = { ok: true, id, rev: '0-0' };
+                if (callback)
+                    callback(null, result);
+                return result;
             }).catch((err) => {
-                callback(err);
+                if (callback)
+                    callback(err);
+                throw err;
             });
+            return promise;
         };
     }
     // Static properties