Merge pull request #549 from sasjs/improvements-file-uploader

fix: FileUploader extends BaseJobExecutor

package-lock.json

@@ -6351,6 +6351,7 @@
             "rimraf": "^3.0.2",
             "semver": "^7.3.5",
             "ssri": "^8.0.1",
+            "tar": "^6.1.0",
             "treeverse": "^1.0.4",
             "walk-up-path": "^1.0.0"
           }

sasjs-tests/package.json

@@ -23,7 +23,7 @@
     "test": "react-scripts test",
     "eject": "react-scripts eject",
     "update:adapter": "cd .. && npm run package:lib && cd sasjs-tests && npm i ../build/sasjs-adapter-5.0.0.tgz",
-    "deploy:tests": "rsync -avhe ssh ./build/* --delete sabhas@sas.analytium.co.uk:/var/www/html/sabhas/sasjs-test || npm run deploy:tests-win",
+    "deploy:tests": "rsync -avhe ssh ./build/* --delete $SSH_ACCOUNT:$DEPLOY_PATH || npm run deploy:tests-win",
     "deploy:tests-win": "scp %DEPLOY_PATH% ./build/*",
     "deploy": "npm run update:adapter && npm run build && npm run deploy:tests"
   },

sasjs-tests/public/config.json

@@ -2,7 +2,7 @@
   "userName": "",
   "password": "",
   "sasJsConfig": {
-    "serverUrl": "https://sas.analytium.co.uk/",
+    "serverUrl": "",
     "appLoc": "/Public/app",
     "serverType": "SASVIYA",
     "debug": false,

sasjs-tests/src/App.tsx

@@ -14,16 +14,16 @@ const App = (): ReactElement<{}> => {
   useEffect(() => {
     if (adapter) {
       const testSuites = [
-        // basicTests(adapter, config.userName, config.password),
-        // sendArrTests(adapter),
-        // sendObjTests(adapter),
-        // specialCaseTests(adapter),
+        basicTests(adapter, config.userName, config.password),
+        sendArrTests(adapter),
+        sendObjTests(adapter),
+        specialCaseTests(adapter),
         sasjsRequestTests(adapter)
       ]
 
-      // if (adapter.getSasjsConfig().serverType === 'SASVIYA') {
-      //   testSuites.push(computeTests(adapter))
-      // }
+      if (adapter.getSasjsConfig().serverType === 'SASVIYA') {
+        testSuites.push(computeTests(adapter))
+      }
 
       setTestSuites(testSuites)
     }

sasjs-tests/src/testSuites/Basic.ts

@@ -1,4 +1,4 @@
-import SASjs, { SASjsConfig } from '@sasjs/adapter'
+import SASjs, { LoginMechanism, SASjsConfig } from '@sasjs/adapter'
 import { TestSuite } from '@sasjs/test-framework'
 import { ServerType } from '@sasjs/utils/types'
 
@@ -13,7 +13,8 @@ const defaultConfig: SASjsConfig = {
   debug: false,
   contextName: 'SAS Job Execution compute context',
   useComputeApi: false,
-  allowInsecureRequests: false
+  allowInsecureRequests: false,
+  loginMechanism: LoginMechanism.Default
 }
 
 const customConfig = {
@@ -41,6 +42,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 +62,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 +165,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

@@ -1,107 +0,0 @@
-import { isUrl, getValidJson, parseSasViyaDebugResponse } from './utils'
-import { UploadFile } from './types/UploadFile'
-import { ErrorResponse, LoginRequiredError } from './types/errors'
-import { RequestClient } from './request/RequestClient'
-import { ServerType } from '@sasjs/utils/types'
-import SASjs from './SASjs'
-import { Server } from 'https'
-import { SASjsConfig } from './types'
-import { config } from 'process'
-
-export class FileUploader {
-  constructor(
-    private sasjsConfig: SASjsConfig,
-    private jobsPath: string,
-    private requestClient: RequestClient
-  ) {
-    if (this.sasjsConfig.serverUrl) isUrl(this.sasjsConfig.serverUrl)
-  }
-
-  public uploadFile(sasJob: string, files: UploadFile[], params: any) {
-    if (files?.length < 1)
-      return Promise.reject(
-        new ErrorResponse('At least one file must be provided.')
-      )
-    if (!sasJob || sasJob === '')
-      return Promise.reject(new ErrorResponse('sasJob must be provided.'))
-
-    let paramsString = ''
-
-    for (let param in params) {
-      if (params.hasOwnProperty(param)) {
-        paramsString += `&${param}=${params[param]}`
-      }
-    }
-
-    const program = this.sasjsConfig.appLoc
-      ? this.sasjsConfig.appLoc.replace(/\/?$/, '/') + sasJob.replace(/^\//, '')
-      : sasJob
-    const uploadUrl = `${this.jobsPath}/?${
-      '_program=' + program
-    }${paramsString}`
-
-    const formData = new FormData()
-
-    for (let file of files) {
-      formData.append('file', file.file, file.fileName)
-    }
-
-    const csrfToken = this.requestClient.getCsrfToken('file')
-    if (csrfToken) formData.append('_csrf', csrfToken.value)
-    if (this.sasjsConfig.debug) formData.append('_debug', '131')
-    if (
-      this.sasjsConfig.serverType === ServerType.SasViya &&
-      this.sasjsConfig.contextName
-    )
-      formData.append('_contextname', this.sasjsConfig.contextName)
-
-    const headers = {
-      'cache-control': 'no-cache',
-      Accept: '*/*',
-      '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,
-        this.sasjsConfig.debug,
-        true,
-        sasJob
-      )
-      .then(async (res) => {
-        if (
-          this.sasjsConfig.serverType === ServerType.SasViya &&
-          this.sasjsConfig.debug
-        ) {
-          const jsonResponse = await parseSasViyaDebugResponse(
-            res.result as string,
-            this.requestClient,
-            this.sasjsConfig.serverUrl
-          )
-          return jsonResponse
-        }
-
-        return typeof res.result === 'string'
-          ? getValidJson(res.result)
-          : res.result
-
-        //TODO: append to SASjs requests
-      })
-      .catch((err: Error) => {
-        if (err instanceof LoginRequiredError) {
-          return Promise.reject(
-            new ErrorResponse('You must be logged in to upload a file.', err)
-          )
-        }
-        return Promise.reject(
-          new ErrorResponse('File upload request failed.', err)
-        )
-      })
-  }
-}

src/SASViyaApiClient.ts

@@ -51,6 +51,16 @@ export class SASViyaApiClient {
   )
   private folderMap = new Map<string, Job[]>()
 
+  /**
+   * A helper method used to call appendRequest method of RequestClient
+   * @param response - response from sasjs request
+   * @param program - name of program
+   * @param debug - a boolean that indicates whether debug was enabled or not
+   */
+  public appendRequest(response: any, program: string, debug: boolean) {
+    this.requestClient!.appendRequest(response, program, debug)
+  }
+
   public get debug() {
     return this._debug
   }
@@ -782,24 +792,12 @@ export class SASViyaApiClient {
       jobResult = await this.requestClient.get<any>(
         `${this.serverUrl}${resultLink}/content`,
         access_token,
-        'text/plain',
-        {},
-        debug,
-        true,
-        sasJob
+        'text/plain'
       )
     }
     if (debug && logLink) {
       log = await this.requestClient
-        .get<any>(
-          `${this.serverUrl}${logLink.href}/content`,
-          access_token,
-          'application/json',
-          {},
-          debug,
-          true,
-          sasJob
-        )
+        .get<any>(`${this.serverUrl}${logLink.href}/content`, access_token)
         .then((res: any) => res.result.items.map((i: any) => i.line).join('\n'))
     }
     if (jobStatus === 'failed') {

src/SASjs.ts

@@ -1,8 +1,13 @@
 import { compareTimestamps, asyncForEach } from './utils'
-import { SASjsConfig, UploadFile, EditContextInput, PollOptions } from './types'
+import {
+  SASjsConfig,
+  UploadFile,
+  EditContextInput,
+  PollOptions,
+  LoginMechanism
+} from './types'
 import { SASViyaApiClient } from './SASViyaApiClient'
 import { SAS9ApiClient } from './SAS9ApiClient'
-import { FileUploader } from './FileUploader'
 import { AuthManager } from './auth'
 import {
   ServerType,
@@ -16,9 +21,11 @@ import {
   WebJobExecutor,
   ComputeJobExecutor,
   JesJobExecutor,
-  Sas9JobExecutor
+  Sas9JobExecutor,
+  FileUploader
 } from './job-execution'
 import { ErrorResponse } from './types/errors'
+import { LoginOptions, LoginResult } from './types/Login'
 
 const defaultConfig: SASjsConfig = {
   serverUrl: '',
@@ -29,7 +36,8 @@ const defaultConfig: SASjsConfig = {
   debug: false,
   contextName: 'SAS Job Execution compute context',
   useComputeApi: null,
-  allowInsecureRequests: false
+  allowInsecureRequests: false,
+  loginMechanism: LoginMechanism.Default
 }
 
 /**
@@ -50,7 +58,6 @@ export default class SASjs {
   private sas9JobExecutor: JobExecutor | null = null
 
   constructor(config?: any) {
-    console.log('from SASjs constructor')
     this.sasjsConfig = {
       ...defaultConfig,
       ...config
@@ -500,7 +507,7 @@ export default class SASjs {
       ...this.sasjsConfig,
       ...config
     }
-    await this.setupConfiguration()
+    this.setupConfiguration()
   }
 
   /**
@@ -527,8 +534,27 @@ export default class SASjs {
    * @param username - a string representing the username.
    * @param password - a string representing the password.
    */
-  public async logIn(username: string, password: string) {
-    return this.authManager!.logIn(username, password)
+  public async logIn(
+    username?: string,
+    password?: string,
+    options: LoginOptions = {}
+  ): Promise<LoginResult> {
+    if (this.sasjsConfig.loginMechanism === LoginMechanism.Default) {
+      if (!username || !password) {
+        throw new Error(
+          'A username and password are required when using the default login mechanism.'
+        )
+      }
+      return this.authManager!.logIn(username, password)
+    }
+
+    if (typeof window === typeof undefined) {
+      throw new Error(
+        'The redirected login mechanism is only available for use in the browser.'
+      )
+    }
+
+    return this.authManager!.redirectedLogIn(options)
   }
 
   /**
@@ -545,24 +571,32 @@ export default class SASjs {
    *  Process). Is prepended at runtime with the value of `appLoc`.
    * @param files - array of files to be uploaded, including File object and file name.
    * @param params - request URL parameters.
-   * @param overrideSasjsConfig - object to override existing config (optional)
+   * @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 - a function that is called if the
+   * user is not logged in (eg to display a login form). The request will be
+   * resubmitted after successful login.
    */
-  public uploadFile(
+  public async uploadFile(
     sasJob: string,
     files: UploadFile[],
-    params: any,
-    overrideSasjsConfig?: any
+    params: { [key: string]: any } | null,
+    config: { [key: string]: any } = {},
+    loginRequiredCallback?: () => any
   ) {
-    const fileUploader = overrideSasjsConfig
-      ? new FileUploader(
-          { ...this.sasjsConfig, ...overrideSasjsConfig },
-          this.jobsPath,
-          this.requestClient!
-        )
-      : this.fileUploader ||
-        new FileUploader(this.sasjsConfig, this.jobsPath, this.requestClient!)
+    config = {
+      ...this.sasjsConfig,
+      ...config
+    }
+    const data = { files, params }
 
-    return fileUploader.uploadFile(sasJob, files, params)
+    return await this.fileUploader!.execute(
+      sasJob,
+      data,
+      config,
+      loginRequiredCallback
+    )
   }
 
   /**
@@ -612,7 +646,6 @@ export default class SASjs {
         config.useComputeApi !== null
       ) {
         if (config.useComputeApi) {
-          console.log(615)
           return await this.computeJobExecutor!.execute(
             sasJob,
             data,
@@ -849,6 +882,7 @@ export default class SASjs {
     await this.webJobExecutor?.resendWaitingRequests()
     await this.computeJobExecutor?.resendWaitingRequests()
     await this.jesJobExecutor?.resendWaitingRequests()
+    await this.fileUploader?.resendWaitingRequests()
   }
 
   /**
@@ -885,10 +919,8 @@ export default class SASjs {
    * @returns SASjsRequest[]
    */
   public getSasRequests() {
-    console.log('from getSASRequests')
-    const requests = this.requestClient!.getRequests()
+    const requests = [...this.requestClient!.getRequests()]
     const sortedRequests = requests.sort(compareTimestamps)
-    console.log('sortedRequests', sortedRequests)
     return sortedRequests
   }
 
@@ -916,10 +948,17 @@ export default class SASjs {
       this.sasjsConfig.serverUrl = this.sasjsConfig.serverUrl.slice(0, -1)
     }
 
-    this.requestClient = new RequestClient(
-      this.sasjsConfig.serverUrl,
-      this.sasjsConfig.allowInsecureRequests
-    )
+    if (!this.requestClient) {
+      this.requestClient = new RequestClient(
+        this.sasjsConfig.serverUrl,
+        this.sasjsConfig.allowInsecureRequests
+      )
+    } else {
+      this.requestClient.setConfig(
+        this.sasjsConfig.serverUrl,
+        this.sasjsConfig.allowInsecureRequests
+      )
+    }
 
     this.jobsPath =
       this.sasjsConfig.serverType === ServerType.SasViya
@@ -961,7 +1000,8 @@ export default class SASjs {
     }
 
     this.fileUploader = new FileUploader(
-      this.sasjsConfig,
+      this.sasjsConfig.serverUrl,
+      this.sasjsConfig.serverType!,
       this.jobsPath,
       this.requestClient
     )

src/api/viya/executeScript.ts

@@ -239,15 +239,7 @@ export async function executeScript(
     const resultLink = `/compute/sessions/${executionSessionId}/filerefs/_webout/content`
 
     jobResult = await requestClient
-      .get<any>(
-        resultLink,
-        access_token,
-        'text/plain',
-        {},
-        debug,
-        true,
-        jobPath
-      )
+      .get<any>(resultLink, access_token, 'text/plain')
       .catch(async (e) => {
         if (e instanceof NotFoundError) {
           if (logLink) {

src/api/viya/pollJobState.ts

@@ -4,7 +4,7 @@ import { getTokens } from '../../auth/getTokens'
 import { RequestClient } from '../../request/RequestClient'
 import { JobStatePollError } from '../../types/errors'
 import { Link, WriteStream } from '../../types'
-import { isNode } from '../../utils'
+import { delay, isNode } from '../../utils'
 
 export async function pollJobState(
   requestClient: RequestClient,
@@ -246,5 +246,3 @@ const doPoll = async (
 
   return { state, pollCount }
 }
-
-const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))

src/auth/AuthManager.ts

@@ -1,11 +1,16 @@
 import { ServerType } from '@sasjs/utils/types'
 import { RequestClient } from '../request/RequestClient'
+import { LoginOptions, LoginResult } from '../types/Login'
 import { serialize } from '../utils'
+import { openWebPage } from './openWebPage'
+import { verifySas9Login } from './verifySas9Login'
+import { verifySasViyaLogin } from './verifySasViyaLogin'
 
 export class AuthManager {
   public userName = ''
   private loginUrl: string
   private logoutUrl: string
+  private redirectedLoginUrl = `/SASLogon/home`
   constructor(
     private serverUrl: string,
     private serverType: ServerType,
@@ -19,65 +24,137 @@ export class AuthManager {
         : '/SASLogon/logout.do?'
   }
 
+  /**
+   * Opens Pop up window to SAS Login screen.
+   * And checks if user has finished login process.
+   */
+  public async redirectedLogIn({
+    onLoggedOut
+  }: LoginOptions): Promise<LoginResult> {
+    const { isLoggedIn: isLoggedInAlready, userName: currentSessionUsername } =
+      await this.fetchUserName()
+
+    if (isLoggedInAlready) {
+      await this.loginCallback()
+
+      return {
+        isLoggedIn: true,
+        userName: currentSessionUsername
+      }
+    }
+
+    const loginPopup = await openWebPage(
+      this.redirectedLoginUrl,
+      'SASLogon',
+      {
+        width: 500,
+        height: 600
+      },
+      onLoggedOut
+    )
+
+    if (!loginPopup) {
+      return { isLoggedIn: false, userName: '' }
+    }
+
+    const { isLoggedIn } =
+      this.serverType === ServerType.SasViya
+        ? await verifySasViyaLogin(loginPopup)
+        : await verifySas9Login(loginPopup)
+
+    loginPopup.close()
+
+    if (isLoggedIn) {
+      if (this.serverType === ServerType.Sas9) {
+        await this.performCASSecurityCheck()
+      }
+
+      const { userName } = await this.fetchUserName()
+
+      await this.loginCallback()
+
+      return { isLoggedIn: true, userName }
+    }
+
+    return { isLoggedIn: false, userName: '' }
+  }
+
   /**
    * 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<LoginResult> {
+    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 {
+        await this.logOut()
+        loginForm = await this.getNewLoginForm()
       }
-    }
+    } 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`
-
-        await this.requestClient.get<string>(
-          `/SASLogon/login?service=${casAuthenticationUrl}`,
-          undefined
-        )
+        await this.performCASSecurityCheck()
       }
 
       this.loginCallback()
-    }
+    } else this.userName = ''
 
     return {
-      isLoggedIn: !!loggedIn,
+      isLoggedIn,
       userName: this.userName
     }
   }
 
+  private async performCASSecurityCheck() {
+    const casAuthenticationUrl = `${this.serverUrl}/SASStoredProcess/j_spring_cas_security_check`
+
+    await this.requestClient.get<string>(
+      `/SASLogon/login?service=${casAuthenticationUrl}`,
+      undefined
+    )
+  }
+
   private async sendLoginRequest(
     loginForm: { [key: string]: any },
     loginParams: { [key: string]: any }
@@ -103,14 +180,53 @@ 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
+  }> {
+    const { isLoggedIn, userName } = await this.fetchUserName()
+    let loginForm = null
+
+    if (!isLoggedIn) {
+      //We will logout to make sure cookies are removed and login form is presented
+      //Residue can happen in case of session expiration
+      await this.logOut()
+
+      loginForm = await this.getNewLoginForm()
+    }
+
+    return Promise.resolve({
+      isLoggedIn,
+      userName: userName.toLowerCase(),
+      loginForm
+    })
+  }
+
+  private async getNewLoginForm() {
+    const { result: formResponse } = await this.requestClient.get<string>(
+      this.loginUrl.replace('.do', ''),
+      undefined,
+      'text/plain'
+    )
+
+    return await this.getLoginForm(formResponse)
+  }
+
+  private async fetchUserName(): Promise<{
+    isLoggedIn: boolean
+    userName: string
+  }> {
     //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.serverType === ServerType.SasViya
+        ? `${this.serverUrl}/identities/users/@currentUser`
         : `${this.serverUrl}/SASStoredProcess`
 
     const { result: loginResponse } = await this.requestClient
@@ -120,27 +236,27 @@ export class AuthManager {
       })
 
     const isLoggedIn = loginResponse !== 'authErr'
-    let loginForm = null
+    const userName = isLoggedIn ? this.extractUserName(loginResponse) : ''
 
-    if (!isLoggedIn) {
-      //We will logout to make sure cookies are removed and login form is presented
-      //Residue can happen in case of session expiration
-      await this.logOut()
+    return { isLoggedIn, userName }
+  }
 
-      const { result: formResponse } = await this.requestClient.get<string>(
-        this.loginUrl.replace('.do', ''),
-        undefined,
-        'text/plain'
-      )
+  private extractUserName = (response: any): string => {
+    switch (this.serverType) {
+      case ServerType.SasViya:
+        return response?.id
 
-      loginForm = await this.getLoginForm(formResponse)
+      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('')
     }
-
-    return Promise.resolve({
-      isLoggedIn,
-      userName: this.userName,
-      loginForm
-    })
   }
 
   private getLoginForm(response: any) {

src/auth/openWebPage.ts

@@ -0,0 +1,40 @@
+import { openLoginPrompt } from '../utils/loginPrompt'
+
+interface WindowFeatures {
+  width: number
+  height: number
+}
+
+const defaultWindowFeatures: WindowFeatures = { width: 500, height: 600 }
+
+export async function openWebPage(
+  url: string,
+  windowName: string = '',
+  WindowFeatures: WindowFeatures = defaultWindowFeatures,
+  onLoggedOut?: () => Promise<Boolean>
+): Promise<Window | null> {
+  const { width, height } = WindowFeatures
+  const left = screen.width / 2 - width / 2
+  const top = screen.height / 2 - height / 2
+
+  const loginPopup = window.open(
+    url,
+    windowName,
+    `toolbar=0,location=0,menubar=0,width=${width},height=${height},left=${left},top=${top}`
+  )
+
+  if (!loginPopup) {
+    const getUserAction: () => Promise<Boolean> = onLoggedOut ?? openLoginPrompt
+
+    const doLogin = await getUserAction()
+    return doLogin
+      ? window.open(
+          url,
+          windowName,
+          `toolbar=0,location=0,menubar=0,width=${width},height=${height},left=${left},top=${top}`
+        )
+      : null
+  }
+
+  return loginPopup
+}

src/auth/spec/AuthManager.spec.ts

@@ -3,10 +3,14 @@ import * as dotenv from 'dotenv'
 import { ServerType } from '@sasjs/utils/types'
 import axios from 'axios'
 import {
+  mockedCurrentUserApi,
   mockLoginAuthoriseRequiredResponse,
   mockLoginSuccessResponse
 } from './mockResponses'
 import { serialize } from '../../utils'
+import * as openWebPageModule from '../openWebPage'
+import * as verifySasViyaLoginModule from '../verifySasViyaLogin'
+import * as verifySas9LoginModule from '../verifySas9Login'
 import { RequestClient } from '../../request/RequestClient'
 jest.mock('axios')
 const mockedAxios = axios as jest.Mocked<typeof axios>
@@ -57,134 +61,614 @@ describe('AuthManager', () => {
     expect((authManager as any).logoutUrl).toEqual('/SASLogon/logout?')
   })
 
-  it('should call the auth callback and return when already logged in', async () => {
-    const authManager = new AuthManager(
-      serverUrl,
-      serverType,
-      requestClient,
-      authCallback
-    )
-    jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
-      Promise.resolve({
-        isLoggedIn: true,
-        userName: 'test',
-        loginForm: 'test'
-      })
-    )
+  describe('login - default mechanism', () => {
+    it('should call the auth callback and return when already logged in', async () => {
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
+        Promise.resolve({
+          isLoggedIn: true,
+          userName,
+          loginForm: 'test'
+        })
+      )
 
-    const loginResponse = await authManager.logIn(userName, password)
+      const loginResponse = await authManager.logIn(userName, password)
 
-    expect(loginResponse.isLoggedIn).toBeTruthy()
-    expect(loginResponse.userName).toEqual(userName)
-    expect(authCallback).toHaveBeenCalledTimes(1)
-  })
-
-  it('should post a login request to the server if not logged in', async () => {
-    const authManager = new AuthManager(
-      serverUrl,
-      serverType,
-      requestClient,
-      authCallback
-    )
-    jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
-      Promise.resolve({
-        isLoggedIn: false,
-        userName: 'test',
-        loginForm: { name: 'test' }
-      })
-    )
-    mockedAxios.post.mockImplementation(() =>
-      Promise.resolve({ data: mockLoginSuccessResponse })
-    )
-
-    const loginResponse = await authManager.logIn(userName, password)
-
-    expect(loginResponse.isLoggedIn).toBeTruthy()
-    expect(loginResponse.userName).toEqual(userName)
-
-    const loginParams = serialize({
-      _service: 'default',
-      username: userName,
-      password,
-      name: 'test'
+      expect(loginResponse.isLoggedIn).toBeTruthy()
+      expect(loginResponse.userName).toEqual(userName)
+      expect(authCallback).toHaveBeenCalledTimes(1)
     })
-    expect(mockedAxios.post).toHaveBeenCalledWith(
-      `/SASLogon/login`,
-      loginParams,
-      {
-        withCredentials: true,
-        headers: {
-          'Content-Type': 'application/x-www-form-urlencoded',
-          Accept: '*/*'
+
+    it('should post a login request to the server when already logged in with other username', async () => {
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
+        Promise.resolve({
+          isLoggedIn: true,
+          userName: 'someOtherUsername',
+          loginForm: null
+        })
+      )
+      jest
+        .spyOn(authManager, 'logOut')
+        .mockImplementation(() => Promise.resolve(true))
+
+      jest
+        .spyOn<any, any>(authManager, 'getNewLoginForm')
+        .mockImplementation(() =>
+          Promise.resolve({
+            name: 'test'
+          })
+        )
+      mockedAxios.post.mockImplementation(() =>
+        Promise.resolve({ data: mockLoginSuccessResponse })
+      )
+
+      const loginResponse = await authManager.logIn(userName, password)
+
+      expect(loginResponse.isLoggedIn).toBeTruthy()
+      expect(loginResponse.userName).toEqual(userName)
+
+      const loginParams = serialize({
+        _service: 'default',
+        username: userName,
+        password,
+        name: 'test'
+      })
+      expect(authCallback).toHaveBeenCalledTimes(1)
+      expect(authManager.logOut).toHaveBeenCalledTimes(1)
+      expect(authManager['getNewLoginForm']).toHaveBeenCalledTimes(1)
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        `/SASLogon/login`,
+        loginParams,
+        {
+          withCredentials: true,
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Accept: '*/*'
+          }
         }
-      }
-    )
-    expect(authCallback).toHaveBeenCalledTimes(1)
+      )
+      expect(authCallback).toHaveBeenCalledTimes(1)
+    })
+
+    it('should post a login request to the server when not logged in', async () => {
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
+        Promise.resolve({
+          isLoggedIn: false,
+          userName: '',
+          loginForm: { name: 'test' }
+        })
+      )
+      mockedAxios.post.mockImplementation(() =>
+        Promise.resolve({ data: mockLoginSuccessResponse })
+      )
+
+      const loginResponse = await authManager.logIn(userName, password)
+
+      expect(loginResponse.isLoggedIn).toBeTruthy()
+      expect(loginResponse.userName).toEqual(userName)
+
+      const loginParams = serialize({
+        _service: 'default',
+        username: userName,
+        password,
+        name: 'test'
+      })
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        `/SASLogon/login`,
+        loginParams,
+        {
+          withCredentials: true,
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Accept: '*/*'
+          }
+        }
+      )
+      expect(authCallback).toHaveBeenCalledTimes(1)
+    })
+
+    it('should post a login & a cas_security request to the SAS9 server when not logged in', async () => {
+      const serverType = ServerType.Sas9
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
+        Promise.resolve({
+          isLoggedIn: false,
+          userName: '',
+          loginForm: { name: 'test' }
+        })
+      )
+      mockedAxios.post.mockImplementation(() =>
+        Promise.resolve({ data: mockLoginSuccessResponse })
+      )
+      mockedAxios.get.mockImplementation(() => Promise.resolve({ status: 200 }))
+
+      const loginResponse = await authManager.logIn(userName, password)
+
+      expect(loginResponse.isLoggedIn).toBeTruthy()
+      expect(loginResponse.userName).toEqual(userName)
+
+      const loginParams = serialize({
+        _service: 'default',
+        username: userName,
+        password,
+        name: 'test'
+      })
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        `/SASLogon/login`,
+        loginParams,
+        {
+          withCredentials: true,
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Accept: '*/*'
+          }
+        }
+      )
+      const casAuthenticationUrl = `${serverUrl}/SASStoredProcess/j_spring_cas_security_check`
+      expect(mockedAxios.get).toHaveBeenCalledWith(
+        `/SASLogon/login?service=${casAuthenticationUrl}`,
+        getHeadersJson
+      )
+      expect(authCallback).toHaveBeenCalledTimes(1)
+    })
+
+    it('should return empty username if unable to logged in', async () => {
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
+        Promise.resolve({
+          isLoggedIn: false,
+          userName: '',
+          loginForm: { name: 'test' }
+        })
+      )
+      mockedAxios.post.mockImplementation(() =>
+        Promise.resolve({ data: 'Not Signed in' })
+      )
+
+      const loginResponse = await authManager.logIn(userName, password)
+
+      expect(loginResponse.isLoggedIn).toBeFalsy()
+      expect(loginResponse.userName).toEqual('')
+
+      const loginParams = serialize({
+        _service: 'default',
+        username: userName,
+        password,
+        name: 'test'
+      })
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        `/SASLogon/login`,
+        loginParams,
+        {
+          withCredentials: true,
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Accept: '*/*'
+          }
+        }
+      )
+    })
+
+    it('should parse and submit the authorisation form when necessary', async () => {
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      jest
+        .spyOn(requestClient, 'authorize')
+        .mockImplementation(() => Promise.resolve())
+      jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
+        Promise.resolve({
+          isLoggedIn: false,
+          userName: 'test',
+          loginForm: { name: 'test' }
+        })
+      )
+      mockedAxios.post.mockImplementationOnce(() =>
+        Promise.resolve({
+          data: mockLoginAuthoriseRequiredResponse,
+          config: { url: 'https://test.com/SASLogon/login' },
+          request: { responseURL: 'https://test.com/OAuth/authorize' }
+        })
+      )
+
+      mockedAxios.get.mockImplementationOnce(() =>
+        Promise.resolve({
+          data: mockLoginAuthoriseRequiredResponse
+        })
+      )
+
+      await authManager.logIn(userName, password)
+
+      expect(requestClient.authorize).toHaveBeenCalledWith(
+        mockLoginAuthoriseRequiredResponse
+      )
+    })
   })
 
