@docstack/pouchdb-adapter-googledrive 0.0.8 → 0.0.9

package/lib/adapter.d.ts

@@ -0,0 +1,20 @@
+import { GoogleDriveAdapterOptions } from './types';
+/** Combined options type for PouchDB adapter */
+interface AdapterOptions extends GoogleDriveAdapterOptions {
+    name: string;
+}
+/** Callback type for adapter initialization */
+type AdapterCallback = (err: Error | null, api?: any) => void;
+/**
+ * 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).
+ */
+export declare function GoogleDriveAdapter(PouchDB: any): {
+    (this: any, opts: AdapterOptions, callback: AdapterCallback): void;
+    valid(): boolean;
+    use_prefix: boolean;
+};
+export default GoogleDriveAdapter;

package/lib/adapter.js

@@ -0,0 +1,650 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleDriveAdapter = GoogleDriveAdapter;
+const drive_1 = require("./drive");
+/**
+ * Schedule a function to run asynchronously.
+ */
+function nextTick(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).
+ */
+function GoogleDriveAdapter(PouchDB) {
+    function GoogleDrivePouch(opts, callback) {
+        const api = this;
+        const name = opts.name;
+        // Clone options to avoid mutation
+        const adapterOpts = Object.assign({}, opts);
+        // Internal state
+        let instanceId;
+        let db;
+        // Initialize DriveHandler
+        console.log('Initializing DriveHandler with options:', adapterOpts);
+        db = new drive_1.DriveHandler(adapterOpts, name);
+        // 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) => {
+            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 () {
+            return 'googledrive';
+        };
+        api._id = function (callback) {
+            callback(null, instanceId);
+        };
+        // Info now must be async-ish (calculated from Index)
+        api._info = function (callback) {
+            // 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 = {};
+            }
+            // 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) {
+                    log('_get missing', id);
+                    const err = {
+                        status: 404,
+                        error: true,
+                        name: 'not_found',
+                        message: 'missing'
+                    };
+                    if (callback)
+                        callback(err);
+                    throw 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 = {};
+            }
+            // 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);
+                        if (!doc && (!entry || entry.deleted))
+                            return { key: id, error: 'not_found' };
+                        if (!doc && entry) {
+                            // This implies fetch failed but exists in index? Or null result.
+                            return { key: id, error: 'not_found' };
+                        }
+                        const row = {
+                            id,
+                            key: id,
+                            value: { rev: entry?.rev || doc._rev }
+                        };
+                        row.doc = doc;
+                        return row;
+                    });
+                    const result = {
+                        total_rows: total,
+                        offset: startIndex,
+                        rows: rows.filter(r => !r.error || !opts.keys) // Filter errored unless specifically asked via keys?
+                        // CouchDB usually returns error row if distinct keys requested.
+                    };
+                    if (opts.update_seq)
+                        result.update_seq = db.seq;
+                    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 {
+                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;
+            const results = [];
+            const newEdits = opts.new_edits !== false;
+            const changes = [];
+            // We need to validate revisions against Index
+            // This does NOT require fetching bodies usually
+            for (const doc of docs) {
+                const id = doc._id;
+                const seq = db.getNextSeq() + changes.length;
+                const entry = db.getIndexEntry(id);
+                if (doc._deleted) {
+                    if (!entry || entry.deleted) {
+                        results.push({
+                            ok: false,
+                            id,
+                            error: 'not_found',
+                            reason: 'missing'
+                        });
+                        continue;
+                    }
+                    // Check rev
+                    const oldRev = entry.rev || '0-0'; // Index has latest
+                    // If mismatch? PouchDB handles conflict logic before calling us sometimes?
+                    // But we should verify. 
+                    // If doc._rev matches entry.rev, we are good.
+                    const revNum = parseInt(oldRev.split('-')[0], 10) + 1;
+                    const newRev = revNum + '-' + generateRevId();
+                    changes.push({
+                        seq,
+                        id,
+                        rev: newRev,
+                        deleted: true,
+                        timestamp: Date.now()
+                    });
+                    results.push({ ok: true, id, rev: newRev });
+                }
+                else {
+                    let newRev;
+                    if (newEdits) {
+                        const oldRev = entry?.rev || '0-0';
+                        const revNum = parseInt(oldRev.split('-')[0], 10) + 1;
+                        newRev = revNum + '-' + generateRevId();
+                    }
+                    else {
+                        newRev = doc._rev;
+                    }
+                    const savedDoc = Object.assign({}, doc, { _rev: newRev });
+                    changes.push({
+                        seq,
+                        id,
+                        rev: newRev,
+                        doc: savedDoc,
+                        timestamp: Date.now()
+                    });
+                    results.push({ ok: true, id, rev: newRev });
+                }
+            }
+            log('_bulkDocs flushing', changes.length, 'changes');
+            // Append changes to log
+            const promise = db.appendChanges(changes).then(() => {
+                if (callback)
+                    nextTick(() => callback(null, results));
+                return results;
+            }).catch((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);
+            const since = opts.since || 0;
+            const limit = typeof opts.limit === 'number' ? opts.limit : Infinity;
+            const returnDocs = opts.return_docs !== false;
+            const results = [];
+            let lastSeq = since;
+            let complete = false;
+            // 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);
+                            }
+                        }
+                    }
+                };
+                cancelLive = db.onChange(liveListener);
+            }
+            // Process initial changes
+            async function processChangesAsync() {
+                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;
+                    const change = {
+                        id: id,
+                        seq: entry.seq,
+                        changes: [{ rev: entry.rev }]
+                    };
+                    if (opts.include_docs) {
+                        try {
+                            change.doc = await db.get(id);
+                        }
+                        catch (e) {
+                            log('_changes include_docs error', e);
+                        }
+                    }
+                    if (opts.onChange)
+                        opts.onChange(change);
+                    if (returnDocs)
+                        results.push(change);
+                    processed++;
+                    lastSeq = Math.max(lastSeq, entry.seq);
+                }
+                // ✅ 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 });
+                }
+            }
+            // 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) {
+            const promise = db.compact().then(() => {
+                const result = { ok: true };
+                if (callback)
+                    callback(null, result);
+                return result;
+            }).catch((err) => {
+                if (callback)
+                    callback(err);
+                throw err;
+            });
+            return promise;
+        };
+        api._getRevisionTree = function (docId, 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();
+            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;
+                opts = {};
+            }
+            db.stopPolling();
+            if (opts.deleteFolder) {
+                return db.deleteFolder().then(() => {
+                    if (typeof callback === 'function') {
+                        callback(null, { ok: true });
+                    }
+                    return { ok: true };
+                }).catch((err) => {
+                    if (typeof callback === 'function') {
+                        callback(err);
+                    }
+                    throw err;
+                });
+            }
+            else {
+                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;
+                opts = {};
+            }
+            const id = doc._id;
+            const rev = '0-1';
+            const savedDoc = Object.assign({}, doc, { _rev: rev });
+            const change = {
+                seq: db.getNextSeq(),
+                id,
+                rev,
+                doc: savedDoc,
+                timestamp: Date.now()
+            };
+            const promise = db.appendChanges([change]).then(() => {
+                const result = { ok: true, id, rev };
+                if (callback)
+                    callback(null, result);
+                return result;
+            }).catch((err) => {
+                if (callback)
+                    callback(err);
+                throw err;
+            });
+            return promise;
+        };
+        api._getLocal = function (id, 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 ...
+            if (typeof opts === 'function') {
+                callback = opts;
+                opts = {};
+            }
+            const id = doc._id;
+            // Check existence async if we want to be strict, but index check is ok
+            if (!db.getIndexEntry(id)) {
+                const err = { status: 404, error: true, name: 'not_found' };
+                if (callback)
+                    callback(err);
+                return Promise.reject(err);
+            }
+            // ...
+            // Simplified removeLocal
+            const change = {
+                seq: db.getNextSeq(),
+                id,
+                rev: '0-0',
+                deleted: true,
+                timestamp: Date.now()
+            };
+            const promise = db.appendChanges([change]).then(() => {
+                const result = { ok: true, id, rev: '0-0' };
+                if (callback)
+                    callback(null, result);
+                return result;
+            }).catch((err) => {
+                if (callback)
+                    callback(err);
+                throw err;
+            });
+            return promise;
+        };
+    }
+    // Static properties
+    GoogleDrivePouch.valid = function () {
+        return true;
+    };
+    GoogleDrivePouch.use_prefix = false;
+    return GoogleDrivePouch;
+}
+/**
+ * Generate a random revision ID
+ */
+function generateRevId() {
+    return Math.random().toString(36).substring(2, 11) +
+        Math.random().toString(36).substring(2, 11);
+}
+exports.default = GoogleDriveAdapter;

package/lib/cache.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Simple Least Recently Used (LRU) Cache
+ */
+export declare class LRUCache<K, V> {
+    private capacity;
+    private map;
+    constructor(capacity: number);
+    get(key: K): V | undefined;
+    put(key: K, value: V): void;
+    remove(key: K): void;
+    clear(): void;
+}