fix(request-client): return Internal Server Error code in case of Stored Process Error

fix: handle sasjs server response

.github/dependabot.yml

@@ -1,7 +1,7 @@
 version: 2
 updates:
-- package-ecosystem: npm
-  directory: "/"
-  schedule:
-    interval: daily
-  open-pull-requests-limit: 10
+  - package-ecosystem: npm
+    directory: '/'
+    schedule:
+      interval: monthly
+    open-pull-requests-limit: 10

.github/workflows/build.yml

@@ -13,14 +13,15 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [15.x]
+        node-version: [lts/fermium]
 
     steps:
       - uses: actions/checkout@v2
       - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v2
         with:
           node-version: ${{ matrix.node-version }}
+          cache: npm
       - name: Install Dependencies
         run: npm ci
       - name: Check code style

.gitignore

@@ -5,4 +5,4 @@ build
 
 /coverage
 
-.DS_Store
+.DS_Store

.npmignore

@@ -3,3 +3,4 @@ docs/
 .github/
 *.md
 *.spec.ts
+.all-contributorsrc

README.md

@@ -36,7 +36,7 @@ Ok ok. Deploy this [example.html](https://raw.githubusercontent.com/sasjs/adapte
 
 The backend part can be deployed as follows:
 
-```
+```sas
 %let appLoc=/Public/app/readme;  /* Metadata or Viya Folder per SASjs config */
 filename mc url "https://raw.githubusercontent.com/sasjs/core/main/all.sas";
 %inc mc; /* compile macros (can also be downloaded & compiled seperately) */
@@ -85,11 +85,11 @@ let sasJs = new SASjs.default(
 );
 ```
 If you've installed it via NPM, you can import it as a default import like so:
-```
+```js
   import SASjs from '@sasjs/adapter';
 ```
 You can then instantiate it with:
-```
+```js
 const sasJs = new SASjs({your config})
 ```
 
@@ -119,6 +119,7 @@ sasJs.request("/path/to/my/service", dataObject)
     console.log(response.tablewith2cols1row[0].COL1.value)
   })
 ```
+
 We supply the path to the SAS service, and a data object.  The data object can be null (for services with no input), or can contain one or more tables in the following format:
 
 ```javascript
@@ -146,6 +147,7 @@ The adapter will also cache the logs (if debug enabled) and even the work tables
 The SAS side is handled by a number of macros in the [macro core](https://github.com/sasjs/core) library.
 
 The following snippet shows the process of SAS tables arriving / leaving:
+
 ```sas
 /* fetch all input tables sent from frontend - they arrive as work tables */
 %webout(FETCH)
@@ -161,7 +163,6 @@ run;
 %webout(OBJ,tables,fmt=N) /* unformatted (raw) data */
 %webout(OBJ,tables,label=newtable) /* rename tables on export */
 %webout(CLOSE) /* close the JSON and send some extra useful variables too */
-
 ```
 
 ## Configuration
@@ -172,6 +173,7 @@ Configuration on the client side involves passing an object on startup, which ca
 * `serverType` - either `SAS9` or `SASVIYA`.
 * `serverUrl` - the location (including http protocol and port) of the SAS Server. Can be omitted, eg if serving directly from the SAS Web Server, or in streaming mode.
 * `debug` - if `true` then SAS Logs and extra debug information is returned.
+* `LoginMechanism` - either `Default` or `Redirected`.  If `Redirected` then authentication occurs through the injection of an additional screen, which contains the SASLogon prompt.  This allows for more complex authentication flows (such as 2FA) and avoids the need to handle passwords in the application itself.  The styling of the redirect flow can also be modified.  If left at "Default" then the developer must capture the username and password and use these with the `.login()` method.
 * `useComputeApi` - Only relevant when the serverType is `SASVIYA`. If `true` the [Compute API](#using-the-compute-api) is used.  If `false` the [JES API](#using-the-jes-api) is used.  If `null` or `undefined` the [Web](#using-jes-web-app) approach is used.
 * `contextName` - Compute context on which the requests will be called.  If missing or not provided, defaults to `Job Execution Compute context`.
 
@@ -196,7 +198,7 @@ Here we are running Jobs using the Job Execution Service except this time we are
 
 This approach (`useComputeApi: false`) also ensures that jobs are displayed in Environment Manager.
 
-```
+```json
 {
   appLoc:"/Your/Path",
   serverType:"SASVIYA",
@@ -210,12 +212,12 @@ This approach is by far the fastest, as a result of the optimisations we have bu
 
 With this approach (`useComputeApi: true`), the requests/logs will _not_ appear in the list in Environment manager.
 
-```
+```json
 {
   appLoc:"/Your/Path",
   serverType:"SASVIYA",
   useComputeApi: true,
-  contextName: 'yourComputeContext'
+  contextName: "yourComputeContext"
 }
 ```
 

package.json

@@ -41,36 +41,40 @@
   "license": "ISC",
   "devDependencies": {
     "@types/axios": "^0.14.0",
+    "@types/express": "^4.17.13",
     "@types/form-data": "^2.5.0",
-    "@types/jest": "^27.0.1",
+    "@types/jest": "^27.0.2",
     "@types/mime": "^2.0.3",
+    "@types/pem": "^1.9.6",
     "@types/tough-cookie": "^4.0.1",
     "copyfiles": "^2.4.1",
     "cp": "^0.2.0",
     "dotenv": "^10.0.0",
-    "jest": "^27.1.0",
+    "express": "^4.17.1",
+    "jest": "^27.2.0",
     "jest-extended": "^0.11.5",
     "node-polyfill-webpack-plugin": "^1.1.4",
     "path": "^0.12.7",
+    "pem": "^1.14.4",
     "process": "^0.11.10",
     "rimraf": "^3.0.2",
-    "semantic-release": "^17.4.7",
-    "terser-webpack-plugin": "^5.2.0",
+    "semantic-release": "^18.0.0",
+    "terser-webpack-plugin": "^5.2.4",
     "ts-jest": "^27.0.3",
-    "ts-loader": "^9.2.2",
+    "ts-loader": "^9.2.6",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0",
-    "typedoc": "^0.21.9",
+    "typedoc": "0.19.2",
     "typedoc-neo-theme": "^1.1.1",
     "typedoc-plugin-external-module-name": "^4.0.6",
     "typescript": "4.3.5",
-    "webpack": "^5.44.0",
+    "webpack": "^5.56.0",
     "webpack-cli": "^4.7.2"
   },
   "main": "index.js",
   "dependencies": {
-    "@sasjs/utils": "^2.30.0",
-    "axios": "^0.21.1",
+    "@sasjs/utils": "^2.32.0",
+    "axios": "^0.21.4",
     "axios-cookiejar-support": "^1.0.1",
     "form-data": "^4.0.0",
     "https": "^1.0.0",

sasjs-tests/package.json

@@ -5,7 +5,7 @@
   "private": true,
   "dependencies": {
     "@sasjs/adapter": "file:../build/sasjs-adapter-5.0.0.tgz",
-    "@sasjs/test-framework": "^1.4.0",
+    "@sasjs/test-framework": "^1.4.2",
     "@types/jest": "^26.0.20",
     "@types/node": "^14.14.41",
     "@types/react": "^17.0.1",

sasjs-tests/src/testSuites/Basic.ts

@@ -13,7 +13,6 @@ const defaultConfig: SASjsConfig = {
   debug: false,
   contextName: 'SAS Job Execution compute context',
   useComputeApi: false,
-  allowInsecureRequests: false,
   loginMechanism: LoginMechanism.Default
 }
 
@@ -78,8 +77,8 @@ export const basicTests = (
           'common/sendArr',
           stringData,
           undefined,
-          () => {
-            adapter.logIn(userName, password)
+          async () => {
+            await adapter.logIn(userName, password)
           }
         )
       },

src/SAS9ApiClient.ts

@@ -1,3 +1,4 @@
+import * as https from 'https'
 import { generateTimestamp } from '@sasjs/utils/time'
 import * as NodeFormData from 'form-data'
 import { Sas9RequestClient } from './request/Sas9RequestClient'
@@ -13,10 +14,10 @@ export class SAS9ApiClient {
   constructor(
     private serverUrl: string,
     private jobsPath: string,
-    allowInsecureRequests: boolean
+    httpsAgentOptions?: https.AgentOptions
   ) {
     if (serverUrl) isUrl(serverUrl)
-    this.requestClient = new Sas9RequestClient(serverUrl, allowInsecureRequests)
+    this.requestClient = new Sas9RequestClient(serverUrl, httpsAgentOptions)
   }
 
   /**

src/SASjs.ts

@@ -4,10 +4,14 @@ import {
   UploadFile,
   EditContextInput,
   PollOptions,
-  LoginMechanism
+  LoginMechanism,
+  FolderMember,
+  ServiceMember,
+  ExecutionQuery
 } from './types'
 import { SASViyaApiClient } from './SASViyaApiClient'
 import { SAS9ApiClient } from './SAS9ApiClient'
+import { SASjsApiClient } from './SASjsApiClient'
 import { AuthManager } from './auth'
 import {
   ServerType,
@@ -29,6 +33,7 @@ import { LoginOptions, LoginResult } from './types/Login'
 
 const defaultConfig: SASjsConfig = {
   serverUrl: '',
+  pathSASJS: '/SASjsApi/stp/execute',
   pathSAS9: '/SASStoredProcess/do',
   pathSASViya: '/SASJobExecution',
   appLoc: '/Public/seedapp',
@@ -36,7 +41,6 @@ const defaultConfig: SASjsConfig = {
   debug: false,
   contextName: 'SAS Job Execution compute context',
   useComputeApi: null,
-  allowInsecureRequests: false,
   loginMechanism: LoginMechanism.Default
 }
 
@@ -49,6 +53,7 @@ export default class SASjs {
   private jobsPath: string = ''
   private sasViyaApiClient: SASViyaApiClient | null = null
   private sas9ApiClient: SAS9ApiClient | null = null
+  private SASjsApiClient: SASjsApiClient | null = null
   private fileUploader: FileUploader | null = null
   private authManager: AuthManager | null = null
   private requestClient: RequestClient | null = null
@@ -57,7 +62,7 @@ export default class SASjs {
   private jesJobExecutor: JobExecutor | null = null
   private sas9JobExecutor: JobExecutor | null = null
 
-  constructor(config?: any) {
+  constructor(config?: Partial<SASjsConfig>) {
     this.sasjsConfig = {
       ...defaultConfig,
       ...config
@@ -523,10 +528,11 @@ export default class SASjs {
 
   /**
    * Checks whether a session is active, or login is required.
+   * @param accessToken - an optional access token is required for SASjs server type.
    * @returns - a promise which resolves with an object containing two values - a boolean `isLoggedIn`, and a string `userName`.
    */
-  public async checkSession() {
-    return this.authManager!.checkSession()
+  public async checkSession(accessToken?: string) {
+    return this.authManager!.checkSession(accessToken)
   }
 
   /**
@@ -559,9 +565,10 @@ export default class SASjs {
 
   /**
    * Logs out of the configured SAS server.
+   * @param accessToken - an optional access token is required for SASjs server type.
    */
-  public logOut() {
-    return this.authManager!.logOut()
+  public logOut(accessToken?: string) {
+    return this.authManager!.logOut(accessToken)
   }
 
   /**
@@ -792,7 +799,7 @@ export default class SASjs {
         sasApiClient = new SAS9ApiClient(
           serverUrl,
           this.jobsPath,
-          this.sasjsConfig.allowInsecureRequests
+          this.sasjsConfig.httpsAgentOptions
         )
       }
     } else {
@@ -824,6 +831,14 @@ export default class SASjs {
     )
   }
 
+  public async deployToSASjs(members: [FolderMember, ServiceMember]) {
+    return await this.SASjsApiClient?.deploy(members, this.sasjsConfig.appLoc)
+  }
+
+  public async executeJobSASjs(query: ExecutionQuery) {
+    return await this.SASjsApiClient?.executeJob(query)
+  }
+
   /**
    * Kicks off execution of the given job via the compute API.
    * @returns an object representing the compute session created for the given job.
@@ -951,19 +966,21 @@ export default class SASjs {
     if (!this.requestClient) {
       this.requestClient = new RequestClient(
         this.sasjsConfig.serverUrl,
-        this.sasjsConfig.allowInsecureRequests
+        this.sasjsConfig.httpsAgentOptions
       )
     } else {
       this.requestClient.setConfig(
         this.sasjsConfig.serverUrl,
-        this.sasjsConfig.allowInsecureRequests
+        this.sasjsConfig.httpsAgentOptions
       )
     }
 
     this.jobsPath =
       this.sasjsConfig.serverType === ServerType.SasViya
         ? this.sasjsConfig.pathSASViya
-        : this.sasjsConfig.pathSAS9
+        : this.sasjsConfig.serverType === ServerType.Sas9
+        ? this.sasjsConfig.pathSAS9
+        : this.sasjsConfig.pathSASJS || ''
 
     this.authManager = new AuthManager(
       this.sasjsConfig.serverUrl,
@@ -973,30 +990,44 @@ export default class SASjs {
     )
 
     if (this.sasjsConfig.serverType === ServerType.SasViya) {
-      if (this.sasViyaApiClient)
+      if (this.sasViyaApiClient) {
         this.sasViyaApiClient!.setConfig(
           this.sasjsConfig.serverUrl,
           this.sasjsConfig.appLoc
         )
-      else
+      } else {
         this.sasViyaApiClient = new SASViyaApiClient(
           this.sasjsConfig.serverUrl,
           this.sasjsConfig.appLoc,
           this.sasjsConfig.contextName,
           this.requestClient
         )
+      }
 
       this.sasViyaApiClient.debug = this.sasjsConfig.debug
     }
+
     if (this.sasjsConfig.serverType === ServerType.Sas9) {
-      if (this.sas9ApiClient)
+      if (this.sas9ApiClient) {
         this.sas9ApiClient!.setConfig(this.sasjsConfig.serverUrl)
-      else
+      } else {
         this.sas9ApiClient = new SAS9ApiClient(
           this.sasjsConfig.serverUrl,
           this.jobsPath,
-          this.sasjsConfig.allowInsecureRequests
+          this.sasjsConfig.httpsAgentOptions
         )
+      }
+    }
+
+    if (this.sasjsConfig.serverType === ServerType.Sasjs) {
+      if (this.SASjsApiClient) {
+        this.SASjsApiClient.setConfig(this.sasjsConfig.serverUrl)
+      } else {
+        this.SASjsApiClient = new SASjsApiClient(
+          this.sasjsConfig.serverUrl,
+          this.requestClient
+        )
+      }
     }
 
     this.fileUploader = new FileUploader(
@@ -1018,7 +1049,8 @@ export default class SASjs {
       this.sasjsConfig.serverUrl,
       this.sasjsConfig.serverType!,
       this.jobsPath,
-      this.sasjsConfig.allowInsecureRequests
+      this.requestClient,
+      this.sasjsConfig.httpsAgentOptions
     )
 
     this.computeJobExecutor = new ComputeJobExecutor(

src/SASjsApiClient.ts

@@ -0,0 +1,39 @@
+import { FolderMember, ServiceMember, ExecutionQuery } from './types'
+import { RequestClient } from './request/RequestClient'
+
+export class SASjsApiClient {
+  constructor(
+    private serverUrl: string,
+    private requestClient: RequestClient
+  ) {}
+
+  public setConfig(serverUrl: string) {
+    if (serverUrl) this.serverUrl = serverUrl
+  }
+
+  public async deploy(members: [FolderMember, ServiceMember], appLoc: string) {
+    const { result } = await this.requestClient.post<{
+      status: string
+      message: string
+      example?: {}
+    }>(
+      'SASjsApi/drive/deploy',
+      { fileTree: members, appLoc: appLoc },
+      undefined
+    )
+
+    return Promise.resolve(result)
+  }
+
+  public async executeJob(query: ExecutionQuery) {
+    const { result } = await this.requestClient.post<{
+      status: string
+      message: string
+      log?: string
+      logPath?: string
+      error?: {}
+    }>('SASjsApi/stp/execute', query, undefined)
+
+    return Promise.resolve(result)
+  }
+}

src/auth/AuthManager.ts

@@ -21,7 +21,9 @@ export class AuthManager {
     this.logoutUrl =
       this.serverType === ServerType.Sas9
         ? '/SASLogon/logout?'
-        : '/SASLogon/logout.do?'
+        : this.serverType === ServerType.SasViya
+        ? '/SASLogon/logout.do?'
+        : '/SASjsApi/auth/logout'
   }
 
   /**
@@ -180,20 +182,21 @@ export class AuthManager {
 
   /**
    * Checks whether a session is active, or login is required.
+   * @param accessToken - an optional access token is required for SASjs server type.
    * @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(): Promise<{
+  public async checkSession(accessToken?: string): Promise<{
     isLoggedIn: boolean
     userName: string
     loginForm?: any
   }> {
-    const { isLoggedIn, userName } = await this.fetchUserName()
+    const { isLoggedIn, userName } = await this.fetchUserName(accessToken)
     let loginForm = null
 
-    if (!isLoggedIn) {
+    if (!isLoggedIn && this.serverType !== ServerType.Sasjs) {
       //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()
@@ -218,19 +221,20 @@ export class AuthManager {
     return await this.getLoginForm(formResponse)
   }
 
-  private async fetchUserName(): Promise<{
+  private async fetchUserName(accessToken?: string): 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 === ServerType.SasViya
         ? `${this.serverUrl}/identities/users/@currentUser`
-        : `${this.serverUrl}/SASStoredProcess`
+        : this.serverType === ServerType.Sas9
+        ? `${this.serverUrl}/SASStoredProcess`
+        : `${this.serverUrl}/SASjsApi/session`
 
+    // Access token is required for server type `SASjs`
     const { result: loginResponse } = await this.requestClient
-      .get<string>(url, undefined, 'text/plain')
+      .get<string>(url, accessToken, 'text/plain')
       .catch((err: any) => {
         return { result: 'authErr' }
       })
@@ -256,6 +260,13 @@ export class AuthManager {
           .split(' ')
           .map((name: string) => name.slice(0, 3).toLowerCase())
           .join('')
+
+      case ServerType.Sasjs:
+        return response?.username
+
+      default:
+        console.error('Server Type not found in extractUserName function')
+        return ''
     }
   }
 
@@ -302,8 +313,12 @@ export class AuthManager {
 
   /**
    * Logs out of the configured SAS server.
+   * @param accessToken - an optional access token is required for SASjs server type.
    */
-  public logOut() {
+  public logOut(accessToken?: string) {
+    if (this.serverType === ServerType.Sasjs) {
+      return this.requestClient.post(this.logoutUrl, undefined, accessToken)
+    }
     this.requestClient.clearCsrfTokens()
     return this.requestClient.get(this.logoutUrl, undefined).then(() => true)
   }

src/auth/getAccessToken.ts

@@ -46,7 +46,7 @@ export async function getAccessToken(
     )
     .then((res) => res.result as SasAuthResponse)
     .catch((err) => {
-      throw prefixMessage(err, 'Error while getting access token')
+      throw prefixMessage(err, 'Error while getting access token. ')
     })
 
   return authResponse

src/job-execution/ComputeJobExecutor.ts

@@ -45,7 +45,6 @@ export class ComputeJobExecutor extends BaseJobExecutor {
           }
 
           if (e instanceof LoginRequiredError) {
-            await loginCallback()
             this.appendWaitingRequest(() => {
               return this.execute(
                 sasJob,
@@ -61,6 +60,8 @@ export class ComputeJobExecutor extends BaseJobExecutor {
                 }
               )
             })
+
+            await loginCallback()
           } else {
             reject(new ErrorResponse(e?.message, e))
           }

src/job-execution/JesJobExecutor.ts

@@ -45,8 +45,6 @@ export class JesJobExecutor extends BaseJobExecutor {
           }
 
           if (e instanceof LoginRequiredError) {
-            await loginCallback()
-
             this.appendWaitingRequest(() => {
               return this.execute(
                 sasJob,
@@ -64,6 +62,8 @@ export class JesJobExecutor extends BaseJobExecutor {
                 }
               )
             })
+
+            await loginCallback()
           } else {
             reject(new ErrorResponse(e?.message, e))
           }

src/job-execution/Sas9JobExecutor.ts

@@ -1,9 +1,11 @@
+import * as https from 'https'
 import { ServerType } from '@sasjs/utils/types'
 import * as NodeFormData from 'form-data'
 import { ErrorResponse } from '../types/errors'
 import { convertToCSV, isRelativePath } from '../utils'
 import { BaseJobExecutor } from './JobExecutor'
 import { Sas9RequestClient } from '../request/Sas9RequestClient'
+import { RequestClient } from '../request/RequestClient'
 
 /**
  * Job executor for SAS9 servers for use in Node.js environments.
@@ -12,15 +14,16 @@ import { Sas9RequestClient } from '../request/Sas9RequestClient'
  * job execution requests.
  */
 export class Sas9JobExecutor extends BaseJobExecutor {
-  private requestClient: Sas9RequestClient
+  private sas9RequestClient: Sas9RequestClient
   constructor(
     serverUrl: string,
     serverType: ServerType,
     private jobsPath: string,
-    allowInsecureRequests: boolean
+    private requestClient: RequestClient,
+    httpsAgentOptions?: https.AgentOptions
   ) {
     super(serverUrl, serverType)
-    this.requestClient = new Sas9RequestClient(serverUrl, allowInsecureRequests)
+    this.sas9RequestClient = new Sas9RequestClient(serverUrl, httpsAgentOptions)
   }
 
   async execute(sasJob: string, data: any, config: any) {
@@ -36,6 +39,8 @@ export class Sas9JobExecutor extends BaseJobExecutor {
         : ''
     }`
 
+    apiUrl = `${apiUrl}${config.debug ? '&_debug=131' : ''}`
+
     let requestParams = {
       ...this.getRequestParams(config)
     }
@@ -48,6 +53,8 @@ export class Sas9JobExecutor extends BaseJobExecutor {
       } catch (e: any) {
         return Promise.reject(new ErrorResponse(e?.message, e))
       }
+    } else {
+      data = ''
     }
 
     for (const key in requestParams) {
@@ -56,16 +63,18 @@ export class Sas9JobExecutor extends BaseJobExecutor {
       }
     }
 
-    await this.requestClient.login(
+    await this.sas9RequestClient.login(
       config.username,
       config.password,
       this.jobsPath
     )
+
     const contentType =
       data && Object.keys(data).length
         ? 'multipart/form-data; boundary=' + (formData as any)._boundary
         : 'text/plain'
-    return await this.requestClient!.post(
+
+    return await this.sas9RequestClient!.post(
       apiUrl,
       formData,
       undefined,
@@ -75,6 +84,28 @@ export class Sas9JobExecutor extends BaseJobExecutor {
         Connection: 'Keep-Alive'
       }
     )
+      .then((res: any) => {
+        let resString = res
+
+        if (typeof res === 'object') {
+          resString = JSON.stringify(res)
+        }
+
+        this.requestClient!.appendRequest(resString, sasJob, config.debug)
+
+        return res
+      })
+      .catch((err: any) => {
+        let errString = err
+
+        if (typeof err === 'object') {
+          errString = JSON.stringify(errString)
+        }
+
+        this.requestClient!.appendRequest(errString, sasJob, config.debug)
+
+        return err
+      })
   }
 
   private getRequestParams(config: any): any {

src/job-execution/WebJobExecutor.ts

@@ -15,7 +15,8 @@ import { SASViyaApiClient } from '../SASViyaApiClient'
 import {
   isRelativePath,
   parseSasViyaDebugResponse,
-  appendExtraResponseAttributes
+  appendExtraResponseAttributes,
+  getValidJson
 } from '../utils'
 import { BaseJobExecutor } from './JobExecutor'
 import { parseWeboutResponse } from '../utils/parseWeboutResponse'
@@ -53,7 +54,36 @@ export class WebJobExecutor extends BaseJobExecutor {
     let apiUrl = `${config.serverUrl}${this.jobsPath}/?${'_program=' + program}`
 
     if (config.serverType === ServerType.SasViya) {
-      const jobUri = await this.getJobUri(sasJob)
+      let jobUri
+      try {
+        jobUri = await this.getJobUri(sasJob)
+      } catch (e: any) {
+        return new Promise(async (resolve, reject) => {
+          if (e instanceof LoginRequiredError) {
+            this.appendWaitingRequest(() => {
+              return this.execute(
+                sasJob,
+                data,
+                config,
+                loginRequiredCallback,
+                authConfig,
+                extraResponseAttributes
+              ).then(
+                (res: any) => {
+                  resolve(res)
+                },
+                (err: any) => {
+                  reject(err)
+                }
+              )
+            })
+
+            await loginCallback()
+          } else {
+            reject(new ErrorResponse(e?.message, e))
+          }
+        })
+      }
 
       apiUrl += jobUri.length > 0 ? '&_job=' + jobUri : ''
 
@@ -84,6 +114,7 @@ export class WebJobExecutor extends BaseJobExecutor {
       const stringifiedData = JSON.stringify(data)
       if (
         config.serverType === ServerType.Sas9 ||
+        config.serverType === ServerType.Sasjs ||
         stringifiedData.length > 500000 ||
         stringifiedData.includes(';')
       ) {
@@ -113,12 +144,25 @@ export class WebJobExecutor extends BaseJobExecutor {
     }
 
     const requestPromise = new Promise((resolve, reject) => {
-      this.requestClient!.post(apiUrl, formData, undefined)
+      // Access token is required for server type `SASjs`
+      this.requestClient!.post(apiUrl, formData, authConfig?.access_token)
         .then(async (res: any) => {
-          this.requestClient!.appendRequest(res, sasJob, config.debug)
+          const resObj =
+            this.serverType === ServerType.Sasjs
+              ? {
+                  result: res.result._webout,
+                  log: res.result.log
+                }
+              : res
+          this.requestClient!.appendRequest(resObj, sasJob, config.debug)
 
           let jsonResponse = res.result
 
+          if (this.serverType === ServerType.Sasjs) {
+            const webout = parseWeboutResponse(res.result._webout, apiUrl)
+            jsonResponse = getValidJson(webout)
+          }
+
           if (config.debug) {
             switch (this.serverType) {
               case ServerType.SasViya:

src/request/RequestClient.ts

@@ -1,4 +1,5 @@
-import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios'
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios'
+import * as https from 'https'
 import { CsrfToken } from '..'
 import { isAuthorizeFormRequired, isLogInRequired } from '../auth'
 import {
@@ -12,7 +13,11 @@ import { SASjsRequest } from '../types'
 import { parseWeboutResponse } from '../utils/parseWeboutResponse'
 import { prefixMessage } from '@sasjs/utils/error'
 import { SAS9AuthError } from '../types/errors/SAS9AuthError'
-import { parseGeneratedCode, parseSourceCode } from '../utils'
+import {
+  parseGeneratedCode,
+  parseSourceCode,
+  createAxiosInstance
+} from '../utils'
 
 export interface HttpClient {
   get<T>(
@@ -54,12 +59,15 @@ export class RequestClient implements HttpClient {
   protected fileUploadCsrfToken: CsrfToken | undefined
   protected httpClient!: AxiosInstance
 
-  constructor(protected baseUrl: string, allowInsecure = false) {
-    this.createHttpClient(baseUrl, allowInsecure)
+  constructor(
+    protected baseUrl: string,
+    httpsAgentOptions?: https.AgentOptions
+  ) {
+    this.createHttpClient(baseUrl, httpsAgentOptions)
   }
 
-  public setConfig(baseUrl: string, allowInsecure = false) {
-    this.createHttpClient(baseUrl, allowInsecure)
+  public setConfig(baseUrl: string, httpsAgentOptions?: https.AgentOptions) {
+    this.createHttpClient(baseUrl, httpsAgentOptions)
   }
 
   public getCsrfToken(type: 'general' | 'file' = 'general') {
@@ -281,7 +289,11 @@ export class RequestClient implements HttpClient {
     }
 
     try {
-      const response = await this.httpClient.post(url, content, { headers })
+      const response = await this.httpClient.post(url, content, {
+        headers,
+        transformRequest: (requestBody) => requestBody
+      })
+
       return {
         result: response.data,
         etag: response.headers['etag'] as string
@@ -507,23 +519,18 @@ 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
-      })
-    }
+  private createHttpClient(
+    baseUrl: string,
+    httpsAgentOptions?: https.AgentOptions
+  ) {
+    const httpsAgent = httpsAgentOptions
+      ? new https.Agent(httpsAgentOptions)
+      : undefined
+
+    this.httpClient = createAxiosInstance(baseUrl, httpsAgent)
 
     this.httpClient.defaults.validateStatus = (status) =>
-      status >= 200 && status < 305
+      status >= 200 && status < 401
   }
 }
 
@@ -620,7 +627,7 @@ const parseError = (data: string) => {
       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)
+        return new JobExecutionError(500, message, log)
       }
     }
   } catch (_) {}

src/request/Sas9RequestClient.ts

@@ -1,3 +1,4 @@
+import * as https from 'https'
 import { AxiosRequestConfig } from 'axios'
 import axiosCookieJarSupport from 'axios-cookiejar-support'
 import * as tough from 'tough-cookie'
@@ -9,8 +10,8 @@ import { RequestClient, throwIfError } from './RequestClient'
  * Handles redirects and cookie management.
  */
 export class Sas9RequestClient extends RequestClient {
-  constructor(baseUrl: string, allowInsecure = false) {
-    super(baseUrl, allowInsecure)
+  constructor(baseUrl: string, httpsAgentOptions?: https.AgentOptions) {
+    super(baseUrl, httpsAgentOptions)
     this.httpClient.defaults.maxRedirects = 0
     this.httpClient.defaults.validateStatus = (status) =>
       status >= 200 && status < 303

src/test/RequestClient.spec.ts

@@ -0,0 +1,167 @@
+import * as pem from 'pem'
+import * as http from 'http'
+import * as https from 'https'
+import { app, mockedAuthResponse } from './SAS_server_app'
+import { ServerType } from '@sasjs/utils'
+import SASjs from '../SASjs'
+import * as axiosModules from '../utils/createAxiosInstance'
+
+const axiosActual = jest.requireActual('axios')
+
+jest
+  .spyOn(axiosModules, 'createAxiosInstance')
+  .mockImplementation((baseURL: string, httpsAgent?: https.Agent) =>
+    axiosActual.create({ baseURL, httpsAgent })
+  )
+
+const PORT = 8000
+const SERVER_URL = `https://localhost:${PORT}/`
+
+const ERROR_MESSAGES = {
+  selfSigned: 'self signed certificate',
+  CCA: 'unable to verify the first certificate'
+}
+
+describe('RequestClient', () => {
+  let server: http.Server
+
+  const adapter = new SASjs({
+    serverUrl: `http://localhost:${PORT}/`,
+    serverType: ServerType.SasViya
+  })
+
+  beforeAll(async () => {
+    await new Promise((resolve: any, reject: any) => {
+      server = app
+        .listen(PORT, () => resolve())
+        .on('error', (err: any) => reject(err))
+    })
+  })
+
+  afterAll(() => {
+    server.close()
+  })
+
+  it('should response the POST method', async () => {
+    const authResponse = await adapter.getAccessToken(
+      'clientId',
+      'clientSecret',
+      'authCode'
+    )
+
+    expect(authResponse.access_token).toBe(mockedAuthResponse.access_token)
+  })
+
+  it('should response the POST method with Unauthorized', async () => {
+    await expect(
+      adapter.getAccessToken('clientId', 'clientSecret', 'incorrect')
+    ).rejects.toThrow(
+      'Error while getting access token. Request failed with status code 401'
+    )
+  })
+})
+
+describe('RequestClient - Self Signed Server', () => {
+  let adapter: SASjs
+
+  let httpsServer: https.Server
+  let sslConfig: pem.CertificateCreationResult
+
+  beforeAll(async () => {
+    ;({ httpsServer, keys: sslConfig } = await setupSelfSignedServer())
+    await new Promise((resolve: any, reject: any) => {
+      httpsServer
+        .listen(PORT, () => resolve())
+        .on('error', (err: any) => reject(err))
+    })
+
+    adapter = new SASjs({
+      serverUrl: SERVER_URL,
+      serverType: ServerType.SasViya,
+      httpsAgentOptions: { ca: [sslConfig.certificate] }
+    })
+  })
+
+  afterAll(() => {
+    httpsServer.close()
+  })
+
+  it('should throw error for not providing certificate', async () => {
+    const adapterWithoutCertificate = new SASjs({
+      serverUrl: SERVER_URL,
+      serverType: ServerType.SasViya
+    })
+
+    await expect(
+      adapterWithoutCertificate.getAccessToken(
+        'clientId',
+        'clientSecret',
+        'authCode'
+      )
+    ).rejects.toThrow(
+      `Error while getting access token. ${ERROR_MESSAGES.selfSigned}`
+    )
+  })
+
+  it('should response the POST method using insecure flag', async () => {
+    const adapterAllowInsecure = new SASjs({
+      serverUrl: SERVER_URL,
+      serverType: ServerType.SasViya,
+      httpsAgentOptions: { rejectUnauthorized: false }
+    })
+
+    const authResponse = await adapterAllowInsecure.getAccessToken(
+      'clientId',
+      'clientSecret',
+      'authCode'
+    )
+
+    expect(authResponse.access_token).toBe(mockedAuthResponse.access_token)
+  })
+
+  it('should response the POST method', async () => {
+    const authResponse = await adapter.getAccessToken(
+      'clientId',
+      'clientSecret',
+      'authCode'
+    )
+
+    expect(authResponse.access_token).toBe(mockedAuthResponse.access_token)
+  })
+
+  it('should response the POST method with Unauthorized', async () => {
+    await expect(
+      adapter.getAccessToken('clientId', 'clientSecret', 'incorrect')
+    ).rejects.toThrow(
+      'Error while getting access token. Request failed with status code 401'
+    )
+  })
+})
+
+const setupSelfSignedServer = async (): Promise<{
+  httpsServer: https.Server
+  keys: pem.CertificateCreationResult
+}> => {
+  return await new Promise(async (resolve) => {
+    const keys = await createCertificate()
+
+    const httpsServer = https.createServer(
+      { key: keys.clientKey, cert: keys.certificate },
+      app
+    )
+
+    resolve({ httpsServer, keys })
+  })
+}
+
+const createCertificate = async (): Promise<pem.CertificateCreationResult> => {
+  return await new Promise((resolve, reject) => {
+    pem.createCertificate(
+      { days: 1, selfSigned: true },
+      (error: any, keys: pem.CertificateCreationResult) => {
+        if (error) reject(false)
+        resolve(keys)
+      }
+    )
+  })
+}

src/test/SAS_server_app.ts

@@ -0,0 +1,38 @@
+import express = require('express')
+
+export const app = express()
+
+export const mockedAuthResponse = {
+  access_token: 'access_token',
+  token_type: 'bearer',
+  id_token: 'id_token',
+  refresh_token: 'refresh_token',
+  expires_in: 43199,
+  scope: 'openid',
+  jti: 'jti'
+}
+
+app.get('/', function (req: any, res: any) {
+  res.send('Hello World')
+})
+
+app.post('/SASLogon/oauth/token', function (req: any, res: any) {
+  let valid = true
+  // capture the encoded form data
+  req.on('data', (data: any) => {
+    const resData = data.toString()
+
+    if (resData.includes('incorrect')) valid = false
+  })
+
+  // send a response when finished reading
+  // the encoded form data
+  req.on('end', () => {
+    if (valid) res.status(200).send(mockedAuthResponse)
+    else
+      res.status(401).send({
+        error: 'unauthorized',
+        error_description: 'Bad credentials'
+      })
+  })
+})

src/test/SessionManager.spec.ts

@@ -1,6 +1,5 @@
 import { SessionManager } from '../SessionManager'
 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'