-  it('should parse and submit the authorisation form when necessary', async () => {
-    const authManager = new AuthManager(
-      serverUrl,
-      serverType,
-      requestClient,
-      authCallback
-    )
-    jest
-      .spyOn(requestClient, 'authorize')
-      .mockImplementation(() => Promise.resolve())
-    jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
-      Promise.resolve({
-        isLoggedIn: false,
-        userName: 'test',
-        loginForm: { name: 'test' }
-      })
-    )
-    mockedAxios.post.mockImplementationOnce(() =>
-      Promise.resolve({
-        data: mockLoginAuthoriseRequiredResponse,
-        config: { url: 'https://test.com/SASLogon/login' },
-        request: { responseURL: 'https://test.com/OAuth/authorize' }
-      })
-    )
+  describe('login - redirect mechanism', () => {
+    beforeAll(() => {
+      jest.mock('../openWebPage')
+      jest
+        .spyOn(openWebPageModule, 'openWebPage')
+        .mockImplementation(() =>
+          Promise.resolve({ close: jest.fn() } as unknown as Window)
+        )
+      jest.mock('../verifySasViyaLogin')
+      jest
+        .spyOn(verifySasViyaLoginModule, 'verifySasViyaLogin')
+        .mockImplementation(() => Promise.resolve({ isLoggedIn: true }))
+      jest.mock('../verifySas9Login')
+      jest
+        .spyOn(verifySas9LoginModule, 'verifySas9Login')
+        .mockImplementation(() => Promise.resolve({ isLoggedIn: true }))
+    })
 
-    mockedAxios.get.mockImplementationOnce(() =>
-      Promise.resolve({
-        data: mockLoginAuthoriseRequiredResponse
-      })
-    )
+    it('should call the auth callback and return when already logged in', async () => {
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      jest
+        .spyOn<any, any>(authManager, 'fetchUserName')
+        .mockImplementation(() =>
+          Promise.resolve({
+            isLoggedIn: true,
+            userName
+          })
+        )
 
-    await authManager.logIn(userName, password)
+      const loginResponse = await authManager.redirectedLogIn({})
 
-    expect(requestClient.authorize).toHaveBeenCalledWith(
-      mockLoginAuthoriseRequiredResponse
-    )
+      expect(loginResponse.isLoggedIn).toBeTruthy()
+      expect(loginResponse.userName).toEqual(userName)
+      expect(authCallback).toHaveBeenCalledTimes(1)
+    })
+
+    it('should perform login via pop up if not logged in', async () => {
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      jest
+        .spyOn<any, any>(authManager, 'fetchUserName')
+        .mockImplementationOnce(() =>
+          Promise.resolve({
+            isLoggedIn: false,
+            userName: ''
+          })
+        )
+        .mockImplementationOnce(() =>
+          Promise.resolve({
+            isLoggedIn: true,
+            userName
+          })
+        )
+
+      const loginResponse = await authManager.redirectedLogIn({})
+
+      expect(loginResponse.isLoggedIn).toBeTruthy()
+      expect(loginResponse.userName).toEqual(userName)
+
+      expect(openWebPageModule.openWebPage).toHaveBeenCalledWith(
+        `/SASLogon/home`,
+        'SASLogon',
+        {
+          width: 500,
+          height: 600
+        },
+        undefined
+      )
+      expect(authManager['fetchUserName']).toHaveBeenCalledTimes(2)
+      expect(verifySasViyaLoginModule.verifySasViyaLogin).toHaveBeenCalledTimes(
+        1
+      )
+      expect(authCallback).toHaveBeenCalledTimes(1)
+    })
+
+    it('should perform login via pop up if not logged in with server sas9', async () => {
+      const serverType = ServerType.Sas9
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      jest
+        .spyOn<any, any>(authManager, 'fetchUserName')
+        .mockImplementationOnce(() =>
+          Promise.resolve({
+            isLoggedIn: false,
+            userName: ''
+          })
+        )
+        .mockImplementationOnce(() =>
+          Promise.resolve({
+            isLoggedIn: true,
+            userName
+          })
+        )
+
+      const loginResponse = await authManager.redirectedLogIn({})
+
+      expect(loginResponse.isLoggedIn).toBeTruthy()
+      expect(loginResponse.userName).toEqual(userName)
+
+      expect(openWebPageModule.openWebPage).toHaveBeenCalledWith(
+        `/SASLogon/home`,
+        'SASLogon',
+        {
+          width: 500,
+          height: 600
+        },
+        undefined
+      )
+      expect(authManager['fetchUserName']).toHaveBeenCalledTimes(2)
+      expect(verifySas9LoginModule.verifySas9Login).toHaveBeenCalledTimes(1)
+      expect(authCallback).toHaveBeenCalledTimes(1)
+    })
+
+    it('should return empty username if user unable to re-login via pop up', async () => {
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      jest
+        .spyOn<any, any>(authManager, 'fetchUserName')
+        .mockImplementationOnce(() =>
+          Promise.resolve({
+            isLoggedIn: false,
+            userName: ''
+          })
+        )
+        .mockImplementationOnce(() =>
+          Promise.resolve({
+            isLoggedIn: true,
+            userName
+          })
+        )
+      jest
+        .spyOn(verifySasViyaLoginModule, 'verifySasViyaLogin')
+        .mockImplementation(() => Promise.resolve({ isLoggedIn: false }))
+
+      const loginResponse = await authManager.redirectedLogIn({})
+
+      expect(loginResponse.isLoggedIn).toBeFalsy()
+      expect(loginResponse.userName).toEqual('')
+
+      expect(openWebPageModule.openWebPage).toHaveBeenCalledWith(
+        `/SASLogon/home`,
+        'SASLogon',
+        {
+          width: 500,
+          height: 600
+        },
+        undefined
+      )
+      expect(authManager['fetchUserName']).toHaveBeenCalledTimes(1)
+
+      expect(authCallback).toHaveBeenCalledTimes(0)
+    })
+
+    it('should return empty username if user rejects to re-login', async () => {
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      jest
+        .spyOn<any, any>(authManager, 'fetchUserName')
+        .mockImplementationOnce(() =>
+          Promise.resolve({
+            isLoggedIn: false,
+            userName: ''
+          })
+        )
+        .mockImplementationOnce(() =>
+          Promise.resolve({
+            isLoggedIn: true,
+            userName
+          })
+        )
+      jest
+        .spyOn(openWebPageModule, 'openWebPage')
+        .mockImplementation(() => Promise.resolve(null))
+
+      const loginResponse = await authManager.redirectedLogIn({})
+
+      expect(loginResponse.isLoggedIn).toBeFalsy()
+      expect(loginResponse.userName).toEqual('')
+
+      expect(openWebPageModule.openWebPage).toHaveBeenCalledWith(
+        `/SASLogon/home`,
+        'SASLogon',
+        {
+          width: 500,
+          height: 600
+        },
+        undefined
+      )
+      expect(authManager['fetchUserName']).toHaveBeenCalledTimes(1)
+
+      expect(authCallback).toHaveBeenCalledTimes(0)
+    })
   })
 
-  it('should check and return session information if logged in', async () => {
-    const authManager = new AuthManager(
-      serverUrl,
-      serverType,
-      requestClient,
-      authCallback
-    )
-    mockedAxios.get.mockImplementation(() =>
-      Promise.resolve({ data: '<button onClick="logout">' })
-    )
+  describe('checkSession', () => {
+    it('return session information when logged in', async () => {
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      mockedAxios.get.mockImplementation(() =>
+        Promise.resolve({ data: mockedCurrentUserApi(userName) })
+      )
 
-    const response = await authManager.checkSession()
-    expect(response.isLoggedIn).toBeTruthy()
-    expect(mockedAxios.get).toHaveBeenNthCalledWith(
-      1,
-      `http://test-server.com/identities`,
-      {
-        withCredentials: true,
-        responseType: 'text',
-        transformResponse: undefined,
-        headers: {
-          Accept: '*/*',
-          'Content-Type': 'text/plain'
+      const response = await authManager.checkSession()
+      expect(response.isLoggedIn).toBeTruthy()
+      expect(response.userName).toEqual(userName)
+      expect(mockedAxios.get).toHaveBeenNthCalledWith(
+        1,
+        `http://test-server.com/identities/users/@currentUser`,
+        {
+          withCredentials: true,
+          responseType: 'text',
+          transformResponse: undefined,
+          headers: {
+            Accept: '*/*',
+            'Content-Type': 'text/plain'
+          }
         }
-      }
-    )
+      )
+    })
+
+    it('return session information when logged in - SAS9', async () => {
+      // username cannot have `-` and cannot be uppercased
+      const username = 'testusername'
+      const serverType = ServerType.Sas9
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      mockedAxios.get.mockImplementation(() =>
+        Promise.resolve({
+          data: `"title":"Log Off ${username}","url":"javascript: clearFrame(\"/SASStoredProcess/do?_action=logoff\")"' })`
+        })
+      )
+
+      const response = await authManager.checkSession()
+      expect(response.isLoggedIn).toBeTruthy()
+      expect(response.userName).toEqual(username)
+      expect(mockedAxios.get).toHaveBeenNthCalledWith(
+        1,
+        `http://test-server.com/SASStoredProcess`,
+        {
+          withCredentials: true,
+          responseType: 'text',
+          transformResponse: undefined,
+          headers: {
+            Accept: '*/*',
+            'Content-Type': 'text/plain'
+          }
+        }
+      )
+    })
+
+    it('return session information when logged in - SAS9 - having full name in html', async () => {
+      const fullname = 'FirstName LastName'
+      const username = 'firlas'
+      const serverType = ServerType.Sas9
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      mockedAxios.get.mockImplementation(() =>
+        Promise.resolve({
+          data: `"title":"Log Off ${fullname}","url":"javascript: clearFrame(\"/SASStoredProcess/do?_action=logoff\")"' })`
+        })
+      )
+
+      const response = await authManager.checkSession()
+      expect(response.isLoggedIn).toBeTruthy()
+      expect(response.userName).toEqual(username)
+      expect(mockedAxios.get).toHaveBeenNthCalledWith(
+        1,
+        `http://test-server.com/SASStoredProcess`,
+        {
+          withCredentials: true,
+          responseType: 'text',
+          transformResponse: undefined,
+          headers: {
+            Accept: '*/*',
+            'Content-Type': 'text/plain'
+          }
+        }
+      )
+    })
+
+    it('perform logout when not logged in', async () => {
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      mockedAxios.get
+        .mockImplementationOnce(() => Promise.resolve({ status: 401 }))
+        .mockImplementation(() => Promise.resolve({}))
+
+      const response = await authManager.checkSession()
+      expect(response.isLoggedIn).toBeFalsy()
+      expect(response.userName).toEqual('')
+      expect(mockedAxios.get).toHaveBeenNthCalledWith(
+        1,
+        `http://test-server.com/identities/users/@currentUser`,
+        {
+          withCredentials: true,
+          responseType: 'text',
+          transformResponse: undefined,
+          headers: {
+            Accept: '*/*',
+            'Content-Type': 'text/plain'
+          }
+        }
+      )
+      expect(mockedAxios.get).toHaveBeenNthCalledWith(
+        2,
+        `/SASLogon/logout.do?`,
+        getHeadersJson
+      )
+    })
   })
 })
+
+const getHeadersJson = {
+  withCredentials: true,
+  headers: {
+    'Content-Type': 'application/json',
+    Accept: 'application/json'
+  },
+  responseType: 'json'
+}

src/auth/spec/mockResponses.ts

@@ -22,3 +22,28 @@ export const generateToken = (timeToLiveSeconds: number): string => {
   const token = `${header}.${payload}.${signature}`
   return token
 }
+
+export const mockedCurrentUserApi = (username: string) => ({
+  creationTimeStamp: '2021-04-17T14:13:14.000Z',
+  modifiedTimeStamp: '2021-08-31T22:08:07.000Z',
+  id: username,
+  type: 'user',
+  name: 'Full User Name',
+  links: [
+    {
+      method: 'GET',
+      rel: 'self',
+      href: `/identities/users/${username}`,
+      uri: `/identities/users/${username}`,
+      type: 'user'
+    },
+    {
+      method: 'GET',
+      rel: 'alternate',
+      href: `/identities/users/${username}`,
+      uri: `/identities/users/${username}`,
+      type: 'application/vnd.sas.summary'
+    }
+  ],
+  version: 2
+})

src/auth/spec/openWebPage.spec.ts

@@ -0,0 +1,64 @@
+/**
+ * @jest-environment jsdom
+ */
+import { openWebPage } from '../openWebPage'
+import * as loginPromptModule from '../../utils/loginPrompt'
+
+describe('openWebPage', () => {
+  const serverUrl = 'http://test-server.com'
+
+  describe('window.open is not blocked', () => {
+    const mockedOpen = jest
+      .fn()
+      .mockImplementation(() => ({} as unknown as Window))
+    const originalOpen = window.open
+
+    beforeAll(() => {
+      window.open = mockedOpen
+    })
+    afterAll(() => {
+      window.open = originalOpen
+    })
+
+    it(`should return new Window popup - using default adapter's dialog`, async () => {
+      await expect(openWebPage(serverUrl)).resolves.toBeDefined()
+
+      expect(mockedOpen).toBeCalled()
+    })
+  })
+
+  describe('window.open is blocked', () => {
+    const mockedOpen = jest.fn().mockImplementation(() => null)
+    const originalOpen = window.open
+
+    beforeAll(() => {
+      window.open = mockedOpen
+    })
+    afterAll(() => {
+      window.open = originalOpen
+    })
+
+    it(`should return new Window popup - using default adapter's dialog`, async () => {
+      jest.mock('../../utils/loginPrompt')
+      jest
+        .spyOn(loginPromptModule, 'openLoginPrompt')
+        .mockImplementation(() => Promise.resolve(true))
+
+      await expect(openWebPage(serverUrl)).resolves.toBeDefined()
+      expect(loginPromptModule.openLoginPrompt).toBeCalled()
+      expect(mockedOpen).toBeCalled()
+    })
+
+    it(`should return new Window popup - using frontend's provided onloggedOut`, async () => {
+      const onLoggedOut = jest
+        .fn()
+        .mockImplementation(() => Promise.resolve(true))
+
+      await expect(
+        openWebPage(serverUrl, undefined, undefined, onLoggedOut)
+      ).resolves.toBeDefined()
+      expect(onLoggedOut).toBeCalled()
+      expect(mockedOpen).toBeCalled()
+    })
+  })
+})

src/auth/spec/verifySas9Login.spec.ts

@@ -0,0 +1,37 @@
+/**
+ * @jest-environment jsdom
+ */
+import { verifySas9Login } from '../verifySas9Login'
+import * as delayModule from '../../utils/delay'
+
+describe('verifySas9Login', () => {
+  const serverUrl = 'http://test-server.com'
+
+  beforeAll(() => {
+    jest.mock('../../utils')
+    jest
+      .spyOn(delayModule, 'delay')
+      .mockImplementation(() => Promise.resolve({}))
+  })
+
+  it('should return isLoggedIn true by checking state of popup', async () => {
+    const popup = {
+      window: {
+        location: { href: serverUrl + `/SASLogon/home` },
+        document: { body: { innerText: '<h3>You have signed in.</h3>' } }
+      }
+    } as unknown as Window
+
+    await expect(verifySas9Login(popup)).resolves.toEqual({
+      isLoggedIn: true
+    })
+  })
+
+  it('should return isLoggedIn false if user closed popup, already', async () => {
+    const popup: Window = { closed: true } as unknown as Window
+
+    await expect(verifySas9Login(popup)).resolves.toEqual({
+      isLoggedIn: false
+    })
+  })
+})

src/auth/spec/verifySasViyaLogin.spec.ts

@@ -0,0 +1,38 @@
+/**
+ * @jest-environment jsdom
+ */
+import { verifySasViyaLogin } from '../verifySasViyaLogin'
+import * as delayModule from '../../utils/delay'
+
+describe('verifySasViyaLogin', () => {
+  const serverUrl = 'http://test-server.com'
+
+  beforeAll(() => {
+    jest.mock('../../utils')
+    jest
+      .spyOn(delayModule, 'delay')
+      .mockImplementation(() => Promise.resolve({}))
+    document.cookie = encodeURIComponent('Current-User={"userId":"user-hash"}')
+  })
+
+  it('should return isLoggedIn true by checking state of popup', async () => {
+    const popup = {
+      window: {
+        location: { href: serverUrl + `/SASLogon/home` },
+        document: { body: { innerText: '<h3>You have signed in.</h3>' } }
+      }
+    } as unknown as Window
+
+    await expect(verifySasViyaLogin(popup)).resolves.toEqual({
+      isLoggedIn: true
+    })
+  })
+
+  it('should return isLoggedIn false if user closed popup, already', async () => {
+    const popup: Window = { closed: true } as unknown as Window
+
+    await expect(verifySasViyaLogin(popup)).resolves.toEqual({
+      isLoggedIn: false
+    })
+  })
+})

src/auth/verifySas9Login.ts

@@ -0,0 +1,20 @@
+import { delay } from '../utils'
+
+export async function verifySas9Login(loginPopup: Window): Promise<{
+  isLoggedIn: boolean
+}> {
+  let isLoggedIn = false
+  let startTime = new Date()
+  let elapsedSeconds = 0
+  do {
+    await delay(1000)
+    if (loginPopup.closed) break
+
+    isLoggedIn =
+      loginPopup.window.location.href.includes('SASLogon') &&
+      loginPopup.window.document.body.innerText.includes('You have signed in.')
+    elapsedSeconds = (new Date().valueOf() - startTime.valueOf()) / 1000
+  } while (!isLoggedIn && elapsedSeconds < 5 * 60)
+
+  return { isLoggedIn }
+}

src/auth/verifySasViyaLogin.ts

@@ -0,0 +1,33 @@
+import { delay } from '../utils'
+
+export async function verifySasViyaLogin(loginPopup: Window): Promise<{
+  isLoggedIn: boolean
+}> {
+  let isLoggedIn = false
+  let startTime = new Date()
+  let elapsedSeconds = 0
+  do {
+    await delay(1000)
+    if (loginPopup.closed) break
+    isLoggedIn = isLoggedInSASVIYA()
+    elapsedSeconds = (new Date().valueOf() - startTime.valueOf()) / 1000
+  } while (!isLoggedIn && elapsedSeconds < 5 * 60)
+
+  let isAuthorized = false
+  startTime = new Date()
+  do {
+    await delay(1000)
+    if (loginPopup.closed) break
+    isAuthorized =
+      loginPopup.window.location.href.includes('SASLogon') ||
+      loginPopup.window.document.body?.innerText?.includes(
+        'You have signed in.'
+      )
+    elapsedSeconds = (new Date().valueOf() - startTime.valueOf()) / 1000
+  } while (!isAuthorized && elapsedSeconds < 5 * 60)
+
+  return { isLoggedIn: isLoggedIn && isAuthorized }
+}
+
+export const isLoggedInSASVIYA = () =>
+  document.cookie.includes('Current-User') && document.cookie.includes('userId')

src/job-execution/ComputeJobExecutor.ts

@@ -35,11 +35,12 @@ export class ComputeJobExecutor extends BaseJobExecutor {
           expectWebout
         )
         .then((response) => {
-          console.log('then block of compute job executor')
+          this.sasViyaApiClient.appendRequest(response, sasJob, config.debug)
           resolve(response.result)
         })
         .catch(async (e: Error) => {
           if (e instanceof ComputeJobExecutionError) {
+            this.sasViyaApiClient.appendRequest(e, sasJob, config.debug)
             reject(new ErrorResponse(e?.message, e))
           }
 

src/job-execution/FileUploader.ts

@@ -0,0 +1,143 @@
+import {
+  getValidJson,
+  parseSasViyaDebugResponse,
+  parseWeboutResponse
+} from '../utils'
+import { UploadFile } from '../types/UploadFile'
+import {
+  ErrorResponse,
+  JobExecutionError,
+  LoginRequiredError
+} from '../types/errors'
+import { RequestClient } from '../request/RequestClient'
+import { ServerType } from '@sasjs/utils/types'
+import { BaseJobExecutor } from './JobExecutor'
+
+interface dataFileUpload {
+  files: UploadFile[]
+  params: { [key: string]: any } | null
+}
+
+export class FileUploader extends BaseJobExecutor {
+  constructor(
+    serverUrl: string,
+    serverType: ServerType,
+    private jobsPath: string,
+    private requestClient: RequestClient
+  ) {
+    super(serverUrl, serverType)
+  }
+
+  public async execute(
+    sasJob: string,
+    data: any,
+    config: any,
+    loginRequiredCallback?: any
+  ) {
+    const { files, params }: dataFileUpload = data
+    const loginCallback = loginRequiredCallback || (() => Promise.resolve())
+
+    if (!files?.length)
+      throw new ErrorResponse('At least one file must be provided.')
+
+    if (!sasJob || sasJob === '')
+      throw new ErrorResponse('sasJob must be provided.')
+
+    let paramsString = ''
+
+    for (let param in params)
+      if (params.hasOwnProperty(param))
+        paramsString += `&${param}=${params[param]}`
+
+    const program = config.appLoc
+      ? config.appLoc.replace(/\/?$/, '/') + sasJob.replace(/^\//, '')
+      : sasJob
+    const uploadUrl = `${this.jobsPath}/?${
+      '_program=' + program
+    }${paramsString}`
+
+    const formData = new FormData()
+
+    for (let file of files) {
+      formData.append('file', file.file, file.fileName)
+    }
+
+    const csrfToken = this.requestClient.getCsrfToken('file')
+    if (csrfToken) formData.append('_csrf', csrfToken.value)
+    if (config.debug) formData.append('_debug', '131')
+    if (config.serverType === ServerType.SasViya && config.contextName)
+      formData.append('_contextname', config.contextName)
+
+    const headers = {
+      'cache-control': 'no-cache',
+      Accept: '*/*',
+      '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
+    const requestPromise = new Promise((resolve, reject) => {
+      this.requestClient
+        .post(uploadUrl, formData, undefined, 'application/json', headers)
+        .then(async (res: any) => {
+          this.requestClient.appendRequest(res, sasJob, config.debug)
+
+          let jsonResponse = res.result
+
+          if (config.debug) {
+            switch (this.serverType) {
+              case ServerType.SasViya:
+                jsonResponse = await parseSasViyaDebugResponse(
+                  res.result,
+                  this.requestClient,
+                  config.serverUrl
+                )
+                break
+              case ServerType.Sas9:
+                jsonResponse =
+                  typeof res.result === 'string'
+                    ? parseWeboutResponse(res.result, uploadUrl)
+                    : res.result
+                break
+            }
+          } else {
+            jsonResponse =
+              typeof res.result === 'string'
+                ? getValidJson(res.result)
+                : res.result
+          }
+
+          resolve(jsonResponse)
+        })
+        .catch(async (e: Error) => {
+          if (e instanceof JobExecutionError) {
+            this.requestClient!.appendRequest(e, sasJob, config.debug)
+            reject(new ErrorResponse(e?.message, e))
+          }
+
+          if (e instanceof LoginRequiredError) {
+            this.appendWaitingRequest(() => {
+              return this.execute(
+                sasJob,
+                data,
+                config,
+                loginRequiredCallback
+              ).then(
+                (res: any) => {
+                  resolve(res)
+                },
+                (err: any) => {
+                  reject(err)
+                }
+              )
+            })
+
+            await loginCallback()
+          } else {
+            reject(new ErrorResponse('File upload request failed.', e))
+          }
+        })
+    })
+    return requestPromise
+  }
+}

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) {
@@ -27,26 +28,19 @@ export class JesJobExecutor extends BaseJobExecutor {
       this.sasViyaApiClient
         ?.executeJob(sasJob, config.contextName, config.debug, data, authConfig)
         .then((response: any) => {
-          let responseObject = {}
+          this.sasViyaApiClient.appendRequest(response, sasJob, config.debug)
 
-          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)
         })
         .catch(async (e: Error) => {
           if (e instanceof JobExecutionError) {
+            this.sasViyaApiClient.appendRequest(e, sasJob, config.debug)
+
             reject(new ErrorResponse(e?.message, e))
           }
 

src/job-execution/JobExecutor.ts

@@ -1,7 +1,6 @@
 import { AuthConfig, ServerType } from '@sasjs/utils/types'
-import { SASjsRequest } from '../types'
 import { ExtraResponseAttributes } from '@sasjs/utils/types'
-import { asyncForEach, parseGeneratedCode, parseSourceCode } from '../utils'
+import { asyncForEach } from '../utils'
 
 export type ExecuteFunction = () => Promise<any>
 
@@ -21,7 +20,6 @@ export abstract class BaseJobExecutor implements JobExecutor {
   constructor(protected serverUrl: string, protected serverType: ServerType) {}
 
   private waitingRequests: ExecuteFunction[] = []
-  private requests: SASjsRequest[] = []
 
   abstract execute(
     sasJob: string,

src/job-execution/Sas9JobExecutor.ts

@@ -45,7 +45,7 @@ export class Sas9JobExecutor extends BaseJobExecutor {
     if (data) {
       try {
         formData = generateFileUploadForm(formData, data)
-      } catch (e) {
+      } catch (e: any) {
         return Promise.reject(new ErrorResponse(e?.message, e))
       }
     }

src/job-execution/WebJobExecutor.ts

@@ -1,9 +1,12 @@
-import { ServerType } from '@sasjs/utils/types'
+import {
+  AuthConfig,
+  ExtraResponseAttributes,
+  ServerType
+} from '@sasjs/utils/types'
 import {
   ErrorResponse,
   JobExecutionError,
-  LoginRequiredError,
-  WeboutResponseError
+  LoginRequiredError
 } from '../types/errors'
 import { generateFileUploadForm } from '../file/generateFileUploadForm'
 import { generateTableUploadForm } from '../file/generateTableUploadForm'
@@ -11,8 +14,8 @@ import { RequestClient } from '../request/RequestClient'
 import { SASViyaApiClient } from '../SASViyaApiClient'
 import {
   isRelativePath,
-  getValidJson,
-  parseSasViyaDebugResponse
+  parseSasViyaDebugResponse,
+  appendExtraResponseAttributes
 } from '../utils'
 import { BaseJobExecutor } from './JobExecutor'
 import { parseWeboutResponse } from '../utils/parseWeboutResponse'
@@ -37,7 +40,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)
@@ -48,10 +53,7 @@ export class WebJobExecutor extends BaseJobExecutor {
     let apiUrl = `${config.serverUrl}${this.jobsPath}/?${'_program=' + program}`
 
     if (config.serverType === ServerType.SasViya) {
-      const jobUri =
-        config.serverType === ServerType.SasViya
-          ? await this.getJobUri(sasJob)
-          : ''
+      const jobUri = await this.getJobUri(sasJob)
 
       apiUrl += jobUri.length > 0 ? '&_job=' + jobUri : ''
 
@@ -88,7 +90,7 @@ export class WebJobExecutor extends BaseJobExecutor {
         // file upload approach
         try {
           formData = generateFileUploadForm(formData, data)
-        } catch (e) {
+        } catch (e: any) {
           return Promise.reject(new ErrorResponse(e?.message, e))
         }
       } else {
@@ -98,7 +100,7 @@ export class WebJobExecutor extends BaseJobExecutor {
             generateTableUploadForm(formData, data)
           formData = newFormData
           requestParams = { ...requestParams, ...params }
-        } catch (e) {
+        } catch (e: any) {
           return Promise.reject(new ErrorResponse(e?.message, e))
         }
       }
@@ -111,50 +113,51 @@ export class WebJobExecutor extends BaseJobExecutor {
     }
 
     const requestPromise = new Promise((resolve, reject) => {
-      this.requestClient!.post(
-        apiUrl,
-        formData,
-        undefined,
-        'application/json',
-        {},
-        config.debug,
-        true,
-        sasJob
-      )
+      this.requestClient!.post(apiUrl, formData, undefined)
         .then(async (res: any) => {
-          if (this.serverType === ServerType.SasViya && config.debug) {
-            const jsonResponse = await parseSasViyaDebugResponse(
-              res.result,
-              this.requestClient,
-              this.serverUrl
-            )
-            resolve(jsonResponse)
-          }
-          if (this.serverType === ServerType.Sas9 && config.debug) {
-            let jsonResponse = res.result
-            if (typeof res.result === 'string')
-              jsonResponse = parseWeboutResponse(res.result, apiUrl)
+          this.requestClient!.appendRequest(res, sasJob, config.debug)
 
-            getValidJson(jsonResponse)
-            resolve(res.result)
+          let jsonResponse = 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)
-          resolve(res.result)
+
+          const responseObject = appendExtraResponseAttributes(
+            { result: jsonResponse },
+            extraResponseAttributes
+          )
+          resolve(responseObject)
         })
         .catch(async (e: Error) => {
           if (e instanceof JobExecutionError) {
+            this.requestClient!.appendRequest(e, sasJob, config.debug)
             reject(new ErrorResponse(e?.message, e))
           }
 
           if (e instanceof LoginRequiredError) {
-            await loginCallback()
-
             this.appendWaitingRequest(() => {
               return this.execute(
                 sasJob,
                 data,
                 config,
-                loginRequiredCallback
+                loginRequiredCallback,
+                authConfig,
+                extraResponseAttributes
               ).then(
                 (res: any) => {
                   resolve(res)
@@ -164,6 +167,8 @@ export class WebJobExecutor extends BaseJobExecutor {
                 }
               )
             })
+
+            await loginCallback()
           } else {
             reject(new ErrorResponse(e?.message, e))
           }

src/job-execution/index.ts

@@ -3,3 +3,4 @@ export * from './JesJobExecutor'
 export * from './JobExecutor'
 export * from './Sas9JobExecutor'
 export * from './WebJobExecutor'
+export * from './FileUploader'

src/request/RequestClient.ts

@@ -52,25 +52,14 @@ export class RequestClient implements HttpClient {
 
   protected csrfToken: CsrfToken = { headerName: '', value: '' }
   protected fileUploadCsrfToken: CsrfToken | undefined
-  protected httpClient: AxiosInstance
+  protected httpClient!: AxiosInstance
 
   constructor(protected baseUrl: string, allowInsecure = false) {
-    const https = require('https')
-    if (allowInsecure && https.Agent) {
-      this.httpClient = axios.create({
-        baseURL: baseUrl,
-        httpsAgent: new https.Agent({
-          rejectUnauthorized: !allowInsecure
-        })
-      })
-    } else {
-      this.httpClient = axios.create({
-        baseURL: baseUrl
-      })
-    }
+    this.createHttpClient(baseUrl, allowInsecure)
+  }
 
-    this.httpClient.defaults.validateStatus = (status) =>
-      status >= 200 && status < 305
+  public setConfig(baseUrl: string, allowInsecure = false) {
+    this.createHttpClient(baseUrl, allowInsecure)
   }
 
   public getCsrfToken(type: 'general' | 'file' = 'general') {
@@ -105,8 +94,7 @@ export class RequestClient implements HttpClient {
    * @param program - name of program
    * @param debug - a boolean that indicates whether debug was enabled or not
    */
-  public appendRequest = (response: any, program: string, debug: boolean) => {
-    console.log('from appendRequest')
+  public appendRequest(response: any, program: string, debug: boolean) {
     let sourceCode = ''
     let generatedCode = ''
     let sasWork = null
@@ -152,9 +140,7 @@ export class RequestClient implements HttpClient {
     accessToken: string | undefined,
     contentType: string = 'application/json',
     overrideHeaders: { [key: string]: string | number } = {},
-    debug: boolean = false,
-    captureRequest: boolean = false,
-    sasJob: string = ''
+    debug: boolean = false
   ): Promise<{ result: T; etag: string; status: number }> {
     const headers = {
       ...this.getHeaders(accessToken, contentType),
@@ -174,11 +160,8 @@ export class RequestClient implements HttpClient {
       .get<T>(url, requestConfig)
       .then((response) => {
         throwIfError(response)
-        const responseToReturn = this.parseResponse<T>(response)
-        if (captureRequest) {
-          this.appendRequest(responseToReturn, sasJob, debug)
-        }
-        return responseToReturn
+
+        return this.parseResponse<T>(response)
       })
       .catch(async (e) => {
         return await this.handleError(
@@ -199,15 +182,12 @@ export class RequestClient implements HttpClient {
       })
   }
 
-  public post<T>(
+  public async post<T>(
     url: string,
     data: any,
     accessToken: string | undefined,
     contentType = 'application/json',
-    overrideHeaders: { [key: string]: string | number } = {},
-    debug: boolean = false,
-    captureRequest: boolean = false,
-    sasJob: string = ''
+    overrideHeaders: { [key: string]: string | number } = {}
   ): Promise<{ result: T; etag: string }> {
     const headers = {
       ...this.getHeaders(accessToken, contentType),
@@ -218,11 +198,7 @@ export class RequestClient implements HttpClient {
       .post<T>(url, data, { headers, withCredentials: true })
       .then((response) => {
         throwIfError(response)
-        const responseToReturn = this.parseResponse<T>(response)
-        if (captureRequest) {
-          this.appendRequest(responseToReturn, sasJob, debug)
-        }
-        return responseToReturn
+        return this.parseResponse<T>(response)
       })
       .catch(async (e) => {
         return await this.handleError(e, () =>
@@ -310,7 +286,7 @@ export class RequestClient implements HttpClient {
         result: response.data,
         etag: response.headers['etag'] as string
       }
-    } catch (e) {
+    } catch (e: any) {
       const response = e.response as AxiosResponse
       if (response?.status === 403 || response?.status === 449) {
         this.parseAndSetFileUploadCsrfToken(response)
@@ -530,6 +506,25 @@ export class RequestClient implements HttpClient {
 
     return responseToReturn
   }
+
+  private createHttpClient(baseUrl: string, allowInsecure = false) {
+    const https = require('https')
+    if (allowInsecure && https.Agent) {
+      this.httpClient = axios.create({
+        baseURL: baseUrl,
+        httpsAgent: new https.Agent({
+          rejectUnauthorized: !allowInsecure
+        })
+      })
+    } else {
+      this.httpClient = axios.create({
+        baseURL: baseUrl
+      })
+    }
+
+    this.httpClient.defaults.validateStatus = (status) =>
+      status >= 200 && status < 305
+  }
 }
 
 export const throwIfError = (response: AxiosResponse) => {
@@ -575,46 +570,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/FileUploader.spec.ts

@@ -2,7 +2,7 @@
  * @jest-environment jsdom
  */
 
-import { FileUploader } from '../FileUploader'
+import { FileUploader } from '../job-execution/FileUploader'
 import { SASjsConfig, UploadFile } from '../types'
 import { RequestClient } from '../request/RequestClient'
 import axios from 'axios'
@@ -39,56 +39,66 @@ describe('FileUploader', () => {
   }
 
   const fileUploader = new FileUploader(
-    config,
+    config.serverUrl,
+    config.serverType!,
     '/jobs/path',
     new RequestClient('https://sample.server.com')
   )
 
   it('should upload successfully', async () => {
     const sasJob = 'test/upload'
-    const { files, params } = prepareFilesAndParams()
+    const data = prepareFilesAndParams()
     mockedAxios.post.mockImplementation(() =>
       Promise.resolve({ data: sampleResponse })
     )
 
-    const res = await fileUploader.uploadFile(sasJob, files, params)
+    const res = await fileUploader.execute(sasJob, data, config)
 
     expect(res).toEqual(JSON.parse(sampleResponse))
   })
 
+  it('should upload successfully when login is required', async () => {
+    mockedAxios.post
+      .mockImplementationOnce(() =>
+        Promise.resolve({ data: '<form action="Logon">' })
+      )
+      .mockImplementationOnce(() => Promise.resolve({ data: sampleResponse }))
+
+    const loginCallback = jest.fn().mockImplementation(async () => {
+      await fileUploader.resendWaitingRequests()
+      Promise.resolve()
+    })
+
+    const sasJob = 'test'
+    const data = prepareFilesAndParams()
+
+    const res = await fileUploader.execute(sasJob, data, config, loginCallback)
+
+    expect(res).toEqual(JSON.parse(sampleResponse))
+
+    expect(mockedAxios.post).toHaveBeenCalledTimes(2)
+    expect(loginCallback).toHaveBeenCalled()
+  })
+
   it('should an error when no files are provided', async () => {
     const sasJob = 'test/upload'
     const files: UploadFile[] = []
     const params = { table: 'libtable' }
 
-    const err = await fileUploader
-      .uploadFile(sasJob, files, params)
+    const res: any = await fileUploader
+      .execute(sasJob, files, params, config)
       .catch((err: any) => err)
-    expect(err.error.message).toEqual('At least one file must be provided.')
+    expect(res.error.message).toEqual('At least one file must be provided.')
   })
 
   it('should throw an error when no sasJob is provided', async () => {
     const sasJob = ''
-    const { files, params } = prepareFilesAndParams()
+    const data = prepareFilesAndParams()
 
-    const err = await fileUploader
-      .uploadFile(sasJob, files, params)
+    const res: any = await fileUploader
+      .execute(sasJob, data, config)
       .catch((err: any) => err)
-    expect(err.error.message).toEqual('sasJob must be provided.')
-  })
-
-  it('should throw an error when login is required', async () => {
-    mockedAxios.post.mockImplementation(() =>
-      Promise.resolve({ data: '<form action="Logon">' })
-    )
-
-    const sasJob = 'test'
-    const { files, params } = prepareFilesAndParams()
-
-    const err = await fileUploader
-      .uploadFile(sasJob, files, params)
-      .catch((err: any) => err)
-    expect(err.error.message).toEqual('You must be logged in to upload a file.')
+    expect(res.error.message).toEqual('sasJob must be provided.')
   })
 
   it('should throw an error when invalid JSON is returned by the server', async () => {
@@ -97,12 +107,13 @@ describe('FileUploader', () => {
     )
 
     const sasJob = 'test'
-    const { files, params } = prepareFilesAndParams()
+    const data = prepareFilesAndParams()
 
-    const err = await fileUploader
-      .uploadFile(sasJob, files, params)
+    const res: any = await fileUploader
+      .execute(sasJob, data, config)
       .catch((err: any) => err)
-    expect(err.error.message).toEqual('File upload request failed.')
+
+    expect(res.error.message).toEqual('File upload request failed.')
   })
 
   it('should throw an error when the server request fails', async () => {
@@ -111,11 +122,11 @@ describe('FileUploader', () => {
     )
 
     const sasJob = 'test'
-    const { files, params } = prepareFilesAndParams()
+    const data = prepareFilesAndParams()
 
-    const err = await fileUploader
-      .uploadFile(sasJob, files, params)
+    const res: any = await fileUploader
+      .execute(sasJob, data, config)
       .catch((err: any) => err)
-    expect(err.error.message).toEqual('File upload request failed.')
+    expect(res.error.message).toEqual('File upload request failed.')
   })
 })

src/types/Login.ts

@@ -0,0 +1,8 @@
+export interface LoginOptions {
+  onLoggedOut?: () => Promise<boolean>
+}
+
+export interface LoginResult {
+  isLoggedIn: boolean
+  userName: string
+}

src/types/SASjsConfig.ts

@@ -59,4 +59,13 @@ export class SASjsConfig {
    * Changing this setting is not recommended.
    */
   allowInsecureRequests = false
+  /**
+   * Supported login mechanisms are - Redirected and Default
+   */
+  loginMechanism: LoginMechanism = LoginMechanism.Default
+}
+
+export enum LoginMechanism {
+  Default = 'Default',
+  Redirected = 'Redirected'
 }

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/delay.ts

@@ -0,0 +1,2 @@
+export const delay = (ms: number) =>
+  new Promise((resolve) => setTimeout(resolve, ms))

src/utils/index.ts

@@ -1,6 +1,7 @@
 export * from './asyncForEach'
 export * from './compareTimestamps'
 export * from './convertToCsv'
+export * from './delay'
 export * from './isNode'
 export * from './isRelativePath'
 export * from './isUri'
@@ -15,3 +16,4 @@ export * from './parseWeboutResponse'
 export * from './fetchLogByChunks'
 export * from './getValidJson'
 export * from './parseViyaDebugResponse'
+export * from './appendExtraResponseAttributes'

src/utils/loginPrompt/index.ts

@@ -0,0 +1,177 @@
+enum domIDs {
+  styles = 'sasjsAdapterStyles',
+  overlay = 'sasjsAdapterLoginPromptBG',
+  dialog = 'sasjsAdapterLoginPrompt'
+}
+const cssPrefix = 'sasjs-adapter'
+
+const classes = {
+  popUp: `${cssPrefix}popUp`,
+  popUpBG: `${cssPrefix}popUpBG`
+}
+
+export const openLoginPrompt = (): Promise<boolean> => {
+  return new Promise(async (resolve) => {
+    const style = document.createElement('style')
+    style.id = domIDs.styles
+    style.innerText = cssContent
+
+    const loginPromptBG = document.createElement('div')
+    loginPromptBG.id = domIDs.overlay
+    loginPromptBG.classList.add(classes.popUpBG)
+
+    const loginPrompt = document.createElement('div')
+    loginPrompt.id = domIDs.dialog
+    loginPrompt.classList.add(classes.popUp)
+
+    const title = document.createElement('h1')
+    title.innerText = 'Session Expired!'
+    loginPrompt.appendChild(title)
+
+    const descHolder = document.createElement('div')
+    const desc = document.createElement('span')
+    desc.innerText = 'You need to relogin, click OK to login.'
+    descHolder.appendChild(desc)
+    loginPrompt.appendChild(descHolder)
+
+    const buttonCancel = document.createElement('button')
+    buttonCancel.classList.add('cancel')
+    buttonCancel.innerText = 'Cancel'
+    buttonCancel.onclick = () => {
+      closeLoginPrompt()
+      resolve(false)
+    }
+    loginPrompt.appendChild(buttonCancel)
+
+    const buttonOk = document.createElement('button')
+    buttonOk.classList.add('confirm')
+    buttonOk.innerText = 'Ok'
+    buttonOk.onclick = () => {
+      closeLoginPrompt()
+      resolve(true)
+    }
+    loginPrompt.appendChild(buttonOk)
+
+    document.body.style.overflow = 'hidden'
+
+    document.body.appendChild(style)
+    document.body.appendChild(loginPromptBG)
+    document.body.appendChild(loginPrompt)
+  })
+}
+const closeLoginPrompt = () => {
+  Object.values(domIDs).forEach((id) => {
+    const elem = document.getElementById(id)
+    elem?.parentNode?.removeChild(elem)
+  })
+
+  document.body.style.overflow = 'auto'
+}
+
+const cssContent = `
+.${classes.popUpBG} ,
+.${classes.popUp} {
+  z-index: 10000;
+}
+.${classes.popUp} {
+  box-sizing: border-box;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  display: block;
+  position: fixed;
+  top: 40%;
+  left: 50%;
+  padding: 0;
+  font-size: 14px;
+  font-family: 'PT Sans', sans-serif;
+  color: #fff;
+  border-style: none;
+  z-index: 999;
+  overflow: hidden;
+  background: rgba(0, 0, 0, 0.2);
+  margin: 0;
+  width: 100%;
+  max-width: 300px;
+  height: auto;
+  max-height: 300px;
+  transform: translate(-50%, -50%);
+}
+.${classes.popUp} > h1 {
+  box-sizing: border-box;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  padding: 5px;
+  min-height: 40px;
+  font-size: 1.2em;
+  font-weight: bold;
+  text-align: center;
+  color: #fff;
+  background-color: transparent;
+  border-style: none;
+  border-width: 5px;
+  border-color: black;
+}
+.${classes.popUp} > div {
+  width: 100%;
+  height: calc(100% -108px);
+  margin: 0;
+  display: block;
+  box-sizing: border-box;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  padding: 5%;
+  text-align: center;
+  border-width: 1px;
+  border-color: #ccc;
+  border-style: none none solid none;
+  overflow: auto;
+}
+.${classes.popUp} > div > span {
+  display: table-cell;
+  box-sizing: border-box;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  width: 300px;
+  height: 108px;
+  vertical-align: middle;
+  border-style: none;
+}
+.${classes.popUp} .cancel {
+  float: left;
+}
+.${classes.popUp} .confirm {
+  float: right;
+}
+.${classes.popUp} > button {
+  box-sizing: border-box;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  margin: 0;
+  padding: 10px;
+  width: 50%;
+  border: 1px none #ccc;
+  color: #fff;
+  font-family: inherit;
+  cursor: pointer;
+  height: 50px;
+  background: rgba(1, 1, 1, 0.2);
+}
+.${classes.popUp} > button:hover {
+  background: rgba(0, 0, 0, 0.2);
+}
+.${classes.popUpBG} {
+  display: block;
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  margin: 0;
+  padding: 0;
+  opacity: 0.95;
+  z-index: 50;
+  background-image: radial-gradient(#0378cd, #012036);
+}
+`