Merge pull request #259 from sasjs/issue-258

Issue 258

src/job-execution/ComputeJobExecutor.ts

@@ -20,35 +20,52 @@ export class ComputeJobExecutor extends BaseJobExecutor {
     const waitForResult = true
     const expectWebout = true
 
-    return this.sasViyaApiClient
+    const requestPromise = new Promise((resolve, reject) => {
-      ?.executeComputeJob(
+      this.sasViyaApiClient
-        sasJob,
+        ?.executeComputeJob(
-        config.contextName,
+          sasJob,
-        config.debug,
+          config.contextName,
-        data,
+          config.debug,
-        accessToken,
+          data,
-        waitForResult,
+          accessToken,
-        expectWebout
+          waitForResult,
-      )
+          expectWebout
-      .then((response) => {
+        )
-        this.appendRequest(response, sasJob, config.debug)
+        .then((response) => {
-        let responseJson
+          this.appendRequest(response, sasJob, config.debug)
 
-        return response.result
+          resolve(response.result)
+        })
+        .catch(async (e: Error) => {
+          if (e instanceof ComputeJobExecutionError) {
+            this.appendRequest(e, sasJob, config.debug)
 
-        return responseJson
+            reject(new ErrorResponse(e?.message, e))
-      })
+          }
-      .catch(async (e: Error) => {
+
-        if (e instanceof ComputeJobExecutionError) {
+          if (e instanceof LoginRequiredError) {
-          this.appendRequest(e, sasJob, config.debug)
+            await loginCallback()
-        }
+            this.appendWaitingRequest(() => {
-        if (e instanceof LoginRequiredError) {
+              return this.execute(
-          await loginCallback()
+                sasJob,
-          this.appendWaitingRequest(() =>
+                data,
-            this.execute(sasJob, data, config, loginRequiredCallback)
+                config,
-          )
+                loginRequiredCallback
-        }
+              ).then(
-        return Promise.reject(new ErrorResponse(e?.message, e))
+                (res: any) => {
-      })
+                  resolve(res)
+                },
+                (err: any) => {
+                  reject(err)
+                }
+              )
+            })
+          } else {
+            reject(new ErrorResponse(e?.message, e))
+          }
+        })
+    })
+
+    return requestPromise
   }
 }

src/job-execution/JesJobExecutor.ts

@@ -17,24 +17,52 @@ export class JesJobExecutor extends BaseJobExecutor {
     accessToken?: string
   ) {
     const loginCallback = loginRequiredCallback || (() => Promise.resolve())
-    return await this.sasViyaApiClient
-      ?.executeJob(sasJob, config.contextName, config.debug, data, accessToken)
-      .then((response) => {
-        this.appendRequest(response, sasJob, config.debug)
 
-        return response.result
+    const requestPromise = new Promise((resolve, reject) => {
-      })
+      this.sasViyaApiClient
-      .catch(async (e: Error) => {
+        ?.executeJob(
-        if (e instanceof JobExecutionError) {
+          sasJob,
-          this.appendRequest(e, sasJob, config.debug)
+          config.contextName,
-        }
+          config.debug,
-        if (e instanceof LoginRequiredError) {
+          data,
-          await loginCallback()
+          accessToken
-          this.appendWaitingRequest(() =>
+        )
-            this.execute(sasJob, data, config, loginRequiredCallback)
+        .then((response) => {
-          )
+          this.appendRequest(response, sasJob, config.debug)
-        }
+
-        return Promise.reject(new ErrorResponse(e?.message, e))
+          resolve(response.result)
-      })
+        })
+        .catch(async (e: Error) => {
+          if (e instanceof JobExecutionError) {
+            this.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
+              ).then(
+                (res: any) => {
+                  resolve(res)
+                },
+                (err: any) => {
+                  reject(err)
+                }
+              )
+            })
+          } else {
+            reject(new ErrorResponse(e?.message, e))
+          }
+        })
+    })
+
+    return requestPromise
   }
 }

