@leapdev/auth-agent 2.5.4 → 2.6.0

package/README.md

@@ -273,6 +273,19 @@ Create an auth session and open a new app
 -   `newWindow` **[boolean][37]** If true, the new app will be open in the new browser tab. If false, app will be open in the current browser tab. (optional, default `false`)
 -   `authHost` **[string][36]** The authHost that the new app is using. (optional, default value is the same authHost as current app)
 
+## getRefreshTokenForApp
+
+Getting an RefreshToken For App.
+In order to be able get a refreshToken for an App, app needs to 
+  - have "offline_access" scope enabled in its client
+  - have `${leap-auth-url}/oauth/close` in its client's "allowed redirect urls"
+
+### Parameters
+
+-   `clientId` **[string][36]** clientId of the app (requried)
+-   `scopes` **[Array<string>][37]** requested scopes  
+
+
 [1]: #init
 
 [2]: #parameters

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leapdev/auth-agent",
-  "version": "2.5.4",
+  "version": "2.6.0",
   "description": "LEAP Auth Agent",
   "license": "LEAP Legal Software, PTY LTD",
   "main": "./src/index.js",
@@ -8,7 +8,7 @@
   "dependencies": {
     "lodash": "^4.17.21",
     "uuid": "^8.3.2",
-    "pubnub": "10.2.3",
+    "pubnub": "11.0.1",
     "tslib": "^2.3.0"
   },
   "peerDependencies": {}

package/src/index.umd.js

@@ -4470,7 +4470,7 @@
                   grant_type: 'authorization_code',
                   code: params.code,
                   code_verifier: params.verifier,
-                  client_id: __classPrivateFieldGet(this, _LeapAuthService_clientId, "f"),
+                  client_id: params.clientId || __classPrivateFieldGet(this, _LeapAuthService_clientId, "f"),
                   redirect_uri: params.redirectUri
                 }
               },
@@ -7242,6 +7242,79 @@
             iframe.setAttribute('src', authorizeUrl);
           });
         };
+        this.getRefreshTokenForApp = params => __awaiter(this, void 0, void 0, function* () {
+          const {
+            clientId,
+            scopes
+          } = params;
+          const code_verifier = createRandomString(64);
+          const state = createRandomString(6);
+          const nonce = createRandomString(6);
+          const {
+            code_challenge,
+            code_challenge_method
+          } = yield createCodeChallenge(code_verifier);
+          const requestScopesArray = scopes || [];
+          requestScopesArray.push('offline_access');
+          const request_scopes = requestScopesArray.join(',');
+          const redirectUri = `${__classPrivateFieldGet(this, _Authentication_config, "f").authHost}/oauth/close`;
+          const url = `${__classPrivateFieldGet(this, _Authentication_config, "f").authHost}/oauth/authorize?response_type=code&scope=${request_scopes}&client_id=${clientId}&redirect_uri=${encodeURIComponent(redirectUri)}&code_challenge=${encodeURIComponent(code_challenge)}&code_challenge_method=${code_challenge_method}&nonce=${nonce}&state=${state}&prompt=none`;
+          return new Promise((res, rej) => {
+            const newWindow = window.open(url, '_blank', 'width=800,height=600');
+            if (!newWindow) {
+              rej('unable to open new window');
+              return;
+            }
+            const timeoutSetTimeoutId = setTimeout(() => {
+              rej('get-refresh-token timeout');
+              window.removeEventListener('message', windowEventHandler, false);
+              newWindow.close();
+            }, DEFAULT_AUTHORIZE_TIMEOUT_IN_SECONDS * 1000);
+            const windowEventHandler = e => __awaiter(this, void 0, void 0, function* () {
+              if (e.origin !== __classPrivateFieldGet(this, _Authentication_config, "f").authHost) return;
+              if (e.data.type !== 'closeMe') return;
+              newWindow.close();
+              clearTimeout(timeoutSetTimeoutId);
+              window.removeEventListener('message', windowEventHandler, false);
+              if (e.data.queryParams) {
+                const {
+                  code,
+                  state: stateFromCloseWindow
+                } = e.data.queryParams;
+                if (code && state && state === stateFromCloseWindow) {
+                  try {
+                    const result = yield __classPrivateFieldGet(this, _Authentication_leapAuthService, "f").exchangeAuthCodeForAccessToken({
+                      code,
+                      verifier: code_verifier,
+                      redirectUri: redirectUri,
+                      clientId: clientId
+                    });
+                    if (result && result.refresh_token) {
+                      res({
+                        refreshToken: result.refresh_token,
+                        code_verifier: code_verifier
+                      });
+                    } else {
+                      throw new Error('Failed to exchange auth code for access token');
+                    }
+                  } catch (_) {
+                    console.warn('Failed to exchange auth code for access token');
+                    res({
+                      refreshToken: undefined,
+                      code_verifier: undefined
+                    });
+                  }
+                }
+              } else {
+                res({
+                  refreshToken: undefined,
+                  code_verifier: undefined
+                });
+              }
+            });
+            window.addEventListener('message', windowEventHandler);
+          });
+        });
         _Authentication_exchangeAuthCodeForAccessToken.set(this, params => __awaiter(this, void 0, void 0, function* () {
           const {
             verifier,
@@ -7660,6 +7733,19 @@
         authHost
       });
     });
