@open-webapp/drive-sync 0.5.0 → 0.5.1

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/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.5.0",
+  "version": "0.5.1",
   "type": "module",
   "repository": {
     "type": "git",