Merge pull request #326 from sasjs/isUrl-fix

chore(deps-dev): bump @types/jest from 26.0.20 to 26.0.22

package.json

@@ -36,31 +36,31 @@
   },
   "license": "ISC",
   "devDependencies": {
-    "@types/jest": "^26.0.20",
+    "@types/jest": "^26.0.22",
     "cp": "^0.2.0",
     "dotenv": "^8.2.0",
     "jest": "^26.6.3",
     "jest-extended": "^0.11.5",
     "path": "^0.12.7",
     "rimraf": "^3.0.2",
-    "semantic-release": "^17.4.1",
+    "semantic-release": "^17.4.2",
     "terser-webpack-plugin": "^4.2.3",
     "ts-jest": "^25.5.1",
-    "ts-loader": "^8.0.17",
+    "ts-loader": "^8.1.0",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0",
-    "typedoc": "^0.20.30",
+    "typedoc": "^0.20.35",
     "typedoc-neo-theme": "^1.1.0",
     "typedoc-plugin-external-module-name": "^4.0.6",
     "typescript": "^3.9.9",
-    "webpack": "^5.24.4",
+    "webpack": "^5.33.2",
     "webpack-cli": "^4.5.0"
   },
   "main": "index.js",
   "dependencies": {
-    "@sasjs/utils": "^2.6.3",
+    "@sasjs/utils": "^2.10.2",
     "axios": "^0.21.1",
-    "form-data": "^3.0.0",
+    "form-data": "^4.0.0",
     "https": "^1.0.0"
   }
 }

src/SASjs.ts

@@ -12,6 +12,7 @@ import {
   ComputeJobExecutor,
   JesJobExecutor
 } from './job-execution'