+    const getRefreshTokenForApp = params => __awaiter(void 0, void 0, void 0, function* () {
+      const {
+        clientId,
+        scopes
+      } = params;
+      if (!auth) {
+        throw Error('Not init yet');
+      }
+      return auth.getRefreshTokenForApp({
+        clientId,
+        scopes
+      });
+    });
     const AuthAgent = {
       init,
       registerHook,
@@ -7684,7 +7770,8 @@
       authoriseSupport,
       changePassword,
       registerEventListener,
-      passthrough
+      passthrough,
+      getRefreshTokenForApp
     };
 
     exports.AuthAgent = AuthAgent;

package/src/lib/auth-agent.d.ts

@@ -26,4 +26,11 @@ export declare const AuthAgent: {
     changePassword: (redirectUrl?: string | undefined, newWindow?: boolean | undefined, callback?: any) => void;
     registerEventListener: (topic: string, messageType: string, callback: any) => void;
     passthrough: (url: string, newWindow?: boolean, authHost?: string | undefined) => Promise<void>;
+    getRefreshTokenForApp: (params: {
+        clientId: string;
+        scopes?: string[];
+    }) => Promise<{
+        refreshToken: string | undefined;
+        code_verifier: string | undefined;
+    }>;
 };

package/src/lib/auth-agent.js

@@ -195,6 +195,13 @@ const passthrough = (url, newWindow = false, authHost) => __awaiter(void 0, void
     }
     yield auth.passthrough({ url, newWindow, authHost });
 });
+const getRefreshTokenForApp = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { clientId, scopes } = params;
+    if (!auth) {
+        throw Error('Not init yet');
+    }
+    return auth.getRefreshTokenForApp({ clientId, scopes });
+});
 export const AuthAgent = {
     init,
     registerHook,
@@ -220,4 +227,5 @@ export const AuthAgent = {
     changePassword,
     registerEventListener,
     passthrough,
+    getRefreshTokenForApp,
 };

package/src/lib/auth.service.d.ts

@@ -8,6 +8,7 @@ export declare class LeapAuthService {
         code: string;
         redirectUri: string;
         verifier: string;
+        clientId?: string;
     }) => Promise<LeapToken>;
     renewAccessToken: (params: {
         refreshToken: string;

package/src/lib/auth.service.js

@@ -52,7 +52,7 @@ export class LeapAuthService {
                             grant_type: 'authorization_code',
                             code: params.code,
                             code_verifier: params.verifier,
-                            client_id: __classPrivateFieldGet(this, _LeapAuthService_clientId, "f"),
+                            client_id: params.clientId || __classPrivateFieldGet(this, _LeapAuthService_clientId, "f"),
                             redirect_uri: params.redirectUri,
                         },
                     },

package/src/lib/authentication.d.ts

@@ -77,4 +77,11 @@ export declare class Authentication {
     triggerHooks: (hookName: HookName) => Promise<any>;
     afterAuthenticated: () => Promise<string | undefined>;
     runIframe: (authorizeUrl: string, state: string, timeoutInSeconds?: number) => Promise<any>;
+    getRefreshTokenForApp: (params: {
+        clientId: string;
+        scopes?: string[];
+    }) => Promise<{
+        refreshToken: string | undefined;
+        code_verifier: string | undefined;
+    }>;
 }

package/src/lib/authentication.js

@@ -421,6 +421,69 @@ export class Authentication {
                 iframe.setAttribute('src', authorizeUrl);
             });
         };
