chore(deps): bump form-data and cypress

Bumps [form-data](https://github.com/form-data/form-data) to 4.0.4 and updates ancestor dependency [cypress](https://github.com/cypress-io/cypress). These dependencies need to be updated together. Updates `form-data` from 2.3.3 to 4.0.4 - [Release notes](https://github.com/form-data/form-data/releases) - [Changelog](https://github.com/form-data/form-data/blob/master/CHANGELOG.md) - [Commits](https://github.com/form-data/form-data/commits/v4.0.4) Updates `cypress` from 7.7.0 to 15.6.0 - [Release notes](https://github.com/cypress-io/cypress/releases) - [Changelog](https://github.com/cypress-io/cypress/blob/develop/CHANGELOG.md) - [Commits](https://github.com/cypress-io/cypress/compare/v7.7.0...v15.6.0) --- updated-dependencies: - dependency-name: form-data dependency-version: 4.0.4 dependency-type: indirect - dependency-name: cypress dependency-version: 15.6.0 dependency-type: direct:development ... Signed-off-by: dependabot[bot] <support@github.com>
chore(git): merge pull request #848 from sasjs/readme_update_20250828
2025-12-11 01:14:36 +00:00 · 2025-11-17 11:44:26 +00:00 · 2025-10-17 11:54:14 +02:00 · 2025-09-18 19:26:30 +02:00 · 2025-09-18 17:16:45 +01:00 · 2025-09-18 18:10:30 +02:00
62 changed files with 18981 additions and 10527 deletions
--- a/.github/workflows/build-unit-tests.yml
+++ b/.github/workflows/build-unit-tests.yml
@@ -0,0 +1,58 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: SASjs Build and Unit Test
+
+on:
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+
+    strategy:
+      matrix:
+        node-version: [lts/hydrogen]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node-version }}
+
+       # 2. Restore npm cache manually
+      - name: Restore npm cache
+        uses: actions/cache@v3
+        id: npm-cache
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-
+
+      - name: Check npm audit
+        run: npm audit --production --audit-level=low
+
+      - name: Install Dependencies
+        run: npm ci
+
+      - name: Install Rimraf
+        run: npm i rimraf
+
+      - name: Check code style
+        run: npm run lint
+
+      - name: Run unit tests
+        run: npm test
+
+      - name: Build Package
+        run: npm run package:lib
+        env:
+          CI: true
+
+      # For some reason if coverage report action is run before other commands, those commands can't access the directories and files on which they depend on
+      - name: Generate coverage report
+        uses: artiomtr/jest-coverage-report-action@v2.0-rc.2
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/generateDocs.yml
+++ b/.github/workflows/generateDocs.yml
@@ -21,7 +21,16 @@ jobs:
        uses: actions/setup-node@v2
        with:
          node-version: ${{ matrix.node-version }}
-          cache: npm
+
+                 # 2. Restore npm cache manually
+      - name: Restore npm cache
+        uses: actions/cache@v3
+        id: npm-cache
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-

      - name: Install Dependencies
        run: npm ci
--- a/.github/workflows/npmpublish.yml
+++ b/.github/workflows/npmpublish.yml
@@ -22,7 +22,16 @@ jobs:
        uses: actions/setup-node@v2
        with:
          node-version: ${{ matrix.node-version }}
-          cache: npm
+
+       # 2. Restore npm cache manually
+      - name: Restore npm cache
+        uses: actions/cache@v3
+        id: npm-cache
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-

      - name: Install Dependencies
        run: npm ci
--- a/.github/workflows/server-tests.yml
+++ b/.github/workflows/server-tests.yml
@@ -1,13 +1,13 @@
 # This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
 # For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions

-name: SASjs Build
+name: SASjs Build and Server Tests

 on:
  pull_request:

 jobs:
-  build:
+  test:
    runs-on: ubuntu-22.04

    strategy:
@@ -20,11 +20,16 @@ jobs:
        uses: actions/setup-node@v2
        with:
          node-version: ${{ matrix.node-version }}
-          cache: npm

-      # FIXME: uncomment 'Check npm audit' step after axios version bump
-      # - name: Check npm audit
-      #   run: npm audit --production --audit-level=low
+      # 2. Restore npm cache manually
+      - name: Restore npm cache
+        uses: actions/cache@v3
+        id: npm-cache
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-

      - name: Install Dependencies
        run: npm ci
@@ -32,12 +37,6 @@ jobs:
      - name: Install Rimraf
        run: npm i rimraf

-      - name: Check code style
-        run: npm run lint
-
-      - name: Run unit tests
-        run: npm test
-
      - name: Build Package
        run: npm run package:lib
        env:
@@ -106,9 +105,3 @@ jobs:
          echo "SASJS_USERNAME=${{ secrets.SASJS_USERNAME }}"

          sh ./sasjs-tests/sasjs-cypress-run.sh ${{ secrets.MATRIX_TOKEN }} https://github.com/${{github.repository}}/actions/runs/${{github.run_id}}
