@open-webapp/drive-sync 0.1.0 → 0.3.0

package/dist/testing/pickerFake.js

@@ -0,0 +1,189 @@
+/**
+ * A scriptable double for Google Picker (google.picker),
+ * for use in tests of code that calls `window.google.picker.PickerBuilder`
+ * and related APIs.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const pickerFake = createPickerFake()
+ * pickerFake.install()
+ * // ... exercise code under test that calls openPicker() ...
+ * pickerFake.simulatePick([{ fileId: '123', name: 'doc.txt', mimeType: 'text/plain' }])
+ * await expect(openPickerPromise).resolves.toEqual([...])
+ * expect(pickerFake.calls).toHaveLength(1)
+ * ```
+ */
+export function createPickerFake() {
+    const calls = [];
+    let storedCallback = null;
+    let previousGapi;
+    let hadGapi = false;
+    let previousGoogle;
+    let hadGoogle = false;
+    let previousGooglePicker;
+    let hadGooglePicker = false;
+    /**
+     * Fake DocsView class for stubbing window.google.picker.DocsView.
+     * Stores MIME types and parent folder ID, and is chainable.
+     */
+    class FakeDocsView {
+        mimeTypes;
+        parentId;
+        setMimeTypes(types) {
+            this.mimeTypes = types;
+            return this;
+        }
+        setParent(folderId) {
+            this.parentId = folderId;
+            return this;
+        }
+    }
+    /**
+     * Fake PickerInstance (returned by PickerBuilder.build()).
+     * When setVisible(true) is called, it's recorded but callback is not fired
+     * until simulatePick or simulateCancel is called.
+     */
+    class FakePickerInstance {
+        setVisible(visible) {
+            // Visibility change is recorded implicitly by the builder construction.
+            // The callback will be triggered by simulatePick/simulateCancel.
+        }
+    }
+    /**
+     * Fake PickerBuilder class for stubbing window.google.picker.PickerBuilder.
+     * Chainable methods all return `this`, and build() returns a FakePickerInstance.
+     */
+    class FakePickerBuilder {
+        currentCall = {
+            views: [],
+            features: [],
+        };
+        addView(view) {
+            this.currentCall.views.push({
+                mimeTypes: view.mimeTypes,
+                parentId: view.parentId,
+            });
+            return this;
+        }
+        setOAuthToken(token) {
+            this.currentCall.oauthToken = token;
+            return this;
+        }
+        setDeveloperKey(key) {
+            this.currentCall.developerKey = key;
+            return this;
+        }
+        setAppId(appId) {
+            this.currentCall.appId = appId;
+            return this;
+        }
+        enableFeature(feature) {
+            this.currentCall.features.push(feature);
+            return this;
+        }
+        setCallback(callback) {
+            storedCallback = callback;
+            return this;
+        }
+        build() {
+            // Record the call once build() is invoked (not before, so all config is captured)
+            calls.push(this.currentCall);
+            return new FakePickerInstance();
+        }
+    }
+    return {
+        calls,
+        simulatePick(files) {
+            if (!storedCallback) {
+                return;
+            }
+            const callback = storedCallback;
+            queueMicrotask(() => {
+                callback({
+                    action: 'picked',
+                    docs: files.map((file) => ({
+                        id: file.fileId,
+                        name: file.name,
+                        mimeType: file.mimeType,
+                    })),
+                });
+            });
+        },
+        simulateCancel() {
+            if (!storedCallback) {
+                return;
+            }
+            const callback = storedCallback;
+            queueMicrotask(() => {
+                callback({
+                    action: 'cancel',
+                });
+            });
+        },
+        install() {
+            const w = globalThis;
+            // Save and replace window.gapi
+            hadGapi = Object.prototype.hasOwnProperty.call(w, 'gapi');
+            previousGapi = w.gapi;
+            w.gapi = {
+                load(api, callback) {
+                    if (api === 'picker') {
+                        queueMicrotask(callback);
+                    }
+                },
+            };
+            // Save and replace window.google
+            hadGoogle = Object.prototype.hasOwnProperty.call(w, 'google');
+            previousGoogle = w.google;
+            if (!w.google) {
+                w.google = {};
+            }
+            // Save and replace window.google.picker
+            hadGooglePicker = Object.prototype.hasOwnProperty.call(w.google, 'picker');
+            previousGooglePicker = w.google.picker;
+            w.google.picker = {
+                PickerBuilder: FakePickerBuilder,
+                DocsView: FakeDocsView,
+                Action: {
+                    PICKED: 'picked',
+                    CANCEL: 'cancel',
+                },
+                ViewId: {
+                    DOCS: 'docs',
+                },
+                Feature: {
+                    MULTISELECT_ENABLED: 'multiselect',
+                },
+            };
+        },
+        uninstall() {
+            const w = globalThis;
+            // Restore window.gapi
+            if (hadGapi) {
+                w.gapi = previousGapi;
+            }
+            else {
+                delete w.gapi;
+            }
+            // Restore window.google.picker
+            if (hadGooglePicker) {
+                w.google.picker = previousGooglePicker;
+            }
+            else if (w.google) {
+                delete w.google.picker;
+            }
+            // Restore window.google (if it was only created by install())
+            if (!hadGoogle) {
+                delete w.google;
+            }
+            else {
+                w.google = previousGoogle;
+            }
+        },
+        reset() {
+            calls.length = 0;
+            storedCallback = null;
+        },
+    };
+}

