@docstack/pouchdb-adapter-googledrive 0.0.5 → 0.0.8

package/lib/adapter.js

@@ -1,440 +0,0 @@
-"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) {
-    queueMicrotask(fn);
-}
-/**
- * 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
-        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);
-            });
-        }
-        // Load data from Drive and initialize
-        db.load().then(() => {
-            afterDBCreated();
-        }).catch((err) => {
-            callback(err);
-        });
-        // ============ 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) {
-            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);
-            });
-        };
-        // 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 => {
-                if (!doc) {
-                    return callback({
-                        status: 404,
-                        error: true,
-                        name: 'not_found',
-                        message: 'missing',
-                        reason: 'missing'
-                    });
-                }
-                const metadata = {
-                    id: doc._id,
-                    rev: doc._rev,
-                    winningRev: doc._rev,
-                    deleted: !!doc._deleted
-                };
-                callback(null, { doc, metadata });
-            }).catch(err => {
-                callback(err);
-            });
-        };
-        // 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 => {
-                    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;
-                    callback(null, result);
-                }).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));
-            }
-        };
-        // 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 });
-                }
-            }
-            // Append changes to log
-            db.appendChanges(changes).then(() => {
-                nextTick(() => callback(null, results));
-            }).catch((err) => {
-                callback(err);
-            });
-        };
-        // 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;
-            // 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.
-                    }
-                    // Supporting async processChanges is cleaner.
-                }
-                // ... This requires rewrite for async iteration ...
-            }
-            // Simplified Async Version
-            async function processChangesAsync() {
-                const keys = db.getIndexKeys();
-                let processed = 0;
-                for (const id of keys) {
-                    if (complete || processed >= limit)
-                        break;
-                    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) {
-                        change.doc = await db.get(id);
-                    }
-                    if (opts.onChange)
-                        opts.onChange(change);
-                    if (returnDocs)
-                        results.push(change);
-                    processed++;
-                    lastSeq = Math.max(lastSeq, entry.seq);
-                }
-                if (opts.complete && !complete) {
-                    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);
-                });
-            });
-            return {
-                cancel() {
-                    complete = true;
-                }
-            };
-        };
-        // Manual compaction trigger
-        api._compact = function (callback) {
-            db.compact().then(() => {
-                callback(null, { ok: true });
-            }).catch((err) => {
-                callback(err);
-            });
-        };
-        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);
-        };
-        api._close = function (callback) {
-            db.stopPolling();
-            nextTick(callback);
-        };
-        api._destroy = function (opts, callback) {
-            if (typeof opts === 'function') {
-                callback = opts;
-                opts = {};
-            }
-            db.stopPolling();
-            if (opts.deleteFolder) {
-                db.deleteFolder().then(() => {
-                    callback(null, { ok: true });
-                }).catch((err) => {
-                    callback(err);
-                });
-            }
-            else {
-                nextTick(() => callback(null, { ok: true }));
-            }
-        };
-        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()
-            };
-            db.appendChanges([change]).then(() => {
-                callback(null, { ok: true, id, rev });
-            }).catch((err) => {
-                callback(err);
-            });
-        };
-        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);
-        };
-        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)) {
-                return callback({ status: 404, error: true, name: 'not_found' });
-            }
-            // ...
-            // Simplified removeLocal
-            const change = {
-                seq: db.getNextSeq(),
-                id,
-                rev: '0-0',
-                deleted: true,
-                timestamp: Date.now()
-            };
-            db.appendChanges([change]).then(() => {
-                callback(null, { ok: true, id, rev: '0-0' });
-            }).catch((err) => {
-                callback(err);
-            });
-        };
-    }
-    // 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

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

package/lib/cache.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LRUCache = void 0;
-/**
- * Simple Least Recently Used (LRU) Cache
- */
-class LRUCache {
-    constructor(capacity) {
-        this.capacity = capacity;
-        this.map = new Map();
-    }
-    get(key) {
-        const value = this.map.get(key);
-        if (value !== undefined) {
-            // Refresh: delete and re-add to end (most contiguous)
-            this.map.delete(key);
-            this.map.set(key, value);
-        }
-        return value;
-    }
-    put(key, value) {
-        if (this.map.has(key)) {
-            // Update existing
-            this.map.delete(key);
-        }
-        else if (this.map.size >= this.capacity) {
-            // Evict least recently used (first item)
-            const firstKey = this.map.keys().next().value;
-            if (firstKey !== undefined) {
-                this.map.delete(firstKey);
-            }
-        }
-        this.map.set(key, value);
-    }
-    remove(key) {
-        this.map.delete(key);
-    }
-    clear() {
-        this.map.clear();
-    }
-}
-exports.LRUCache = LRUCache;

package/lib/client.d.ts

@@ -1,29 +0,0 @@
-export interface DriveFile {
-    id: string;
-    name: string;
-    mimeType: string;
-    parents?: string[];
-    etag?: string;
-}
-export interface DriveClientOptions {
-    accessToken: string | (() => Promise<string>);
-}
-export declare class GoogleDriveClient {
-    private options;
-    constructor(options: DriveClientOptions);
-    private getToken;
-    private fetch;
-    listFiles(q: string): Promise<DriveFile[]>;
-    getFile(fileId: string): Promise<any>;
-    getFileMetadata(fileId: string): Promise<DriveFile>;
-    createFile(name: string, parents: string[] | undefined, mimeType: string, content: string): Promise<{
-        id: string;
-        etag: string;
-    }>;
-    updateFile(fileId: string, content: string, expectedEtag?: string): Promise<{
-        id: string;
-        etag: string;
-    }>;
-    deleteFile(fileId: string): Promise<void>;
-    private buildMultipart;
-}

