Merge pull request #504 from sasjs/extract-username-while-check-session

fix: while checking session extract username also

.npmignore

@@ -1,4 +1,5 @@
 sasjs-tests/
 docs/
 .github/
-CONTRIBUTING.md
+*.md
+*.spec.ts

checkNodeVersion.js

@@ -0,0 +1,16 @@
+const result = process.versions
+if (result && result.node) {
+  if (parseInt(result.node) < 14) {
+    console.log(
+      '\x1b[31m%s\x1b[0m',
+      `❌ Process failed due to Node Version,\nPlease install and use Node Version >= 14\nYour current Node Version is: ${result.node}`
+    )
+    process.exit(1)
+  }
+} else {
+  console.log(
+    '\x1b[31m%s\x1b[0m',
+    'Something went wrong while checking Node version'
+  )
+  process.exit(1)
+}

package.json

@@ -3,8 +3,10 @@
   "description": "JavaScript adapter for SAS",
   "homepage": "https://adapter.sasjs.io",
   "scripts": {
+    "preinstall": "node checkNodeVersion",
+    "prebuild": "node checkNodeVersion",
     "build": "rimraf build && rimraf node && mkdir node && copyfiles -u 1 \"./src/**/*\" ./node && webpack && rimraf build/src && rimraf node",
-    "package:lib": "npm run build && copyfiles ./package.json build && cd build && npm version \"5.0.0\" && npm pack",
+    "package:lib": "npm run build && copyfiles ./package.json ./checkNodeVersion.js build && cd build && npm version \"5.0.0\" && npm pack",
     "publish:lib": "npm run build && cd build && npm publish",
     "lint:fix": "npx prettier --write \"src/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}\" && npx prettier --write \"sasjs-tests/src/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}\"",
     "lint": "npx prettier --check \"src/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}\" && npx prettier --check \"sasjs-tests/src/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}\"",
@@ -40,41 +42,38 @@
   "devDependencies": {
     "@types/axios": "^0.14.0",
     "@types/form-data": "^2.5.0",
-    "@types/jest": "^26.0.24",
+    "@types/jest": "^27.0.1",
     "@types/mime": "^2.0.3",
     "@types/tough-cookie": "^4.0.1",
     "copyfiles": "^2.4.1",
     "cp": "^0.2.0",
     "dotenv": "^10.0.0",
-    "jest": "^27.0.6",
+    "jest": "^27.1.0",
     "jest-extended": "^0.11.5",
     "node-polyfill-webpack-plugin": "^1.1.4",
     "path": "^0.12.7",
     "process": "^0.11.10",
     "rimraf": "^3.0.2",
-    "semantic-release": "^17.4.4",
-    "terser-webpack-plugin": "^5.1.4",
+    "semantic-release": "^17.4.7",
+    "terser-webpack-plugin": "^5.2.0",
     "ts-jest": "^27.0.3",
     "ts-loader": "^9.2.2",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0",
-    "typedoc": "^0.21.4",
+    "typedoc": "^0.21.9",
     "typedoc-neo-theme": "^1.1.1",
     "typedoc-plugin-external-module-name": "^4.0.6",
-    "typescript": "^4.3.5",
+    "typescript": "4.3.5",
     "webpack": "^5.44.0",
     "webpack-cli": "^4.7.2"
   },
   "main": "index.js",
   "dependencies": {
-    "@sasjs/utils": "^2.27.1",
+    "@sasjs/utils": "^2.30.0",
     "axios": "^0.21.1",
     "axios-cookiejar-support": "^1.0.1",
     "form-data": "^4.0.0",
     "https": "^1.0.0",
     "tough-cookie": "^4.0.0"
-  },
-  "engines": {
-    "node": ">=15"
   }
 }

sasjs-tests/src/testSuites/Basic.ts

@@ -41,6 +41,19 @@ export const basicTests = (
       assertion: (response: any) =>
         response && response.isLoggedIn && response.userName === userName
     },