src/job-execution/WebJobExecutor.ts

@@ -7,6 +7,11 @@ import { SASViyaApiClient } from '../SASViyaApiClient'
 import { isRelativePath } from '../utils'
 import { BaseJobExecutor } from './JobExecutor'
 
+export interface WaitingRequstPromise {
+  promise: Promise<any> | null
+  resolve: any
+  reject: any
+}
 export class WebJobExecutor extends BaseJobExecutor {
   constructor(
     serverUrl: string,
@@ -80,30 +85,51 @@ export class WebJobExecutor extends BaseJobExecutor {
       }
     }
 
-    return this.requestClient!.post(apiUrl, formData, undefined)
+    const requestPromise = new Promise((resolve, reject) => {
-      .then(async (res) => {
+      this.requestClient!.post(apiUrl, formData, undefined)
-        if (this.serverType === ServerType.SasViya && config.debug) {
+        .then(async (res) => {
-          const jsonResponse = await this.parseSasViyaDebugResponse(
+          if (this.serverType === ServerType.SasViya && config.debug) {
-            res.result as string
+            const jsonResponse = await this.parseSasViyaDebugResponse(
-          )
+              res.result as string
+            )
+            this.appendRequest(res, sasJob, config.debug)
+            resolve(jsonResponse)
+          }
           this.appendRequest(res, sasJob, config.debug)
-          return jsonResponse
+          resolve(res.result)
-        }
+        })
-        this.appendRequest(res, sasJob, config.debug)
+        .catch(async (e: Error) => {
-        return res.result
+          if (e instanceof JobExecutionError) {
-      })
+            this.appendRequest(e, sasJob, config.debug)
-      .catch(async (e: Error) => {
+
-        if (e instanceof JobExecutionError) {
+            reject(new ErrorResponse(e?.message, e))
-          this.appendRequest(e, sasJob, config.debug)
+          }
-        }
+
-        if (e instanceof LoginRequiredError) {
+          if (e instanceof LoginRequiredError) {
-          await loginCallback()
+            await loginCallback()
-          this.appendWaitingRequest(() =>
+
-            this.execute(sasJob, data, config, loginRequiredCallback)
+            this.appendWaitingRequest(() => {
-          )
+              return this.execute(
-        }
+                sasJob,
-        return Promise.reject(new ErrorResponse(e?.message, e))
+                data,
-      })
+                config,
+                loginRequiredCallback
+              ).then(
+                (res: any) => {
+                  resolve(res)
+                },
+                (err: any) => {
+                  reject(err)
+                }
+              )
+            })
+          } else {
+            reject(new ErrorResponse(e?.message, e))
+          }
+        })
+    })
+
+    return requestPromise
   }
 
   private parseSasViyaDebugResponse = async (response: string) => {

src/request/RequestClient.ts

@@ -386,6 +386,7 @@ export class RequestClient implements HttpClient {
   private parseResponse<T>(response: AxiosResponse<any>) {
     const etag = response?.headers ? response.headers['etag'] : ''
     let parsedResponse
+    let includeSAS9Log: boolean = false
 
     try {
       if (typeof response.data === 'string') {
@@ -399,11 +400,20 @@ export class RequestClient implements HttpClient {
       } catch {
         parsedResponse = response.data
       }
+
+      includeSAS9Log = true
     }
-    return {
+
+    let responseToReturn: { result: T; etag: any; log?: string } = {
       result: parsedResponse as T,
       etag
     }
+
+    if (includeSAS9Log) {
+      responseToReturn.log = response.data
+    }
+
+    return responseToReturn
   }
 }
 

src/test/SessionManager.spec.ts

@@ -29,7 +29,10 @@ describe('SessionManager', () => {
         Promise.resolve({ data: sampleResponse })
       )
 
-      const expectedResponse = { etag: '', result: sampleResponse }
+      const expectedResponse = {
+        etag: '',
+        result: sampleResponse
+      }
 
       await expect(
         sessionManager.getVariable(