package/lib/client.js

@@ -1,129 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GoogleDriveClient = void 0;
-const BASE_URL = 'https://www.googleapis.com/drive/v3/files';
-const UPLOAD_URL = 'https://www.googleapis.com/upload/drive/v3/files';
-class GoogleDriveClient {
-    constructor(options) {
-        this.options = options;
-    }
-    async getToken() {
-        if (typeof this.options.accessToken === 'function') {
-            return await this.options.accessToken();
-        }
-        return this.options.accessToken;
-    }
-    async fetch(url, init) {
-        const token = await this.getToken();
-        const headers = new Headers(init.headers);
-        headers.set('Authorization', `Bearer ${token}`);
-        const res = await fetch(url, { ...init, headers });
-        const method = init.method || 'GET';
-        if (!res.ok) {
-            // Basic error handling
-            const text = await res.text();
-            let errorMsg = `Drive API Error: ${res.status} ${res.statusText} (${method} ${url})`;
-            try {
-                const json = JSON.parse(text);
-                if (json.error && json.error.message) {
-                    errorMsg += ` - ${json.error.message}`;
-                }
-            }
-            catch { }
-            const err = new Error(errorMsg);
-            err.status = res.status;
-            throw err;
-        }
-        return res;
-    }
-    async listFiles(q) {
-        const params = new URLSearchParams({
-            q,
-            fields: 'files(id, name, mimeType, parents, etag)',
-            spaces: 'drive',
-            pageSize: '1000' // Ensure we get enough
-        });
-        const res = await this.fetch(`${BASE_URL}?${params.toString()}`, { method: 'GET' });
-        const data = await res.json();
-        return data.files || [];
-    }
-    async getFile(fileId) {
-        // Try getting media
-        try {
-            const params = new URLSearchParams({ alt: 'media' });
-            const res = await this.fetch(`${BASE_URL}/${fileId}?${params.toString()}`, { method: 'GET' });
-            // Standard fetch handles JSON/Text transparency? 
-            // We expect JSON mostly, but sometimes we might want text.
-            // PouchDB adapter flow: downloadJson, downloadNdjson
-            // Let's rely on content-type or caller expectation?
-            // The usage in `drive.ts` expects parsed JSON/NDJSON lines.
-            // Let's return the raw Text or JSON based on Content-Type?
-            const contentType = res.headers.get('content-type');
-            if (contentType && contentType.includes('application/json')) {
-                return await res.json();
-            }
-            return await res.text();
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    // Single metadata get (for etag check)
-    async getFileMetadata(fileId) {
-        const params = new URLSearchParams({ fields: 'id, name, mimeType, parents, etag' });
-        const res = await this.fetch(`${BASE_URL}/${fileId}?${params.toString()}`, { method: 'GET' });
-        return await res.json();
-    }
-    async createFile(name, parents, mimeType, content) {
-        const metadata = {
-            name,
-            mimeType,
-            parents
-        };
-        // Folders or empty content can use simple metadata-only POST
-        if (!content && mimeType === 'application/vnd.google-apps.folder') {
-            const res = await this.fetch(`${BASE_URL}?fields=id,etag`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(metadata)
-            });
-            return await res.json();
-        }
-        const multipartBody = this.buildMultipart(metadata, content, mimeType);
-        const res = await this.fetch(`${UPLOAD_URL}?uploadType=multipart&fields=id,etag`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': `multipart/related; boundary=${multipartBody.boundary}`
-            },
-            body: multipartBody.body
-        });
-        return await res.json();
-    }
-    async updateFile(fileId, content, expectedEtag) {
-        // Update content (media) usually, but sometimes meta?
-        // In our usage (saveMeta), we update body.
-        const res = await this.fetch(`${UPLOAD_URL}/${fileId}?uploadType=media&fields=id,etag`, {
-            method: 'PATCH',
-            headers: expectedEtag ? { 'If-Match': expectedEtag, 'Content-Type': 'application/json' } : { 'Content-Type': 'application/json' },
-            body: content
-        });
-        return await res.json();
-    }
-    async deleteFile(fileId) {
-        await this.fetch(`${BASE_URL}/${fileId}`, { method: 'DELETE' });
-    }
-    buildMultipart(metadata, content, contentType) {
-        const boundary = '-------' + Math.random().toString(36).substring(2);
-        const delimiter = `\r\n--${boundary}\r\n`;
-        const closeDelimiter = `\r\n--${boundary}--`;
-        const body = delimiter +
-            'Content-Type: application/json\r\n\r\n' +
-            JSON.stringify(metadata) +
-            delimiter +
-            `Content-Type: ${contentType}\r\n\r\n` +
-            content +
-            closeDelimiter;
-        return { body, boundary };
-    }
-}
-exports.GoogleDriveClient = GoogleDriveClient;