Merge pull request #749 from sasjs/update-sasjs-request-client

fix: update parse response method of sasjsRequestClient

.github/dependabot.yml

@@ -4,4 +4,4 @@ updates:
     directory: "/"
     schedule:
       interval: "monthly"
-    open-pull-requests-limit: 2
+    open-pull-requests-limit: 1

README.md

@@ -237,7 +237,8 @@ run;
 %webout(OBJ,a) /* Rows in table `a` are objects (easy to use) */
 %webout(ARR,b) /* Rows in table `b` are arrays (compact) */
 %webout(OBJ,c,fmt=N) /* Table `c` is sent unformatted (raw) */
-%webout(OBJ,c,label=d) /* Rename as `d` on JS side */
+%webout(OBJ,c,label=d) /* Rename table as `d` in output JSON */
+%webout(OBJ,c,label=e, maxobs=10) /* send only 10 rows back */
 %webout(CLOSE) /* Close the JSON and add default variables */
 ```
 

src/SASjs.ts

@@ -1,4 +1,4 @@
-import { compareTimestamps, asyncForEach } from './utils'
+import { compareTimestamps, asyncForEach, validateInput } from './utils'
 import {
   SASjsConfig,
   UploadFile,
@@ -24,6 +24,7 @@ import { SasjsRequestClient } from './request/SasjsRequestClient'
 import {
   JobExecutor,
   WebJobExecutor,
+  SasjsJobExecutor,
   ComputeJobExecutor,
   JesJobExecutor,
   Sas9JobExecutor,
@@ -59,6 +60,7 @@ export default class SASjs {
   private authManager: AuthManager | null = null
   private requestClient: RequestClient | null = null
   private webJobExecutor: JobExecutor | null = null
+  private sasjsJobExecutor: JobExecutor | null = null
   private computeJobExecutor: JobExecutor | null = null
   private jesJobExecutor: JobExecutor | null = null
   private sas9JobExecutor: JobExecutor | null = null
@@ -102,10 +104,14 @@ export default class SASjs {
    * @param code - a string of code from the file to run.
    * @param authConfig - (optional) a valid client, secret, refresh and access tokens that are authorised to execute scripts.
    */
-  public async executeScriptSASjs(code: string, authConfig?: AuthConfig) {
+  public async executeScriptSASjs(
+    code: string,
+    runTime?: string,
+    authConfig?: AuthConfig
+  ) {
     this.isMethodSupported('executeScriptSASJS', [ServerType.Sasjs])
 
-    return await this.sasJSApiClient?.executeScript(code, authConfig)
+    return await this.sasJSApiClient?.executeScript(code, runTime, authConfig)
   }
 
   /**
@@ -686,12 +692,12 @@ export default class SASjs {
       ...config
     }
 
-    const validationResult = this.validateInput(data)
+    const validationResult = validateInput(data)
 
     // status is true if the data passes validation checks above
     if (validationResult.status) {
       if (config.serverType === ServerType.Sasjs) {
-        return await this.webJobExecutor!.execute(
+        return await this.sasjsJobExecutor!.execute(
           sasJob,
           data,
           config,
@@ -748,74 +754,6 @@ export default class SASjs {
     }
   }
 
-  /**
-   * This function validates the input data structure and table naming convention
-   *
-   * @param data A json object that contains one or more tables, it can also be null
-   * @returns An object which contains two attributes: 1) status: boolean, 2) msg: string
-   */
-  private validateInput(data: { [key: string]: any } | null): {
-    status: boolean
-    msg: string
-  } {
-    if (data === null) return { status: true, msg: '' }
-
-    const isSasFormatsTable = (key: string) =>
-      key.match(/^\$.*/) && Object.keys(data).includes(key.replace(/^\$/, ''))
-
-    for (const key in data) {
-      if (!key.match(/^[a-zA-Z_]/) && !isSasFormatsTable(key)) {
-        return {
-          status: false,
-          msg: 'First letter of table should be alphabet or underscore.'
-        }
-      }
-
-      if (!key.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/) && !isSasFormatsTable(key)) {
-        return { status: false, msg: 'Table name should be alphanumeric.' }
-      }
-
-      if (key.length > 32) {
-        return {
-          status: false,
-          msg: 'Maximum length for table name could be 32 characters.'
-        }
-      }
-
-      if (this.getType(data[key]) !== 'Array' && !isSasFormatsTable(key)) {
-        return {
-          status: false,
-          msg: 'Parameter data contains invalid table structure.'
-        }
-      }
-
-      for (let i = 0; i < data[key].length; i++) {
-        if (this.getType(data[key][i]) !== 'object') {
-          return {
-            status: false,
-            msg: `Table ${key} contains invalid structure.`
-          }
-        }
-      }
-    }
-
-    return { status: true, msg: '' }
-  }
-
-  /**
-   * this function returns the type of variable
-   *
-   * @param data it could be anything, like string, array, object etc.
-   * @returns a string which tells the type of input parameter
-   */
-  private getType(data: any): string {
-    if (Array.isArray(data)) {
-      return 'Array'
-    } else {
-      return typeof data
-    }
-  }
-
   /**
    * Creates the folders and services at the given location `appLoc` on the given server `serverUrl`.
    * @param serviceJson - the JSON specifying the folders and services to be created.
@@ -1117,6 +1055,12 @@ export default class SASjs {
       this.sasViyaApiClient!
     )
 
+    this.sasjsJobExecutor = new SasjsJobExecutor(
+      this.sasjsConfig.serverUrl,
+      this.jobsPath,
+      this.requestClient
+    )
+
     this.sas9JobExecutor = new Sas9JobExecutor(
       this.sasjsConfig.serverUrl,
       this.sasjsConfig.serverType!,

src/SASjsApiClient.ts

@@ -3,7 +3,7 @@ import { ExecutionQuery } from './types'
 import { RequestClient } from './request/RequestClient'
 import { getAccessTokenForSasjs } from './auth/getAccessTokenForSasjs'
 import { refreshTokensForSasjs } from './auth/refreshTokensForSasjs'
-import { parseWeboutResponse } from './utils'
+import { parseWeboutResponse, SASJS_LOGS_SEPARATOR } from './utils'
 import { getTokens } from './auth/getTokens'
 
 export class SASjsApiClient {
@@ -64,9 +64,14 @@ export class SASjsApiClient {
   /**
    * Executes code on a SASJS server.
    * @param code - a string of code to execute.
+   * @param runTime - a string to representing runTime for code execution
    * @param authConfig - an object for authentication.
    */
-  public async executeScript(code: string, authConfig?: AuthConfig) {
+  public async executeScript(
+    code: string,
+    runTime: string = 'sas',
+    authConfig?: AuthConfig
+  ) {
     let access_token = (authConfig || {}).access_token
     if (authConfig) {
       ;({ access_token } = await getTokens(
@@ -79,13 +84,9 @@ export class SASjsApiClient {
     let parsedSasjsServerLog = ''
 
     await this.requestClient
-      .post('SASjsApi/code/execute', { code }, access_token)
+      .post('SASjsApi/code/execute', { code, runTime }, access_token)
       .then((res: any) => {
-        if (res.result?.log) {
-          parsedSasjsServerLog = res.result.log
-            .map((logLine: any) => logLine.line)
-            .join('\n')
-        }
+        if (res.log) parsedSasjsServerLog = res.log
       })
       .catch((err) => {
         parsedSasjsServerLog = err

src/auth/AuthManager.ts

@@ -223,9 +223,17 @@ export class AuthManager {
 
   private async getNewLoginForm() {
     if (this.serverType === ServerType.Sasjs) {
-      // server will be sending CSRF cookie,
+      // server will be sending CSRF token in response,
+      // need to save in cookie so that,
       // http client will use it automatically
-      return this.requestClient.get('/', undefined)
+      return this.requestClient.get('/', undefined).then(({ result }) => {
+        const cookie =
+          /<script>document.cookie = '(XSRF-TOKEN=.*; Max-Age=86400; SameSite=Strict; Path=\/;)'<\/script>/.exec(
+            result as string
+          )?.[1]
+
+        if (cookie) document.cookie = cookie
+      })
     }
 
     const { result: formResponse } = await this.requestClient.get<string>(

src/auth/refreshTokensForSasjs.ts

@@ -28,7 +28,7 @@ export async function refreshTokensForSasjs(
       }
     })
     .catch((err) => {
-      throw prefixMessage(err, 'Error while refreshing tokens')
+      throw prefixMessage(err, 'Error while refreshing tokens: ')
     })
 
   return authResponse

src/auth/refreshTokensForViya.ts

@@ -42,7 +42,7 @@ export async function refreshTokensForViya(
     )
     .then((res) => res.result)
     .catch((err) => {
-      throw prefixMessage(err, 'Error while refreshing tokens')
+      throw prefixMessage(err, 'Error while refreshing tokens: ')
     })
 
   return authResponse

src/auth/spec/refreshTokensForSasjs.spec.ts

@@ -27,17 +27,20 @@ describe('refreshTokensForSasjs', () => {
 
   it('should handle errors while refreshing tokens', async () => {
     setupMocks()
+
     const refresh_token = generateToken(30)
+    const tokenError = 'unable to verify the first certificate'
+
     jest
       .spyOn(requestClient, 'post')
-      .mockImplementation(() => Promise.reject('Token Error'))
+      .mockImplementation(() => Promise.reject(tokenError))
 
     const error = await refreshTokensForSasjs(
       requestClient,
       refresh_token
     ).catch((e: any) => e)
 
-    expect(error).toContain('Error while refreshing tokens')
+    expect(error).toEqual(`Error while refreshing tokens: ${tokenError}`)
   })
 })
 

src/auth/spec/refreshTokensForViya.spec.ts

@@ -46,17 +46,20 @@ describe('refreshTokensForViya', () => {
 
   it('should handle errors while refreshing tokens', async () => {
     setupMocks()
+
     const access_token = generateToken(30)
     const refresh_token = generateToken(30)
+    const tokenError = 'unable to verify the first certificate'
     const authConfig: AuthConfig = {
       access_token,
       refresh_token,
       client: 'cl13nt',
       secret: 's3cr3t'
     }
+
     jest
       .spyOn(requestClient, 'post')
-      .mockImplementation(() => Promise.reject('Token Error'))
+      .mockImplementation(() => Promise.reject(tokenError))
 
     const error = await refreshTokensForViya(
       requestClient,
@@ -65,7 +68,7 @@ describe('refreshTokensForViya', () => {
       authConfig.refresh_token
     ).catch((e: any) => e)
 
-    expect(error).toContain('Error while refreshing tokens')
+    expect(error).toEqual(`Error while refreshing tokens: ${tokenError}`)
   })
 })
 

src/job-execution/FileUploader.ts

@@ -1,7 +1,8 @@
 import {
   getValidJson,
   parseSasViyaDebugResponse,
-  parseWeboutResponse
+  parseWeboutResponse,
+  SASJS_LOGS_SEPARATOR
 } from '../utils'
 import { UploadFile } from '../types/UploadFile'
 import {
@@ -99,21 +100,8 @@ export class FileUploader extends BaseJobExecutor {
                     ? parseWeboutResponse(res.result, uploadUrl)
                     : res.result
                 break
-              case ServerType.Sasjs:
-                if (typeof res.result._webout === 'object') {
-                  jsonResponse = res.result._webout
-                } else {
-                  const webout = parseWeboutResponse(
-                    res.result._webout,
-                    uploadUrl
-                  )
-                  jsonResponse = getValidJson(webout)
-                }
-                break
             }
-          } else if (this.serverType === ServerType.Sasjs) {
-            jsonResponse = getValidJson(res.result._webout)
-          } else {
+          } else if (this.serverType !== ServerType.Sasjs) {
             jsonResponse =
               typeof res.result === 'string'
                 ? getValidJson(res.result)

src/job-execution/JobExecutor.ts

@@ -1,6 +1,6 @@
 import { AuthConfig, ServerType } from '@sasjs/utils/types'
 import { ExtraResponseAttributes } from '@sasjs/utils/types'
-import { asyncForEach } from '../utils'
+import { asyncForEach, isRelativePath } from '../utils'
 
 export type ExecuteFunction = () => Promise<any>
 
@@ -45,4 +45,17 @@ export abstract class BaseJobExecutor implements JobExecutor {
   protected appendWaitingRequest(request: ExecuteFunction) {
     this.waitingRequests.push(request)
   }
+
+  protected getRequestParams(config: any): any {
+    const requestParams: any = {}
+
+    if (config.debug) {
+      requestParams['_omittextlog'] = 'false'
+      requestParams['_omitsessionresults'] = 'false'
+
+      requestParams['_debug'] = 131
+    }
+
+    return requestParams
+  }
 }

src/job-execution/Sas9JobExecutor.ts

@@ -102,7 +102,7 @@ export class Sas9JobExecutor extends BaseJobExecutor {
     return requestPromise
   }
 
-  private getRequestParams(config: any): any {
+  protected getRequestParams(config: any): any {
     const requestParams: any = {}
 
     if (config.debug) {

src/job-execution/SasjsJobExecutor.ts

@@ -0,0 +1,141 @@
+import * as NodeFormData from 'form-data'
+import {
+  AuthConfig,
+  ExtraResponseAttributes,
+  ServerType
+} from '@sasjs/utils/types'
+import {
+  ErrorResponse,
+  JobExecutionError,
+  LoginRequiredError
+} from '../types/errors'
+import { generateFileUploadForm } from '../file/generateFileUploadForm'
+
+import { RequestClient } from '../request/RequestClient'
+
+import { isRelativePath, appendExtraResponseAttributes } from '../utils'
+import { BaseJobExecutor } from './JobExecutor'
+
+export class SasjsJobExecutor extends BaseJobExecutor {
+  constructor(
+    serverUrl: string,
+    private jobsPath: string,
+    private requestClient: RequestClient
+  ) {
+    super(serverUrl, ServerType.Sasjs)
+  }
+
+  async execute(
+    sasJob: string,
+    data: any,
+    config: any,
+    loginRequiredCallback?: any,
+    authConfig?: AuthConfig,
+    extraResponseAttributes: ExtraResponseAttributes[] = []
+  ) {
+    const loginCallback = loginRequiredCallback
+    const program =
+      isRelativePath(sasJob) && config.appLoc
+        ? config.appLoc.replace(/\/?$/, '/') + sasJob.replace(/^\//, '')
+        : sasJob
+
+    let apiUrl = `${config.serverUrl}${this.jobsPath}/?${'_program=' + program}`
+
+    let requestParams = {
+      ...this.getRequestParams(config)
+    }
+
+    /**
+     * Use the available form data object (FormData in Browser, NodeFormData in
+     *  Node)
+     */
+    let formData =
+      typeof FormData === 'undefined' ? new NodeFormData() : new FormData()
+
+    if (data) {
+      // file upload approach
+      try {
+        formData = generateFileUploadForm(formData, data)
+      } catch (e: any) {
+        return Promise.reject(new ErrorResponse(e?.message, e))
+      }
+    }
+
+    for (const key in requestParams) {
+      if (requestParams.hasOwnProperty(key)) {
+        formData.append(key, requestParams[key])
+      }
+    }
+
+    /* The NodeFormData object does not set the request header - so, set it */
+    const contentType =
+      formData instanceof NodeFormData && typeof FormData === 'undefined'
+        ? `multipart/form-data; boundary=${formData.getBoundary()}`
+        : undefined
+
+    const requestPromise = new Promise((resolve, reject) => {
+      this.requestClient!.post(
+        apiUrl,
+        formData,
+        authConfig?.access_token,
+        contentType
+      )
+        .then(async (res: any) => {
+          if (Object.entries(res.result).length < 1) {
+            throw new JobExecutionError(
+              0,
+              `No webout was returned by job ${program}.  Please check the SAS log for more info.`,
+              res.log
+            )
+          }
+
+          this.requestClient!.appendRequest(res, sasJob, config.debug)
+
+          const responseObject = appendExtraResponseAttributes(
+            res,
+            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) {
+            if (!loginRequiredCallback) {
+              reject(
+                new ErrorResponse(
+                  'Request is not authenticated. Make sure .env file exists with valid credentials.',
+                  e
+                )
+              )
+            }
+
+            this.appendWaitingRequest(() => {
+              return this.execute(
+                sasJob,
+                data,
+                config,
+                loginRequiredCallback,
+                authConfig,
+                extraResponseAttributes
+              ).then(
+                (res: any) => {
+                  resolve(res)
+                },
+                (err: any) => {
+                  reject(err)
+                }
+              )
+            })
+
+            if (loginCallback) await loginCallback()
+          } else reject(new ErrorResponse(e?.message, e))
+        })
+    })
+
+    return requestPromise
+  }
+}

src/job-execution/WebJobExecutor.ts

@@ -16,12 +16,10 @@ import { SASViyaApiClient } from '../SASViyaApiClient'
 import {
   isRelativePath,
   parseSasViyaDebugResponse,
-  appendExtraResponseAttributes,
-  getValidJson
+  appendExtraResponseAttributes
 } from '../utils'
 import { BaseJobExecutor } from './JobExecutor'
 import { parseWeboutResponse } from '../utils/parseWeboutResponse'
-import { Server } from 'https'
 
 export interface WaitingRequstPromise {
   promise: Promise<any> | null
@@ -121,7 +119,6 @@ export class WebJobExecutor extends BaseJobExecutor {
       const stringifiedData = JSON.stringify(data)
       if (
         config.serverType === ServerType.Sas9 ||
-        config.serverType === ServerType.Sasjs ||
         stringifiedData.length > 500000 ||
         stringifiedData.includes(';')
       ) {
@@ -164,31 +161,7 @@ export class WebJobExecutor extends BaseJobExecutor {
         contentType
       )
         .then(async (res: any) => {
-          const parsedSasjsServerLog =
-            this.serverType === ServerType.Sasjs
-              ? res.result.log.map((logLine: any) => logLine.line).join('\n')
-              : res.result.log
-
-          const resObj =
-            this.serverType === ServerType.Sasjs
-              ? {
-                  result: res.result._webout,
-                  log: parsedSasjsServerLog
-                }
-              : res
-
-          if (
-            this.serverType === ServerType.Sasjs &&
-            res.result._webout.length < 1
-          ) {
-            throw new JobExecutionError(
-              0,
-              `No webout was returned by job ${program}. Server type is SASJS and the calling function is WebJobExecutor. Please check the SAS log for more info.`,
-              parsedSasjsServerLog
-            )
-          }
-
-          this.requestClient!.appendRequest(resObj, sasJob, config.debug)
+          this.requestClient!.appendRequest(res, sasJob, config.debug)
 
           let jsonResponse = res.result
 
@@ -207,21 +180,11 @@ export class WebJobExecutor extends BaseJobExecutor {
                     ? parseWeboutResponse(res.result, apiUrl)
                     : res.result
                 break
-              case ServerType.Sasjs:
-                if (typeof res.result._webout === 'object') {
-                  jsonResponse = res.result._webout
-                } else {
-                  const webout = parseWeboutResponse(res.result._webout, apiUrl)
-                  jsonResponse = getValidJson(webout)
-                }
-                break
             }
-          } else if (this.serverType === ServerType.Sasjs) {
-            jsonResponse = getValidJson(res.result._webout)
           }
 
           const responseObject = appendExtraResponseAttributes(
-            { result: jsonResponse, log: parsedSasjsServerLog },
+            { result: jsonResponse, log: res.log },
             extraResponseAttributes
           )
           resolve(responseObject)
@@ -261,9 +224,7 @@ export class WebJobExecutor extends BaseJobExecutor {
             })
 
             if (loginCallback) await loginCallback()
-          } else {
-            reject(new ErrorResponse(e?.message, e))
-          }
+          } else reject(new ErrorResponse(e?.message, e))
         })
     })
 
@@ -301,39 +262,4 @@ export class WebJobExecutor extends BaseJobExecutor {
     }
     return uri
   }
-
-  private getRequestParams(config: any): any {
-    const requestParams: any = {}
-
-    if (config.debug) {
-      requestParams['_omittextlog'] = 'false'
-      requestParams['_omitsessionresults'] = 'false'
-
-      requestParams['_debug'] = 131
-    }
-
-    return requestParams
-  }
-
-  private parseSAS9ErrorResponse(response: string) {
-    const logLines = response.split('\n')
-    const parsedLines: string[] = []
-    let firstErrorLineIndex: number = -1
-
-    logLines.map((line: string, index: number) => {
-      if (
-        line.toLowerCase().includes('error') &&
-        !line.toLowerCase().includes('this request completed with errors.') &&
-        firstErrorLineIndex === -1
-      ) {
-        firstErrorLineIndex = index
-      }
-    })
-
-    for (let i = firstErrorLineIndex - 10; i <= firstErrorLineIndex + 10; i++) {
-      parsedLines.push(logLines[i])
-    }
-
-    return parsedLines.join(', ')
-  }
 }

src/job-execution/index.ts

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

src/request/RequestClient.ts

@@ -19,7 +19,7 @@ import {
   parseSourceCode,
   createAxiosInstance
 } from '../utils'
-import { InvalidCsrfError } from '../types/errors/InvalidCsrfError'
+import { InvalidSASjsCsrfError } from '../types/errors/InvalidSASjsCsrfError'
 
 export interface HttpClient {
   get<T>(
@@ -133,29 +133,13 @@ export class RequestClient implements HttpClient {
         } else {
           sasWork = response.log
         }
-      } else if (response?.result?.log) {
-        //In this scenario we know we got the response from SASJS server
-        //Log is array of `{ line: '' }` so we need to convert it back to text
-        //To be able to parse it with current functions.
-        let log: string = ''
-
-        if (typeof log !== 'string') {
-          log = response.result.log
-            .map((logLine: any) => logLine.line)
-            .join('\n')
-        }
-
-        sourceCode = parseSourceCode(log)
-        generatedCode = parseGeneratedCode(log)
-
-        if (response?.result?._webout) {
-          sasWork = response.result._webout.WORK
-        } else {
-          sasWork = log
-        }
       } else if (response?.result) {
-        sourceCode = parseSourceCode(response.result)
-        generatedCode = parseGeneratedCode(response.result)
+        // We parse only if it's a string, otherwise it would throw error
+        if (typeof response.result === 'string') {
+          sourceCode = parseSourceCode(response.result)
+          generatedCode = parseGeneratedCode(response.result)
+        }
+
         sasWork = response.result.WORK
       }
     }
@@ -499,12 +483,20 @@ export class RequestClient implements HttpClient {
       throw e
     }
 
-    if (e instanceof InvalidCsrfError) {
-      // Fetching root will inject CSRF token in cookie
+    if (e instanceof InvalidSASjsCsrfError) {
+      // Fetching root and creating CSRF cookie
       await this.httpClient
         .get('/', {
           withCredentials: true
         })
+        .then((response) => {
+          const cookie =
+            /<script>document.cookie = '(XSRF-TOKEN=.*; Max-Age=86400; SameSite=Strict; Path=\/;)'<\/script>/.exec(
+              response.data
+            )?.[1]
+
+          if (cookie) document.cookie = cookie
+        })
         .catch((err) => {
           throw prefixMessage(err, 'Error while re-fetching CSRF token.')
         })
@@ -611,8 +603,11 @@ export const throwIfError = (response: AxiosResponse) => {
         throw new LoginRequiredError(response.data)
       }
 
-      if (response.data.toLowerCase() === 'invalid csrf token!') {
-        throw new InvalidCsrfError()
+      if (
+        typeof response.data === 'string' &&
+        response.data.toLowerCase() === 'invalid csrf token!'
+      ) {
+        throw new InvalidSASjsCsrfError()
       }
       break
     case 401:

src/request/SasjsRequestClient.ts

@@ -1,9 +1,12 @@
 import { RequestClient } from './RequestClient'
+import { AxiosResponse } from 'axios'
+import { SASJS_LOGS_SEPARATOR, getValidJson } from '../utils'
 
 /**
  * Specific request client for SASJS.
  * Append tokens in headers.
  */
+
 export class SasjsRequestClient extends RequestClient {
   getHeaders = (accessToken: string | undefined, contentType: string) => {
     const headers: any = {}
@@ -20,4 +23,32 @@ export class SasjsRequestClient extends RequestClient {
 
     return headers
   }
+
+  protected parseResponse<T>(response: AxiosResponse<any>) {
+    const etag = response?.headers ? response.headers['etag'] : ''
+    let parsedResponse = {}
+    let log
+
+    try {
+      if (typeof response.data === 'string') {
+        parsedResponse = JSON.parse(response.data)
+      } else {
+        parsedResponse = response.data
+      }
+    } catch {
+      if (response.data.includes(SASJS_LOGS_SEPARATOR)) {
+        const splittedResponse = response.data.split(SASJS_LOGS_SEPARATOR)
+        log = splittedResponse[1]
+        if (splittedResponse[0].trim())
+          parsedResponse = getValidJson(splittedResponse[0])
+      } else parsedResponse = response.data
+    }
+
+    return {
+      result: parsedResponse as T,
+      log,
+      etag,
+      status: response.status
+    }
+  }
 }

src/types/errors/InvalidCsrfError.ts

@@ -1,9 +0,0 @@
-export class InvalidCsrfError extends Error {
-  constructor() {
-    const message = 'Invalid CSRF token!'
-
-    super(`Auth error: ${message}`)
-    this.name = 'InvalidCsrfError'
-    Object.setPrototypeOf(this, InvalidCsrfError.prototype)
-  }
-}

src/types/errors/InvalidSASjsCsrfError.ts

@@ -0,0 +1,9 @@
+export class InvalidSASjsCsrfError extends Error {
+  constructor() {
+    const message = 'Invalid CSRF token!'
+
+    super(`Auth error: ${message}`)
+    this.name = 'InvalidSASjsCsrfError'
+    Object.setPrototypeOf(this, InvalidSASjsCsrfError.prototype)
+  }
+}

src/utils/constants.ts

@@ -0,0 +1,2 @@
+export const SASJS_LOGS_SEPARATOR =
+  'SASJS_LOGS_SEPARATOR_163ee17b6ff24f028928972d80a26784'

src/utils/index.ts

@@ -1,20 +1,22 @@
+export * from './appendExtraResponseAttributes'
 export * from './asyncForEach'
 export * from './compareTimestamps'
 export * from './convertToCsv'
+export * from './constants'
 export * from './createAxiosInstance'
 export * from './delay'
+export * from './fetchLogByChunks'
+export * from './getValidJson'
 export * from './isNode'
 export * from './isRelativePath'
 export * from './isUri'
 export * from './isUrl'
 export * from './needsRetry'
 export * from './parseGeneratedCode'
-export * from './parseSourceCode'
 export * from './parseSasViyaLog'
+export * from './parseSourceCode'
+export * from './parseViyaDebugResponse'
+export * from './parseWeboutResponse'
 export * from './serialize'
 export * from './splitChunks'
-export * from './parseWeboutResponse'
-export * from './fetchLogByChunks'
-export * from './getValidJson'
-export * from './parseViyaDebugResponse'
-export * from './appendExtraResponseAttributes'
+export * from './validateInput'

src/utils/spec/convertToCsv.spec.ts

@@ -1,4 +1,4 @@
-import { convertToCSV, isFormatsTable } from './convertToCsv'
+import { convertToCSV, isFormatsTable } from '../convertToCsv'
 
 describe('convertToCsv', () => {
   const tableName = 'testTable'

src/utils/spec/validateInput.spec.ts

@@ -0,0 +1,84 @@
+import {
+  validateInput,
+  INVALID_TABLE_STRUCTURE,
+  MORE_INFO
+} from '../validateInput'
+
+const tableArray = [{ col1: 'first col value' }]
+const stringData: any = { table1: tableArray }
+
+describe('validateInput', () => {
+  it('should not return an error message if input data valid', () => {
+    const validationResult = validateInput(stringData)
+    expect(validationResult).toEqual({
+      status: true,
+      msg: ''
+    })
+  })
+
+  it('should not return an error message if input data is null', () => {
+    const validationResult = validateInput(null)
+    expect(validationResult).toEqual({
+      status: true,
+      msg: ''
+    })
+  })
+
+  it('should return an error message if input data is an array', () => {
+    const validationResult = validateInput(tableArray)
+    expect(validationResult).toEqual({
+      status: false,
+      msg: INVALID_TABLE_STRUCTURE
+    })
+  })
+
+  it('should return an error message if first letter of table is neither alphabet nor underscore', () => {
+    const validationResult = validateInput({ '1stTable': tableArray })
+    expect(validationResult).toEqual({
+      status: false,
+      msg: 'First letter of table should be alphabet or underscore.'
+    })
+  })
+
+  it('should return an error message if table name contains a character other than alphanumeric or underscore', () => {
+    const validationResult = validateInput({ 'table!': tableArray })
+    expect(validationResult).toEqual({
+      status: false,
+      msg: 'Table name should be alphanumeric.'
+    })
+  })
+
+  it('should return an error message if length of table name contains exceeds 32', () => {
+    const validationResult = validateInput({
+      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx: tableArray
+    })
+    expect(validationResult).toEqual({
+      status: false,
+      msg: 'Maximum length for table name could be 32 characters.'
+    })
+  })
+
+  it('should return an error message if table does not have array of objects', () => {
+    const validationResult = validateInput({ table: stringData })
+    expect(validationResult).toEqual({
+      status: false,
+      msg: INVALID_TABLE_STRUCTURE
+    })
+  })
+
+  it('should return an error message if a table array has an item other than object', () => {
+    const validationResult = validateInput({ table1: ['invalid'] })
+    expect(validationResult).toEqual({
+      status: false,
+      msg: `Table table1 contains invalid structure. ${MORE_INFO}`
+    })
+  })
+
+  it('should return an error message if a row in a table contains an column with undefined value', () => {
+    const validationResult = validateInput({ table1: [{ column: undefined }] })
+    expect(validationResult).toEqual({
+      status: false,
+      msg: `A row in table table1 contains invalid value. Can't assign undefined to column.`
+    })
+  })
+})