-
-      # For some reason if coverage report action is run before other commands, those commands can't access the directories and files on which they depend on
-      - name: Generate coverage report
-        uses: artiomtr/jest-coverage-report-action@v2.0-rc.2
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
--- a/README.md
+++ b/README.md
@@ -3,18 +3,16 @@
 [![npm package][npm-image]][npm-url]
 [![Github Workflow][githubworkflow-image]][githubworkflow-url]
 [![npm](https://img.shields.io/npm/dt/@sasjs/adapter)]()
-![Snyk Vulnerabilities for npm package](https://img.shields.io/snyk/vulnerabilities/npm/@sasjs/adapter)
-[![License](https://img.shields.io/apm/l/atomic-design-ui.svg)](/LICENSE)
+![GitHub License](https://img.shields.io/github/license/sasjs/adapter)
 ![GitHub top language](https://img.shields.io/github/languages/top/sasjs/adapter)
 ![GitHub issues](https://img.shields.io/github/issues/sasjs/adapter)
 [![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-908a85?logo=gitpod)](https://gitpod.io/#https://github.com/sasjs/adapter)

-
-[npm-image]:https://img.shields.io/npm/v/@sasjs/adapter.svg
-[npm-url]:http://npmjs.org/package/@sasjs/adapter
-[githubworkflow-image]:https://github.com/sasjs/adapter/actions/workflows/build.yml/badge.svg
-[githubworkflow-url]:https://github.com/sasjs/adapter/blob/main/.github/workflows/build.yml
-[dependency-image]:https://david-dm.org/sasjs/adapter.svg
+[npm-image]: https://img.shields.io/npm/v/@sasjs/adapter.svg
+[npm-url]: http://npmjs.org/package/@sasjs/adapter
+[githubworkflow-image]: https://github.com/sasjs/adapter/actions/workflows/build-unit-tests.yml/badge.svg
+[githubworkflow-url]: https://github.com/sasjs/adapter/blob/main/.github/workflows/build.yml
+[dependency-image]: https://david-dm.org/sasjs/adapter.svg

 SASjs is a open-source framework for building Web Apps on SAS® platforms. You can use as much or as little of it as you like. This repository contains the JS adapter, the part that handles the to/from SAS communication on the client side. There are 3 ways to install it:

@@ -69,24 +67,27 @@ There are three parts to consider:

 To install the library you can simply run `npm i @sasjs/adapter` or include a `<script>` tag with a reference to our [CDN](https://www.jsdelivr.com/package/npm/@sasjs/adapter).

-Full technical documentation is available [here](https://adapter.sasjs.io).  The main parts are:
+Full technical documentation is available [here](https://adapter.sasjs.io). The main parts are:

 ### Instantiation
+
 The following code will instantiate an instance of the adapter:

 ```javascript
-let sasJs = new SASjs.default(
-  {
-    appLoc: "/Your/SAS/Folder",
-    serverType:"SAS9"
-  }
-);
+let sasJs = new SASjs.default({
+  appLoc: '/Your/SAS/Folder',
+  serverType: 'SAS9'
+})
 ```
+
 If you've installed it via NPM, you can import it as a default import like so:
+
 ```js
-  import SASjs from '@sasjs/adapter';
+import SASjs from '@sasjs/adapter'
 ```
+
 You can then instantiate it with:
+
 ```js
 const sasJs = new SASjs({your config})
 ```
@@ -94,10 +95,11 @@ const sasJs = new SASjs({your config})
 More on the config later.

 ### SAS Logon
-All authentication from the adapter is done against SASLogon.  There are two approaches that can be taken, which are configured using the `loginMechanism` attribute of the sasJs config object (above):

-* `loginMechanism:'Redirected'` - this approach enables authentication through a SASLogon window, supporting complex authentication flows (such as 2FA) and avoids the need to handle passwords in the application itself.  The styling of the window can be modified using CSS.
-* `loginMechanism:'Default'` - this approach requires that the username and password are captured, and used within the `.login()` method.  This can be helpful for development, or automated testing.
+All authentication from the adapter is done against SASLogon. There are two approaches that can be taken, which are configured using the `loginMechanism` attribute of the sasJs config object (above):
+
+- `loginMechanism:'Redirected'` - this approach enables authentication through a SASLogon window, supporting complex authentication flows (such as 2FA) and avoids the need to handle passwords in the application itself. The styling of the window can be modified using CSS.
+- `loginMechanism:'Default'` - this approach requires that the username and password are captured, and used within the `.login()` method. This can be helpful for development, or automated testing.

 Sample code for logging in with the `Default` approach:

@@ -114,42 +116,47 @@ sasJs.logIn('USERNAME','PASSWORD'

 More examples of using authentication, and more, can be found in the [SASjs Seed Apps](https://github.com/search?q=topic%3Asasjs-app+org%3Asasjs+fork%3Atrue) on github.

-###  Request / Response
+### Request / Response
+
 A simple request can be sent to SAS in the following fashion:

 ```javascript
-sasJs.request("/path/to/my/service", dataObject)
-  .then((response) => {
-    // all tables are in the response object, eg:
-    console.log(response.tablewith2cols1row[0].COL1.value)
-  })
+sasJs.request('/path/to/my/service', dataObject).then((response) => {
+  // all tables are in the response object, eg:
+  console.log(response.tablewith2cols1row[0].COL1.value)
+})
 ```

 We supply the path to the SAS service, and a data object.

-If the path starts with a `/` then it should be a full path to the service.  If there is no leading `/` then it is relative to the `appLoc`.
+If the path starts with a `/` then it should be a full path to the service. If there is no leading `/` then it is relative to the `appLoc`.

 The data object can be null (for services with no input), or can contain one or more "tables" in the following format:

 ```javascript
-let dataObject={
-	"tablewith2cols1row": [{
-		"col1": "val1",
-		"col2": 42
-	}],
-	"tablewith1col2rows": [{
-		"col": "row1"
-	}, {
-		"col": "row2"
-	}]
-};
+let dataObject = {
+  tablewith2cols1row: [
+    {
+      col1: 'val1',
+      col2: 42
+    }
+  ],
+  tablewith1col2rows: [
+    {
+      col: 'row1'
+    },
+    {
+      col: 'row2'
+    }
+  ]
+}
 ```

 These tables (`tablewith2cols1row` and `tablewith1col2rows`) will be created in SAS WORK after running `%webout(FETCH)` in your SAS service.

 The `request()` method also has optional parameters such as a config object and a callback login function.

-The response object will contain returned tables and columns.  Table names are always lowercase, and column names uppercase.
+The response object will contain returned tables and columns. Table names are always lowercase, and column names uppercase.

 The adapter will also cache the logs (if debug enabled) and even the work tables. For performance, it is best to keep debug mode off.

@@ -169,45 +176,46 @@ To execute a script on Viya a session has to be created first which is time-cons

 The SAS type (char/numeric) of the values is determined according to a set of rules:

-* If the values are numeric, the SAS type is numeric
-* If the values are all string, the SAS type is character
-* If the values contain a single character (a-Z + underscore + .) AND a numeric, then the SAS type is numeric (with special missing values).
-* `null` is set to either '.' or '' depending on the assigned or derived type per the above rules.  If entire column is `null` then the type will be numeric.
+- If the values are numeric, the SAS type is numeric
+- If the values are all string, the SAS type is character
+- If the values contain a single character (a-Z + underscore + .) AND a numeric, then the SAS type is numeric (with special missing values).
+- `null` is set to either '.' or '' depending on the assigned or derived type per the above rules. If entire column is `null` then the type will be numeric.

 The following table illustrates the formats applied to columns under various scenarios:

-|JS Values |SAS Format|
-|---|---|
-|'a', 'a' |$char1.|
-|0, '_' |best.|
-|'Z', 0 |best.|
-|'a', 'aaa' |$char3.|
-|null, 'a', 'aaa' | $char3.|
-|null, 'a', 0 | best.|
-|null, null | best.|
-|null, '' | $char1.|
-|null, 'a' | $char1.|
-|'a' | $char1.|
-|'a', null | $char1.|
-|'a', null, 0 | best.|
+| JS Values        | SAS Format |
+| ---------------- | ---------- |
+| 'a', 'a'         | $char1.    |
+| 0, '\_'          | best.      |
+| 'Z', 0           | best.      |
+| 'a', 'aaa'       | $char3.    |
+| null, 'a', 'aaa' | $char3.    |
+| null, 'a', 0     | best.      |
+| null, null       | best.      |
+| null, ''         | $char1.    |
+| null, 'a'        | $char1.    |
+| 'a'              | $char1.    |
+| 'a', null        | $char1.    |
+| 'a', null, 0     | best.      |

-Validation is also performed on the values.  The following combinations will throw errors:
+Validation is also performed on the values. The following combinations will throw errors:

-|JS Values |SAS Format|
-|---|---|
-|null, 'aaaa', 0 | Error: mixed types. 'aaaa' is not a special missing value.|
-|0, 'a', '!' | Error: mixed types. '!' is not a special missing value|
-|1.1, '.', 0| Error: mixed types.  For regular nulls, use `null`|
+| JS Values       | SAS Format                                                 |
+| --------------- | ---------------------------------------------------------- |
+| null, 'aaaa', 0 | Error: mixed types. 'aaaa' is not a special missing value. |
+| 0, 'a', '!'     | Error: mixed types. '!' is not a special missing value     |
+| 1.1, '.', 0     | Error: mixed types. For regular nulls, use `null`          |

 ### Variable Format Override
+
 The auto-detect functionality above is thwarted in the following scenarios:

-* A character column containing only `null` values (is considered numeric)
-* A numeric column containing only special missing values (is considered character)
+- A character column containing only `null` values (is considered numeric)
+- A numeric column containing only special missing values (is considered character)

 To cater for these scenarios, an optional array of formats can be passed along with the data to ensure that SAS will read them in correctly.

-To understand these formats, it should be noted that the JSON data is NOT passed directly (as JSON) to SAS. It is first converted into CSV, and the header row is actually an `infile` statement in disguise.  It looks a bit like this:
+To understand these formats, it should be noted that the JSON data is NOT passed directly (as JSON) to SAS. It is first converted into CSV, and the header row is actually an `infile` statement in disguise. It looks a bit like this:

 ```csv
 CHARVAR1:$char4. CHARVAR2:$char1. NUMVAR:best.
@@ -218,14 +226,13 @@ ABCD,X,.
 To provide overrides to this header row, the tables object can be constructed as follows (with a leading '$' in the table name):

 ```javascript
-let specialData={
-  "tablewith2cols2rows": [
-    {"col1": "val1","specialMissingsCol": "A"},
-    {"col1": "val2","specialMissingsCol": "_"}
+let specialData = {
+  tablewith2cols2rows: [
+    { col1: 'val1', specialMissingsCol: 'A' },
+    { col1: 'val2', specialMissingsCol: '_' }
  ],
-  "$tablewith2cols2rows":{"formats":{"specialMissingsCol":"best."}
-  }
-};
+  $tablewith2cols2rows: { formats: { specialMissingsCol: 'best.' } }
+}
 ```

 It is not necessary to provide formats for ALL the columns, only the ones that need to be overridden.
@@ -254,14 +261,15 @@ run;
 %webout(CLOSE) /* Close the JSON and add default variables */
 ```

-By default, special SAS numeric missings (_a-Z) are converted to `null` in the JSON.  If you'd like to preserve these, use the `missing=STRING` option as follows:
+By default, special SAS numeric missings (\_a-Z) are converted to `null` in the JSON. If you'd like to preserve these, use the `missing=STRING` option as follows:

 ```sas
 %webout(OBJ,a,missing=STRING)
 ```
+
 In this case, special missings (such as `.a`, `.b`) are converted to javascript string values (`'A', 'B'`).

-Where an entire column is made up of special missing numerics, there would be no way to distinguish it from a single-character column by looking at the values.  To cater for this scenario, it is possible to export the variable types (and other attributes such as label and format) by adding a `showmeta` param to the `webout()` macro as follows:
+Where an entire column is made up of special missing numerics, there would be no way to distinguish it from a single-character column by looking at the values. To cater for this scenario, it is possible to export the variable types (and other attributes such as label and format) by adding a `showmeta` param to the `webout()` macro as follows:

 ```sas
 %webout(OBJ,a,missing=STRING,showmeta=YES)
@@ -271,23 +279,23 @@ The `%webout()` macro itself is just a wrapper for the [mp_jsonout](https://core

 ## Configuration

-Configuration on the client side involves passing an object on startup, which can also be passed with each request.  Technical documentation on the SASjsConfig class is available [here](https://adapter.sasjs.io/classes/types.sasjsconfig.html).  The main config items are:
+Configuration on the client side involves passing an object on startup, which can also be passed with each request. Technical documentation on the SASjsConfig class is available [here](https://github.com/sasjs/adapter/blob/master/src/types/SASjsConfig.ts). The main config items are:

-* `appLoc` - this is the folder (eg in metadata or SAS Drive) under which the SAS services are created.
-* `serverType` - either `SAS9`, `SASVIYA` or `SASJS`.  The `SASJS` server type is for use with [sasjs/server](https://github.com/sasjs/server).
-* `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.
-* `verbose` - optional, if `true` then a summary of every HTTP response is logged.
-* `loginMechanism` - either `Default` or `Redirected`.  See [SAS Logon](#sas-logon) section.
-* `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`.
-* `requestHistoryLimit` - Request history limit. Increasing this limit may affect browser performance, especially with debug (logs) enabled.  Default is 10.
+- `appLoc` - this is the folder (eg in metadata or SAS Drive) under which the SAS services are created.
+- `serverType` - either `SAS9`, `SASVIYA` or `SASJS`. The `SASJS` server type is for use with [sasjs/server](https://github.com/sasjs/server).
+- `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.
+- `verbose` - optional, if `true` then a summary of every HTTP response is logged.
+- `loginMechanism` - either `Default` or `Redirected`. See [SAS Logon](#sas-logon) section.
+- `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`.
+- `requestHistoryLimit` - Request history limit. Increasing this limit may affect browser performance, especially with debug (logs) enabled. Default is 10.

-The adapter supports a number of approaches for interfacing with Viya (`serverType` is `SASVIYA`).  For maximum performance, be sure to [configure your compute context](https://sasjs.io/guide-viya/#shared-account-and-server-re-use) with `reuseServerProcesses` as `true` and a system account in `runServerAs`.  This functionality is available since Viya 3.5.  This configuration is supported when [creating contexts using the CLI](https://sasjs.io/sasjs-cli-context/#sasjs-context-create).
+The adapter supports a number of approaches for interfacing with Viya (`serverType` is `SASVIYA`). For maximum performance, be sure to [configure your compute context](https://sasjs.io/guide-viya/#shared-account-and-server-re-use) with `reuseServerProcesses` as `true` and a system account in `runServerAs`. This functionality is available since Viya 3.5. This configuration is supported when [creating contexts using the CLI](https://sasjs.io/sasjs-cli-context/#sasjs-context-create).

 ### Using JES Web App

-In this setup, all requests are routed through the JES web app, at `YOURSERVER/SASJobExecution?_program=/your/program`.  This is the most reliable method, and also the slowest.  One request is made to the JES app, and remaining requests (getting job uri, session spawning, passing parameters, running the program, fetching the log) are handled by the SAS server inside the JES app.
+In this setup, all requests are routed through the JES web app, at `YOURSERVER/SASJobExecution?_program=/your/program`. This is the most reliable method, and also the slowest. One request is made to the JES app, and remaining requests (getting job uri, session spawning, passing parameters, running the program, fetching the log) are handled by the SAS server inside the JES app.

 ```
 {
@@ -300,34 +308,35 @@ In this setup, all requests are routed through the JES web app, at `YOURSERVER/S
 Note - to use the web approach, the `useComputeApi` property must be `undefined` or `null`.

 ### Using the JES API
-Here we are running Jobs using the Job Execution Service except this time we are making the requests directly using the REST API instead of through the JES Web App.  This is helpful when we need to call web services outside of a browser (eg with the SASjs CLI or other commandline tools).  To save one network request, the adapter prefetches the JOB URIs and passes them in the `__job` parameter.  Depending on your network bandwidth, it may or may not be faster than the JES Web approach.
+
+Here we are running Jobs using the Job Execution Service except this time we are making the requests directly using the REST API instead of through the JES Web App. This is helpful when we need to call web services outside of a browser (eg with the SASjs CLI or other commandline tools). To save one network request, the adapter prefetches the JOB URIs and passes them in the `__job` parameter. Depending on your network bandwidth, it may or may not be faster than the JES Web approach.

 This approach (`useComputeApi: false`) also ensures that jobs are displayed in Environment Manager.

 ```json
 {
-  appLoc:"/Your/Path",
-  serverType:"SASVIYA",
-  useComputeApi: false,
-  contextName: 'yourComputeContext'
+  "appLoc": "/Your/Path",
+  "serverType": "SASVIYA",
+  "useComputeApi": false,
+  "contextName": "yourComputeContext"
 }
 ```

 ### Using the Compute API
-This approach is by far the fastest, as a result of the optimisations we have built into the adapter.  With this configuration, in the first sasjs request, we take a URI map of the services in the target folder, and create a session manager.  This manager will spawn a additional session every time a request is made. Subsequent requests will use the existing 'hot' session, if it exists.  Sessions are always deleted after every use, which actually makes this _less_ resource intensive than a typical JES web app, in which all sessions are kept alive by default for 15 minutes.
+
+This approach is by far the fastest, as a result of the optimisations we have built into the adapter. With this configuration, in the first sasjs request, we take a URI map of the services in the target folder, and create a session manager. This manager will spawn a additional session every time a request is made. Subsequent requests will use the existing 'hot' session, if it exists. Sessions are always deleted after every use, which actually makes this _less_ resource intensive than a typical JES web app, in which all sessions are kept alive by default for 15 minutes.

 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"
+  "appLoc": "/Your/Path",
+  "serverType": "SASVIYA",
+  "useComputeApi": true,
+  "contextName": "yourComputeContext"
 }
 ```

-
 # More resources

 For more information and examples specific to this adapter you can check out the [user guide](https://sasjs.io/sasjs-adapter/) or the [technical](http://adapter.sasjs.io/) documentation.
@@ -336,7 +345,6 @@ For more information on building web apps in general, check out these [resources

 As a SAS customer you can also request a copy of [Data Controller](https://datacontroller.io) - free for up to 5 users, this tool makes use of all parts of the SASjs framework.

-
 ## Star Gazing

 If you find this library useful, help us grow our star graph!
@@ -344,8 +352,11 @@ If you find this library useful, help us grow our star graph!
 ![](https://starchart.cc/sasjs/adapter.svg)

 ## Contributors ✨
+
 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
+
 [![All Contributors](https://img.shields.io/badge/all_contributors-9-orange.svg?style=flat-square)](#contributors-)
+
 <!-- ALL-CONTRIBUTORS-BADGE:END -->

 Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
--- a/cypress/integration/sasjs.tests.ts
+++ b/cypress/integration/sasjs.tests.ts
@@ -4,93 +4,56 @@ const password = Cypress.env('password')
 const testingFinishTimeout = Cypress.env('testingFinishTimeout')

 context('sasjs-tests', function () {
-  this.beforeAll(() => {
+  before(() => {
    cy.visit(sasjsTestsUrl)
  })

-  this.beforeEach(() => {
+  beforeEach(() => {
    cy.reload()
  })

-  it('Should have all tests successfull', (done) => {
+  function loginIfNeeded() {
    cy.get('body').then(($body) => {
-      cy.wait(1000).then(() => {
-        const startButton = $body.find(
-          '.ui.massive.icon.primary.left.labeled.button'
-        )[0]
-
-        if (
-          !startButton ||
-          (startButton && !Cypress.dom.isVisible(startButton))
-        ) {
-          cy.get('input[placeholder="User Name"]').type(username)
-          cy.get('input[placeholder="Password"]').type(password)
-          cy.get('.submit-button').click()
-        }
-
-        cy.get('input[placeholder="User Name"]', { timeout: 40000 })
-          .should('not.exist')
-          .then(() => {
-            cy.get('.ui.massive.icon.primary.left.labeled.button')
-              .click()
-              .then(() => {
-                cy.get('.ui.massive.loading.primary.button', {
-                  timeout: testingFinishTimeout
-                })
-                  .should('not.exist')
-                  .then(() => {
-                    cy.get('span.icon.failed')
-                      .should('not.exist')
-                      .then(() => {
-                        done()
-                      })
-                  })
-              })
-          })
-      })
+      if ($body.find('input[placeholder="User Name"]').length > 0) {
+        cy.get('input[placeholder="User Name"]')
+          .should('be.visible')
+          .type(username)
+        cy.get('input[placeholder="Password"]')
+          .should('be.visible')
+          .type(password)
+        cy.get('.submit-button').should('be.visible').click()
+        cy.get('input[placeholder="User Name"]').should('not.exist') // Wait for login to finish
+      }
    })
+  }
+
+  it('Should have all tests successful', () => {
+    loginIfNeeded()
+
+    cy.get('.ui.massive.icon.primary.left.labeled.button')
+      .should('be.visible')
+      .click()
+
+    cy.get('.ui.massive.loading.primary.button', {
+      timeout: testingFinishTimeout
+    }).should('not.exist')
+
+    cy.get('span.icon.failed').should('not.exist')
  })

-  it('Should have all tests successfull with debug on', (done) => {
-    cy.get('body').then(($body) => {
-      cy.wait(1000).then(() => {
-        const startButton = $body.find(
-          '.ui.massive.icon.primary.left.labeled.button'
-        )[0]
+  it('Should have all tests successful with debug on', () => {
+    loginIfNeeded()

-        if (
-          !startButton ||
-          (startButton && !Cypress.dom.isVisible(startButton))
-        ) {
-          cy.get('input[placeholder="User Name"]').type(username)
-          cy.get('input[placeholder="Password"]').type(password)
-          cy.get('.submit-button').click()
-        }
+    cy.get('.ui.fitted.toggle.checkbox label').should('be.visible').click()

-        cy.get('.ui.fitted.toggle.checkbox label')
-          .click()
-          .then(() => {
-            cy.get('input[placeholder="User Name"]', { timeout: 40000 })
-              .should('not.exist')
-              .then(() => {
-                cy.get('.ui.massive.icon.primary.left.labeled.button')
-                  .click()
-                  .then(() => {
-                    cy.get('.ui.massive.loading.primary.button', {
-                      timeout: testingFinishTimeout
-                    })
-                      .should('not.exist')
-                      .then(() => {
-                        cy.get('span.icon.failed')
-                          .should('not.exist')
-                          .then(() => {
-                            done()
-                          })
-                      })
-                  })
-              })
-          })
-      })
-    })
+    cy.get('.ui.massive.icon.primary.left.labeled.button')
+      .should('be.visible')
+      .click()
+
+    cy.get('.ui.massive.loading.primary.button', {
+      timeout: testingFinishTimeout
+    }).should('not.exist')
+
+    cy.get('span.icon.failed').should('not.exist')
  })
 })
--- a/cypress/screenshots/sasjs.tests.ts/sasjs-tests
+++ b/cypress/screenshots/sasjs.tests.ts/sasjs-tests
--- a/cypress/videos/sasjs.tests.ts.mp4
+++ b/cypress/videos/sasjs.tests.ts.mp4
--- a/jest.config.js
+++ b/jest.config.js
@@ -142,6 +142,8 @@ module.exports = {
  // Options that will be passed to the testEnvironment
  // testEnvironmentOptions: {},

+  testEnvironment: 'node',
+
  // Adds a location field to test results
  // testLocationInResults: false,

--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -45,18 +45,21 @@
  "license": "ISC",
  "devDependencies": {
    "@cypress/webpack-preprocessor": "5.9.1",
+    "@types/cors": "^2.8.17",
    "@types/express": "4.17.13",
-    "@types/jest": "27.4.0",
+    "@types/jest": "29.5.14",
    "@types/mime": "2.0.3",
    "@types/pem": "1.9.6",
    "@types/tough-cookie": "4.0.2",
    "copyfiles": "2.4.1",
+    "cors": "^2.8.5",
    "cp": "0.2.0",
-    "cypress": "7.7.0",
+    "cypress": "15.6.0",
    "dotenv": "16.0.0",
    "express": "4.17.3",
-    "jest": "27.4.7",
-    "jest-extended": "2.0.0",
+    "jest": "29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "jest-extended": "4.0.2",
    "node-polyfill-webpack-plugin": "1.1.4",
    "path": "0.12.7",
    "pem": "1.14.5",
@@ -64,22 +67,22 @@
    "process": "0.11.10",
    "semantic-release": "19.0.3",
    "terser-webpack-plugin": "5.3.6",
-    "ts-jest": "27.1.3",
+    "ts-jest": "29.2.6",
    "ts-loader": "9.4.0",
    "tslint": "6.1.3",
    "tslint-config-prettier": "1.18.0",
    "typedoc": "0.23.24",
    "typedoc-plugin-rename-defaults": "0.6.4",
-    "typescript": "4.8.3",
+    "typescript": "4.9.5",
    "webpack": "5.76.2",
    "webpack-cli": "4.9.2"
  },
  "main": "index.js",
  "dependencies": {
-    "@sasjs/utils": "^3.5.1",
-    "axios": "0.27.2",
-    "axios-cookiejar-support": "1.0.1",
-    "form-data": "4.0.0",
+    "@sasjs/utils": "3.5.2",
+    "axios": "1.12.2",
+    "axios-cookiejar-support": "5.0.5",
+    "form-data": "4.0.4",
    "https": "1.0.0",
    "tough-cookie": "4.1.3"
  }
--- a/sasjs-tests/.env
+++ b/sasjs-tests/.env
@@ -1 +1,3 @@
-SKIP_PREFLIGHT_CHECK=true
+SKIP_PREFLIGHT_CHECK=true
+# Removes index.html inline scripts
+INLINE_RUNTIME_CHUNK=false
--- a/sasjs-tests/craco.config.js
+++ b/sasjs-tests/craco.config.js
@@ -0,0 +1,15 @@
+// craco.config.js
+// We use craco instead of react-scripts so we can override webpack config, to include source maps
+// so we can debug @sasjs/adapter easier when tests fail
+module.exports = {
+  webpack: {
+    configure: (webpackConfig, { env }) => {
+      // Disable optimizations in both development and production
+      webpackConfig.optimization.minimize = false;
+      webpackConfig.optimization.minimizer = [];
+      webpackConfig.optimization.concatenateModules = false;
+      webpackConfig.optimization.splitChunks = { cacheGroups: { default: false } };
+      return webpackConfig;
+    }
+  }
+};
--- a/sasjs-tests/package-lock.json
+++ b/sasjs-tests/package-lock.json
--- a/sasjs-tests/package.json
+++ b/sasjs-tests/package.json
@@ -4,6 +4,7 @@
  "homepage": ".",
  "private": true,
  "dependencies": {
+    "@sasjs/adapter": "file:../build/sasjs-adapter-5.0.0.tgz",
    "@sasjs/test-framework": "1.5.7",
    "@types/jest": "^26.0.20",
    "@types/node": "^14.14.41",
@@ -13,12 +14,12 @@
    "react": "^16.0.1",
    "react-dom": "^16.0.1",
    "react-router-dom": "^5.2.0",
-    "react-scripts": "^5.0.1",
+    "react-scripts": "4.0.3",
    "typescript": "^4.1.3"
  },
  "scripts": {
-    "start": "react-scripts start",
-    "build": "react-scripts build",
+    "start": "NODE_OPTIONS=--openssl-legacy-provider react-scripts start",
+    "build": "NODE_OPTIONS=--openssl-legacy-provider craco build",
    "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",
@@ -42,6 +43,8 @@
    ]
  },
  "devDependencies": {
-    "node-sass": "9.0.0"
+    "@craco/craco": "6.4.3",
+    "node-sass": "9.0.0",
+    "source-map-loader": "0.2.4"
  }
 }
--- a/sasjs-tests/sasjs/sasjsconfig.json
+++ b/sasjs-tests/sasjs/sasjsconfig.json
@@ -24,6 +24,26 @@
        "streamServiceName": "adapter-tests",
        "assetPaths": []
      }
+    },
+    {
+      "name": "viya",
+      "serverUrl": "",
+      "serverType": "SASVIYA",
+      "httpsAgentOptions": {
+        "allowInsecureRequests": false
+      },
+      "appLoc": "/Public/app/adapter-tests",
+      "deployConfig": {
+        "deployServicePack": true,
+        "deployScripts": []
+      },
+      "streamConfig": {
+        "streamWeb": true,
+        "streamWebFolder": "webv",
+        "webSourcePath": "build",
+        "streamServiceName": "adapter-tests",
+        "assetPaths": []
+      }
    }
  ]
 }
--- a/sasjs-tests/src/App.tsx
+++ b/sasjs-tests/src/App.tsx
@@ -19,7 +19,7 @@ const App = (): ReactElement<{}> => {
        basicTests(adapter, config.userName, config.password),
        sendArrTests(adapter, appLoc),
        sendObjTests(adapter),
-        specialCaseTests(adapter),
+        // specialCaseTests(adapter),
        sasjsRequestTests(adapter),
        fileUploadTests(adapter)
      ]
--- a/sasjs-tests/src/testSuites/Basic.ts
+++ b/sasjs-tests/src/testSuites/Basic.ts
@@ -87,6 +87,20 @@ export const basicTests = (
        return response.table1[0][0] === stringData.table1[0].col1
      }
    },
+    {
+      title: 'Web request',
+      description: 'Should run the request with old web approach',
+      test: async () => {
+        const config: Partial<SASjsConfig> = {
+          useComputeApi: false
+        }
+
+        return await adapter.request('common/sendArr', stringData, config)
+      },
+      assertion: (response: any) => {
+        return response.table1[0][0] === stringData.table1[0].col1
+      }
+    },
    {
      title: 'Request with debug on',
      description:
@@ -159,20 +173,6 @@ export const basicTests = (
          sasjsConfig.debug === false
        )
      }
-    },
-    {
-      title: 'Web request',
-      description: 'Should run the request with old web approach',
-      test: async () => {
-        const config: Partial<SASjsConfig> = {
-          useComputeApi: false
-        }
-
-        return await adapter.request('common/sendArr', stringData, config)
-      },
-      assertion: (response: any) => {
-        return response.table1[0][0] === stringData.table1[0].col1
-      }
    }
  ]
 })
--- a/sasjs-tests/src/testSuites/SasjsRequests.ts
+++ b/sasjs-tests/src/testSuites/SasjsRequests.ts
@@ -20,30 +20,30 @@ export const sasjsRequestTests = (adapter: SASjs): TestSuite => ({
          return requests[0].SASWORK === null
        }
      }
-    },
-    {
-      title: 'Make error and capture log',
-      description:
-        'Should make an error and capture log, in the same time it is testing if debug override is working',
-      test: async () => {
-        return adapter
-          .request('common/makeErr', data, { debug: true })
-          .catch(() => {
-            const sasRequests = adapter.getSasRequests()
-            const makeErrRequest: any =
-              sasRequests.find((req) => req.serviceLink.includes('makeErr')) ||
-              null
-
-            if (!makeErrRequest) return false
-
-            return !!(
-              makeErrRequest.logFile && makeErrRequest.logFile.length > 0
-            )
-          })
-      },
-      assertion: (response) => {
-        return response
-      }
    }
+    // {
+    //   title: 'Make error and capture log',
+    //   description:
+    //     'Should make an error and capture log, in the same time it is testing if debug override is working',
+    //   test: async () => {
+    //     return adapter
+    //       .request('common/makeErr', data, { debug: true })
+    //       .catch(() => {
+    //         const sasRequests = adapter.getSasRequests()
+    //         const makeErrRequest: any =
+    //           sasRequests.find((req) => req.serviceLink.includes('makeErr')) ||
+    //           null
+
+    //         if (!makeErrRequest) return false
+
+    //         return !!(
+    //           makeErrRequest.logFile && makeErrRequest.logFile.length > 0
+    //         )
+    //       })
+    //   },
+    //   assertion: (response) => {
+    //     return response
+    //   }
+    // }
  ]
 })
--- a/sasjs-tests/src/testSuites/SpecialCases.ts
+++ b/sasjs-tests/src/testSuites/SpecialCases.ts
@@ -134,8 +134,19 @@ export const specialCaseTests = (adapter: SASjs): TestSuite => ({
        return adapter.request('common/sendArr', moreSpecialCharData)
      },
      assertion: (res: any) => {
-        // If sas session is latin9 we can't process the special characters
-        if (res.SYSENCODING === 'latin9') return true
+        // If sas session is `latin9` or `wlatin1` we can't process the special characters,
+        // But it can happen that response is broken JSON, so we first need to check if
+        // it's object and then check accordingly
+
+        if (typeof res === 'object') {
+          // Valid JSON response
+          if (res.SYSENCODING === 'latin9' || res.SYSENCODING === 'wlatin1')
+            return true
+        } else {
+          // Since we got string response (broken JSON), we need to check with regex
+          const regex = /"SYSENCODING"\s*:\s*"(?:wlatin1|latin9)"/
+          if (regex.test(res)) return true
+        }

        return (
          res.table1[0][0] === moreSpecialCharData.table1[0].speech0 &&
--- a/sasjs-tests/tsconfig.json
+++ b/sasjs-tests/tsconfig.json
@@ -6,6 +6,8 @@
      "dom.iterable",
      "esnext"
    ],
+    "sourceMap": true,
+    "inlineSources": true,
    "allowJs": true,
    "skipLibCheck": true,
    "esModuleInterop": true,
--- a/src/SAS9ApiClient.ts
+++ b/src/SAS9ApiClient.ts
@@ -1,6 +1,6 @@
 import * as https from 'https'
 import { generateTimestamp } from '@sasjs/utils/time'
-import * as NodeFormData from 'form-data'
+import NodeFormData from 'form-data'
 import { Sas9RequestClient } from './request/Sas9RequestClient'
 import { isUrl } from './utils'

--- a/src/SASViyaApiClient.ts
+++ b/src/SASViyaApiClient.ts
@@ -1,5 +1,5 @@
 import { isRelativePath, isUri, isUrl } from './utils'
-import * as NodeFormData from 'form-data'
+import NodeFormData from 'form-data'
 import {
  Job,
  Session,
@@ -28,6 +28,7 @@ import { uploadTables } from './api/viya/uploadTables'
 import { executeOnComputeApi } from './api/viya/executeOnComputeApi'
 import { getAccessTokenForViya } from './auth/getAccessTokenForViya'
 import { refreshTokensForViya } from './auth/refreshTokensForViya'
+import { FileResource } from './types/FileResource'

 interface JobExecutionResult {
  result?: { result: object }
@@ -311,6 +312,84 @@ export class SASViyaApiClient {
    )
  }

+  /**
+   * Fetches the file content for a file in the specified folder.
+   *
+   * @param folderPath - the full path to the folder containing the file. eg: /Public/folder1/folder2
+   * @param fileName - the name of the file in the `folderPath`
+   * @param accessToken - an access token for authorizing the request
+   */
+  public async getFileContent(
+    folderPath: string,
+    fileName: string,
+    accessToken?: string
+  ) {
+    const fileUri = await this.getFileUri(
+      folderPath,
+      fileName,
+      accessToken
+    ).catch((err) => {
+      throw prefixMessage(
+        err,
+        `Error while getting file URI for: ${fileName} in folder: ${folderPath}. `
+      )
+    })
+
+    return await this.requestClient
+      .get<string>(`${this.serverUrl}${fileUri}/content`, accessToken)
+      .then((res) => res.result)
+  }
+
+  /**
+   * Updates the file content for a file in the specified folder.
+   *
+   * @param folderPath - the full path to the folder containing the file. eg: /Public/folder1/folder2
+   * @param fileName - the name of the file in the `folderPath`
+   * @param content - the new content to be written to the file
+   * @param accessToken - an access token for authorizing the request
+   */
+  public async updateFileContent(
+    folderPath: string,
+    fileName: string,
+    content: string,
+    accessToken?: string
+  ) {
+    const fileUri = await this.getFileUri(
+      folderPath,
+      fileName,
+      accessToken
+    ).catch((err) => {
+      throw prefixMessage(
+        err,
+        `Error while getting file URI for: ${fileName} in folder: ${folderPath}. `
+      )
+    })
+
+    // Fetch the file resource details to get the Etag and content type
+    const { result: originalFileResource, etag } =
+      await this.requestClient.get<FileResource>(
+        `${this.serverUrl}${fileUri}`,
+        accessToken
+      )
+
+    if (!originalFileResource || !etag)
+      throw new Error(
+        `File ${fileName} does not have an ETag, or request failed.`
+      )
+
+    return await this.requestClient
+      .put<FileResource>(
+        `${this.serverUrl}${fileUri}/content`,
+        content,
+        accessToken,
+        {
+          'If-Match': etag,
+          'Content-Type': originalFileResource.contentType
+        }
+      )
+      .then((res) => res.result)
+  }
+
  /**
   * Fetches a folder. Path to the folder is required.
   * @param folderPath - the absolute path to the folder.
@@ -791,14 +870,14 @@ export class SASViyaApiClient {
      _webin_file_count: files.length,
      _OMITJSONLISTING: true,
      _OMITJSONLOG: true,
-      _OMITSESSIONRESULTS: true,
+      _omitSessionResults: false,
      _OMITTEXTLISTING: true,
      _OMITTEXTLOG: true
    }

    if (debug) {
      jobArguments['_OMITTEXTLOG'] = 'false'
-      jobArguments['_OMITSESSIONRESULTS'] = 'false'
+      jobArguments['_omitSessionResults'] = 'false'
      jobArguments['_DEBUG'] = 131
    }

@@ -941,6 +1020,7 @@ export class SASViyaApiClient {
      })

    if (!folder) return undefined
+
    return folder
  }

@@ -952,6 +1032,30 @@ export class SASViyaApiClient {
    return `/folders/folders/${folderDetails.id}`
  }

+  private async getFileUri(
+    folderPath: string,
+    fileName: string,
+    accessToken?: string
+  ): Promise<string> {
+    const folderMembers = await this.listFolder(folderPath, accessToken, 1000, {
+      returnDetails: true
+    }).catch((err) => {
+      throw prefixMessage(err, `Error while listing folder: ${folderPath}. `)
+    })
+
+    if (!folderMembers || !folderMembers.length)
+      throw new Error(`No members found in folder: ${folderPath}`)
+
+    const fileUri = folderMembers.find(
+      (member) => member.name === fileName
+    )?.uri
+
+    if (!fileUri)
+      throw new Error(`File ${fileName} not found in folder: ${folderPath}`)
+
+    return fileUri
+  }
+
  private async getRecycleBinUri(accessToken?: string) {
    const url = '/folders/folders/@myRecycleBin'

@@ -999,14 +1103,19 @@ export class SASViyaApiClient {
  }

  /**
-   * Lists children folders for given Viya folder.
+   * Lists children folders/files for given Viya folder.
   * @param sourceFolder - the full path (eg `/Public/example/myFolder`) or URI of the source folder listed. Providing URI instead of path will save one extra request.
   * @param accessToken - an access token for authorizing the request.
+   * @param {Object} [options] - Additional options.
+   * @param {boolean} [options.returnDetails=false] - when set to true, the function will return an array of objects with member details, otherwise it will return an array of member names.
   */
  public async listFolder(
    sourceFolder: string,
    accessToken?: string,
-    limit: number = 20
+    limit: number = 20,
+    options?: {
+      returnDetails?: boolean
+    }
  ) {
    // checks if 'sourceFolder' is already a URI
    const sourceFolderUri = isUri(sourceFolder)
@@ -1018,11 +1127,20 @@ export class SASViyaApiClient {
      accessToken
    )

+    let membersToReturn = []
+
    if (members && members.items) {
-      return members.items.map((item: any) => item.name)
-    } else {
-      return []
+      // If returnDetails is true, return full member details
+      if (options?.returnDetails) {
+        membersToReturn = members.items
+      } else {
+        // If returnDetails is false, return only member names
+        membersToReturn = members.items.map((item: any) => item.name)
+      }
    }
+
+    // Return members without Etag
+    return membersToReturn
  }

  /**
--- a/src/SASjs.ts
+++ b/src/SASjs.ts
@@ -9,7 +9,8 @@ import {
  ErrorResponse,
  LoginOptions,
  LoginResult,
-  ExecutionQuery
+  ExecutionQuery,
+  Tables
 } from './types'
 import { SASViyaApiClient } from './SASViyaApiClient'
 import { SAS9ApiClient } from './SAS9ApiClient'
@@ -411,6 +412,51 @@ export default class SASjs {
    )
  }

+  /**
+   * Fetches the file content for a file in the specified folder.
+   *
+   * @param folderPath - the full path to the folder containing the file. eg: /Public/folder1/folder2
+   * @param fileName - the name of the file in the `folderPath`
+   * @param accessToken - an access token for authorizing the request
+   */
+  public async getFileContent(
+    folderPath: string,
+    fileName: string,
+    accessToken?: string
+  ) {
+    this.isMethodSupported('getFileContent', [ServerType.SasViya])
+
+    return await this.sasViyaApiClient!.getFileContent(
+      folderPath,
+      fileName,
+      accessToken
+    )
+  }
+
+  /**
+   * Updates the file content for a file in the specified folder.
+   *
+   * @param folderPath - the full path to the folder containing the file. eg: /Public/folder1/folder2
+   * @param fileName - the name of the file in the `folderPath`
+   * @param content - the new content to be written to the file
+   * @param accessToken - an access token for authorizing the request
+   */
+  public async updateFileContent(
+    folderPath: string,
+    fileName: string,
+    content: string,
+    accessToken?: string
+  ) {
+    this.isMethodSupported('updateFileContent', [ServerType.SasViya])
+
+    return await this.sasViyaApiClient!.updateFileContent(
+      folderPath,
+      fileName,
+      content,
+      accessToken
+    )
+  }
+
  /**
   * Fetches a folder from the SAS file system.
   * @param folderPath - path of the folder to be fetched.
@@ -436,18 +482,23 @@ export default class SASjs {
   * Lists children folders for given Viya folder.
   * @param sourceFolder - the full path (eg `/Public/example/myFolder`) or URI of the source folder listed. Providing URI instead of path will save one extra request.
   * @param accessToken - an access token for authorizing the request.
+   * @param returnDetails - when set to true, the function will return an array of objects with member details, otherwise it will return an array of member names.
   */
  public async listFolder(
    sourceFolder: string,
    accessToken?: string,
-    limit?: number
+    limit?: number,
+    returnDetails = false
  ) {
    this.isMethodSupported('listFolder', [ServerType.SasViya])

    return await this.sasViyaApiClient?.listFolder(
      sourceFolder,
      accessToken,
-      limit
+      limit,
+      {
+        returnDetails
+      }
    )
  }

@@ -1170,8 +1221,8 @@ export default class SASjs {
   * @param errorCallBack - function that should be triggered on every HTTP response with the status different from 2**.
   */
  public enableVerboseMode(
-    successCallBack?: (response: AxiosResponse | AxiosError) => AxiosResponse,
-    errorCallBack?: (response: AxiosResponse | AxiosError) => AxiosResponse
+    successCallBack?: (response: AxiosResponse) => AxiosResponse,
+    errorCallBack?: (response: AxiosError) => AxiosError
  ) {
    this.requestClient?.enableVerboseMode(successCallBack, errorCallBack)
  }
@@ -1190,4 +1241,15 @@ export default class SASjs {
  public setVerboseMode = (verboseMode: VerboseMode) => {
    this.requestClient?.setVerboseMode(verboseMode)
  }
+
+  /**
+   * Create a tables class containing one or more tables to be sent to
+   * SAS.
+   * @param table - initial table data
+   * @param macroName - macro name
+   * @returns Tables class
+   */
+  Tables(table: Record<string, any>, macroName: string) {
+    return new Tables(table, macroName)
+  }
 }
--- a/src/SASjsApiClient.ts
+++ b/src/SASjsApiClient.ts
@@ -1,4 +1,4 @@
-import * as NodeFormData from 'form-data'
+import NodeFormData from 'form-data'
 import { AuthConfig, ServerType, ServicePackSASjs } from '@sasjs/utils/types'
 import { prefixMessage } from '@sasjs/utils/error'
 import { ExecutionQuery } from './types'
--- a/src/api/viya/spec/saveLog.spec.ts
+++ b/src/api/viya/spec/saveLog.spec.ts
@@ -69,5 +69,5 @@ const setupMocks = () => {
    .mockImplementation(() => Promise.resolve('Test Log'))
  jest
    .spyOn(writeStreamModule, 'writeStream')
-    .mockImplementation(() => Promise.resolve())
+    .mockImplementation(() => Promise.resolve(true))
 }
--- a/src/api/viya/spec/writeStream.spec.ts
+++ b/src/api/viya/spec/writeStream.spec.ts
@@ -10,12 +10,22 @@ import {
 describe('writeStream', () => {
  const filename = 'test.txt'
  const content = 'test'
+
  let stream: WriteStream

  beforeAll(async () => {
    stream = await createWriteStream(filename)
  })

+  beforeEach(async () => {
+    await deleteFile(filename).catch(() => {}) // Ignore errors if the file doesn't exist
+    stream = await createWriteStream(filename)
+  })
+
+  afterEach(async () => {
+    await deleteFile(filename).catch(() => {}) // Ensure cleanup after test
+  })
+
  it('should resolve when the stream is written successfully', async () => {
    await expect(writeStream(stream, content)).toResolve()
    await expect(fileExists(filename)).resolves.toEqual(true)
@@ -25,11 +35,30 @@ describe('writeStream', () => {
  })

  it('should reject when the write errors out', async () => {
+    // Mock implementation of the write method
    jest
      .spyOn(stream, 'write')
-      .mockImplementation((_, callback) => callback(new Error('Test Error')))
+      .mockImplementation(
+        (
+          chunk: any,
+          encodingOrCb?:
+            | BufferEncoding
+            | ((error: Error | null | undefined) => void),
+          cb?: (error: Error | null | undefined) => void
+        ) => {
+          const callback =
+            typeof encodingOrCb === 'function' ? encodingOrCb : cb
+          if (callback) {
+            callback(new Error('Test Error')) // Simulate an error
+          }
+          return true // Simulate that the write operation was called
+        }
+      )
+
+    // Call the writeStream function and catch the error
    const error = await writeStream(stream, content).catch((e: any) => e)

+    // Assert that the error is correctly handled
    expect(error.message).toEqual('Test Error')
  })
 })
--- a/src/api/viya/writeStream.ts
+++ b/src/api/viya/writeStream.ts
@@ -3,9 +3,14 @@ import { WriteStream } from '../../types'
 export const writeStream = async (
  stream: WriteStream,
  content: string
-): Promise<void> =>
-  stream.write(content + '\n', (e: any) => {
-    if (e) return Promise.reject(e)
-
-    return Promise.resolve()
+): Promise<boolean> => {
+  return new Promise((resolve, reject) => {
+    stream.write(content + '\n', (err: Error | null | undefined) => {
+      if (err) {
+        reject(err) // Reject on write error
+      } else {
+        resolve(true) // Resolve on successful write
+      }
+    })
  })
+}
--- a/src/auth/refreshTokensForViya.ts
+++ b/src/auth/refreshTokensForViya.ts
@@ -1,6 +1,6 @@
 import { SasAuthResponse, ServerType } from '@sasjs/utils/types'
 import { prefixMessage } from '@sasjs/utils/error'
-import * as NodeFormData from 'form-data'
+import NodeFormData from 'form-data'
 import { RequestClient } from '../request/RequestClient'
 import { isNode } from '../utils'
 import { getTokenRequestErrorPrefix } from './getTokenRequestErrorPrefix'
--- a/src/auth/spec/AuthManager.spec.ts
+++ b/src/auth/spec/AuthManager.spec.ts
@@ -159,7 +159,7 @@ describe('AuthManager', () => {
        `/SASLogon/login`,
        loginParams,
        {
-          withCredentials: true,
+          withXSRFToken: true,
          headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
            Accept: '*/*'
@@ -207,7 +207,7 @@ describe('AuthManager', () => {
        `/SASLogon/login`,
        loginParams,
        {
-          withCredentials: true,
+          withXSRFToken: true,
          headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
            Accept: '*/*'
@@ -256,7 +256,7 @@ describe('AuthManager', () => {
        `/SASLogon/login`,
        loginParams,
        {
-          withCredentials: true,
+          withXSRFToken: true,
          headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
            Accept: '*/*'
@@ -539,7 +539,7 @@ describe('AuthManager', () => {
        1,
        `http://test-server.com/identities/users/@currentUser`,
        {
-          withCredentials: true,
+          withXSRFToken: true,
          responseType: 'text',
          transformResponse: undefined,
          headers: {
@@ -573,7 +573,7 @@ describe('AuthManager', () => {
        1,
        `http://test-server.com/SASStoredProcess`,
        {
-          withCredentials: true,
+          withXSRFToken: true,
          responseType: 'text',
          transformResponse: undefined,
          headers: {
@@ -602,7 +602,7 @@ describe('AuthManager', () => {
        1,
        `http://test-server.com/identities/users/@currentUser`,
        {
-          withCredentials: true,
+          withXSRFToken: true,
          responseType: 'text',
          transformResponse: undefined,
          headers: {
@@ -621,7 +621,7 @@ describe('AuthManager', () => {
 })

 const getHeadersJson = {
-  withCredentials: true,
+  withXSRFToken: true,
  headers: {
    'Content-Type': 'application/json',
    Accept: 'application/json'
--- a/src/auth/spec/getAccessTokenForViya.spec.ts
+++ b/src/auth/spec/getAccessTokenForViya.spec.ts
@@ -1,5 +1,5 @@
 import { AuthConfig } from '@sasjs/utils/types'
-import * as NodeFormData from 'form-data'
+import NodeFormData from 'form-data'
 import { generateToken, mockAuthResponse } from './mockResponses'
 import { RequestClient } from '../../request/RequestClient'
 import { getAccessTokenForViya } from '../getAccessTokenForViya'
--- a/src/auth/spec/refreshTokensForViya.spec.ts
+++ b/src/auth/spec/refreshTokensForViya.spec.ts
@@ -1,5 +1,5 @@
 import { AuthConfig, ServerType } from '@sasjs/utils/types'
-import * as NodeFormData from 'form-data'
+import NodeFormData from 'form-data'
 import { generateToken, mockAuthResponse } from './mockResponses'
 import { RequestClient } from '../../request/RequestClient'
 import { refreshTokensForViya } from '../refreshTokensForViya'
--- a/src/file/generateFileUploadForm.ts
+++ b/src/file/generateFileUploadForm.ts
@@ -1,4 +1,4 @@
-import * as NodeFormData from 'form-data'
+import NodeFormData from 'form-data'
 import { convertToCSV } from '../utils/convertToCsv'
 import { isNode } from '../utils'

--- a/src/file/generateTableUploadForm.ts
+++ b/src/file/generateTableUploadForm.ts
@@ -1,4 +1,4 @@
-import * as NodeFormData from 'form-data'
+import NodeFormData from 'form-data'
 import { convertToCSV, isFormatsTable } from '../utils/convertToCsv'
 import { splitChunks } from '../utils/splitChunks'

--- a/src/file/spec/generateFileUploadForm.spec.ts
+++ b/src/file/spec/generateFileUploadForm.spec.ts
@@ -1,6 +1,6 @@
 import { generateFileUploadForm } from '../generateFileUploadForm'
 import { convertToCSV } from '../../utils/convertToCsv'
-import * as NodeFormData from 'form-data'
+import NodeFormData from 'form-data'
 import * as isNodeModule from '../../utils/isNode'

 describe('generateFileUploadForm', () => {
--- a/src/job-execution/JobExecutor.ts
+++ b/src/job-execution/JobExecutor.ts
@@ -51,7 +51,7 @@ export abstract class BaseJobExecutor implements JobExecutor {

    if (config.debug) {
      requestParams['_omittextlog'] = 'false'
-      requestParams['_omitsessionresults'] = 'false'
+      requestParams['_omitSessionResults'] = 'false'

      requestParams['_debug'] = 131
    }
--- a/src/job-execution/Sas9JobExecutor.ts
+++ b/src/job-execution/Sas9JobExecutor.ts
@@ -1,6 +1,6 @@
 import * as https from 'https'
 import { ServerType } from '@sasjs/utils/types'
-import * as NodeFormData from 'form-data'
+import NodeFormData from 'form-data'
 import { ErrorResponse } from '../types/errors'
 import { convertToCSV, isRelativePath } from '../utils'
 import { BaseJobExecutor } from './JobExecutor'
--- a/src/job-execution/SasjsJobExecutor.ts
+++ b/src/job-execution/SasjsJobExecutor.ts
@@ -1,4 +1,4 @@
-import * as NodeFormData from 'form-data'
+import NodeFormData from 'form-data'
 import {
  AuthConfig,
  ExtraResponseAttributes,
@@ -73,8 +73,10 @@ export class SasjsJobExecutor extends BaseJobExecutor {
    /* 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
+        ? `multipart/form-data; boundary=${
+            formData.getHeaders()['content-type']
+          }`
+        : 'multipart/form-data'

    const requestPromise = new Promise((resolve, reject) => {
      this.requestClient!.post(
--- a/src/job-execution/WebJobExecutor.ts
+++ b/src/job-execution/WebJobExecutor.ts
@@ -1,4 +1,4 @@
-import * as NodeFormData from 'form-data'
+import NodeFormData from 'form-data'
 import {
  AuthConfig,
  ExtraResponseAttributes,
@@ -150,8 +150,10 @@ export class WebJobExecutor extends BaseJobExecutor {
    /* 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
+        ? `multipart/form-data; boundary=${
+            formData.getHeaders()['content-type']
+          }`
+        : 'multipart/form-data'

    const requestPromise = new Promise((resolve, reject) => {
      this.requestClient!.post(
--- a/src/request/RequestClient.ts
+++ b/src/request/RequestClient.ts
@@ -2,9 +2,9 @@ import {
  AxiosError,
  AxiosInstance,
  AxiosRequestConfig,
+  AxiosRequestHeaders,
  AxiosResponse
 } from 'axios'
-import axios from 'axios'
 import * as https from 'https'
 import { CsrfToken } from '..'
 import { isAuthorizeFormRequired, isLogInRequired } from '../auth'
@@ -160,7 +160,7 @@ export class RequestClient implements HttpClient {
    const requestConfig: AxiosRequestConfig = {
      headers,
      responseType: contentType === 'text/plain' ? 'text' : 'json',
-      withCredentials: true
+      withXSRFToken: true
    }

    if (contentType === 'text/plain') {
@@ -191,6 +191,13 @@ export class RequestClient implements HttpClient {
      })
  }

+  /**
+   * @param contentType  Newer version of Axios is more strict so if you don't
+   * set the contentType to `form data` while sending a FormData object
+   * application/json will be used by default, axios won’t treat it as FormData.
+   * Instead, it serializes data as JSON—resulting in a payload like
+   * {"sometable":{}} and we lose the multipart/form-data formatting.
+   */
  public async post<T>(
    url: string,
    data: any,
@@ -207,7 +214,7 @@ export class RequestClient implements HttpClient {
    return this.httpClient
      .post<T>(url, data, {
        headers,
-        withCredentials: true,
+        withXSRFToken: true,
        ...additionalSettings
      })
      .then((response) => {
@@ -234,7 +241,7 @@ export class RequestClient implements HttpClient {
    }

    return this.httpClient
-      .put<T>(url, data, { headers, withCredentials: true })
+      .put<T>(url, data, { headers, withXSRFToken: true })
      .then((response) => {
        throwIfError(response)
        return this.parseResponse<T>(response)
@@ -253,7 +260,7 @@ export class RequestClient implements HttpClient {
    const headers = this.getHeaders(accessToken, 'application/json')

    return this.httpClient
-      .delete<T>(url, { headers, withCredentials: true })
+      .delete<T>(url, { headers, withXSRFToken: true })
      .then((response) => {
        throwIfError(response)
        return this.parseResponse<T>(response)
@@ -271,7 +278,7 @@ export class RequestClient implements HttpClient {
    const headers = this.getHeaders(accessToken, 'application/json')

    return this.httpClient
-      .patch<T>(url, data, { headers, withCredentials: true })
+      .patch<T>(url, data, { headers, withXSRFToken: true })
      .then((response) => {
        throwIfError(response)
        return this.parseResponse<T>(response)
@@ -413,95 +420,17 @@ export class RequestClient implements HttpClient {
    return bodyLines.join('\n')
  }

-  private defaultInterceptionCallBack = (
-    axiosResponse: AxiosResponse | AxiosError
-  ) => {
-    // Message indicating absent value.
-    const noValueMessage = 'Not provided'
+  private handleAxiosResponse = (response: AxiosResponse) => {
+    const { status, config, request, data } = response

-    // Fallback request object that can be safely used to form request summary.
-    type FallbackRequest = { _header?: string; res: { rawHeaders: string[] } }
-    // _header is not present in responses with status 1**
-    // rawHeaders are not present in responses with status 1**
-    let fallbackRequest: FallbackRequest = {
-      _header: `${noValueMessage}\n`,
-      res: { rawHeaders: [noValueMessage] }
-    }
+    const reqHeaders = request?._header ?? 'Not provided\n'
+    const rawHeaders = request?.res?.rawHeaders ?? ['Not provided']

-    // Fallback response object that can be safely used to form response summary.
-    type FallbackResponse = {
-      status?: number | string
-      request?: FallbackRequest
-      config: { data?: string }
-      data?: unknown
-    }
-    let fallbackResponse: FallbackResponse = axiosResponse
+    const resHeaders = this.formatHeaders(rawHeaders)
+    const parsedResBody = this.parseInterceptedBody(data)

-    if (axios.isAxiosError(axiosResponse)) {
-      const { response, request, config } = axiosResponse
-
-      // Try to use axiosResponse.response to form response summary.
-      if (response) {
-        fallbackResponse = response
-      } else {
-        // Try to use axiosResponse.request to form request summary.
-        if (request) {
-          const { _header, _currentRequest } = request
-
-          // Try to use axiosResponse.request._header to form request summary.
-          if (_header) {
-            fallbackRequest._header = _header
-          }
-          // Try to use axiosResponse.request._currentRequest._header to form request summary.
-          else if (_currentRequest && _currentRequest._header) {
-            fallbackRequest._header = _currentRequest._header
-          }
-
-          const { res } = request
-
-          // Try to use axiosResponse.request.res.rawHeaders to form request summary.
-          if (res && res.rawHeaders) {
-            fallbackRequest.res.rawHeaders = res.rawHeaders
-          }
-        }
-
-        // Fallback config that can be safely used to form response summary.
-        const fallbackConfig = { data: noValueMessage }
-
-        fallbackResponse = {
-          status: noValueMessage,
-          request: fallbackRequest,
-          config: config || fallbackConfig,
-          data: noValueMessage
-        }
-      }
-    }
-
-    const { status, config, request, data: resData } = fallbackResponse
-    const { data: reqData } = config
-    const { _header: reqHeaders, res } = request || fallbackRequest
-    const { rawHeaders } = res
-
-    // Converts an array of strings into a single string with the following format:
-    // <headerName>: <headerValue>
-    const resHeaders = rawHeaders.reduce(
-      (acc: string, value: string, i: number) => {
-        if (i % 2 === 0) {
-          acc += `${i === 0 ? '' : '\n'}${value}`
-        } else {
-          acc += `: ${value}`
-        }
-
-        return acc
-      },
-      ''
-    )
-
-    const parsedResBody = this.parseInterceptedBody(resData)
-
-    // HTTP response summary.
    process.logger?.info(`HTTP Request (first 50 lines):
-${reqHeaders}${this.parseInterceptedBody(reqData)}
+${reqHeaders}${this.parseInterceptedBody(config.data)}

 HTTP Response Code: ${this.prettifyString(status)}

@@ -509,7 +438,70 @@ HTTP Response (first 50 lines):
 ${resHeaders}${parsedResBody ? `\n\n${parsedResBody}` : ''}
 `)

-    return axiosResponse
+    return response
+  }
+
+  private handleAxiosError = (error: AxiosError) => {
+    // Message indicating absent value.
+    const noValueMessage = 'Not provided'
+    const { response, request, config } = error
+
+    // Fallback request object that can be safely used to form request summary.
+    // _header is not present in responses with status 1**
+    // rawHeaders are not present in responses with status 1**
+    let fallbackRequest = {
+      _header: `${noValueMessage}\n`,
+      res: { rawHeaders: [noValueMessage] }
+    }
+
+    if (request) {
+      fallbackRequest = {
+        _header:
+          request._header ?? request._currentRequest?._header ?? noValueMessage,
+        res: { rawHeaders: request.res?.rawHeaders ?? [noValueMessage] }
+      }
+    }
+
+    // Fallback response object that can be safely used to form response summary.
+    let fallbackResponse = response || {
+      status: noValueMessage,
+      request: fallbackRequest,
+      config: config || {
+        data: noValueMessage,
+        headers: {} as AxiosRequestHeaders
+      },
+      data: noValueMessage
+    }
+
+    const { status, request: req, data: resData } = fallbackResponse
+    const { _header: reqHeaders, res } = req
+
+    const resHeaders = this.formatHeaders(res.rawHeaders)
+    const parsedResBody = this.parseInterceptedBody(resData)
+
+    process.logger?.info(`HTTP Request (first 50 lines):
+${reqHeaders}${this.parseInterceptedBody(config?.data)}
+
+HTTP Response Code: ${this.prettifyString(status)}
+
+HTTP Response (first 50 lines):
+${resHeaders}${parsedResBody ? `\n\n${parsedResBody}` : ''}
+`)
+
+    return error
+  }
+
+  // Converts an array of strings into a single string with the following format:
+  // <headerName>: <headerValue>
+  private formatHeaders = (rawHeaders: string[]): string => {
+    return rawHeaders.reduce((acc, value, i) => {
+      if (i % 2 === 0) {
+        acc += `${i === 0 ? '' : '\n'}${value}`
+      } else {
+        acc += `: ${value}`
+      }
+      return acc
+    }, '')
  }

  /**
@@ -529,8 +521,8 @@ ${resHeaders}${parsedResBody ? `\n\n${parsedResBody}` : ''}
   * @param errorCallBack - function that should be triggered on every HTTP response with the status different from 2**.
   */
  public enableVerboseMode = (
-    successCallBack = this.defaultInterceptionCallBack,
-    errorCallBack = this.defaultInterceptionCallBack
+    successCallBack = this.handleAxiosResponse,
+    errorCallBack = this.handleAxiosError
  ) => {
    this.httpInterceptor = this.httpClient.interceptors.response.use(
      successCallBack,
@@ -645,7 +637,7 @@ ${resHeaders}${parsedResBody ? `\n\n${parsedResBody}` : ''}
      // Fetching root and creating CSRF cookie
      await this.httpClient
        .get('/', {
-          withCredentials: true
+          withXSRFToken: true
        })
        .then((response) => {
          const cookie =
--- a/src/request/Sas9RequestClient.ts
+++ b/src/request/Sas9RequestClient.ts
@@ -1,6 +1,6 @@
 import * as https from 'https'
 import { AxiosRequestConfig } from 'axios'
-import axiosCookieJarSupport from 'axios-cookiejar-support'
+import { wrapper } from 'axios-cookiejar-support'
 import * as tough from 'tough-cookie'
 import { prefixMessage } from '@sasjs/utils/error'
 import { RequestClient, throwIfError } from './RequestClient'
@@ -17,8 +17,8 @@ export class Sas9RequestClient extends RequestClient {
    this.httpClient.defaults.validateStatus = (status) =>
      status >= 200 && status < 303

-    if (axiosCookieJarSupport) {
-      axiosCookieJarSupport(this.httpClient)
+    if (wrapper) {
+      wrapper(this.httpClient)
      this.httpClient.defaults.jar = new tough.CookieJar()
    }
  }
@@ -50,7 +50,7 @@ export class Sas9RequestClient extends RequestClient {
    const requestConfig: AxiosRequestConfig = {
      headers,
      responseType: contentType === 'text/plain' ? 'text' : 'json',
-      withCredentials: true
+      withXSRFToken: true
    }
    if (contentType === 'text/plain') {
      requestConfig.transformResponse = undefined
@@ -103,7 +103,7 @@ export class Sas9RequestClient extends RequestClient {
    }

    return this.httpClient
-      .post<T>(url, data, { headers, withCredentials: true })
+      .post<T>(url, data, { headers, withXSRFToken: true })
      .then(async (response) => {
        if (response.status === 302) {
          return await this.get(
--- a/src/request/spec/SasjsRequestClient.spec.ts
+++ b/src/request/spec/SasjsRequestClient.spec.ts
@@ -1,6 +1,6 @@
 import { SASJS_LOGS_SEPARATOR, SasjsRequestClient } from '../SasjsRequestClient'
 import { SasjsParsedResponse } from '../../types'
-import { AxiosResponse } from 'axios'
+import { AxiosRequestHeaders, AxiosResponse } from 'axios'

 describe('SasjsRequestClient', () => {
  const requestClient = new SasjsRequestClient('')
@@ -37,7 +37,9 @@ ${SASJS_LOGS_SEPARATOR}`,
      status,
      statusText: 'ok',
      headers: { etag },
-      config: {}
+      config: {
+        headers: {} as AxiosRequestHeaders
+      }
    }

    const expectedParsedResponse: SasjsParsedResponse<string> = {
@@ -65,7 +67,9 @@ ${printOutput}`,
      status,
      statusText: 'ok',
      headers: { etag },
-      config: {}
+      config: {
+        headers: {} as AxiosRequestHeaders
+      }
    }

    const expectedParsedResponse: SasjsParsedResponse<string> = {
@@ -100,7 +104,9 @@ ${SASJS_LOGS_SEPARATOR}`,
      status,
      statusText: 'ok',
      headers: { etag },
-      config: {}
+      config: {
+        headers: {} as AxiosRequestHeaders
+      }
    }

    const expectedParsedResponse: SasjsParsedResponse<string> = {
@@ -139,7 +145,9 @@ ${printOutput}`,
      status,
      statusText: 'ok',
      headers: { etag },
-      config: {}
+      config: {
+        headers: {} as AxiosRequestHeaders
+      }
    }

    const expectedParsedResponse: SasjsParsedResponse<string> = {
--- a/src/spec/SAS9ApiClient.spec.ts
+++ b/src/spec/SAS9ApiClient.spec.ts
@@ -0,0 +1,130 @@
+/**
+ * @jest-environment node
+ */
+import * as https from 'https'
+import NodeFormData from 'form-data'
+import { SAS9ApiClient } from '../SAS9ApiClient'
+import { Sas9RequestClient } from '../request/Sas9RequestClient'
+
+// Mock the Sas9RequestClient so that we can control its behavior
+jest.mock('../request/Sas9RequestClient', () => {
+  return {
+    Sas9RequestClient: jest
+      .fn()
+      .mockImplementation(
+        (serverUrl: string, httpsAgentOptions?: https.AgentOptions) => {
+          return {
+            login: jest.fn().mockResolvedValue(undefined),
+            post: jest.fn().mockResolvedValue({ result: 'execution result' })
+          }
+        }
+      )
+  }
+})
+
+describe('SAS9ApiClient', () => {
+  const serverUrl = 'http://test-server.com'
+  const jobsPath = '/SASStoredProcess/do'
+  let client: SAS9ApiClient
+  let mockRequestClient: any
+
+  beforeEach(() => {
+    client = new SAS9ApiClient(serverUrl, jobsPath)
+    // Retrieve the instance of the mocked Sas9RequestClient
+    mockRequestClient = (Sas9RequestClient as jest.Mock).mock.results[0].value
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  describe('getConfig', () => {
+    it('should return the correct configuration', () => {
+      const config = client.getConfig()
+      expect(config).toEqual({ serverUrl })
+    })
+  })
+
+  describe('setConfig', () => {
+    it('should update the serverUrl when a valid value is provided', () => {
+      const newUrl = 'http://new-server.com'
+      client.setConfig(newUrl)
+      expect(client.getConfig()).toEqual({ serverUrl: newUrl })
+    })
+
+    it('should not update the serverUrl when an empty string is provided', () => {
+      const originalConfig = client.getConfig()
+      client.setConfig('')
+      expect(client.getConfig()).toEqual(originalConfig)
+    })
+  })
+
+  describe('executeScript', () => {
+    const linesOfCode = ['line1;', 'line2;']
+    const userName = 'testUser'
+    const password = 'testPass'
+    const fixedTimestamp = '1234567890'
+    const expectedFilename = `sasjs-execute-sas9-${fixedTimestamp}.sas`
+
+    beforeAll(() => {
+      // Stub generateTimestamp so that we get a consistent filename in our tests.
+      jest
+        .spyOn(require('@sasjs/utils/time'), 'generateTimestamp')
+        .mockReturnValue(fixedTimestamp)
+    })
+
+    afterAll(() => {
+      jest.restoreAllMocks()
+    })
+
+    it('should execute the script and return the result', async () => {
+      const result = await client.executeScript(linesOfCode, userName, password)
+
+      // Verify that login is called with the correct parameters.
+      expect(mockRequestClient.login).toHaveBeenCalledWith(
+        userName,
+        password,
+        jobsPath
+      )
+
+      // Build the expected stored process URL.
+      const codeInjectorPath = `/User Folders/${userName}/My Folder/sasjs/runner`
+      const expectedUrl =
+        `${jobsPath}/?` + '_program=' + codeInjectorPath + '&_debug=log'
+
+      // Verify that post was called with the expected stored process URL.
+      expect(mockRequestClient.post).toHaveBeenCalledWith(
+        expectedUrl,
+        expect.any(NodeFormData),
+        undefined,
+        expect.stringContaining('multipart/form-data; boundary='),
+        expect.objectContaining({
+          'Content-Length': expect.any(Number),
+          'Content-Type': expect.stringContaining(
+            'multipart/form-data; boundary='
+          ),
+          Accept: '*/*'
+        })
+      )
+
+      // The method should return the result from the post call.
+      expect(result).toEqual('execution result')
+    })
+
+    it('should include the force output code in the uploaded form data', async () => {
+      await client.executeScript(linesOfCode, userName, password)
+      // Retrieve the form data passed to post
+      const postCallArgs = (mockRequestClient.post as jest.Mock).mock.calls[0]
+      const formData: NodeFormData = postCallArgs[1]
+
+      // We can inspect the boundary and ensure that the filename was generated correctly.
+      expect(formData.getBoundary()).toBeDefined()
+
+      // The filename is used as the key for the form field.
+      const formDataBuffer = formData.getBuffer().toString()
+      expect(formDataBuffer).toContain(expectedFilename)
+      // Also check that the force output code is appended.
+      expect(formDataBuffer).toContain("put 'Executed sasjs run';")
+    })
+  })
+})
--- a/src/spec/SASjsApiClient.spec.ts
+++ b/src/spec/SASjsApiClient.spec.ts
@@ -0,0 +1,231 @@
+import NodeFormData from 'form-data'
+import {
+  SASjsApiClient,
+  SASjsAuthResponse,
+  ScriptExecutionResult
+} from '../SASjsApiClient'
+import { AuthConfig, ServicePackSASjs } from '@sasjs/utils/types'
+import { ExecutionQuery } from '../types'
+
+// Create a mock request client with a post method.
+const mockPost = jest.fn()
+const mockRequestClient = {
+  post: mockPost
+}
+
+// Instead of referencing external variables, inline the dummy values in the mock factories.
+jest.mock('../auth/getTokens', () => ({
+  getTokens: jest.fn().mockResolvedValue({ access_token: 'dummyAccessToken' })
+}))
+
+jest.mock('../auth/getAccessTokenForSasjs', () => ({
+  getAccessTokenForSasjs: jest.fn().mockResolvedValue({
+    access_token: 'newAccessToken',
+    refresh_token: 'newRefreshToken'
+  } as any)
+}))
+
+jest.mock('../auth/refreshTokensForSasjs', () => ({
+  refreshTokensForSasjs: jest.fn().mockResolvedValue({
+    access_token: 'newAccessToken',
+    refresh_token: 'newRefreshToken'
+  } as any)
+}))
+
+// For deployZipFile, mock the file reading function.
+jest.mock('@sasjs/utils/file', () => ({
+  createReadStream: jest.fn().mockResolvedValue('readStreamDummy')
+}))
+
+// Dummy result to compare against.
+const dummyResult = {
+  status: 'OK',
+  message: 'Success',
+  streamServiceName: 'service',
+  example: {}
+}
+
+describe('SASjsApiClient', () => {
+  let client: SASjsApiClient
+
+  beforeEach(() => {
+    client = new SASjsApiClient(mockRequestClient as any)
+    mockPost.mockReset()
+  })
+
+  describe('deploy', () => {
+    it('should deploy service pack using JSON', async () => {
+      // Arrange: Simulate a successful response.
+      mockPost.mockResolvedValue({ result: dummyResult })
+
+      const dataJson: ServicePackSASjs = {
+        appLoc: '',
+        someOtherProp: 'value'
+      } as any
+      const appLoc = '/base/appLoc'
+      const authConfig: AuthConfig = {
+        client: 'clientId',
+        secret: 'secret',
+        access_token: 'token',
+        refresh_token: 'refresh'
+      }
+
+      // Act
+      const result = await client.deploy(dataJson, appLoc, authConfig)
+
+      // Assert: Ensure that the JSON gets the appLoc set if not defined.
+      expect(dataJson.appLoc).toBe(appLoc)
+      expect(mockPost).toHaveBeenCalledWith(
+        'SASjsApi/drive/deploy',
+        dataJson,
+        'dummyAccessToken',
+        undefined,
+        {},
+        { maxContentLength: Infinity, maxBodyLength: Infinity }
+      )
+      expect(result).toEqual(dummyResult)
+    })
+  })
+
+  describe('deployZipFile', () => {
+    it('should deploy zip file and return the result', async () => {
+      // Arrange: Simulate a successful response.
+      mockPost.mockResolvedValue({ result: dummyResult })
+      const zipFilePath = 'path/to/deploy.zip'
+      const authConfig: AuthConfig = {
+        client: 'clientId',
+        secret: 'secret',
+        access_token: 'token',
+        refresh_token: 'refresh'
+      }
+
+      // Act
+      const result = await client.deployZipFile(zipFilePath, authConfig)
+
+      // Assert: Verify that POST is called with multipart form-data.
+      expect(mockPost).toHaveBeenCalled()
+      const callArgs = mockPost.mock.calls[0]
+      expect(callArgs[0]).toBe('SASjsApi/drive/deploy/upload')
+      expect(result).toEqual(dummyResult)
+    })
+  })
+
+  describe('executeJob', () => {
+    it('should execute a job with absolute program path', async () => {
+      // Arrange
+      const query: ExecutionQuery = { _program: '/absolute/path' } as any
+      const appLoc = '/base/appLoc'
+      const authConfig: AuthConfig = { access_token: 'anyToken' } as any
+      mockPost.mockResolvedValue({
+        result: { jobId: 123 },
+        log: 'execution log'
+      })
+
+      // Act
+      const { result, log } = await client.executeJob(query, appLoc, authConfig)
+
+      // Assert: The program path should not be prefixed.
+      expect(mockPost).toHaveBeenCalledWith(
+        'SASjsApi/stp/execute',
+        { _debug: 131, ...query, _program: '/absolute/path' },
+        'anyToken'
+      )
+      expect(result).toEqual({ jobId: 123 })
+      expect(log).toBe('execution log')
+    })
+
+    it('should execute a job with relative program path', async () => {
+      // Arrange
+      const query: ExecutionQuery = { _program: 'relative/path' } as any
+      const appLoc = '/base/appLoc'
+      mockPost.mockResolvedValue({ result: { jobId: 456 }, log: 'another log' })
+
+      // Act
+      const { result, log } = await client.executeJob(query, appLoc)
+
+      // Assert: The program path should be prefixed with appLoc.
+      expect(mockPost).toHaveBeenCalledWith(
+        'SASjsApi/stp/execute',
+        { _debug: 131, ...query, _program: '/base/appLoc/relative/path' },
+        undefined
+      )
+      expect(result).toEqual({ jobId: 456 })
+      expect(log).toBe('another log')
+    })
+  })
+
+  describe('executeScript', () => {
+    it('should execute a script and return the execution result', async () => {
+      // Arrange
+      const code = 'data _null_; run;'
+      const runTime = 'sas'
+      const authConfig: AuthConfig = {
+        client: 'clientId',
+        secret: 'secret',
+        access_token: 'token',
+        refresh_token: 'refresh'
+      }
+      const responsePayload = {
+        log: 'log output',
+        printOutput: 'print output',
+        result: 'web output'
+      }
+      mockPost.mockResolvedValue(responsePayload)
+
+      // Act
+      const result: ScriptExecutionResult = await client.executeScript(
+        code,
+        runTime,
+        authConfig
+      )
+
+      // Assert
+      expect(mockPost).toHaveBeenCalledWith(
+        'SASjsApi/code/execute',
+        { code, runTime },
+        'dummyAccessToken'
+      )
+      expect(result.log).toBe('log output')
+      expect(result.printOutput).toBe('print output')
+      expect(result.webout).toBe('web output')
+    })
+
+    it('should throw an error with a prefixed message when POST fails', async () => {
+      // Arrange
+      const code = 'data _null_; run;'
+      const errorMessage = 'Network Error'
+      mockPost.mockRejectedValue(new Error(errorMessage))
+
+      // Act & Assert
+      await expect(client.executeScript(code)).rejects.toThrow(
+        /Error while sending POST request to execute code/
+      )
+    })
+  })
+
+  describe('getAccessToken', () => {
+    it('should exchange auth code for access token', async () => {
+      // Act
+      const result = await client.getAccessToken('clientId', 'authCode123')
+
+      // Assert: The result should match the dummy auth response.
+      expect(result).toEqual({
+        access_token: 'newAccessToken',
+        refresh_token: 'newRefreshToken'
+      })
+    })
+  })
+
+  describe('refreshTokens', () => {
+    it('should exchange refresh token for new tokens', async () => {
+      // Act
+      const result = await client.refreshTokens('refreshToken123')
+
+      // Assert: The result should match the dummy auth response.
+      expect(result).toEqual({
+        access_token: 'newAccessToken',
+        refresh_token: 'newRefreshToken'
+      })
+    })
+  })
+})
--- a/src/test/RequestClient.spec.ts
+++ b/src/test/RequestClient.spec.ts
@@ -5,7 +5,7 @@ import { app, mockedAuthResponse } from './SAS_server_app'
 import { ServerType } from '@sasjs/utils/types'
 import SASjs from '../SASjs'
 import * as axiosModules from '../utils/createAxiosInstance'
-import axios from 'axios'
+import axios, { AxiosRequestHeaders } from 'axios'
 import {
  LoginRequiredError,
  AuthorizeError,
@@ -24,9 +24,17 @@ const axiosActual = jest.requireActual('axios')
 jest
  .spyOn(axiosModules, 'createAxiosInstance')
  .mockImplementation((baseURL: string, httpsAgent?: https.Agent) =>
-    axiosActual.create({ baseURL, httpsAgent })
+    axiosActual.create({ baseURL, httpsAgent, withXSRFToken: true })
  )

+jest.mock('util', () => {
+  const actualUtil = jest.requireActual('util')
+  return {
+    ...actualUtil,
+    inspect: jest.fn(actualUtil.inspect)
+  }
+})
+
 const PORT = 8000
 const SERVER_URL = `https://localhost:${PORT}/`

@@ -75,7 +83,7 @@ describe('RequestClient', () => {
    expect(rejectionErrorMessage).toEqual(expectedError.message)
  })

-  describe('defaultInterceptionCallBack', () => {
+  describe('defaultInterceptionCallBacks for successful requests and failed requests', () => {
    const reqHeaders = `POST https://sas.server.com/compute/sessions/session_id/jobs HTTP/1.1
 Accept: application/json
 Content-Type: application/json
@@ -96,7 +104,7 @@ Connection: close
            _contextName: 'SAS Job Execution compute context',
            _OMITJSONLISTING: true,
            _OMITJSONLOG: true,
-            _OMITSESSIONRESULTS: true,
+            _omitSessionResults: true,
            _OMITTEXTLISTING: true,
            _OMITTEXTLOG: true
          }
@@ -165,10 +173,6 @@ Connection: close
    })

    it('should log parsed response with status 1**', () => {
-      const spyIsAxiosError = jest
-        .spyOn(axios, 'isAxiosError')
-        .mockImplementation(() => true)
-
      const mockedAxiosError = {
        config: {
          data: reqData
@@ -181,7 +185,7 @@ Connection: close
      } as AxiosError

      const requestClient = new RequestClient('')
-      requestClient['defaultInterceptionCallBack'](mockedAxiosError)
+      requestClient['handleAxiosError'](mockedAxiosError)

      const noValueMessage = 'Not provided'
      const expectedLog = `HTTP Request (first 50 lines):
@@ -195,8 +199,6 @@ ${noValueMessage}
 `

      expect((process as any).logger.info).toHaveBeenCalledWith(expectedLog)
-
-      spyIsAxiosError.mockReset()
    })

    it('should log parsed response with status 2**', () => {
@@ -209,12 +211,15 @@ ${noValueMessage}
        status,
        statusText: '',
        headers: {},
-        config: { data: reqData },
+        config: {
+          data: reqData,
+          headers: {} as AxiosRequestHeaders
+        },
        request: { _header: reqHeaders, res: { rawHeaders: resHeaders } }
      }

      const requestClient = new RequestClient('')
-      requestClient['defaultInterceptionCallBack'](mockedResponse)
+      requestClient['handleAxiosResponse'](mockedResponse)

      const expectedLog = `HTTP Request (first 50 lines):
 ${reqHeaders}${requestClient['parseInterceptedBody'](reqData)}
@@ -235,29 +240,29 @@ ${resHeaders[0]}: ${resHeaders[1]}${
    it('should log parsed response with status 3**', () => {
      const status = getRandomStatus([300, 301, 302, 303, 304, 307, 308])

-      const mockedResponse: AxiosResponse = {
-        data: resData,
-        status,
-        statusText: '',
-        headers: {},
-        config: { data: reqData },
-        request: { _header: reqHeaders, res: { rawHeaders: resHeaders } }
-      }
+      const mockedAxiosError = {
+        config: {
+          data: reqData
+        },
+        request: {
+          _currentRequest: {
+            _header: reqHeaders
+          }
+        }
+      } as AxiosError

      const requestClient = new RequestClient('')
-      requestClient['defaultInterceptionCallBack'](mockedResponse)
+      requestClient['handleAxiosError'](mockedAxiosError)

+      const noValueMessage = 'Not provided'
      const expectedLog = `HTTP Request (first 50 lines):
 ${reqHeaders}${requestClient['parseInterceptedBody'](reqData)}

-HTTP Response Code: ${requestClient['prettifyString'](status)}
+HTTP Response Code: ${requestClient['prettifyString'](noValueMessage)}

 HTTP Response (first 50 lines):
-${resHeaders[0]}: ${resHeaders[1]}${
-        requestClient['parseInterceptedBody'](resData)
-          ? `\n\n${requestClient['parseInterceptedBody'](resData)}`
-          : ''
-      }
+${noValueMessage}
+\n${requestClient['parseInterceptedBody'](noValueMessage)}
 `

      expect((process as any).logger.info).toHaveBeenCalledWith(expectedLog)
@@ -278,7 +283,10 @@ ${resHeaders[0]}: ${resHeaders[1]}${
        status,
        statusText: '',
        headers: {},
-        config: { data: reqData },
+        config: {
+          data: reqData,
+          headers: {} as AxiosRequestHeaders
+        },
        request: { _header: reqHeaders, res: { rawHeaders: resHeaders } }
      }
      const mockedAxiosError = {
@@ -294,7 +302,7 @@ ${resHeaders[0]}: ${resHeaders[1]}${
      } as AxiosError

      const requestClient = new RequestClient('')
-      requestClient['defaultInterceptionCallBack'](mockedAxiosError)
+      requestClient['handleAxiosError'](mockedAxiosError)

      const expectedLog = `HTTP Request (first 50 lines):
 ${reqHeaders}${requestClient['parseInterceptedBody'](reqData)}
@@ -328,7 +336,10 @@ ${resHeaders[0]}: ${resHeaders[1]}${
        status,
        statusText: '',
        headers: {},
-        config: { data: reqData },
+        config: {
+          data: reqData,
+          headers: {} as AxiosRequestHeaders
+        },
        request: { _header: reqHeaders, res: { rawHeaders: resHeaders } }
      }
      const mockedAxiosError = {
@@ -344,7 +355,7 @@ ${resHeaders[0]}: ${resHeaders[1]}${
      } as AxiosError

      const requestClient = new RequestClient('')
-      requestClient['defaultInterceptionCallBack'](mockedAxiosError)
+      requestClient['handleAxiosError'](mockedAxiosError)

      const expectedLog = `HTTP Request (first 50 lines):
 ${reqHeaders}${requestClient['parseInterceptedBody'](reqData)}
@@ -376,8 +387,8 @@ ${resHeaders[0]}: ${resHeaders[1]}${
      requestClient.enableVerboseMode()

      expect(interceptorSpy).toHaveBeenCalledWith(
-        requestClient['defaultInterceptionCallBack'],
-        requestClient['defaultInterceptionCallBack']
+        requestClient['handleAxiosResponse'],
+        requestClient['handleAxiosError']
      )
    })

@@ -388,12 +399,12 @@ ${resHeaders[0]}: ${resHeaders[1]}${
        'use'
      )

-      const successCallback = (response: AxiosResponse | AxiosError) => {
+      const successCallback = (response: AxiosResponse) => {
        console.log('success')

        return response
      }
-      const failureCallback = (response: AxiosResponse | AxiosError) => {
+      const failureCallback = (response: AxiosError) => {
        console.log('failure')

        return response
@@ -429,15 +440,18 @@ ${resHeaders[0]}: ${resHeaders[1]}${
  })

  describe('prettifyString', () => {
+    const inspectMock = UtilsModule.inspect as unknown as jest.Mock
+
+    beforeEach(() => {
+      // Reset the mock before each test to ensure a clean slate
+      inspectMock.mockClear()
+    })
+
    it(`should call inspect without colors when verbose mode is set to 'bleached'`, () => {
      const requestClient = new RequestClient('')
-      let verbose: VerboseMode = 'bleached'
-      requestClient.setVerboseMode(verbose)
-
-      jest.spyOn(UtilsModule, 'inspect')
+      requestClient.setVerboseMode('bleached')

      const testStr = JSON.stringify({ test: 'test' })
-
      requestClient['prettifyString'](testStr)

      expect(UtilsModule.inspect).toHaveBeenCalledWith(testStr, {
@@ -445,15 +459,11 @@ ${resHeaders[0]}: ${resHeaders[1]}${
      })
    })

-    it(`should call inspect with colors when verbose mode is set to 'true'`, () => {
+    it(`should call inspect with colors when verbose mode is set to true`, () => {
      const requestClient = new RequestClient('')
-      let verbose: VerboseMode = true
-      requestClient.setVerboseMode(verbose)
-
-      jest.spyOn(UtilsModule, 'inspect')
+      requestClient.setVerboseMode(true)

      const testStr = JSON.stringify({ test: 'test' })
-
      requestClient['prettifyString'](testStr)

      expect(UtilsModule.inspect).toHaveBeenCalledWith(testStr, {
--- a/src/test/SAS_server_app.ts
+++ b/src/test/SAS_server_app.ts
@@ -1,7 +1,15 @@
 import express = require('express')
+import cors from 'cors'

 export const app = express()

+app.use(
+  cors({
+    origin: 'http://localhost', // Allow requests only from this origin
+    credentials: true // Allow credentials (cookies, auth headers, etc.)
+  })
+)
+
 export const mockedAuthResponse = {
  access_token: 'access_token',
  token_type: 'bearer',
@@ -12,11 +20,11 @@ export const mockedAuthResponse = {
  jti: 'jti'
 }

-app.get('/', function (req: any, res: any) {
+app.get('/', (req: any, res: any) => {
  res.send('Hello World')
 })

-app.post('/SASLogon/oauth/token', function (req: any, res: any) {
+app.post('/SASLogon/oauth/token', (req: any, res: any) => {
  let valid = true

  // capture the encoded form data
--- a/src/types/FileResource.ts
+++ b/src/types/FileResource.ts
@@ -0,0 +1,33 @@
+export interface FileResource {
+  creationTimeStamp: string
+  modifiedTimeStamp: string
+  createdBy: string
+  modifiedBy: string
+  id: string
+  properties: Properties
+  contentDisposition: string
+  contentType: string
+  encoding: string
+  links: Link[]
+  name: string
+  size: number
+  searchable: boolean
+  fileStatus: string
+  fileVersion: number
+  typeDefName: string
+  version: number
+  virusDetected: boolean
+  urlDetected: boolean
+  quarantine: boolean
+}
+
+export interface Link {
+  method: string
+  rel: string
+  href: string
+  uri: string
+  type?: string
+  responseType?: string
+}
+
+export interface Properties {}
--- a/src/types/Tables.spec.ts
+++ b/src/types/Tables.spec.ts
@@ -0,0 +1,28 @@
+import SASjs from '../SASjs'
+
+describe('Tables - basic coverage', () => {
+  const adapter = new SASjs()
+
+  it('should throw an error if first argument is not an array', () => {
+    expect(() => adapter.Tables({}, 'test')).toThrow('First argument')
+  })
+
+  it('should throw an error if second argument is not a string', () => {
+    // @ts-expect-error
+    expect(() => adapter.Tables([], 1234)).toThrow('Second argument')
+  })
+
+  it('should throw an error if macro name ends with a number', () => {
+    expect(() => adapter.Tables([], 'test1')).toThrow('number at the end')
+  })
+
+  it('should throw an error if no arguments are passed', () => {
+    // @ts-expect-error
+    expect(() => adapter.Tables()).toThrow('Missing arguments')
+  })
+
+  it('should create Tables class successfully with _tables property', () => {
+    const tables = adapter.Tables([], 'test')
+    expect(tables).toHaveProperty('_tables')
+  })
+})
--- a/src/types/Tables.ts
+++ b/src/types/Tables.ts
@@ -0,0 +1,29 @@
+import { ArgumentError } from './errors'
+
+export class Tables {
+  _tables: { [macroName: string]: Record<string, any> }
+
+  constructor(table: Record<string, any>, macroName: string) {
+    this._tables = {}
+
+    this.add(table, macroName)
+  }
+
+  add(table: Record<string, any> | null, macroName: string) {
+    if (table && macroName) {
+      if (!(table instanceof Array)) {
+        throw new ArgumentError('First argument must be array')
+      }
+      if (typeof macroName !== 'string') {
+        throw new ArgumentError('Second argument must be string')
+      }
+      if (!isNaN(Number(macroName[macroName.length - 1]))) {
+        throw new ArgumentError('Macro name cannot have number at the end')
+      }
+    } else {
+      throw new ArgumentError('Missing arguments')
+    }
+
+    this._tables[macroName] = table
+  }
+}
--- a/src/types/WriteStream.ts
+++ b/src/types/WriteStream.ts
@@ -1,4 +1,10 @@
-export interface WriteStream {
-  write: (content: string, callback: (err?: Error) => any) => void
-  path: string
+import { WriteStream as FsWriteStream } from 'fs'
+
+export interface WriteStream extends FsWriteStream {
+  write(
+    chunk: any,
+    encoding?: BufferEncoding | ((error: Error | null | undefined) => void),
+    cb?: (error: Error | null | undefined) => void
+  ): boolean
+  path: string | Buffer
 }
--- a/src/types/errors/ArgumentError.ts
+++ b/src/types/errors/ArgumentError.ts
@@ -0,0 +1,7 @@
+export class ArgumentError extends Error {
+  constructor(public message: string) {
+    super(message)
+    this.name = 'ArgumentError'
+    Object.setPrototypeOf(this, ArgumentError.prototype)
+  }
+}
--- a/src/types/errors/index.ts
+++ b/src/types/errors/index.ts
@@ -1,3 +1,4 @@
+export * from './ArgumentError'
 export * from './AuthorizeError'
 export * from './CertificateError'
 export * from './ComputeJobExecutionError'
--- a/src/types/errors/spec/SAS9AuthError.spec.ts
+++ b/src/types/errors/spec/SAS9AuthError.spec.ts
@@ -0,0 +1,30 @@
+import { SAS9AuthError } from '../SAS9AuthError'
+
+describe('SAS9AuthError', () => {
+  it('should have the correct error message', () => {
+    const error = new SAS9AuthError()
+    expect(error.message).toBe(
+      'The credentials you provided cannot be authenticated. Please provide a valid set of credentials.'
+    )
+  })
+
+  it('should have the correct error name', () => {
+    const error = new SAS9AuthError()
+    expect(error.name).toBe('AuthorizeError')
+  })
+
+  it('should be an instance of SAS9AuthError', () => {
+    const error = new SAS9AuthError()
+    expect(error).toBeInstanceOf(SAS9AuthError)
+  })
+
+  it('should be an instance of Error', () => {
+    const error = new SAS9AuthError()
+    expect(error).toBeInstanceOf(Error)
+  })
+
+  it('should set the prototype correctly', () => {
+    const error = new SAS9AuthError()
+    expect(Object.getPrototypeOf(error)).toBe(SAS9AuthError.prototype)
+  })
+})
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -15,3 +15,4 @@ export * from './PollOptions'
 export * from './WriteStream'
 export * from './ExecuteScript'
 export * from './errors'
+export * from './Tables'
--- a/src/utils/convertToCsv.ts
+++ b/src/utils/convertToCsv.ts
@@ -10,10 +10,14 @@ export const convertToCSV = (
  tableName: string
 ) => {
  if (!data[tableName]) {
-    throw prefixMessage(
+    const error = prefixMessage(
      'No table provided to be converted to CSV.',
      'Error while converting to CSV. '
    )
+
+    if (typeof error === 'string') throw new Error(error)
+
+    throw error
  }

  const table = data[tableName]
--- a/src/utils/getFormData.ts
+++ b/src/utils/getFormData.ts
@@ -1,5 +1,5 @@
 import { isNode } from './'
-import * as NodeFormData from 'form-data'
+import NodeFormData from 'form-data'

-export const getFormData = () =>
+export const getFormData = (): NodeFormData | FormData =>
  isNode() ? new NodeFormData() : new FormData()
--- a/src/utils/spec/getFormData.spec.ts
+++ b/src/utils/spec/getFormData.spec.ts
@@ -1,6 +1,6 @@
 import { getFormData } from '..'
 import * as isNodeModule from '../isNode'
-import * as NodeFormData from 'form-data'
+import NodeFormData from 'form-data'

 describe('getFormData', () => {
  it('should return NodeFormData if environment is Node', () => {
@@ -10,8 +10,8 @@ describe('getFormData', () => {
  })

  it('should return FormData if environment is not Node', () => {
-    const formDataMock = () => {}
-    ;(global as any).FormData = formDataMock
+    // Ensure FormData is globally available
+    ;(global as any).FormData = class FormData {}

    jest.spyOn(isNodeModule, 'isNode').mockImplementation(() => false)

--- a/src/utils/spec/parseSasViyaLog.spec.ts
+++ b/src/utils/spec/parseSasViyaLog.spec.ts
@@ -0,0 +1,24 @@
+import { parseSasViyaLog } from '../parseSasViyaLog'
+
+describe('parseSasViyaLog', () => {
+  it('should parse sas viya log if environment is Node', () => {
+    const logResponse = {
+      items: [{ line: 'Line 1' }, { line: 'Line 2' }, { line: 'Line 3' }]
+    }
+
+    const expectedLog = 'Line 1\nLine 2\nLine 3'
+    const result = parseSasViyaLog(logResponse)
+    expect(result).toEqual(expectedLog)
+  })
+
+  it('should handle exceptions and return the original logResponse', () => {
+    // Create a logResponse that will cause an error in the mapping process.
+    const logResponse: any = {
+      items: null
+    }
+    // Since logResponse.items is null, the ternary operator returns the else branch.
+    const expectedLog = JSON.stringify(logResponse)
+    const result = parseSasViyaLog(logResponse)
+    expect(result).toEqual(expectedLog)
+  })
+})
--- a/src/utils/spec/parseViyaDebugResponse.spec.ts
+++ b/src/utils/spec/parseViyaDebugResponse.spec.ts
@@ -0,0 +1,72 @@
+import { RequestClient } from '../../request/RequestClient'
+import { parseSasViyaDebugResponse } from '../parseViyaDebugResponse'
+
+describe('parseSasViyaDebugResponse', () => {
+  let requestClient: RequestClient
+  const serverUrl = 'http://test-server.com'
+
+  beforeEach(() => {
+    requestClient = {
+      get: jest.fn()
+    } as unknown as RequestClient
+  })
+
+  it('should extract URL and call get for Viya 3.5 iframe style', async () => {
+    const iframeUrl = '/path/to/log.json'
+    const response = `<html><body><iframe style="width: 99%; height: 500px" src="${iframeUrl}"></iframe></body></html>`
+    const resultData = { message: 'success' }
+
+    // Mock the get method to resolve with an object containing the JSON result as string.
+    ;(requestClient.get as jest.Mock).mockResolvedValue({
+      result: JSON.stringify(resultData)
+    })
+
+    const result = await parseSasViyaDebugResponse(
+      response,
+      requestClient,
+      serverUrl
+    )
+
+    expect(requestClient.get).toHaveBeenCalledWith(
+      serverUrl + iframeUrl,
+      undefined,
+      'text/plain'
+    )
+    expect(result).toEqual(resultData)
+  })
+
+  it('should extract URL and call get for Viya 4 iframe style', async () => {
+    const iframeUrl = '/another/path/to/log.json'
+    // Note: For Viya 4, the regex splits in such a way that the extracted URL includes an extra starting double-quote.
+    // For example, the URL becomes: '"/another/path/to/log.json'
+    const response = `<html><body><iframe style="width: 99%; height: 500px; background-color:Canvas;" src="${iframeUrl}"></iframe></body></html>`
+    const resultData = { status: 'ok' }
+
+    ;(requestClient.get as jest.Mock).mockResolvedValue({
+      result: JSON.stringify(resultData)
+    })
+
+    const result = await parseSasViyaDebugResponse(
+      response,
+      requestClient,
+      serverUrl
+    )
+    // Expect the extra starting double-quote as per the current implementation.
+    const expectedUrl = serverUrl + `"` + iframeUrl
+
+    expect(requestClient.get).toHaveBeenCalledWith(
+      expectedUrl,
+      undefined,
+      'text/plain'
+    )
+    expect(result).toEqual(resultData)
+  })
+
+  it('should throw an error if iframe URL is not found', async () => {
+    const response = `<html><body>No iframe here</body></html>`
+
+    await expect(
+      parseSasViyaDebugResponse(response, requestClient, serverUrl)
+    ).rejects.toThrow('Unable to find webout file URL.')
+  })
+})
--- a/src/utils/validateInput.ts
+++ b/src/utils/validateInput.ts
@@ -52,19 +52,22 @@ export const validateInput = (
      }
    }

-    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}.`
+    // ES6 is stricter so we had to include the check for the array
+    if (Array.isArray(data[key])) {
+      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}.`
+              }
            }
          }
        }
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,12 +1,14 @@
 {
  "compilerOptions": {
    "lib": ["ES2018", "DOM", "ES2019.String"],
-    "target": "es5",
+    "target": "es6",
    "module": "commonjs",
    "declaration": true,
    "outDir": "./build",
+    "esModuleInterop": true,
    "strict": true,
    "sourceMap": true,
+    "inlineSources": true,
    "typeRoots": ["./node_modules/@types", "./src/types/system"]
  },
  "include": ["src"],
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -13,12 +13,12 @@ const defaultPlugins = [
 ]

 const optimization = {
-  minimize: true,
+  minimize: false,
  minimizer: [
-    new terserPlugin({
-      parallel: true,
-      terserOptions: {}
-    })
+    // new terserPlugin({
+    //   parallel: true,
+    //   terserOptions: {}
+    // })
  ]
 }

@@ -44,6 +44,7 @@ const browserConfig = {
  },
  mode: 'production',
  optimization: optimization,
+  devtool: 'inline-source-map',
  module: {
    rules: [
      {
Author	SHA1	Message	Date
dependabot[bot]	f68e6f11c8	chore(deps): bump form-data and cypress Bumps [form-data](https://github.com/form-data/form-data) to 4.0.4 and updates ancestor dependency [cypress](https://github.com/cypress-io/cypress). These dependencies need to be updated together. Updates `form-data` from 2.3.3 to 4.0.4 - [Release notes](https://github.com/form-data/form-data/releases) - [Changelog](https://github.com/form-data/form-data/blob/master/CHANGELOG.md) - [Commits](https://github.com/form-data/form-data/commits/v4.0.4) Updates `cypress` from 7.7.0 to 15.6.0 - [Release notes](https://github.com/cypress-io/cypress/releases) - [Changelog](https://github.com/cypress-io/cypress/blob/develop/CHANGELOG.md) - [Commits](https://github.com/cypress-io/cypress/compare/v7.7.0...v15.6.0) --- updated-dependencies: - dependency-name: form-data dependency-version: 4.0.4 dependency-type: indirect - dependency-name: cypress dependency-version: 15.6.0 dependency-type: direct:development ... Signed-off-by: dependabot[bot] <support@github.com>	2025-11-17 11:44:26 +00:00
Sead Mulahasanović	79e5acb954	chore(git): merge pull request #848 from sasjs/readme_update_20250828	2025-10-17 11:54:14 +02:00
mulahasanovic	1eb5b29a77	chore(docs): update README.md Remove unavailable and update workflow badge	2025-09-18 19:26:30 +02:00
Allan Bowe	bde28046be	Merge pull request #850 from sasjs/fix-CVE-2025-58754 fix(deps): update axios to v1.12.2	2025-09-18 17:16:45 +01:00
mulahasanovic	eab61a80bf	chore: prettier	2025-09-18 18:10:30 +02:00
mulahasanovic	9149f932c3	chore: prettier	2025-09-18 18:06:05 +02:00
Sead Mulahasanović	fb30ff8876	chore(git): merge pull request #849 from glM26/master fix: update dependency axios to version 1.12.2 (CVE-2025-58754)	2025-09-18 18:03:55 +02:00
Stephan Markiefka	afff422333	feat: Update dependency axios to version 1.12.2	2025-09-18 11:57:09 +02:00
Trevor Moody	b09a8b0891	chore: README.MD updated to correct dead link	2025-08-28 15:46:22 +01:00
Allan Bowe	b49010cfe5	Merge pull request #847 from sasjs/update_20250821 feat: h54s Tables() compatibility	2025-08-22 12:11:34 +01:00
Trevor Moody	fd6fad9b07	feat: h54s Tables() compatibility	2025-08-22 10:24:02 +01:00
Allan Bowe	8a10c229d6	Merge pull request #846 from sasjs/form-data-vulnerabilities Update vulnerable form-data to v4.0.4	2025-07-23 13:38:35 +01:00
M	66462fcc50	fix: update vulnerable form-data to v4.0.4	2025-07-23 13:35:49 +02:00
Allan Bowe	7e23b5db9d	Merge pull request #845 from sasjs/jes-workaround Viya JES approach workaround, job arguments are case-sensitive and webout was not returned	2025-06-09 19:23:48 +01:00
Mihajlo Medjedovic	78f117812e	fix: Viya JES approach workaround, job arguments are case-sensitive and webout was not returned	2025-06-09 16:59:09 +02:00
Allan Bowe	55af8c3f50	Merge pull request #844 from sasjs/ci-fix ci: npm caching fix	2025-06-05 13:46:05 +01:00
Mihajlo Medjedovic	1185c2f1bf	ci: npm caching fix	2025-06-05 14:43:33 +02:00
Allan Bowe	2842636c4a	Merge pull request #843 from sasjs/get-update-file-content-viya Added methods to GET and UPDATE file content on viya	2025-06-05 13:33:47 +01:00
Mihajlo Medjedovic	8c7f614509	ci: jobs	2025-06-05 11:13:30 +02:00
Mihajlo Medjedovic	943f60ea11	ci: jobs	2025-06-05 11:04:06 +02:00
Mihajlo Medjedovic	3de343f135	ci: jobs	2025-06-05 10:37:53 +02:00
Mihajlo Medjedovic	e11c97ec5d	chore: fixing type duplicate	2025-06-05 10:07:13 +02:00
Mihajlo Medjedovic	49fba07824	fix: viya updateFileContent not sending proper content-type	2025-06-04 17:29:38 +02:00
Mihajlo Medjedovic	b1c0e26c23	feat: added methods to GET and UPDATE file content on viya	2025-06-04 17:04:27 +02:00
Allan Bowe	3ec73750b7	Merge pull request #841 from sasjs/bump-axios fix: axios bump	2025-03-14 11:16:54 +00:00
Sabir Hassan	e3c4cb6b90	chore(sasjs-test): skip few tests that are failing due to server	2025-03-14 15:59:31 +05:00
Sabir Hassan	d35f1617b8	chore(cypress): update integration test	2025-03-14 01:29:03 +05:00
Sabir Hassan	302752d79e	chore: revert last commit	2025-03-13 16:56:29 +05:00
Sabir Hassan	4e1e3e8e77	chore: workflow	2025-03-13 16:36:44 +05:00
Mihajlo Medjedovic	954d3ff633	ci: jobs naming	2025-03-11 14:07:31 +01:00
Mihajlo Medjedovic	fce0c7e522	fix: axios 1.8.2	2025-03-11 13:51:58 +01:00
Mihajlo Medjedovic	d0fbc7b8c7	fix: sasjs/utils bump, separated CI jobs into unit tests and server tests	2025-03-11 13:39:40 +01:00
Mihajlo Medjedovic	6171199a7e	fix: prepared for Viya streaming	2025-03-07 16:05:02 +01:00
Mihajlo Medjedovic	4fb0b96f11	fix: new axios requires form data content type, es6 strict issues with iterations	2025-03-07 10:36:43 +01:00
Mihajlo Medjedovic	008a9b4ca5	fix: withXSRFToken instead of withCredentials	2025-03-04 16:29:01 +01:00
Mihajlo Medjedovic	b3b2c1414c	chore: better test coverage	2025-03-04 14:48:22 +01:00
Mihajlo Medjedovic	18be9e8806	fix: jest tests RequestClient.spec.ts	2025-03-03 17:52:53 +01:00
Sabir Hassan	7bdd826418	chore: fix specs for getFormData and convertToCsv	2025-03-03 00:19:50 +05:00
Sabir Hassan	3713a226a4	chore: temp fix for InternalAxiosRequestConfig	2025-03-02 23:33:28 +05:00
Mihajlo Medjedovic	77306fedee	fix: usage and typings, axios, nodeFormData, cookiejar...	2025-02-28 15:04:51 +01:00
Sabir Hassan	be3ce56b85	fix: refactor the default callback for axios interceptors	2025-02-28 18:21:44 +05:00
Mihajlo Medjedovic	851b8fce2a	fix: axios bump	2025-02-28 11:25:44 +01:00