+import { ErrorResponse } from './types/errors'
 
 const defaultConfig: SASjsConfig = {
   serverUrl: '',
@@ -530,15 +531,19 @@ export default class SASjs {
    * @param config - provide any changes to the config here, for instance to
    * enable/disable `debug`. Any change provided will override the global config,
    * for that particular function call.
-   * @param loginRequiredCallback - provide a function here to be called if the
+   * @param loginRequiredCallback - a function that is called if the
    * user is not logged in (eg to display a login form). The request will be
-   * resubmitted after logon.
+   * resubmitted after successful login.
+   * When using a `loginRequiredCallback`, the call to the request will look, for example, like so:
+   * `await request(sasJobPath, data, config, () => setIsLoggedIn(false))`
+   * If you are not passing in any data and configuration, it will look like so:
+   * `await request(sasJobPath, {}, {}, () => setIsLoggedIn(false))`
    */
   public async request(
     sasJob: string,
-    data: any,
-    config: any = {},
-    loginRequiredCallback?: any,
+    data: { [key: string]: any },
+    config: { [key: string]: any } = {},
+    loginRequiredCallback?: () => any,
     accessToken?: string
   ) {
     config = {
@@ -705,9 +710,27 @@ export default class SASjs {
    * @param accessToken - an access token for an authorized user.
    */
   public async fetchLogFileContent(logUrl: string, accessToken?: string) {
-    return await this.requestClient!.get(logUrl, accessToken).then((res) =>
-      JSON.stringify(res.result)
-    )
+    return await this.requestClient!.get(logUrl, accessToken).then((res) => {
+      if (!res)
+        return Promise.reject(
+          new ErrorResponse(
+            'Error while fetching log. Response was not provided.'
+          )
+        )
+
+      try {
+        const result = JSON.stringify(res.result)
+
+        return result
+      } catch (err) {
+        return Promise.reject(
+          new ErrorResponse(
+            'Error while fetching log. The result is not valid.',
+            err
+          )
+        )
+      }
+    })
   }
 
   public getSasRequests() {

src/auth/AuthManager.ts

@@ -82,17 +82,33 @@ export class AuthManager {
    * @returns - a promise which resolves with an object containing two values - a boolean `isLoggedIn`, and a string `userName`.
    */
   public async checkSession() {
-    const { result: loginResponse } = await this.requestClient.get<string>(
-      this.loginUrl.replace('.do', ''),
-      undefined,
-      'text/plain'
-    )
-    const responseText = loginResponse
-    const isLoggedIn = /<button.+onClick.+logout/gm.test(responseText)
-    let loginForm: any = null
+    //For VIYA we will send request on API endpoint. Which is faster then pinging SASJobExecution.
+    //For SAS9 we will send request on SASStoredProcess
+    const url =
+      this.serverType === 'SASVIYA'
+        ? `${this.serverUrl}/identities`
+        : `${this.serverUrl}/SASStoredProcess`
+
+    const { result: loginResponse } = await this.requestClient
+      .get<string>(url, undefined, 'text/plain')
+      .catch((err: any) => {
+        return { result: 'authErr' }
+      })
+
+    const isLoggedIn = loginResponse !== 'authErr'
+    let loginForm = null
 
     if (!isLoggedIn) {
-      loginForm = await this.getLoginForm(responseText)
+      //We will logout to make sure cookies are removed and login form is presented
+      this.logOut()
+
+      const { result: formResponse } = await this.requestClient.get<string>(
+        this.loginUrl.replace('.do', ''),
+        undefined,
+        'text/plain'
+      )
+
+      loginForm = await this.getLoginForm(formResponse)
     }
 
     return Promise.resolve({

src/auth/spec/AuthManager.spec.ts

@@ -176,41 +176,19 @@ describe('AuthManager', () => {
 
     const response = await authManager.checkSession()
     expect(response.isLoggedIn).toBeTruthy()
-    expect(mockedAxios.get).toHaveBeenNthCalledWith(1, `/SASLogon/login`, {
-      withCredentials: true,
-      responseType: 'text',
-      transformResponse: undefined,
-      headers: {
-        Accept: '*/*',
-        'Content-Type': 'text/plain'
+    expect(mockedAxios.get).toHaveBeenNthCalledWith(
+      1,
+      `http://test-server.com/identities`,
+      {
+        withCredentials: true,
+        responseType: 'text',
+        transformResponse: undefined,
+        headers: {
+          Accept: '*/*',
+          'Content-Type': 'text/plain'
+        }
       }
-    })
-
-    done()
-  })
-
-  it('should check and return session information if logged in', async (done) => {
-    const authManager = new AuthManager(
-      serverUrl,
-      serverType,
-      requestClient,
-      authCallback
     )
-    mockedAxios.get.mockImplementation(() =>
-      Promise.resolve({ data: '<button onClick="logout">' })
-    )
-
-    const response = await authManager.checkSession()
-    expect(response.isLoggedIn).toBeTruthy()
-    expect(mockedAxios.get).toHaveBeenNthCalledWith(1, `/SASLogon/login`, {
-      withCredentials: true,
-      responseType: 'text',
-      transformResponse: undefined,
-      headers: {
-        Accept: '*/*',
-        'Content-Type': 'text/plain'
-      }
-    })
 
     done()
   })

src/test/utils/isUrl.spec.ts

@@ -0,0 +1,39 @@
+import { isUrl } from '../../utils/isUrl'
+
+describe('urlValidator', () => {
+  it('should return true with an HTTP URL', () => {
+    const url = 'http://google.com'
+
+    expect(isUrl(url)).toEqual(true)
+  })
+
+  it('should return true with an HTTPS URL', () => {
+    const url = 'https://google.com'
+
+    expect(isUrl(url)).toEqual(true)
+  })
+
+  it('should return true when the URL is blank', () => {
+    const url = ''
+
+    expect(isUrl(url)).toEqual(false)
+  })
+
+  it('should return false when the URL has not supported protocol', () => {
+    const url = 'htpps://google.com'
+
+    expect(isUrl(url)).toEqual(false)
+  })
+
+  it('should return false when the URL is null', () => {
+    const url = null
+
+    expect(isUrl((url as unknown) as string)).toEqual(false)
+  })
+
+  it('should return false when the URL is undefined', () => {
+    const url = undefined
+
+    expect(isUrl((url as unknown) as string)).toEqual(false)
+  })
+})

src/utils/isUrl.ts

@@ -1,16 +1,17 @@
 /**
  * Checks if string is in URL format.
- * @param url - string to check.
+ * @param str - string to check.
  */
-export const isUrl = (url: string): boolean => {
-  const pattern = new RegExp(
-    '^(http://|https://)[a-z0-9]+([-.]{1}[a-z0-9]+)*.[a-z]{2,5}(:[0-9]{1,5})?(/.*)?$',
-    'gi'
-  )
+export const isUrl = (str: string): boolean => {
+  const supportedProtocols = ['http:', 'https:']
 
-  if (pattern.test(url)) return true
-  else
-    throw new Error(
-      `'${url}' is not a valid url. An example of a valid url is 'http://valid-url.com'.`
-    )
+  try {
+    const url = new URL(str)
+
+    if (!supportedProtocols.includes(url.protocol)) return false
+  } catch (_) {
+    return false
+  }
+
+  return true
 }