src/utils/validateInput.ts

@@ -0,0 +1,90 @@
+export const MORE_INFO =
+  'For more info see https://sasjs.io/sasjs-adapter/#request-response'
+export const INVALID_TABLE_STRUCTURE = `Parameter data contains invalid table structure. ${MORE_INFO}`
+
+/**
+ * This function validates the input data structure and table naming convention
+ *
+ * @param data A json object that contains one or more tables, it can also be null
+ * @returns An object which contains two attributes: 1) status: boolean, 2) msg: string
+ */
+export const validateInput = (
+  data: { [key: string]: any } | null
+): {
+  status: boolean
+  msg: string
+} => {
+  if (data === null) return { status: true, msg: '' }
+
+  if (getType(data) !== 'object') {
+    return {
+      status: false,
+      msg: INVALID_TABLE_STRUCTURE
+    }
+  }
+
+  const isSasFormatsTable = (key: string) =>
+    key.match(/^\$.*/) && Object.keys(data).includes(key.replace(/^\$/, ''))
+
+  for (const key in data) {
+    if (!key.match(/^[a-zA-Z_]/) && !isSasFormatsTable(key)) {
+      return {
+        status: false,
+        msg: 'First letter of table should be alphabet or underscore.'
+      }
+    }
+
+    if (!key.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/) && !isSasFormatsTable(key)) {
+      return { status: false, msg: 'Table name should be alphanumeric.' }
+    }
+
+    if (key.length > 32) {
+      return {
+        status: false,
+        msg: 'Maximum length for table name could be 32 characters.'
+      }
+    }
+
+    if (getType(data[key]) !== 'Array' && !isSasFormatsTable(key)) {
+      return {
+        status: false,
+        msg: INVALID_TABLE_STRUCTURE
+      }
+    }
+
+    for (const item of data[key]) {
+      if (getType(item) !== 'object') {
+        return {
+          status: false,
+          msg: `Table ${key} contains invalid structure. ${MORE_INFO}`
+        }
+      } else {
+        const attributes = Object.keys(item)
+        for (const attribute of attributes) {
+          if (item[attribute] === undefined) {
+            return {
+              status: false,
+              msg: `A row in table ${key} contains invalid value. Can't assign undefined to ${attribute}.`
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return { status: true, msg: '' }
+}
+
+/**
+ * this function returns the type of variable
+ *
+ * @param data it could be anything, like string, array, object etc.
+ * @returns a string which tells the type of input parameter
+ */
+const getType = (data: any): string => {
+  if (Array.isArray(data)) {
+    return 'Array'
+  } else {
+    return typeof data
+  }
+}