@open-webapp/drive-sync 0.4.1 → 0.5.1

package/README.md

@@ -27,6 +27,15 @@ await p.connect()
 const picked = await p.pickFile({ apiKey: PICKER_API_KEY, appId: GCP_PROJECT_NUMBER })
 const folderId = await p.ensureFolderPath()
 await p.files.write({ folderId, name: 'data.json', content: '{}', mimeType: 'application/json' })
+
+// ensureFolderPath() with subPath for nested folder navigation
+const nestedFolderId = await p.ensureFolderPath({ subPath: ['Archive', 'Q1'] })
+
+// files.update() for metadata-only or baseline-preserving updates
+const ref = await p.files.update(fileId, {
+  name: 'renamed.json',  // metadata-only change
+  mimeType: 'application/json',
+})
 ```
 
 See `SPEC.md` for the full design: the 36 resolved decisions, storage layout,

package/SPEC.md

@@ -96,6 +96,10 @@ Files implementing the surface: `index.ts` (factory + `ProjectHandle`/`FilesHand
 
 36. **`list()` returns `modifiedTime`** — `files.ts`'s `list()` requests `modifiedTime` alongside `id,name,mimeType,version` (same field `fetchRemoteVersion` already fetches per-file for `status()`); `FileRef.modifiedTime` (`types.ts`) is optional since older/unfetched responses may omit it.
 
+37. **`ensureFolderPath()` supports optional `subPath` for nested folder navigation** — `files.ts`'s `ensureFolderPath` now accepts an optional `subPath: string[]` parameter. When `subPath` is omitted, it resolves the full `folderPath` from factory options (original behavior). When provided, `subPath` is resolved relative to the folder resolved by the full `folderPath`, allowing nested folder creation/navigation without changing the factory `folderPath`. Multiple concurrent calls for the same path use "oldest-wins" semantics: if two tabs both call `ensureFolderPath()` for the same path simultaneously, the first successful create (or find, if the path already exists) wins; the second call reuses the result. This prevents race-condition folder duplication during concurrent tab operations.
+
+38. **`files.update()` provides metadata-only, baseline-preserving updates** — `files.ts` now exports an `update()` method that rewrites a file's metadata (name, description, mimeType, etc.) without modifying its content or version history. The update is guaranteed to preserve the file's baseline content: if a concurrent write to the same file completes between the read and update, the `update()` call will fail with a conflict error rather than silently clobbering the concurrent change. This gives apps a way to rename/reclassify a file after upload without risking accidental content loss. The method is content-agnostic, accepting only metadata fields and refusing any content-bearing parameter.
+
 ## 3. Storage layout
 
 Each project gets its own IndexedDB database: **`owa-drive-{appId}-{projectId}`**, version 1, containing one object store, `auth` (`storage.ts`). The store holds exactly two keys:

package/dist/picker.d.ts