package/dist/token.js

@@ -114,6 +114,17 @@ async function acquireTokenUncoalesced(opts) {
                 }
                 resolve(res);
             },
+            // Without this, a popup that the browser blocks or the user closes
+            // settles NOTHING: GIS reports those through error_callback only, so
+            // the promise below would stay pending forever and every awaiting
+            // Drive call would hang until the caller's own timeout (if any).
+            error_callback: (err) => {
+                reject(new NeedsReauthError(err?.type === 'popup_failed_to_open'
+                    ? 'Google sign-in popup was blocked by the browser'
+                    : err?.type === 'popup_closed'
+                        ? 'Google sign-in popup was closed before completing'
+                        : `Google sign-in failed: ${err?.type ?? 'unknown error'}`, { reason: err?.type ?? 'gis_error' }));
+            },
         });
         opts.logger?.debug('drive-sync: requesting access token', {
             projectId: opts.projectId,

package/dist/types.d.ts

@@ -27,6 +27,26 @@ export interface StoredToken {
 export interface FileRef {
     id: string;
     name?: string;
+    /** Drive's monotonic change counter, when the call requested it. */
+    version?: string;
+}
+/**
+ * Sync state of one file relative to what this client last restored.
+ * Returned by `files.status()`.
+ */
+export interface FileState {
+    fileId: string;
+    /** False when the file is missing or not visible to the connected account. */
+    exists: boolean;
+    /** Version last restored/written by this client; null if never. */
+    baseVersion: string | null;
+    /** Version currently on Drive; null when the file does not exist. */
+    remoteVersion: string | null;
+    /** True when a write would be refused with a RemoteChangedError. */
+    changedSinceRestore: boolean;
+    remoteModifiedTime?: string;
+    /** Epoch ms of the last restore/write by this client; null if never. */
+    lastRestoredAt: number | null;
 }
 /** Drive permission shape as returned/accepted by the Drive Permissions API. */
 export interface DrivePermission {
@@ -35,6 +55,28 @@ export interface DrivePermission {
     role: string;
     emailAddress?: string;
 }
+/** Google Workspace MIME type shorthands for common document types. */
+export type WorkspaceMimeShorthand = 'docs' | 'sheets' | 'slides' | 'forms' | 'drawings';
+/** Options for opening the Google Picker to select files. */
+export interface PickFileOptions {
+    apiKey: string;
+    /**
+     * Cloud project *number* of the OAuth client configured on
+     * `DriveSyncOptions.clientId`. Passed to Picker's `setAppId()`; required
+     * because drive-sync only ever holds a `drive.file`-scoped token.
+     */
+    appId: string;
+    mimeTypes?: (string | WorkspaceMimeShorthand)[];
+    multiSelect?: boolean;
+    parentFolderId?: string;
+}
+/** File information returned after selection from Google Picker. */
+export interface PickedFile {
+    fileId: string;
+    name: string;
+    mimeType: string;
+    content: string | Blob | null;
+}
 /** Options accepted on every Drive-op call site. */
 export interface CallOptions {
     /** Whether an interactive (popup/redirect) auth flow may be triggered. Defaults to false. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-webapp/drive-sync",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "type": "module",
   "repository": {
     "type": "git",