@docstack/pouchdb-adapter-googledrive 0.0.8 → 0.0.9

package/lib/cache.js

@@ -0,0 +1,42 @@
+"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

@@ -0,0 +1,37 @@
+export interface DriveFile {
+    id: string;
+    name: string;
+    mimeType: string;
+    parents?: string[];
+    etag?: string;
+    modifiedTime?: string;
+}
+export interface DriveClientOptions {
+    accessToken: string | (() => Promise<string>);
+    baseUrl?: string;
+    uploadUrl?: string;
+}
+export declare class GoogleDriveClient {
+    private options;
+    constructor(options: DriveClientOptions);
+    private getToken;
+    private fetch;
+    private get baseUrl();
+    private get uploadUrl();
+    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;
+        modifiedTime: string;
+    }>;
+    updateFile(fileId: string, content: string, expectedEtag?: string): Promise<{
+        id: string;
+        etag: string;
+        modifiedTime: string;
+    }>;
+    private extractEtag;
+    deleteFile(fileId: string): Promise<void>;
+    private buildMultipart;
+}

package/lib/client.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleDriveClient = void 0;
+const DEFAULT_BASE_URL = 'https://www.googleapis.com/drive/v3/files';
+const DEFAULT_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 method = init.method || 'GET';
+        const token = await this.getToken();
+        const validHeaders = {
+            'Authorization': `Bearer ${token}`
+        };
+        if (init.headers) {
+            // manual merge if needed, or just iterate
+            new Headers(init.headers).forEach((v, k) => validHeaders[k] = v);
+        }
+        let res;
+        try {
+            res = await fetch(url, { ...init, headers: validHeaders });
+        }
+        catch (networkErr) {
+            const err = new Error(`Network Error: ${networkErr.message} (${method} ${url})`);
+            err.code = 'network_error';
+            err.url = url;
+            err.method = method;
+            throw err;
+        }
+        if (!res.ok) {
+            const text = await res.text();
+            let errorMsg = `Drive API Error: ${res.status} ${res.statusText} (${method} ${url})`;
+            let reason = res.statusText;
+            try {
+                const json = JSON.parse(text);
+                const gError = json.error;
+                if (gError) {
+                    errorMsg += ` - ${gError.message || 'Unknown Error'}`;
+                    if (Array.isArray(gError.errors) && gError.errors.length > 0) {
+                        reason = gError.errors[0].reason || reason;
+                        if (gError.errors[0].message && gError.errors[0].message !== gError.message) {
+                            errorMsg += ` (${gError.errors[0].message})`;
+                        }
+                    }
+                }
+            }
+            catch { }
+            const err = new Error(errorMsg);
+            err.status = res.status;
+            err.code = reason;
+            err.url = url;
+            err.method = method;
+            throw err;
+        }
+        return res;
+    }
+    get baseUrl() {
+        return this.options.baseUrl || DEFAULT_BASE_URL;
+    }
+    get uploadUrl() {
+        return this.options.uploadUrl || DEFAULT_UPLOAD_URL;
+    }
+    async listFiles(q) {
+        const params = new URLSearchParams({
+            q,
+            fields: 'files(id,name,mimeType,parents,modifiedTime)'
+        });
+        // FIX: URLSearchParams uses '+', but Drive API is safer with '%20'
+        const queryString = params.toString().replace(/\+/g, '%20');
+        console.log(`[GoogleDriveClient] listFiles query: ${queryString}`);
+        const res = await this.fetch(`${this.baseUrl}?${queryString}`, { method: 'GET' });
+        const data = await res.json();
+        return data.files || [];
+    }
+    async getFile(fileId) {
+        // Try getting media
+        try {
+            const params = new URLSearchParams({ alt: 'media' });
+            const queryString = params.toString().replace(/\+/g, '%20');
+            const res = await this.fetch(`${this.baseUrl}/${fileId}?${queryString}`, { 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,modifiedTime' });
+        const queryString = params.toString().replace(/\+/g, '%20');
+        const res = await this.fetch(`${this.baseUrl}/${fileId}?${queryString}`, { method: 'GET' });
+        const data = await res.json();
+        return {
+            ...data,
+            etag: this.extractEtag(res, data)
+        };
+    }
+    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(`${this.baseUrl}?fields=id,modifiedTime`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(metadata)
+            });
+            const data = await res.json();
+            return {
+                id: data.id,
+                etag: this.extractEtag(res, data),
+                modifiedTime: data.modifiedTime || res.headers.get('Last-Modified') || ''
+            };
+        }
+        const multipartBody = this.buildMultipart(metadata, content, mimeType);
+        const res = await this.fetch(`${this.uploadUrl}?uploadType=multipart&fields=id,modifiedTime`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': `multipart/related; boundary=${multipartBody.boundary}`
+            },
+            body: multipartBody.body
+        });
+        const data = await res.json();
+        return {
+            id: data.id,
+            etag: this.extractEtag(res, data),
+            modifiedTime: data.modifiedTime || res.headers.get('Last-Modified') || ''
+        };
+    }
+    async updateFile(fileId, content, expectedEtag) {
+        // Update content (media) usually, but sometimes meta?
+        // In our usage (saveMeta), we update body.
+        const res = await this.fetch(`${this.uploadUrl}/${fileId}?uploadType=media&fields=id,modifiedTime`, {
+            method: 'PATCH',
+            headers: expectedEtag ? { 'If-Match': `"${expectedEtag}"`, 'Content-Type': 'application/json' } : { 'Content-Type': 'application/json' },
+            body: content
+        });
+        const data = await res.json();
+        return {
+            id: data.id,
+            etag: this.extractEtag(res, data),
+            modifiedTime: data.modifiedTime || res.headers.get('Last-Modified') || ''
+        };
+    }
+    extractEtag(res, data) {
+        const headerEtag = res.headers.get('ETag');
+        if (headerEtag) {
+            return headerEtag.replace(/"/g, '');
+        }
+        return data.etag || '';
+    }
+    async deleteFile(fileId) {
+        await this.fetch(`${this.baseUrl}/${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;

package/lib/drive.d.ts

@@ -0,0 +1,82 @@
+import { GoogleDriveAdapterOptions, ChangeEntry, IndexEntry } from './types';
+/**
+ * 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
+ */
+export declare class DriveHandler {
+    private client;
+    private options;
+    private folderId;
+    private folderName;
+    private parents;
+    private compactionThreshold;
+    private compactionSizeThreshold;
+    private meta;
+    private metaEtag;
+    private metaModifiedTime;
+    private index;
+    private docCache;
+    private pendingChanges;
+    private currentLogSizeEstimate;
+    private listeners;
+    private pollingInterval;
+    private loadingPromise;
+    private isPollingActive;
+    private fileCache;
+    private processedLogIds;
+    private currentSnapshotIndexId;
+    private debug;
+    private isCompacting;
+    private log;
+    constructor(options: GoogleDriveAdapterOptions, dbName: string);
+    get seq(): number;
+    /** Load the database (Index Only) */
+    load(): Promise<void>;
+    private filesFromLegacySnapshot;
+    /**
+     * Get a document body.
+     * Index -> Cache -> Fetch
+     */
+    get(id: string): Promise<any | null>;
+    /** Generic Download with Caching and Parsing */
+    private fetchFile;
+    /** Get multiple docs (Atomic-ish) used for _allDocs */
+    getMulti(ids: string[]): Promise<any[]>;
+    /** Return all keys in Index */
+    getIndexKeys(): Promise<string[]>;
+    /** Get metadata for a specific ID from Index */
+    getIndexEntry(id: string): IndexEntry | undefined;
+    /** Single change wrapper */
+    appendChange(change: ChangeEntry): Promise<void>;
+    /** Append changes with OCC */
+    appendChanges(changes: ChangeEntry[]): Promise<void>;
+    private tryAppendChanges;
+    /** Update Index with a new change */
+    private updateIndex;
+    private checkConflicts;
+    /** Compact: Create SnapshotIndex + SnapshotData */
+    compact(): Promise<void>;
+    private atomicUpdateMeta;
+    private findOrCreateFolder;
+    private findFile;
+    private downloadJson;
+    private downloadFileAny;
+    private downloadNdjson;
+    private writeChangeFile;
+    private saveMeta;
+    private countTotalChanges;
+    private cleanupOldFiles;
+    private startPolling;
+    private notifyListeners;
+    onChange(cb: (changes: Record<string, any>) => void): () => void;
+    stopPolling(): void;
+    private escapeQuery;
+    deleteFolder(): Promise<void>;
+    getNextSeq(): number;
+}