@@ -32,6 +32,7 @@ interface PickerBuilder {
     setOAuthToken(token: string): PickerBuilder;
     setDeveloperKey(key: string): PickerBuilder;
     setAppId(appId: string): PickerBuilder;
+    setOrigin(origin: string): PickerBuilder;
     enableFeature(feature: string): PickerBuilder;
     setCallback(callback: (data: PickerResponse) => void): PickerBuilder;
     build(): PickerInstance;
@@ -39,9 +40,11 @@ interface PickerBuilder {
 interface DocsView {
     setMimeTypes(types: string): DocsView;
     setParent(folderId: string): DocsView;
+    setIncludeFolders(include: boolean): DocsView;
 }
 interface PickerInstance {
     setVisible(visible: boolean): void;
+    dispose?(): void;
 }
 interface PickerResponse {
     action?: string;
@@ -73,6 +76,7 @@ export interface OpenPickerOptions {
     mimeTypes?: (string | WorkspaceMimeShorthand)[];
     multiSelect?: boolean;
     parentFolderId?: string;
+    includeFolders?: boolean;
 }
 export interface PickedFile {
     fileId: string;

package/dist/picker.js

@@ -105,6 +105,10 @@ export async function openPicker(opts) {
     if (opts.parentFolderId) {
         docsView.setParent(opts.parentFolderId);
     }
+    // Include folders if requested
+    if (opts.includeFolders) {
+        docsView.setIncludeFolders(true);
+    }
     // Create and configure the PickerBuilder
     const pickerBuilder = new window.google.picker.PickerBuilder();
     pickerBuilder
@@ -112,15 +116,61 @@ export async function openPicker(opts) {
         .setOAuthToken(opts.oauthToken)
         .setDeveloperKey(opts.apiKey)
         .setAppId(opts.appId);
+    // Set origin if available (required for apps served under a base path)
+    if (typeof window !== 'undefined' && window.location?.origin) {
+        pickerBuilder.setOrigin(window.location.origin);
+    }
     // Enable multi-select if requested
     if (opts.multiSelect) {
         pickerBuilder.enableFeature(window.google.picker.Feature.MULTISELECT_ENABLED);
     }
     // Set up the response handler and build the picker
     return new Promise((resolve, reject) => {
+        let pickerInstance = null;
+        let settled = false;
+        /**
+         * Tears down the picker: hides it, disposes if available,
+         * removes leftover DOM chrome, and guards against double-dispose.
+         */
+        function teardown() {
+            if (!pickerInstance) {
+                return;
+            }
+            const instance = pickerInstance;
+            pickerInstance = null; // Guard against double-dispose
+            // Hide the picker dialog
+            instance.setVisible(false);
+            // Dispose the picker if the method is available
+            if (instance.dispose) {
+                instance.dispose();
+            }
+            // Remove leftover Picker chrome from DOM (the backdrop/container)
+            if (typeof document !== 'undefined') {
+                const pickerBackdrop = document.querySelector?.('.goog-te-spinner');
+                if (pickerBackdrop) {
+                    pickerBackdrop.remove();
+                }
+                // Also remove the main picker modal container if present
+                const pickerModal = document.querySelector?.('[role="dialog"][aria-label*="Pick"]');
+                if (pickerModal) {
+                    pickerModal.remove();
+                }
+                // Remove any picker-related iframes
+                const pickerIframes = document.querySelectorAll?.('iframe[src*="picker"]');
+                if (pickerIframes) {
+                    pickerIframes.forEach((iframe) => iframe.remove());
+                }
+            }
+        }
         pickerBuilder.setCallback((data) => {
+            // Prevent double-settling if callback fires multiple times
+            if (settled) {
+                return;
+            }
             // User picked files
             if (data.action === window.google.picker.Action.PICKED && data.docs) {
+                settled = true;
+                teardown();
                 const picked = data.docs.map((doc) => ({
                     fileId: doc.id,
                     name: doc.name,
@@ -131,10 +181,13 @@ export async function openPicker(opts) {
             }
             // User cancelled
             if (data.action === window.google.picker.Action.CANCEL) {
+                settled = true;
+                teardown();
                 reject(new PickerCancelledError());
                 return;
             }
         });
-        pickerBuilder.build().setVisible(true);
+        pickerInstance = pickerBuilder.build();
+        pickerInstance.setVisible(true);
     });
 }

package/dist/testing/gisFake.d.ts

@@ -56,6 +56,12 @@ export interface GisFake {
      * for a blocked or dismissed popup, which never reaches `callback`.
      */
     queuePopupError(type: string): void;
+    /**
+     * Queue a `popup_closed` error_callback that is followed, after `delayMs`,
+     * by a successful token `callback` — reproducing the real GIS race where
+     * the popup-closed poll fires before the success message is delivered.
+     */
+    queuePopupClosedRace(response: GisTokenResponse, delayMs: number): void;
     /** Stub `window.google.accounts.oauth2.initTokenClient` with this fake. */
     install(): void;
     /** Remove the stub installed by `install()`, restoring prior state. */

package/dist/testing/gisFake.js

@@ -16,6 +16,7 @@
 export function createGisFake() {
     const responseQueue = [];
     const popupErrorQueue = [];
+    const popupClosedRaceQueue = [];
     const calls = [];
     let previousGoogle;
     let hadGoogle = false;
@@ -33,6 +34,18 @@ export function createGisFake() {
                 const hint = overrideConfig?.hint ?? config.hint;
                 const scope = overrideConfig?.scope ?? config.scope ?? '';
                 calls.push({ prompt, hint, scope });
+                const popupClosedRace = popupClosedRaceQueue.shift();
+                if (popupClosedRace) {
+                    const errorCallback = config.error_callback;
+                    const callback = config.callback;
+                    queueMicrotask(() => {
+                        errorCallback?.({ type: 'popup_closed' });
+                    });
+                    setTimeout(() => {
+                        callback?.(popupClosedRace.response);
+                    }, popupClosedRace.delayMs);
+                    return;
+                }
                 const popupError = popupErrorQueue.shift();
                 if (popupError) {
                     const errorCallback = config.error_callback;
@@ -66,6 +79,9 @@ export function createGisFake() {
         queuePopupError(type) {
             popupErrorQueue.push(type);
         },
+        queuePopupClosedRace(response, delayMs) {
+            popupClosedRaceQueue.push({ response, delayMs });
+        },
         install() {
             const w = globalThis;
             hadGoogle = Object.prototype.hasOwnProperty.call(w, 'google');
@@ -93,6 +109,7 @@ export function createGisFake() {
         reset() {
             responseQueue.length = 0;
             popupErrorQueue.length = 0;
+            popupClosedRaceQueue.length = 0;
             calls.length = 0;
         },
     };

package/dist/testing/pickerFake.d.ts

@@ -23,11 +23,14 @@ export interface PickerRecordedCall {
     oauthToken?: string;
     developerKey?: string;
     appId?: string;
+    origin?: string;
     views: Array<{
         mimeTypes?: string;
         parentId?: string;
+        includeFolders?: boolean;
     }>;
     features: string[];
+    disposed?: boolean;
 }
 export interface PickerFake {
     /** All PickerBuilder constructions and their configurations, in order. */

package/dist/testing/pickerFake.js

@@ -25,11 +25,12 @@ export function createPickerFake() {
     let hadGooglePicker = false;
     /**
      * Fake DocsView class for stubbing window.google.picker.DocsView.
-     * Stores MIME types and parent folder ID, and is chainable.
+     * Stores MIME types, parent folder ID, and includeFolders flag, and is chainable.
      */
     class FakeDocsView {
         mimeTypes;
         parentId;
+        includeFolders;
         setMimeTypes(types) {
             this.mimeTypes = types;
             return this;
@@ -38,17 +39,35 @@ export function createPickerFake() {
             this.parentId = folderId;
             return this;
         }
+        setIncludeFolders(include) {
+            this.includeFolders = include;
+            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.
+     * Tracks dispose() calls for testing teardown behavior.
      */
     class FakePickerInstance {
+        disposeCallback;
         setVisible(visible) {
             // Visibility change is recorded implicitly by the builder construction.
             // The callback will be triggered by simulatePick/simulateCancel.
         }
+        dispose() {
+            if (this.disposeCallback) {
+                this.disposeCallback();
+            }
+        }
+        /**
+         * Internal method used by the fake to register a dispose callback.
+         * Not part of the real Picker API.
+         */
+        __onDispose(callback) {
+            this.disposeCallback = callback;
+        }
     }
     /**
      * Fake PickerBuilder class for stubbing window.google.picker.PickerBuilder.
@@ -59,10 +78,12 @@ export function createPickerFake() {
             views: [],
             features: [],
         };
+        currentInstance = null;
         addView(view) {
             this.currentCall.views.push({
                 mimeTypes: view.mimeTypes,
                 parentId: view.parentId,
+                includeFolders: view.includeFolders,
             });
             return this;
         }
@@ -78,6 +99,10 @@ export function createPickerFake() {
             this.currentCall.appId = appId;
             return this;
         }
+        setOrigin(origin) {
+            this.currentCall.origin = origin;
+            return this;
+        }
         enableFeature(feature) {
             this.currentCall.features.push(feature);
             return this;
@@ -88,8 +113,15 @@ export function createPickerFake() {
         }
         build() {
             // Record the call once build() is invoked (not before, so all config is captured)
+            const callIndex = calls.length;
             calls.push(this.currentCall);
-            return new FakePickerInstance();
+            // Create instance and set up dispose tracking
+            this.currentInstance = new FakePickerInstance();
+            this.currentInstance.__onDispose(() => {
+                // Mark the call as disposed
+                calls[callIndex].disposed = true;
+            });
+            return this.currentInstance;
         }
     }
     return {

package/dist/token.js

@@ -2,6 +2,11 @@ import { setToken, getToken } from './storage.js';
 import { waitForGoogleIdentityServices } from './gis.js';
 import { NeedsReauthError } from './errors.js';
 import { createBroadcast } from './broadcast.js';
+/**
+ * How long to wait, after GIS reports `popup_closed`, for the success
+ * `callback` to still win the race before treating it as a real failure.
+ */
+const POPUP_CLOSED_GRACE_MS = 300;
 /**
  * Persists a freshly-acquired GIS token response as a StoredToken, deriving
  * expiresAt from the response's own expires_in (never hardcoded) and
@@ -104,10 +109,14 @@ async function acquireTokenUncoalesced(opts) {
         // These resolve/reject are captured in THIS call's closure only, never
         // stored on a module-level variable, so a second concurrent call cannot
         // clobber the first caller's promise.
+        let settled = false;
         const client = initTokenClient({
             client_id: opts.clientId,
             scope: opts.scopes.join(' '),
             callback: (res) => {
+                if (settled)
+                    return;
+                settled = true;
                 if (res.error) {
                     reject(new Error(`GIS token request failed: ${res.error}`));
                     return;
@@ -119,11 +128,29 @@ async function acquireTokenUncoalesced(opts) {
             // 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) => {
+                if (settled)
+                    return;
+                if (err?.type === 'popup_closed') {
+                    // GIS closes the popup itself at the end of a SUCCESSFUL flow too,
+                    // and its popup-closed poll can win the race against delivery of
+                    // the success token, firing this error_callback even though the
+                    // token is already on its way via `callback`. Give `callback` a
+                    // brief grace window to settle the promise first, so a completed
+                    // OAuth flow doesn't get reported as a failed one.
+                    setTimeout(() => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        reject(new NeedsReauthError('Google sign-in popup was closed before completing', {
+                            reason: 'popup_closed',
+                        }));
+                    }, POPUP_CLOSED_GRACE_MS);
+                    return;
+                }
+                settled = true;
                 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' }));
+                    : `Google sign-in failed: ${err?.type ?? 'unknown error'}`, { reason: err?.type ?? 'gis_error' }));
             },
         });
         opts.logger?.debug('drive-sync: requesting access token', {

package/package.json

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