@refoldai/refold-js 10.0.0 → 10.1.0

package/refold.ts

@@ -92,6 +92,29 @@ export interface InputField  {
     }[];
 }
 
+export interface OAuthParams {
+    /** The application slug. */
+    slug: string;
+    /** The key value pairs of auth data. */
+    payload?: Record<string, string>;
+    /** Whether to close the authentication window automatically. */
+    autoClose?: boolean;
+    /** Maximum time in milliseconds to wait for authentication before giving up. Set to `0` to wait indefinitely. Defaults to 5 minutes. */
+    timeout?: number;
+}
+
+export interface KeyBasedParams {
+    /** The application slug. */
+    slug: string;
+    /** The key value pairs of auth data. */
+    payload?: Record<string, string>;
+}
+
+export interface ConnectParams extends OAuthParams {
+    /** The authentication type to use. If not provided, it defaults to `keybased` if payload is provided, otherwise `oauth2`. */
+    type?: AuthType;
+}
+
 /** The payload object for config. */
 export interface ConfigPayload {
     /** The application slug. */
@@ -361,6 +384,15 @@ export interface Execution {
 
 type Field = any;
 
+/** How often, in milliseconds, connection status is polled during authentication. */
+const POLL_INTERVAL = 3e3;
+/** How long, in milliseconds, polling continues after the auth window closes or the wait times out, since the connection may complete moments later. */
+const POLL_GRACE = 6e3;
+/** The number of consecutive polling failures tolerated before authentication is aborted. */
+const MAX_POLL_FAILURES = 3;
+/** The default maximum time, in milliseconds, to wait for authentication. */
+const DEFAULT_CONNECT_TIMEOUT = 300e3;
+
 class Refold {
     private baseUrl: string;
     public token: string;
@@ -509,56 +541,99 @@ class Refold {
     /**
      * Handle OAuth for the specified application.
      * @private
-     * @param {String} slug The application slug.
-     * @param {Object.<string, string>} [params] The key value pairs of auth data.
+     * @param params - The parameters for the OAuth flow.
+     * @param params.slug - The application slug.
+     * @param params.payload - The key value pairs of auth data.
+     * @param params.autoClose - Whether to close the authentication window automatically. Defaults to `true`.
+     * @param params.timeout - Maximum time in milliseconds to wait for authentication before giving up. Set to `0` to wait indefinitely. Defaults to 5 minutes.
      * @returns {Promise<Boolean>} Whether the user authenticated.
      */
-    private async oauth(slug: string, params?: Record<string, string>): Promise<boolean> {
+    private async oauth({
+        slug,
+        payload,
+        autoClose = true,
+        timeout = DEFAULT_CONNECT_TIMEOUT,
+    }: OAuthParams): Promise<boolean> {
+        const oauthUrl = await this.getOAuthUrl(slug, payload);
+
+        const connectWindow = window.open(oauthUrl);
+        if (!connectWindow) {
+            throw Object.assign(
+                new Error("The authentication window could not be opened. It may have been blocked by the browser."),
+                { code: "POPUP_BLOCKED" },
+            );
+        }
+
+        const hasActiveOAuthAccount = (app: Application) =>
+            Boolean(app?.connected_accounts?.filter(a => a.auth_type === AuthType.OAuth2).some(a => a.status === AuthStatus.Active));
+
         return new Promise((resolve, reject) => {
-            this.getOAuthUrl(slug, params)
-            .then(oauthUrl => {
-                const connectWindow = window.open(oauthUrl);
-
-                // keep checking connection status
-                const interval = setInterval(() => {
-                    this.getApp(slug)
-                    .then(app => {
-                        if (app && app.connected_accounts?.filter(a => a.auth_type === AuthType.OAuth2).some(a => a.status === AuthStatus.Active)) {
-                            // close auth window
-                            connectWindow && connectWindow.close();
-                            // clear interval
-                            clearInterval(interval);
-                            // resovle status
-                            resolve(true);
-                        } else {
-                            // user closed oauth window without authenticating
-                            if (connectWindow && connectWindow.closed) {
-                                // clear interval
-                                clearInterval(interval);
-                                // resolve status
-                                resolve(false);
-                            }
-                        }
-                    })
-                    .catch(e => {
-                        console.error(e);
-                        // connectWindow?.close();
+            const startedAt = Date.now();
+            let inFlight = false;
+            let consecutiveFailures = 0;
+            let firstFailure: unknown;
+            let graceStartedAt: number | undefined;
+
+            // keep checking connection status
+            const interval = setInterval(() => {
+                const timedOut = timeout > 0 && Date.now() - startedAt >= timeout;
+                if (connectWindow.closed || timedOut) {
+                    // the connection may complete moments around the window
+                    // closing or the wait timing out, so keep polling for a
+                    // little longer before giving up
+                    if (timedOut && autoClose) connectWindow.close();
+                    graceStartedAt ??= Date.now();
+                    if (Date.now() - graceStartedAt >= POLL_GRACE) {
                         clearInterval(interval);
-                        reject(e);
-                    });
-                }, 3e3);
-            })
-            .catch(reject);
+                        resolve(false);
+                        return;
+                    }
+                }
+
+                // don't check the status again until the previous check settles
+                if (inFlight) return;
+                inFlight = true;
+
+                this.getApp(slug)
+                .then(app => {
+                    inFlight = false;
+                    consecutiveFailures = 0;
+                    firstFailure = undefined;
+                    if (hasActiveOAuthAccount(app)) {
+                        // close auth window
+                        if (autoClose) connectWindow.close();
+                        // clear interval
+                        clearInterval(interval);
+                        // resolve status
+                        resolve(true);
+                    }
+                })
+                .catch(e => {
+                    console.error(e);
+                    inFlight = false;
+                    // tolerate transient errors while the user authenticates
+                    consecutiveFailures += 1;
+                    firstFailure ??= e;
+                    if (consecutiveFailures >= MAX_POLL_FAILURES) {
+                        clearInterval(interval);
+                        reject(firstFailure);
+                    }
+                });
+            }, POLL_INTERVAL);
         });
     }
 
     /**
      * Save auth data for the specified keybased application.
-     * @param {String} slug The application slug.
-     * @param {Object.<string, string>} [payload] The key value pairs of auth data.
+     * @param params - The parameters for key-based auth.
+     * @param params.slug - The application slug.
+     * @param params.payload - The key value pairs of auth data.
      * @returns {Promise<Boolean>} Whether the auth data was saved successfully.
      */
-    private async keybased(slug: string, payload?: Record<string, string>): Promise<boolean> {
+    private async keybased({
+        slug,
+        payload,
+    }: KeyBasedParams): Promise<boolean> {
         const res = await fetch(`${this.baseUrl}/api/v2/app/${slug}/save`, {
             method: "POST",
             headers: {
@@ -585,6 +660,8 @@ class Refold {
      * @param params.slug - The application slug.
      * @param params.type - The authentication type to use. If not provided, it defaults to `keybased` if payload is provided, otherwise `oauth2`.
      * @param params.payload - key-value pairs of authentication data required for the specified auth type.
+     * @param params.autoClose - Whether to close the authentication window automatically. If not provided, it defaults to `true`.
+     * @param params.timeout - Maximum time in milliseconds to wait for authentication before giving up. Only applicable to the OAuth2 flow. Set to `0` to wait indefinitely. If not provided, it defaults to 5 minutes.
      * @returns A promise that resolves to true if the connection was successful, otherwise false.
      * @throws Throws an error if the authentication type is invalid or the connection fails.
      */
@@ -592,19 +669,17 @@ class Refold {
         slug,
         type,
         payload,
-    }: {
-        slug: string;
-        type?: AuthType;
-        payload?: Record<string, string>;
-    }): Promise<boolean> {
+        autoClose = true,
+        timeout = DEFAULT_CONNECT_TIMEOUT,
+    }: ConnectParams): Promise<boolean> {
         switch (type) {
             case AuthType.OAuth2:
-                return this.oauth(slug, payload);
+                return this.oauth({ slug, payload, autoClose, timeout });
             case AuthType.KeyBased:
-                return this.keybased(slug, payload);
+                return this.keybased({ slug, payload });
             default:
-                if (payload) return this.keybased(slug, payload);
-                return this.oauth(slug);
+                if (payload) return this.keybased({ slug, payload });
+                return this.oauth({ slug, autoClose, timeout });
         }
     }