+    {
+      title: 'Fetch username for already logged in user',
+      description: 'Should log the user in',
+      test: async () => {
+        await adapter.logIn(userName, password)
+
+        const newAdapterIns = new SASjs(adapter.getSasjsConfig())
+
+        return await newAdapterIns.checkSession()
+      },
+      assertion: (response: any) =>
+        response?.isLoggedIn && response?.userName === userName
+    },
     {
       title: 'Multiple Log in attempts',
       description:
@@ -48,7 +61,7 @@ export const basicTests = (
       test: async () => {
         await adapter.logOut()
         await adapter.logIn('invalid', 'invalid')
-        return adapter.logIn(userName, password)
+        return await adapter.logIn(userName, password)
       },
       assertion: (response: any) =>
         response && response.isLoggedIn && response.userName === userName
@@ -151,7 +164,7 @@ export const basicTests = (
       description:
         'Should complete successful request with extra attributes present in response',
       test: async () => {
-        const config = {
+        const config: Partial<SASjsConfig> = {
           useComputeApi: false
         }
 

src/FileUploader.ts

@@ -61,24 +61,21 @@ export class FileUploader {
       'Content-Type': 'text/plain'
     }
 
+    // currently only web approach is supported for file upload
+    // therefore log is part of response with debug enabled and must be parsed
     return this.requestClient
       .post(uploadUrl, formData, undefined, 'application/json', headers)
       .then(async (res) => {
-        // for web approach on Viya
         if (
-          this.sasjsConfig.debug &&
-          (this.sasjsConfig.useComputeApi === null ||
-            this.sasjsConfig.useComputeApi === undefined) &&
-          this.sasjsConfig.serverType === ServerType.SasViya
+          this.sasjsConfig.serverType === ServerType.SasViya &&
+          this.sasjsConfig.debug
         ) {
           const jsonResponse = await parseSasViyaDebugResponse(
             res.result as string,
             this.requestClient,
             this.sasjsConfig.serverUrl
           )
-          return typeof jsonResponse === 'string'
-            ? getValidJson(jsonResponse)
-            : jsonResponse
+          return jsonResponse
         }
 
         return typeof res.result === 'string'

src/SAS9ApiClient.ts

@@ -10,9 +10,13 @@ import { isUrl } from './utils'
 export class SAS9ApiClient {
   private requestClient: Sas9RequestClient
 
-  constructor(private serverUrl: string, private jobsPath: string) {
+  constructor(
+    private serverUrl: string,
+    private jobsPath: string,
+    allowInsecureRequests: boolean
+  ) {
     if (serverUrl) isUrl(serverUrl)
-    this.requestClient = new Sas9RequestClient(serverUrl, false)
+    this.requestClient = new Sas9RequestClient(serverUrl, allowInsecureRequests)
   }
 
   /**

src/SASjs.ts

@@ -619,6 +619,11 @@ export default class SASjs {
             authConfig
           )
         } else {
+          if (!config.contextName)
+            config = {
+              ...config,
+              contextName: 'SAS Job Execution compute context'
+            }
           return await this.jesJobExecutor!.execute(
             sasJob,
             data,
@@ -749,7 +754,11 @@ export default class SASjs {
         )
         sasApiClient.debug = this.sasjsConfig.debug
       } else if (this.sasjsConfig.serverType === ServerType.Sas9) {
-        sasApiClient = new SAS9ApiClient(serverUrl, this.jobsPath)
+        sasApiClient = new SAS9ApiClient(
+          serverUrl,
+          this.jobsPath,
+          this.sasjsConfig.allowInsecureRequests
+        )
       }
     } else {
       let sasClientConfig: any = null
@@ -944,7 +953,8 @@ export default class SASjs {
       else
         this.sas9ApiClient = new SAS9ApiClient(
           this.sasjsConfig.serverUrl,
-          this.jobsPath
+          this.jobsPath,
+          this.sasjsConfig.allowInsecureRequests
         )
     }
 
@@ -965,7 +975,8 @@ export default class SASjs {
     this.sas9JobExecutor = new Sas9JobExecutor(
       this.sasjsConfig.serverUrl,
       this.sasjsConfig.serverType!,
-      this.jobsPath
+      this.jobsPath,
+      this.sasjsConfig.allowInsecureRequests
     )
 
     this.computeJobExecutor = new ComputeJobExecutor(

src/SessionManager.ts

@@ -5,10 +5,10 @@ import { prefixMessage } from '@sasjs/utils/error'
 import { RequestClient } from './request/RequestClient'
 
 const MAX_SESSION_COUNT = 1
-const RETRY_LIMIT: number = 3
-let RETRY_COUNT: number = 0
 
 export class SessionManager {
+  private loggedErrors: NoSessionStateError[] = []
+
   constructor(
     private serverUrl: string,
     private contextName: string,
@@ -154,69 +154,75 @@ export class SessionManager {
     session: Session,
     etag: string | null,
     accessToken?: string
-  ) {
+  ): Promise<string> {
     const logger = process.logger || console
 
     let sessionState = session.state
 
     const stateLink = session.links.find((l: any) => l.rel === 'state')
 
-    return new Promise(async (resolve, reject) => {
-      if (
-        sessionState === 'pending' ||
-        sessionState === 'running' ||
-        sessionState === ''
-      ) {
-        if (stateLink) {
-          if (this.debug && !this.printedSessionState.printed) {
-            logger.info('Polling session status...')
+    if (
+      sessionState === 'pending' ||
+      sessionState === 'running' ||
+      sessionState === ''
+    ) {
+      if (stateLink) {
+        if (this.debug && !this.printedSessionState.printed) {
+          logger.info('Polling session status...')
 
-            this.printedSessionState.printed = true
-          }
-
-          const { result: state, responseStatus: responseStatus } =
-            await this.getSessionState(
-              `${this.serverUrl}${stateLink.href}?wait=30`,
-              etag!,
-              accessToken
-            ).catch((err) => {
-              throw prefixMessage(err, 'Error while getting session state.')
-            })
-
-          sessionState = state.trim()
-
-          if (this.debug && this.printedSessionState.state !== sessionState) {
-            logger.info(`Current session state is '${sessionState}'`)
-
-            this.printedSessionState.state = sessionState
-            this.printedSessionState.printed = false
-          }
-
-          // There is an internal error present in SAS Viya 3.5
-          // Retry to wait for a session status in such case of SAS internal error
-          if (!sessionState) {
-            if (RETRY_COUNT < RETRY_LIMIT) {
-              RETRY_COUNT++
-
-              resolve(this.waitForSession(session, etag, accessToken))
-            } else {
-              reject(
-                new NoSessionStateError(
-                  responseStatus,
-                  this.serverUrl + stateLink.href,
-                  session.links.find((l: any) => l.rel === 'log')
-                    ?.href as string
-                )
-              )
-            }
-          }
-
-          resolve(sessionState)
+          this.printedSessionState.printed = true
         }
+
+        const { result: state, responseStatus: responseStatus } =
+          await this.getSessionState(
+            `${this.serverUrl}${stateLink.href}?wait=30`,
+            etag!,
+            accessToken
+          ).catch((err) => {
+            throw prefixMessage(err, 'Error while getting session state.')
+          })
+
+        sessionState = state.trim()
+
+        if (this.debug && this.printedSessionState.state !== sessionState) {
+          logger.info(`Current session state is '${sessionState}'`)
+
+          this.printedSessionState.state = sessionState
+          this.printedSessionState.printed = false
+        }
+
+        if (!sessionState) {
+          const stateError = new NoSessionStateError(
+            responseStatus,
+            this.serverUrl + stateLink.href,
+            session.links.find((l: any) => l.rel === 'log')?.href as string
+          )
+
+          if (
+            !this.loggedErrors.find(
+              (err: NoSessionStateError) =>
+                err.serverResponseStatus === stateError.serverResponseStatus
+            )
+          ) {
+            this.loggedErrors.push(stateError)
+
+            logger.info(stateError.message)
+          }
+
+          return await this.waitForSession(session, etag, accessToken)
+        }
+
+        this.loggedErrors = []
+
+        return sessionState
       } else {
-        resolve(sessionState)
+        throw 'Error while getting session state link.'
       }
-    })
+    } else {
+      this.loggedErrors = []
+
+      return sessionState
+    }
   }
 
   private async getSessionState(

src/auth/AuthManager.ts

@@ -23,43 +23,61 @@ export class AuthManager {
    * Logs into the SAS server with the supplied credentials.
    * @param username - a string representing the username.
    * @param password - a string representing the password.
+   * @returns - a boolean `isLoggedin` and a string `username`
    */
-  public async logIn(username: string, password: string) {
-    const loginParams: any = {
+  public async logIn(
+    username: string,
+    password: string
+  ): Promise<{
+    isLoggedIn: boolean
+    userName: string
+  }> {
+    const loginParams = {
       _service: 'default',
       username,
       password
     }
 
-    this.userName = loginParams.username
+    let {
+      isLoggedIn: isLoggedInAlready,
+      loginForm,
+      userName: currentSessionUsername
+    } = await this.checkSession()
 
-    const { isLoggedIn, loginForm } = await this.checkSession()
+    if (isLoggedInAlready) {
+      if (currentSessionUsername === loginParams.username) {
+        await this.loginCallback()
 
-    if (isLoggedIn) {
-      await this.loginCallback()
-
-      return {
-        isLoggedIn,
-        userName: this.userName
+        this.userName = currentSessionUsername!
+        return {
+          isLoggedIn: true,
+          userName: this.userName
+        }
+      } else {
+        this.logOut()
       }
-    }
+    } else this.userName = ''
 
     let loginResponse = await this.sendLoginRequest(loginForm, loginParams)
 
-    let loggedIn = isLogInSuccess(loginResponse)
+    let isLoggedIn = isLogInSuccess(loginResponse)
 
-    if (!loggedIn) {
+    if (!isLoggedIn) {
       if (isCredentialsVerifyError(loginResponse)) {
         const newLoginForm = await this.getLoginForm(loginResponse)
 
         loginResponse = await this.sendLoginRequest(newLoginForm, loginParams)
       }
 
-      const currentSession = await this.checkSession()
-      loggedIn = currentSession.isLoggedIn
+      const res = await this.checkSession()
+      isLoggedIn = res.isLoggedIn
+
+      if (isLoggedIn) this.userName = res.userName!
+    } else {
+      this.userName = loginParams.username
     }
 
-    if (loggedIn) {
+    if (isLoggedIn) {
       if (this.serverType === ServerType.Sas9) {
         const casAuthenticationUrl = `${this.serverUrl}/SASStoredProcess/j_spring_cas_security_check`
 
@@ -70,10 +88,10 @@ export class AuthManager {
       }
 
       this.loginCallback()
-    }
+    } else this.userName = ''
 
     return {
-      isLoggedIn: !!loggedIn,
+      isLoggedIn,
       userName: this.userName
     }
   }
@@ -103,14 +121,21 @@ export class AuthManager {
 
   /**
    * Checks whether a session is active, or login is required.
-   * @returns - a promise which resolves with an object containing two values - a boolean `isLoggedIn`, and a string `userName`.
+   * @returns - a promise which resolves with an object containing three values
+   *  - a boolean `isLoggedIn`
+   *  - a string `userName` and
+   *  - a form `loginForm` if not loggedin.
    */
-  public async checkSession() {
+  public async checkSession(): Promise<{
+    isLoggedIn: boolean
+    userName?: string
+    loginForm?: any
+  }> {
     //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}/identities/users/@currentUser`
         : `${this.serverUrl}/SASStoredProcess`
 
     const { result: loginResponse } = await this.requestClient
@@ -120,11 +145,16 @@ export class AuthManager {
       })
 
     const isLoggedIn = loginResponse !== 'authErr'
+    const userName = isLoggedIn
+      ? this.extractUserName(loginResponse)
+      : undefined
+
     let loginForm = null
 
     if (!isLoggedIn) {
       //We will logout to make sure cookies are removed and login form is presented
-      this.logOut()
+      //Residue can happen in case of session expiration
+      await this.logOut()
 
       const { result: formResponse } = await this.requestClient.get<string>(
         this.loginUrl.replace('.do', ''),
@@ -137,11 +167,29 @@ export class AuthManager {
 
     return Promise.resolve({
       isLoggedIn,
-      userName: this.userName,
+      userName: userName?.toLowerCase(),
       loginForm
     })
   }
 
+  private extractUserName = (response: any): string => {
+    switch (this.serverType) {
+      case ServerType.SasViya:
+        return response?.id
+
+      case ServerType.Sas9:
+        const matched = response?.match(/"title":"Log Off [0-1a-zA-Z ]*"/)
+        const username = matched?.[0].slice(17, -1)
+
+        if (!username.includes(' ')) return username
+
+        return username
+          .split(' ')
+          .map((name: string) => name.slice(0, 3).toLowerCase())
+          .join('')
+    }
+  }
+
   private getLoginForm(response: any) {
     const pattern: RegExp = /<form.+action="(.*Logon[^"]*).*>/
     const matches = pattern.exec(response)

src/auth/spec/AuthManager.spec.ts

@@ -67,7 +67,7 @@ describe('AuthManager', () => {
     jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
       Promise.resolve({
         isLoggedIn: true,
-        userName: 'test',
+        userName,
         loginForm: 'test'
       })
     )
@@ -89,7 +89,6 @@ describe('AuthManager', () => {
     jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
       Promise.resolve({
         isLoggedIn: false,
-        userName: 'test',
         loginForm: { name: 'test' }
       })
     )
@@ -175,7 +174,7 @@ describe('AuthManager', () => {
     expect(response.isLoggedIn).toBeTruthy()
     expect(mockedAxios.get).toHaveBeenNthCalledWith(
       1,
-      `http://test-server.com/identities`,
+      `http://test-server.com/identities/users/@currentUser`,
       {
         withCredentials: true,
         responseType: 'text',

src/job-execution/JesJobExecutor.ts

@@ -7,6 +7,7 @@ import {
 } from '../types/errors'
 import { ExtraResponseAttributes } from '@sasjs/utils/types'
 import { BaseJobExecutor } from './JobExecutor'
+import { appendExtraResponseAttributes } from '../utils'
 
 export class JesJobExecutor extends BaseJobExecutor {
   constructor(serverUrl: string, private sasViyaApiClient: SASViyaApiClient) {
@@ -29,21 +30,10 @@ export class JesJobExecutor extends BaseJobExecutor {
         .then((response: any) => {
           this.appendRequest(response, sasJob, config.debug)
 
-          let responseObject = {}
-
-          if (extraResponseAttributes && extraResponseAttributes.length > 0) {
-            const extraAttributes = extraResponseAttributes.reduce(
-              (map: any, obj: any) => ((map[obj] = response[obj]), map),
-              {}
-            )
-
-            responseObject = {
-              result: response.result,
-              ...extraAttributes
-            }
-          } else {
-            responseObject = response.result
-          }
+          const responseObject = appendExtraResponseAttributes(
+            response,
+            extraResponseAttributes
+          )
 
           resolve(responseObject)
         })

src/job-execution/Sas9JobExecutor.ts

@@ -16,10 +16,11 @@ export class Sas9JobExecutor extends BaseJobExecutor {
   constructor(
     serverUrl: string,
     serverType: ServerType,
-    private jobsPath: string
+    private jobsPath: string,
+    allowInsecureRequests: boolean
   ) {
     super(serverUrl, serverType)
-    this.requestClient = new Sas9RequestClient(serverUrl, false)
+    this.requestClient = new Sas9RequestClient(serverUrl, allowInsecureRequests)
   }
 
   async execute(sasJob: string, data: any, config: any) {

src/job-execution/WebJobExecutor.ts

@@ -1,8 +1,13 @@
-import { ServerType } from '@sasjs/utils/types'
+import {
+  AuthConfig,
+  ExtraResponseAttributes,
+  ServerType
+} from '@sasjs/utils/types'
 import {
   ErrorResponse,
   JobExecutionError,
-  LoginRequiredError
+  LoginRequiredError,
+  WeboutResponseError
 } from '../types/errors'
 import { generateFileUploadForm } from '../file/generateFileUploadForm'
 import { generateTableUploadForm } from '../file/generateTableUploadForm'
@@ -11,7 +16,8 @@ import { SASViyaApiClient } from '../SASViyaApiClient'
 import {
   isRelativePath,
   getValidJson,
-  parseSasViyaDebugResponse
+  parseSasViyaDebugResponse,
+  appendExtraResponseAttributes
 } from '../utils'
 import { BaseJobExecutor } from './JobExecutor'
 import { parseWeboutResponse } from '../utils/parseWeboutResponse'
@@ -36,7 +42,9 @@ export class WebJobExecutor extends BaseJobExecutor {
     sasJob: string,
     data: any,
     config: any,
-    loginRequiredCallback?: any
+    loginRequiredCallback?: any,
+    authConfig?: AuthConfig,
+    extraResponseAttributes: ExtraResponseAttributes[] = []
   ) {
     const loginCallback = loginRequiredCallback || (() => Promise.resolve())
     const program = isRelativePath(sasJob)
@@ -54,7 +62,21 @@ export class WebJobExecutor extends BaseJobExecutor {
 
       apiUrl += jobUri.length > 0 ? '&_job=' + jobUri : ''
 
-      apiUrl += config.contextName ? `&_contextname=${config.contextName}` : ''
+      if (jobUri.length > 0) {
+        apiUrl += '&_job=' + jobUri
+        /**
+         * Using both _job and _program parameters will cause a conflict in the JES web app, as it’s not clear whether or not the server should make the extra fetch for the job uri.
+         * To handle this, we add the extra underscore and recreate the _program variable in the SAS side of the SASjs adapter so it remains available for backend developers.
+         */
+        apiUrl = apiUrl.replace('_program=', '__program=')
+      }
+
+      // if context name exists and is not blank string
+      // then add _contextname variable in apiUrl
+      apiUrl +=
+        config.contextName && !/\s/.test(config.contextName)
+          ? `&_contextname=${config.contextName}`
+          : ''
     }
 
     let requestParams = {
@@ -97,31 +119,34 @@ export class WebJobExecutor extends BaseJobExecutor {
 
     const requestPromise = new Promise((resolve, reject) => {
       this.requestClient!.post(apiUrl, formData, undefined)
-        .then(async (res) => {
-          if (this.serverType === ServerType.SasViya && config.debug) {
-            const jsonResponse = await parseSasViyaDebugResponse(
-              res.result as string,
-              this.requestClient,
-              this.serverUrl
-            )
-            this.appendRequest(res, sasJob, config.debug)
-            resolve(jsonResponse)
-          }
-          if (this.serverType === ServerType.Sas9 && config.debug) {
-            const jsonResponse = parseWeboutResponse(res.result as string)
-            if (jsonResponse === '') {
-              throw new Error(
-                'Valid JSON could not be extracted from response.'
-              )
-            }
+        .then(async (res: any) => {
+          let jsonResponse = res.result
 
-            getValidJson(jsonResponse)
-            this.appendRequest(res, sasJob, config.debug)
-            resolve(res.result)
+          if (config.debug) {
+            switch (this.serverType) {
+              case ServerType.SasViya:
+                jsonResponse = await parseSasViyaDebugResponse(
+                  res.result,
+                  this.requestClient,
+                  this.serverUrl
+                )
+                break
+              case ServerType.Sas9:
+                jsonResponse =
+                  typeof res.result === 'string'
+                    ? parseWeboutResponse(res.result, apiUrl)
+                    : res.result
+                break
+            }
           }
-          getValidJson(res.result as string)
+
           this.appendRequest(res, sasJob, config.debug)
-          resolve(res.result)
+
+          const responseObject = appendExtraResponseAttributes(
+            { result: jsonResponse },
+            extraResponseAttributes
+          )
+          resolve(responseObject)
         })
         .catch(async (e: Error) => {
           if (e instanceof JobExecutionError) {
@@ -138,7 +163,9 @@ export class WebJobExecutor extends BaseJobExecutor {
                 sasJob,
                 data,
                 config,
-                loginRequiredCallback
+                loginRequiredCallback,
+                authConfig,
+                extraResponseAttributes
               ).then(
                 (res: any) => {
                   resolve(res)

src/request/RequestClient.ts

@@ -429,13 +429,7 @@ export class RequestClient implements HttpClient {
       }
     } catch {
       try {
-        const weboutResponse = parseWeboutResponse(response.data)
-        if (weboutResponse === '') {
-          throw new Error('Valid JSON could not be extracted from response.')
-        }
-
-        const jsonResponse = getValidJson(weboutResponse)
-        parsedResponse = jsonResponse
+        parsedResponse = JSON.parse(parseWeboutResponse(response.data))
       } catch {
         parsedResponse = response.data
       }
@@ -505,46 +499,60 @@ export const throwIfError = (response: AxiosResponse) => {
 }
 
 const parseError = (data: string) => {
+  if (!data) return null
+
   try {
     const responseJson = JSON.parse(data?.replace(/[\n\r]/g, ' '))
-    return responseJson.errorCode && responseJson.message
-      ? new JobExecutionError(
-          responseJson.errorCode,
-          responseJson.message,
-          data?.replace(/[\n\r]/g, ' ')
-        )
-      : null
-  } catch (_) {
-    try {
-      const hasError = data?.includes('{"errorCode')
-      if (hasError) {
-        const parts = data.split('{"errorCode')
-        if (parts.length > 1) {
-          const error = '{"errorCode' + parts[1].split('"}')[0] + '"}'
-          const errorJson = JSON.parse(error.replace(/[\n\r]/g, ' '))
-          return new JobExecutionError(
-            errorJson.errorCode,
-            errorJson.message,
-            data?.replace(/[\n\r]/g, '\n')
-          )
-        }
-        return null
-      }
-      try {
-        const hasError = !!data?.match(/stored process not found: /i)
-        if (hasError) {
-          const parts = data.split(/stored process not found: /i)
-          if (parts.length > 1) {
-            const storedProcessPath = parts[1].split('<i>')[1].split('</i>')[0]
-            const message = `Stored process not found: ${storedProcessPath}`
-            return new JobExecutionError(404, message, '')
-          }
-        }
-      } catch (_) {
-        return null
-      }
-    } catch (_) {
-      return null
+    if (responseJson.errorCode && responseJson.message) {
+      return new JobExecutionError(
+        responseJson.errorCode,
+        responseJson.message,
+        data?.replace(/[\n\r]/g, ' ')
+      )
     }
-  }
+  } catch (_) {}
+
+  try {
+    const hasError = data?.includes('{"errorCode')
+    if (hasError) {
+      const parts = data.split('{"errorCode')
+      if (parts.length > 1) {
+        const error = '{"errorCode' + parts[1].split('"}')[0] + '"}'
+        const errorJson = JSON.parse(error.replace(/[\n\r]/g, ' '))
+        return new JobExecutionError(
+          errorJson.errorCode,
+          errorJson.message,
+          data?.replace(/[\n\r]/g, '\n')
+        )
+      }
+    }
+  } catch (_) {}
+
+  try {
+    const hasError = !!data?.match(/stored process not found: /i)
+    if (hasError) {
+      const parts = data.split(/stored process not found: /i)
+      if (parts.length > 1) {
+        const storedProcessPath = parts[1].split('<i>')[1].split('</i>')[0]
+        const message = `Stored process not found: ${storedProcessPath}`
+        return new JobExecutionError(404, message, '')
+      }
+    }
+  } catch (_) {}
+
+  try {
+    const hasError =
+      !!data?.match(/Stored Process Error/i) &&
+      !!data?.match(/This request completed with errors./i)
+    if (hasError) {
+      const parts = data.split('<h2>SAS Log</h2>')
+      if (parts.length > 1) {
+        const log = parts[1].split('<pre>')[1].split('</pre>')[0]
+        const message = `This request completed with errors.`
+        return new JobExecutionError(404, message, log)
+      }
+    }
+  } catch (_) {}
+
+  return null
 }

src/test/SessionManager.spec.ts

@@ -3,6 +3,8 @@ import { RequestClient } from '../request/RequestClient'
 import { NoSessionStateError } from '../types/errors'
 import * as dotenv from 'dotenv'
 import axios from 'axios'
+import { Logger, LogLevel } from '@sasjs/utils'
+import { Session } from '../types'
 
 jest.mock('axios')
 const mockedAxios = axios as jest.Mocked<typeof axios>
@@ -47,36 +49,91 @@ describe('SessionManager', () => {
   })
 
   describe('waitForSession', () => {
+    const session: Session = {
+      id: 'id',
+      state: '',
+      links: [{ rel: 'state', href: '', uri: '', type: '', method: 'GET' }],
+      attributes: {
+        sessionInactiveTimeout: 0
+      },
+      creationTimeStamp: ''
+    }
+
+    beforeEach(() => {
+      ;(process as any).logger = new Logger(LogLevel.Off)
+    })
+
     it('should reject with NoSessionStateError if SAS server did not provide session state', async () => {
-      const responseStatus = 304
+      let requestAttempt = 0
+      const requestAttemptLimit = 10
+      const sessionState = 'idle'
+
+      mockedAxios.get.mockImplementation(() => {
+        requestAttempt += 1
+
+        if (requestAttempt >= requestAttemptLimit) {
+          return Promise.resolve({ data: sessionState, status: 200 })
+        }
+
+        return Promise.resolve({ data: '', status: 304 })
+      })
+
+      jest.spyOn((process as any).logger, 'info')
+
+      sessionManager.debug = true
+
+      await expect(
+        sessionManager['waitForSession'](session, null, 'access_token')
+      ).resolves.toEqual(sessionState)
+
+      expect(mockedAxios.get).toHaveBeenCalledTimes(requestAttemptLimit)
+      expect((process as any).logger.info).toHaveBeenCalledTimes(3)
+      expect((process as any).logger.info).toHaveBeenNthCalledWith(
+        1,
+        'Polling session status...'
+      )
+      expect((process as any).logger.info).toHaveBeenNthCalledWith(
+        2,
+        `Could not get session state. Server responded with 304 whilst checking state: ${process.env.SERVER_URL}`
+      )
+      expect((process as any).logger.info).toHaveBeenNthCalledWith(
+        3,
+        `Current session state is '${sessionState}'`
+      )
+    })
+
+    it('should throw an error if there is no session link', async () => {
+      const customSession = JSON.parse(JSON.stringify(session))
+      customSession.links = []
 
       mockedAxios.get.mockImplementation(() =>
-        Promise.resolve({ data: '', status: responseStatus })
+        Promise.resolve({ data: customSession.state, status: 200 })
       )
 
       await expect(
-        sessionManager['waitForSession'](
-          {
-            id: 'id',
-            state: '',
-            links: [
-              { rel: 'state', href: '', uri: '', type: '', method: 'GET' }
-            ],
-            attributes: {
-              sessionInactiveTimeout: 0
-            },
-            creationTimeStamp: ''
-          },
-          null,
-          'access_token'
-        )
-      ).rejects.toEqual(
-        new NoSessionStateError(
-          responseStatus,
-          process.env.SERVER_URL as string,
-          'logUrl'
-        )
+        sessionManager['waitForSession'](customSession, null, 'access_token')
+      ).rejects.toContain('Error while getting session state link.')
+    })
+
+    it('should throw an error if could not get session state', async () => {
+      mockedAxios.get.mockImplementation(() => Promise.reject('Mocked error'))
+
+      await expect(
+        sessionManager['waitForSession'](session, null, 'access_token')
+      ).rejects.toContain('Error while getting session state.')
+    })
+
+    it('should return session state', async () => {
+      const customSession = JSON.parse(JSON.stringify(session))
+      customSession.state = 'completed'
+
+      mockedAxios.get.mockImplementation(() =>
+        Promise.resolve({ data: customSession.state, status: 200 })
       )
+
+      await expect(
+        sessionManager['waitForSession'](customSession, null, 'access_token')
+      ).resolves.toEqual(customSession.state)
     })
   })
 })

src/test/utils/getValidJson.spec.ts

@@ -1,4 +1,5 @@
 import { getValidJson } from '../../utils'
+import { JsonParseArrayError, InvalidJsonError } from '../../types/errors'
 
 describe('jsonValidator', () => {
   it('should not throw an error with a valid json', () => {
@@ -19,23 +20,17 @@ describe('jsonValidator', () => {
 
   it('should throw an error with an invalid json', () => {
     const json = `{\"test\":\"test\"\"test2\":\"test\"}`
-    let errorThrown = false
-    try {
+    const test = () => {
       getValidJson(json)
-    } catch (error) {
-      errorThrown = true
     }
-    expect(errorThrown).toBe(true)
+    expect(test).toThrowError(InvalidJsonError)
   })
 
   it('should throw an error when an array is passed', () => {
     const array = ['hello', 'world']
-    let errorThrown = false
-    try {
+    const test = () => {
       getValidJson(array)
-    } catch (error) {
-      errorThrown = true
     }
-    expect(errorThrown).toBe(true)
+    expect(test).toThrow(JsonParseArrayError)
   })
 })

src/types/errors/InvalidJsonError.ts

@@ -0,0 +1,7 @@
+export class InvalidJsonError extends Error {
+  constructor() {
+    super('Error: invalid Json string')
+    this.name = 'InvalidJsonError'
+    Object.setPrototypeOf(this, InvalidJsonError.prototype)
+  }
+}

src/types/errors/JsonParseArrayError.ts

@@ -0,0 +1,7 @@
+export class JsonParseArrayError extends Error {
+  constructor() {
+    super('Can not parse array object to json.')
+    this.name = 'JsonParseArrayError'
+    Object.setPrototypeOf(this, JsonParseArrayError.prototype)
+  }
+}

src/types/errors/WeboutResponseError.ts

@@ -0,0 +1,7 @@
+export class WeboutResponseError extends Error {
+  constructor(public url: string) {
+    super(`Error: error while parsing response from ${url}`)
+    this.name = 'WeboutResponseError'
+    Object.setPrototypeOf(this, WeboutResponseError.prototype)
+  }
+}

src/types/errors/index.ts

@@ -8,3 +8,6 @@ export * from './NotFoundError'
 export * from './ErrorResponse'
 export * from './NoSessionStateError'
 export * from './RootFolderNotFoundError'
+export * from './JsonParseArrayError'
+export * from './WeboutResponseError'
+export * from './InvalidJsonError'

src/utils/appendExtraResponseAttributes.ts

@@ -0,0 +1,22 @@
+import { ExtraResponseAttributes } from '@sasjs/utils/types'
+
+export async function appendExtraResponseAttributes(
+  response: any,
+  extraResponseAttributes: ExtraResponseAttributes[]
+) {
+  let responseObject = {}
+
+  if (extraResponseAttributes?.length) {
+    const extraAttributes = extraResponseAttributes.reduce(
+      (map: any, obj: any) => ((map[obj] = response[obj]), map),
+      {}
+    )
+
+    responseObject = {
+      result: response.result,
+      ...extraAttributes
+    }
+  } else responseObject = response.result
+
+  return responseObject
+}

src/utils/getValidJson.ts

@@ -1,16 +1,18 @@
+import { JsonParseArrayError, InvalidJsonError } from '../types/errors'
+
 /**
  * if string passed then parse the string to json else if throw error for all other types unless it is not a valid json object.
  * @param str - string to check.
  */
 export const getValidJson = (str: string | object) => {
   try {
-    if (Array.isArray(str)) {
-      throw new Error('Can not parse array object to json.')
-    }
+    if (Array.isArray(str)) throw new JsonParseArrayError()
+
     if (typeof str === 'object') return str
 
     return JSON.parse(str)
   } catch (e) {
-    throw new Error('Invalid JSON response.')
+    if (e instanceof JsonParseArrayError) throw e
+    throw new InvalidJsonError()
   }
 }

src/utils/index.ts

@@ -15,3 +15,4 @@ export * from './parseWeboutResponse'
 export * from './fetchLogByChunks'
 export * from './getValidJson'
 export * from './parseViyaDebugResponse'
+export * from './appendExtraResponseAttributes'

src/utils/parseViyaDebugResponse.ts

@@ -1,4 +1,5 @@
 import { RequestClient } from '../request/RequestClient'
+import { getValidJson } from '../utils'
 
 /**
  * When querying a Viya job using the Web approach (as opposed to using the APIs) with _DEBUG enabled,
@@ -25,5 +26,5 @@ export const parseSasViyaDebugResponse = async (
 
   return requestClient
     .get(serverUrl + jsonUrl, undefined)
-    .then((res) => res.result)
+    .then((res: any) => getValidJson(res.result))
 }

src/utils/parseWeboutResponse.ts

@@ -1,4 +1,6 @@
-export const parseWeboutResponse = (response: string) => {
+import { WeboutResponseError } from '../types/errors'
+
+export const parseWeboutResponse = (response: string, url?: string) => {
   let sasResponse = ''
 
   if (response.includes('>>weboutBEGIN<<')) {
@@ -7,6 +9,7 @@ export const parseWeboutResponse = (response: string) => {
         .split('>>weboutBEGIN<<')[1]
         .split('>>weboutEND<<')[0]
     } catch (e) {
+      if (url) throw new WeboutResponseError(url)
       sasResponse = ''
       console.error(e)
     }