+        this.getRefreshTokenForApp = (params) => __awaiter(this, void 0, void 0, function* () {
+            const { clientId, scopes } = params;
+            const code_verifier = createRandomString(64);
+            const state = createRandomString(6);
+            const nonce = createRandomString(6);
+            const { code_challenge, code_challenge_method } = yield createCodeChallenge(code_verifier);
+            const requestScopesArray = scopes || [];
+            requestScopesArray.push('offline_access');
+            const request_scopes = requestScopesArray.join(',');
+            const redirectUri = `${__classPrivateFieldGet(this, _Authentication_config, "f").authHost}/oauth/close`;
+            const url = `${__classPrivateFieldGet(this, _Authentication_config, "f").authHost}/oauth/authorize?response_type=code&scope=${request_scopes}&client_id=${clientId}&redirect_uri=${encodeURIComponent(redirectUri)}&code_challenge=${encodeURIComponent(code_challenge)}&code_challenge_method=${code_challenge_method}&nonce=${nonce}&state=${state}&prompt=none`;
+            return new Promise((res, rej) => {
+                const newWindow = window.open(url, '_blank', 'width=800,height=600');
+                if (!newWindow) {
+                    rej('unable to open new window');
+                    return;
+                }
+                const timeoutSetTimeoutId = setTimeout(() => {
+                    rej('get-refresh-token timeout');
+                    window.removeEventListener('message', windowEventHandler, false);
+                    newWindow.close();
+                }, DEFAULT_AUTHORIZE_TIMEOUT_IN_SECONDS * 1000);
+                const windowEventHandler = (e) => __awaiter(this, void 0, void 0, function* () {
+                    if (e.origin !== __classPrivateFieldGet(this, _Authentication_config, "f").authHost)
+                        return;
+                    if (e.data.type !== 'closeMe')
+                        return;
+                    newWindow.close();
+                    clearTimeout(timeoutSetTimeoutId);
+                    window.removeEventListener('message', windowEventHandler, false);
+                    if (e.data.queryParams) {
+                        const { code, state: stateFromCloseWindow } = e.data.queryParams;
+                        if (code && state && state === stateFromCloseWindow) {
+                            try {
+                                const result = yield __classPrivateFieldGet(this, _Authentication_leapAuthService, "f").exchangeAuthCodeForAccessToken({
+                                    code,
+                                    verifier: code_verifier,
+                                    redirectUri: redirectUri,
+                                    clientId: clientId,
+                                });
+                                if (result && result.refresh_token) {
+                                    res({
+                                        refreshToken: result.refresh_token,
+                                        code_verifier: code_verifier,
+                                    });
+                                }
+                                else {
+                                    throw new Error('Failed to exchange auth code for access token');
+                                }
+                            }
+                            catch (_) {
+                                console.warn('Failed to exchange auth code for access token');
+                                res({ refreshToken: undefined, code_verifier: undefined });
+                            }
+                        }
+                    }
+                    else {
+                        res({ refreshToken: undefined, code_verifier: undefined });
+                    }
+                });
+                window.addEventListener('message', windowEventHandler);
+            });
+        });
         _Authentication_exchangeAuthCodeForAccessToken.set(this, (params) => __awaiter(this, void 0, void 0, function* () {
             const { verifier, code, redirectUri } = params;
             if (verifier) {