Merge pull request #668 from sasjs/special-missings

fix: special missing values
fix(convert-to-csv): return empty string if table is not an array
2025-12-11 09:24:35 +00:00 · 2022-03-04 11:07:31 +03:00 · 2022-03-03 17:31:23 +03:00 · 2022-03-03 15:13:58 +03:00 · 2022-03-03 15:07:01 +03:00 · 2022-03-03 13:00:14 +01:00
45 changed files with 25968 additions and 13203 deletions
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -4,4 +4,4 @@ updates:
    directory: '/'
    schedule:
      interval: monthly
-    open-pull-requests-limit: 10
+    open-pull-requests-limit: 2
--- a/.github/reviewer-lottery.yml
+++ b/.github/reviewer-lottery.yml
@@ -2,11 +2,8 @@ groups:
  - name: SASjs Devs # name of the group
    reviewers: 1 # how many reviewers do you want to assign?
    usernames: # github usernames of the reviewers
-      - krishna-acondy
      - YuryShkoda
-      - saadjutt01
      - medjedovicm
-      - allanbowe
      - sabhas
  - name: SASjs QA
    reviewers: 1
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -22,6 +22,8 @@ jobs:
        with:
          node-version: ${{ matrix.node-version }}
          cache: npm
+      - name: Check npm audit
+        run: npm audit --production --audit-level=low
      - name: Install Dependencies
        run: npm ci
      - name: Check code style
--- a/.gitpod.yml
+++ b/.gitpod.yml
@@ -0,0 +1,2 @@
+tasks:
+  - init: npm install && npm run build
--- a/README.md
+++ b/README.md
@@ -20,9 +20,9 @@

 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:

-1 - `npm install @sasjs/adapter` - for use in a node project
+1 - `npm install @sasjs/adapter` - for use in a nodeJS project (recommended)

-2 - [Download](https://cdn.jsdelivr.net/npm/@sasjs/adapter@2/index.js) and use a copy of the latest JS file
+2 - [Download](https://cdn.jsdelivr.net/npm/@sasjs/adapter@3/index.min.js) and use a copy of the latest JS file

 3 - Reference directly from the CDN - in which case click [here](https://www.jsdelivr.com/package/npm/@sasjs/adapter?tab=collection) and select "SRI" to get the script tag with the integrity hash.

@@ -96,7 +96,12 @@ const sasJs = new SASjs({your config})
 More on the config later.

 ### SAS Logon
-The login process can be handled directly, as below, or as a callback function to a SAS request.
+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:

 ```javascript
 sasJs.logIn('USERNAME','PASSWORD'
@@ -109,6 +114,8 @@ 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
 A simple request can be sent to SAS in the following fashion:

@@ -142,6 +149,71 @@ The response object will contain returned tables and columns.  Table names are a

 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.

+### Variable Types
+
+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.
+
+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.|
+
+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`|
+
+### 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)
+
+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:
+
+```csv
+CHARVAR1:$char4. CHARVAR2:$char1. NUMVAR:best.
+LOAD,,0
+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": "_"}
+  ],
+  "$tablewith2cols2rows":{"formats":{"specialMissingsCol":"best."}
+  }
+};
+```
+
+It is not necessary to provide formats for ALL the columns, only the ones that need to be overridden.
+
 ## SAS Inputs / Outputs

 The SAS side is handled by a number of macros in the [macro core](https://github.com/sasjs/core) library.
@@ -153,29 +225,43 @@ The following snippet shows the process of SAS tables arriving / leaving:
 %webout(FETCH)

 /* some sas code */
-data some sas tables;
+data a b c;
  set from js;
 run;

-%webout(OPEN)  /* open the JSON to be returned */
-%webout(OBJ,some) /* `some` table is sent in object format */
-%webout(ARR,sas) /* `sas` table is sent in array format, smaller filesize */
-%webout(OBJ,tables,fmt=N) /* unformatted (raw) data */
-%webout(OBJ,tables,label=newtable) /* rename tables on export */
-%webout(CLOSE) /* close the JSON and send some extra useful variables too */
+%webout(OPEN)  /* Open the JSON to be returned */
+%webout(OBJ,a) /* Rows in table `a` are objects (easy to use) */
+%webout(ARR,b) /* Rows in table `b` are arrays (compact) */
+%webout(OBJ,c,fmt=N) /* Table `c` is sent unformatted (raw) */
+%webout(OBJ,c,label=d) /* Rename as `d` on JS side */
+%webout(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:
+
+```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:
+
+```sas
+%webout(OBJ,a,missing=STRING,showmeta=YES)
 ```

 ## 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:

-* `appLoc` - this is the folder under which the SAS services will be created.
-* `serverType` - either `SAS9` or `SASVIYA`.
+* `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.
-* `LoginMechanism` - either `Default` or `Redirected`.  If `Redirected` then authentication occurs through the injection of an additional screen, which contains the SASLogon prompt.  This allows for more complex authentication flows (such as 2FA) and avoids the need to handle passwords in the application itself.  The styling of the redirect flow can also be modified.  If left at "Default" then the developer must capture the username and password and use these with the `.login()` method.
+* `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).

--- a/jest.config.js
+++ b/jest.config.js
@@ -127,7 +127,7 @@ module.exports = {
  setupFiles: [],

  // A list of paths to modules that run some code to configure or set up the testing framework before each test
-  setupFilesAfterEnv: ['jest-extended'],
+  setupFilesAfterEnv: ['jest-extended/all'],

  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
  // snapshotSerializers: [],
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -40,44 +40,44 @@
  },
  "license": "ISC",
  "devDependencies": {
-    "@types/axios": "^0.14.0",
-    "@types/express": "^4.17.13",
-    "@types/form-data": "^2.5.0",
-    "@types/jest": "^27.0.2",
-    "@types/mime": "^2.0.3",
-    "@types/pem": "^1.9.6",
-    "@types/tough-cookie": "^4.0.1",
-    "copyfiles": "^2.4.1",
-    "cp": "^0.2.0",
-    "dotenv": "^10.0.0",
-    "express": "^4.17.1",
-    "jest": "^27.2.0",
-    "jest-extended": "^0.11.5",
-    "node-polyfill-webpack-plugin": "^1.1.4",
-    "path": "^0.12.7",
-    "pem": "^1.14.4",
-    "process": "^0.11.10",
-    "rimraf": "^3.0.2",
-    "semantic-release": "^18.0.0",
-    "terser-webpack-plugin": "^5.2.4",
-    "ts-jest": "^27.0.3",
-    "ts-loader": "^9.2.6",
-    "tslint": "^6.1.3",
-    "tslint-config-prettier": "^1.18.0",
-    "typedoc": "0.19.2",
-    "typedoc-neo-theme": "^1.1.1",
-    "typedoc-plugin-external-module-name": "^4.0.6",
-    "typescript": "4.3.5",
-    "webpack": "^5.56.0",
-    "webpack-cli": "^4.7.2"
+    "@types/axios": "0.14.0",
+    "@types/express": "4.17.13",
+    "@types/form-data": "2.5.0",
+    "@types/jest": "27.4.0",
+    "@types/mime": "2.0.3",
+    "@types/pem": "1.9.6",
+    "@types/tough-cookie": "4.0.1",
+    "copyfiles": "2.4.1",
+    "cp": "0.2.0",
+    "dotenv": "16.0.0",
+    "express": "4.17.3",
+    "jest": "27.4.7",
+    "jest-extended": "2.0.0",
+    "node-polyfill-webpack-plugin": "1.1.4",
+    "path": "0.12.7",
+    "pem": "1.14.6",
+    "process": "0.11.10",
+    "rimraf": "3.0.2",
+    "semantic-release": "18.0.0",
+    "terser-webpack-plugin": "5.3.1",
+    "ts-jest": "27.1.3",
+    "ts-loader": "9.2.6",
+    "tslint": "6.1.3",
+    "tslint-config-prettier": "1.18.0",
+    "typedoc": "0.22.11",
+    "typedoc-neo-theme": "1.1.1",
+    "typedoc-plugin-external-module-name": "4.0.6",
+    "typescript": "4.5.5",
+    "webpack": "5.69.0",
+    "webpack-cli": "4.9.2"
  },
  "main": "index.js",
  "dependencies": {
-    "@sasjs/utils": "^2.32.0",
-    "axios": "^0.21.4",
-    "axios-cookiejar-support": "^1.0.1",
-    "form-data": "^4.0.0",
-    "https": "^1.0.0",
-    "tough-cookie": "^4.0.0"
+    "@sasjs/utils": "2.36.1",
+    "axios": "0.26.0",
+    "axios-cookiejar-support": "1.0.1",
+    "form-data": "4.0.0",
+    "https": "1.0.0",
+    "tough-cookie": "4.0.0"
  }
 }
--- a/sasjs-tests/README.md
+++ b/sasjs-tests/README.md
@@ -47,7 +47,7 @@ npm i -g copyfiles
 ```
 and then run to build:
 ```bash
-npm run update:adapter && npm run build 
+npm run update:adapter && npm run build
 ```
 when it finishes run to deploy:
 ```bash
@@ -70,7 +70,7 @@ parmcards4;
  %webout(FETCH)
  %webout(OPEN)
  %macro x();
-  %do i=1 %to &_webin_file_count; %webout(OBJ,&&_webin_name&i) %end;
+  %do i=1 %to &_webin_file_count; %webout(OBJ,&&_webin_name&i,missing=STRING,showmeta=YES) %end;
  %mend; %x()
  %webout(CLOSE)
 ;;;;
@@ -79,7 +79,7 @@ parmcards4;
  %webout(FETCH)
  %webout(OPEN)
  %macro x();
-  %do i=1 %to &_webin_file_count; %webout(ARR,&&_webin_name&i) %end;
+  %do i=1 %to &_webin_file_count; %webout(ARR,&&_webin_name&i,missing=STRING,showmeta=YES) %end;
  %mend; %x()
  %webout(CLOSE)
 ;;;;
@@ -111,7 +111,7 @@ parmcards4;
  %macro x();
  %do i=1 %to %sysfunc(countw(&sasjs_tables));
    %let table=%scan(&sasjs_tables,&i);
-    %webout(OBJ,&table)
+    %webout(OBJ,&table,missing=STRING,showmeta=YES)
  %end;
  %mend;
  %x()
@@ -125,7 +125,7 @@ parmcards4;
  %macro x();
  %do i=1 %to %sysfunc(countw(&sasjs_tables));
    %let table=%scan(&sasjs_tables,&i);
-    %webout(ARR,&table)
+    %webout(ARR,&table,missing=STRING,showmeta=YES)
  %end;
  %mend;
  %x()
--- a/sasjs-tests/package-lock.json
+++ b/sasjs-tests/package-lock.json
--- a/sasjs-tests/package.json
+++ b/sasjs-tests/package.json
@@ -5,7 +5,7 @@
  "private": true,
  "dependencies": {
    "@sasjs/adapter": "file:../build/sasjs-adapter-5.0.0.tgz",
-    "@sasjs/test-framework": "^1.4.2",
+    "@sasjs/test-framework": "^1.4.3",
    "@types/jest": "^26.0.20",
    "@types/node": "^14.14.41",
    "@types/react": "^17.0.1",
@@ -22,7 +22,7 @@
    "build": "react-scripts 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",
+    "update:adapter": "cd .. && npm run package:lib && cd sasjs-tests && npm i ../build/sasjs-adapter-5.0.0.tgz --legacy-peer-deps",
    "deploy:tests": "rsync -avhe ssh ./build/* --delete $SSH_ACCOUNT:$DEPLOY_PATH || npm run deploy:tests-win",
    "deploy:tests-win": "scp %DEPLOY_PATH% ./build/*",
    "deploy": "npm run update:adapter && npm run build && npm run deploy:tests"
@@ -43,6 +43,6 @@
    ]
  },
  "devDependencies": {
-    "node-sass": "^5.0.0"
+    "node-sass": "^6.0.1"
  }
 }
--- a/sasjs-tests/src/testSuites/Basic.ts
+++ b/sasjs-tests/src/testSuites/Basic.ts
@@ -6,6 +6,7 @@ const stringData: any = { table1: [{ col1: 'first col value' }] }

 const defaultConfig: SASjsConfig = {
  serverUrl: window.location.origin,
+  pathSASJS: '/SASjsApi/stp/execute',
  pathSAS9: '/SASStoredProcess/do',
  pathSASViya: '/SASJobExecution',
  appLoc: '/Public/seedapp',
--- a/sasjs-tests/src/testSuites/SpecialCases.ts
+++ b/sasjs-tests/src/testSuites/SpecialCases.ts
@@ -79,6 +79,27 @@ const errorAndCsrfData: any = {
  _csrf: [{ col1: 'q', col2: 'w', col3: 'e', col4: 'r' }]
 }

+const testTable = 'sometable'
+export const testTableWithSpecialNumeric: { [key: string]: any } = {
+  [testTable]: [
+    { var1: 'string', var2: 232, specialnumeric: 'A' },
+    { var1: 'string', var2: 232, specialnumeric: 'B' },
+    { var1: 'string', var2: 232, specialnumeric: '_' },
+    { var1: 'string', var2: 232, specialnumeric: 0 },
+    { var1: 'string', var2: 232, specialnumeric: 'Z' },
+    { var1: 'string', var2: 232, specialnumeric: null }
+  ],
+  [`$${testTable}`]: { formats: { var1: '$char12.', specialnumeric: 'best.' } }
+}
+export const testTableWithSpecialNumericOneRow: { [key: string]: any } = {
+  [testTable]: [{ var1: 'string', var2: 232, specialnumeric: 'S' }],
+  [`$${testTable}`]: { formats: { var1: '$char12.', specialnumeric: 'best.' } }
+}
+export const testTableWithSpecialNumericLowercase: { [key: string]: any } = {
+  [testTable]: [{ var1: 'string', var2: 232, specialnumeric: 's' }],
+  [`$${testTable}`]: { formats: { var1: '$char12.', specialnumeric: 'best.' } }
+}
+
 export const specialCaseTests = (adapter: SASjs): TestSuite => ({
  name: 'Special Cases',
  tests: [
@@ -247,6 +268,203 @@ export const specialCaseTests = (adapter: SASjs): TestSuite => ({
          res._csrf[0].COL4 === errorAndCsrfData._csrf[0].col4
        )
      }
+    },
+    {
+      title: 'Special missing values',
+      description: 'Should support special missing values',
+      test: () => {
+        return adapter.request('common/sendObj', testTableWithSpecialNumeric)
+      },
+      assertion: (res: any) => {
+        let assertionRes = true
+
+        // We receive formats in response. We compare it with formats that we included in request to make sure they are equal
+        const resVars = res[`$${testTable}`].vars
+
+        Object.keys(resVars).forEach((key: any, i: number) => {
+          let formatValue =
+            testTableWithSpecialNumeric[`$${testTable}`].formats[
+              key.toLowerCase()
+            ]
+          // If it is char, we change it to $ to be compatible for comparsion
+          // If it is number, it will already be compatible to comapre (best.)
+          formatValue = formatValue?.includes('$') ? '$' : formatValue
+
+          if (
+            formatValue !== undefined &&
+            !resVars[key].format.includes(formatValue)
+          ) {
+            assertionRes = false
+          }
+        })
+
+        // Here we will compare the response values with values we send
+        const resValues = res[testTable]
+
+        testTableWithSpecialNumeric[testTable].forEach(
+          (row: { [key: string]: any }, i: number) =>
+            Object.keys(row).forEach((col: string) => {
+              if (resValues[i][col.toUpperCase()] !== row[col]) {
+                assertionRes = false
+              }
+            })
+        )
+
+        return assertionRes
+      }
+    },
+    {
+      title: 'Special missing values (ONE ROW)',
+      description:
+        'Should support special missing values, when one row is send',
+      test: () => {
+        return adapter.request(
+          'common/sendObj',
+          testTableWithSpecialNumericOneRow
+        )
+      },
+      assertion: (res: any) => {
+        let assertionRes = true
+
+        // We receive formats in response. We compare it with formats that we included in request to make sure they are equal
+        const resVars = res[`$${testTable}`].vars
+
+        Object.keys(resVars).forEach((key: any, i: number) => {
+          let formatValue =
+            testTableWithSpecialNumeric[`$${testTable}`].formats[
+              key.toLowerCase()
+            ]
+          // If it is char, we change it to $ to be compatible for comparsion
+          // If it is number, it will already be compatible to comapre (best.)
+          formatValue = formatValue?.includes('$') ? '$' : formatValue
+
+          if (
+            formatValue !== undefined &&
+            !resVars[key].format.includes(formatValue)
+          ) {
+            assertionRes = false
+          }
+        })
+
+        // Here we will compare the response values with values we send
+        const resValues = res[testTable]
+
+        testTableWithSpecialNumericOneRow[testTable].forEach(
+          (row: { [key: string]: any }, i: number) =>
+            Object.keys(row).forEach((col: string) => {
+              if (resValues[i][col.toUpperCase()] !== row[col]) {
+                assertionRes = false
+              }
+            })
+        )
+
+        return assertionRes
+      }
+    },
+    {
+      title: 'Special missing values (LOWERCASE)',
+      description:
+        'Should support special missing values, when LOWERCASE value is sent',
+      test: () => {
+        return adapter.request(
+          'common/sendObj',
+          testTableWithSpecialNumericLowercase
+        )
+      },
+      assertion: (res: any) => {
+        let assertionRes = true
+
+        // We receive formats in response. We compare it with formats that we included in request to make sure they are equal
+        const resVars = res[`$${testTable}`].vars
+
+        Object.keys(resVars).forEach((key: any, i: number) => {
+          let formatValue =
+            testTableWithSpecialNumericLowercase[`$${testTable}`].formats[
+              key.toLowerCase()
+            ]
+          // If it is a char, we change it to $ to be compatible for comparison
+          // If it is a number, it will already be compatible to compare (best.)
+          formatValue = formatValue?.includes('$') ? '$' : formatValue
+
+          if (
+            formatValue !== undefined &&
+            !resVars[key].format.includes(formatValue)
+          ) {
+            assertionRes = false
+          }
+        })
+
+        // Here we will compare the response values with values we send
+        const resValues = res[testTable]
+
+        testTableWithSpecialNumericLowercase[testTable].forEach(
+          (row: { [key: string]: any }, i: number) =>
+            Object.keys(row).forEach((col: string) => {
+              if (col === 'specialnumeric') {
+                if (
+                  resValues[i][col.toUpperCase()] !== row[col].toUpperCase()
+                ) {
+                  assertionRes = false
+                }
+              } else {
+                if (resValues[i][col.toUpperCase()] !== row[col]) {
+                  assertionRes = false
+                }
+              }
+            })
+        )
+
+        return assertionRes
+      }
+    },
+    {
+      title: 'Special missing values (ONE ROW) useComputeApi undefined',
+      description:
+        'Should support special missing values, when one row is send (On VIYA Web Approach)',
+      test: () => {
+        return adapter.request(
+          'common/sendObj',
+          testTableWithSpecialNumericOneRow,
+          { useComputeApi: undefined }
+        )
+      },
+      assertion: (res: any) => {
+        let assertionRes = true
+
+        // We receive formats in response. We compare it with formats that we included in request to make sure they are equal
+        const resVars = res[`$${testTable}`].vars
+
+        Object.keys(resVars).forEach((key: any, i: number) => {
+          let formatValue =
+            testTableWithSpecialNumeric[`$${testTable}`].formats[
+              key.toLowerCase()
+            ]
+          // If it is char, we change it to $ to be compatible for comparsion
+          // If it is number, it will already be compatible to comapre (best.)
+          formatValue = formatValue?.includes('$') ? '$' : formatValue
+
+          if (
+            formatValue !== undefined &&
+            !resVars[key].format.includes(formatValue)
+          ) {
+            assertionRes = false
+          }
+        })
+
+        // Here we will compare the response values with values we send
+        const resValues = res[testTable]
+
+        testTableWithSpecialNumericOneRow[testTable].forEach(
+          (row: { [key: string]: any }, i: number) =>
+            Object.keys(row).forEach((col: string) => {
+              if (resValues[i][col.toUpperCase()] !== row[col]) {
+                assertionRes = false
+              }
+            })
+        )
+
+        return assertionRes
+      }
    }
  ]
 })
--- a/src/SASjs.ts
+++ b/src/SASjs.ts
@@ -5,9 +5,8 @@ import {
  EditContextInput,
  PollOptions,
  LoginMechanism,
-  FolderMember,
-  ServiceMember,
-  ExecutionQuery
+  ExecutionQuery,
+  FileTree
 } from './types'
 import { SASViyaApiClient } from './SASViyaApiClient'
 import { SAS9ApiClient } from './SAS9ApiClient'
@@ -77,6 +76,13 @@ export default class SASjs {
    return this.requestClient?.getCsrfToken(type)
  }

+  /**
+   * Executes code against a SAS 9 server.  Requires a runner to be present in
+   * the users home directory in metadata.
+   * @param linesOfCode - lines of sas code from the file to run.
+   * @param username - a string representing the username.
+   * @param password - a string representing the password.
+   */
  public async executeScriptSAS9(
    linesOfCode: string[],
    userName: string,
@@ -91,6 +97,38 @@ export default class SASjs {
    )
  }

+  /**
+   * Executes sas code in a SAS Viya compute session.
+   * @param fileName - name of the file to run. It will be converted to path to the file being submitted for execution.
+   * @param linesOfCode - lines of sas code from the file to run.
+   * @param contextName - context name on which code will be run on the server.
+   * @param authConfig - (optional) the access token, refresh token, client and secret for authorizing the request.
+   * @param debug - (optional) if true, global debug config will be overriden
+   */
+  public async executeScriptSASViya(
+    fileName: string,
+    linesOfCode: string[],
+    contextName: string,
+    authConfig?: AuthConfig,
+    debug?: boolean
+  ) {
+    this.isMethodSupported('executeScriptSASViya', [ServerType.SasViya])
+    if (!contextName) {
+      throw new Error(
+        'Context name is undefined. Please set a `contextName` in your SASjs or override config.'
+      )
+    }
+
+    return await this.sasViyaApiClient!.executeScript(
+      fileName,
+      linesOfCode,
+      contextName,
+      authConfig,
+      null,
+      debug ? debug : this.sasjsConfig.debug
+    )
+  }
+
  /**
   * Gets compute contexts.
   * @param accessToken - an access token for an authorized user.
@@ -254,38 +292,6 @@ export default class SASjs {
    return await this.sasViyaApiClient!.createSession(contextName, accessToken)
  }

-  /**
-   * Executes the sas code against given sas server
-   * @param fileName - name of the file to run. It will be converted to path to the file being submitted for execution.
-   * @param linesOfCode - lines of sas code from the file to run.
-   * @param contextName - context name on which code will be run on the server.
-   * @param authConfig - (optional) the access token, refresh token, client and secret for authorizing the request.
-   * @param debug - (optional) if true, global debug config will be overriden
-   */
-  public async executeScriptSASViya(
-    fileName: string,
-    linesOfCode: string[],
-    contextName: string,
-    authConfig?: AuthConfig,
-    debug?: boolean
-  ) {
-    this.isMethodSupported('executeScriptSASViya', [ServerType.SasViya])
-    if (!contextName) {
-      throw new Error(
-        'Context name is undefined. Please set a `contextName` in your SASjs or override config.'
-      )
-    }
-
-    return await this.sasViyaApiClient!.executeScript(
-      fileName,
-      linesOfCode,
-      contextName,
-      authConfig,
-      null,
-      debug ? debug : this.sasjsConfig.debug
-    )
-  }
-
  /**
   * Creates a folder in the logical SAS folder tree
   * @param folderName - name of the folder to be created.
@@ -636,7 +642,8 @@ export default class SASjs {
  }

  /**
-   * Makes a request to the SAS Service specified in `SASjob`. The response
+   * Makes a request to program specified in `SASjob` (could be a Viya Job, a
+   * SAS 9 Stored Process, or a SASjs Server Stored Program). The response
   * object will always contain table names in lowercase, and column names in
   * uppercase. Values are returned formatted by default, unformatted
   * values can be configured as an option in the `%webout` macro.
@@ -645,7 +652,8 @@ export default class SASjs {
   *  the SAS `_program` parameter to run a Job Definition or SAS 9 Stored
   *  Process). Is prepended at runtime with the value of `appLoc`.
   * @param data - a JSON object containing one or more tables to be sent to
-   * SAS. Can be `null` if no inputs required.
+   * SAS.  For an example of the table structure, see the project README. This
+   * value can be `null` if no inputs are required.
   * @param config - provide any changes to the config here, for instance to
   * enable/disable `debug`. Any change provided will override the global config,
   * for that particular function call.
@@ -675,9 +683,19 @@ export default class SASjs {

    const validationResult = this.validateInput(data)

+    // status is true if the data passes validation checks above
    if (validationResult.status) {
-      if (
-        config.serverType !== ServerType.Sas9 &&
+      if (config.serverType === ServerType.Sasjs) {
+        return await this.webJobExecutor!.execute(
+          sasJob,
+          data,
+          config,
+          loginRequiredCallback,
+          authConfig,
+          extraResponseAttributes
+        )
+      } else if (
+        config.serverType === ServerType.SasViya &&
        config.useComputeApi !== undefined &&
        config.useComputeApi !== null
      ) {
@@ -736,15 +754,19 @@ export default class SASjs {
    msg: string
  } {
    if (data === null) return { status: true, msg: '' }
+
+    const isSasFormatsTable = (key: string) =>
+      key.match(/^\$.*/) && Object.keys(data).includes(key.replace(/^\$/, ''))
+
    for (const key in data) {
-      if (!key.match(/^[a-zA-Z_]/)) {
+      if (!key.match(/^[a-zA-Z_]/) && !isSasFormatsTable(key)) {
        return {
          status: false,
          msg: 'First letter of table should be alphabet or underscore.'
        }
      }

-      if (!key.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
+      if (!key.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/) && !isSasFormatsTable(key)) {
        return { status: false, msg: 'Table name should be alphanumeric.' }
      }

@@ -755,7 +777,7 @@ export default class SASjs {
        }
      }

-      if (this.getType(data[key]) !== 'Array') {
+      if (this.getType(data[key]) !== 'Array' && !isSasFormatsTable(key)) {
        return {
          status: false,
          msg: 'Parameter data contains invalid table structure.'
@@ -771,6 +793,7 @@ export default class SASjs {
        }
      }
    }
+
    return { status: true, msg: '' }
  }

@@ -860,8 +883,22 @@ export default class SASjs {
    )
  }

-  public async deployToSASjs(members: [FolderMember, ServiceMember]) {
-    return await this.sasJSApiClient?.deploy(members, this.sasjsConfig.appLoc)
+  /**
+   * Creates the folders and services at the given location `appLoc` on the given server `serverUrl`.
+   * @param members - the JSON specifying the folders and services to be created.
+   * @param appLoc - the base folder in which to create the new folders and
+   * services.  If not provided, is taken from SASjsConfig.
+   * @param authConfig - a valid client, secret, refresh and access tokens that are authorised to execute compute jobs.
+   */
+  public async deployToSASjs(
+    members: FileTree,
+    appLoc?: string,
+    authConfig?: AuthConfig
+  ) {
+    if (!appLoc) {
+      appLoc = this.sasjsConfig.appLoc
+    }
+    return await this.sasJSApiClient?.deploy(members, appLoc, authConfig)
  }

  public async executeJobSASjs(query: ExecutionQuery) {
@@ -999,7 +1036,8 @@ export default class SASjs {
          : RequestClient
      this.requestClient = new RequestClientClass(
        this.sasjsConfig.serverUrl,
-        this.sasjsConfig.httpsAgentOptions
+        this.sasjsConfig.httpsAgentOptions,
+        this.sasjsConfig.requestHistoryLimit
      )
    } else {
      this.requestClient.setConfig(
@@ -1013,7 +1051,7 @@ export default class SASjs {
        ? this.sasjsConfig.pathSASViya
        : this.sasjsConfig.serverType === ServerType.Sas9
        ? this.sasjsConfig.pathSAS9
-        : this.sasjsConfig.pathSASJS || ''
+        : this.sasjsConfig.pathSASJS

    this.authManager = new AuthManager(
      this.sasjsConfig.serverUrl,
--- a/src/SASjsApiClient.ts
+++ b/src/SASjsApiClient.ts
@@ -1,8 +1,11 @@
-import { FolderMember, ServiceMember, ExecutionQuery } from './types'
+import { AuthConfig, ServerType } from '@sasjs/utils/types'
+import { FileTree, ExecutionQuery } from './types'
 import { RequestClient } from './request/RequestClient'
 import { getAccessTokenForSasjs } from './auth/getAccessTokenForSasjs'
 import { refreshTokensForSasjs } from './auth/refreshTokensForSasjs'
 import { getAuthCodeForSasjs } from './auth/getAuthCodeForSasjs'
+import { parseWeboutResponse } from './utils'
+import { getTokens } from './auth/getTokens'

 export class SASjsApiClient {
  constructor(
@@ -14,7 +17,19 @@ export class SASjsApiClient {
    if (serverUrl) this.serverUrl = serverUrl
  }

-  public async deploy(members: [FolderMember, ServiceMember], appLoc: string) {
+  public async deploy(
+    members: FileTree,
+    appLoc: string,
+    authConfig?: AuthConfig
+  ) {
+    let access_token = (authConfig || {}).access_token
+    if (authConfig) {
+      ;({ access_token } = await getTokens(
+        this.requestClient,
+        authConfig,
+        ServerType.Sasjs
+      ))
+    }
    const { result } = await this.requestClient.post<{
      status: string
      message: string
@@ -22,7 +37,10 @@ export class SASjsApiClient {
    }>(
      'SASjsApi/drive/deploy',
      { fileTree: members, appLoc: appLoc },
-      undefined
+      access_token,
+      undefined,
+      {},
+      { maxContentLength: Infinity, maxBodyLength: Infinity }
    )

    return Promise.resolve(result)
@@ -35,8 +53,13 @@ export class SASjsApiClient {
      log?: string
      logPath?: string
      error?: {}
+      _webout?: string
    }>('SASjsApi/stp/execute', query, undefined)

+    if (Object.keys(result).includes('_webout')) {
+      result._webout = parseWeboutResponse(result._webout!)
+    }
+
    return Promise.resolve(result)
  }

--- a/src/SessionManager.ts
+++ b/src/SessionManager.ts
@@ -168,7 +168,7 @@ export class SessionManager {
    ) {
      if (stateLink) {
        if (this.debug && !this.printedSessionState.printed) {
-          logger.info('Polling session status...')
+          logger.info(`Polling: ${this.serverUrl + stateLink.href}`)

          this.printedSessionState.printed = true
        }
--- a/src/api/viya/executeScript.ts
+++ b/src/api/viya/executeScript.ts
@@ -272,7 +272,13 @@ export async function executeScript(

    return { result: jobResult?.result, log }
  } catch (e) {
-    if (e && e.status === 404) {
+    interface HttpError {
+      status: number
+    }
+
+    const error = e as HttpError
+
+    if (error.status === 404) {
      return executeScript(
        requestClient,
        sessionManager,
@@ -287,7 +293,7 @@ export async function executeScript(
        true
      )
    } else {
-      throw prefixMessage(e, 'Error while executing script. ')
+      throw prefixMessage(e as Error, 'Error while executing script. ')
    }
  }
 }
--- a/src/api/viya/pollJobState.ts
+++ b/src/api/viya/pollJobState.ts
@@ -206,10 +206,11 @@ const doPoll = async (

    pollCount++

+    const jobHref = postedJob.links.find((l: Link) => l.rel === 'self')!.href
+
    if (pollOptions?.streamLog) {
-      const jobUrl = postedJob.links.find((l: Link) => l.rel === 'self')
      const { result: job } = await requestClient.get<Job>(
-        jobUrl!.href,
+        jobHref,
        authConfig?.access_token
      )

@@ -231,7 +232,7 @@ const doPoll = async (
    }

    if (debug && printedState !== state) {
-      logger.info('Polling job status...')
+      logger.info(`Polling: ${requestClient.getBaseUrl() + jobHref}/state`)
      logger.info(`Current job state: ${state}`)

      printedState = state
--- a/src/api/viya/spec/pollJobState.spec.ts
+++ b/src/api/viya/spec/pollJobState.spec.ts
@@ -9,7 +9,10 @@ import * as isNodeModule from '../../../utils/isNode'
 import { PollOptions } from '../../../types'
 import { WriteStream } from 'fs'

+const baseUrl = 'http://localhost'
 const requestClient = new (<jest.Mock<RequestClient>>RequestClient)()
+requestClient['httpClient'].defaults.baseURL = baseUrl
+
 const defaultPollOptions: PollOptions = {
  maxPollCount: 100,
  pollInterval: 500,
@@ -195,7 +198,7 @@ describe('pollJobState', () => {
    expect((process as any).logger.info).toHaveBeenCalledTimes(4)
    expect((process as any).logger.info).toHaveBeenNthCalledWith(
      1,
-      'Polling job status...'
+      `Polling: ${baseUrl}/job/state`
    )
    expect((process as any).logger.info).toHaveBeenNthCalledWith(
      2,
@@ -203,7 +206,7 @@ describe('pollJobState', () => {
    )
    expect((process as any).logger.info).toHaveBeenNthCalledWith(
      3,
-      'Polling job status...'
+      `Polling: ${baseUrl}/job/state`
    )
    expect((process as any).logger.info).toHaveBeenNthCalledWith(
      4,
--- a/src/api/viya/spec/writeStream.spec.ts
+++ b/src/api/viya/spec/writeStream.spec.ts
@@ -1,24 +1,34 @@
 import { WriteStream } from '../../../types'
 import { writeStream } from '../writeStream'
-import 'jest-extended'
+import {
+  createWriteStream,
+  fileExists,
+  readFile,
+  deleteFile
+} from '@sasjs/utils'

 describe('writeStream', () => {
-  const stream: WriteStream = {
-    write: jest.fn(),
-    path: 'test'
-  }
+  const filename = 'test.txt'
+  const content = 'test'
+  let stream: WriteStream
+
+  beforeAll(async () => {
+    stream = await createWriteStream(filename)
+  })

  it('should resolve when the stream is written successfully', async () => {
-    expect(writeStream(stream, 'test')).toResolve()
+    await expect(writeStream(stream, content)).toResolve()
+    await expect(fileExists(filename)).resolves.toEqual(true)
+    await expect(readFile(filename)).resolves.toEqual(content + '\n')

-    expect(stream.write).toHaveBeenCalledWith('test\n', expect.anything())
+    await deleteFile(filename)
  })

  it('should reject when the write errors out', async () => {
    jest
      .spyOn(stream, 'write')
      .mockImplementation((_, callback) => callback(new Error('Test Error')))
-    const error = await writeStream(stream, 'test').catch((e) => e)
+    const error = await writeStream(stream, content).catch((e) => e)

    expect(error.message).toEqual('Test Error')
  })
--- a/src/api/viya/uploadTables.ts
+++ b/src/api/viya/uploadTables.ts
@@ -18,7 +18,7 @@ export async function uploadTables(
  const uploadedFiles = []

  for (const tableName in data) {
-    const csv = convertToCSV(data[tableName])
+    const csv = convertToCSV(data, tableName)
    if (csv === 'ERROR: LARGE STRING LENGTH') {
      throw new Error(
        'The max length of a string value in SASjs is 32765 characters.'
--- a/src/api/viya/writeStream.ts
+++ b/src/api/viya/writeStream.ts
@@ -3,13 +3,9 @@ import { WriteStream } from '../../types'
 export const writeStream = async (
  stream: WriteStream,
  content: string
-): Promise<void> => {
-  return new Promise((resolve, reject) => {
-    stream.write(content + '\n', (e) => {
-      if (e) {
-        return reject(e)
-      }
-      return resolve()
-    })
+): Promise<void> =>
+  stream.write(content + '\n', (e) => {
+    if (e) return Promise.reject(e)
+
+    return Promise.resolve()
  })
-}
--- a/src/auth/getAccessTokenForViya.ts
+++ b/src/auth/getAccessTokenForViya.ts
@@ -1,6 +1,5 @@
 import { SasAuthResponse } from '@sasjs/utils/types'
 import { prefixMessage } from '@sasjs/utils/error'
-import * as NodeFormData from 'form-data'
 import { RequestClient } from '../request/RequestClient'

 /**
@@ -24,26 +23,17 @@ export async function getAccessTokenForViya(
    token = Buffer.from(clientId + ':' + clientSecret).toString('base64')
  }
  const headers = {
-    Authorization: 'Basic ' + token
+    Authorization: 'Basic ' + token,
+    Accept: 'application/json'
  }

-  let formData
-  if (typeof FormData === 'undefined') {
-    formData = new NodeFormData()
-  } else {
-    formData = new FormData()
-  }
-  formData.append('grant_type', 'authorization_code')
-  formData.append('code', authCode)
+  const data = new URLSearchParams({
+    grant_type: 'authorization_code',
+    code: authCode
+  })

  const authResponse = await requestClient
-    .post(
-      url,
-      formData,
-      undefined,
-      'multipart/form-data; boundary=' + (formData as any)._boundary,
-      headers
-    )
+    .post(url, data, undefined, 'application/x-www-form-urlencoded', headers)
    .then((res) => res.result as SasAuthResponse)
    .catch((err) => {
      throw prefixMessage(err, 'Error while getting access token. ')
--- a/src/auth/spec/getAccessTokenForViya.spec.ts
+++ b/src/auth/spec/getAccessTokenForViya.spec.ts
@@ -35,11 +35,12 @@ describe('getAccessTokenForViya', () => {

    expect(requestClient.post).toHaveBeenCalledWith(
      '/SASLogon/oauth/token',
-      expect.any(NodeFormData),
+      expect.any(URLSearchParams),
      undefined,
-      expect.stringContaining('multipart/form-data; boundary='),
+      'application/x-www-form-urlencoded',
      {
-        Authorization: 'Basic ' + token
+        Authorization: 'Basic ' + token,
+        Accept: 'application/json'
      }
    )
  })
--- a/src/file/generateFileUploadForm.ts
+++ b/src/file/generateFileUploadForm.ts
@@ -1,12 +1,25 @@
+import * as NodeFormData from 'form-data'
 import { convertToCSV } from '../utils/convertToCsv'

+/**
+ * One of the approaches SASjs takes to send tables-formatted JSON (see README)
+ * to SAS is as multipart form data, where each table is provided as a specially
+ * formatted CSV file.
+ * @param formData Different objects are used depending on whether the adapter is
+ *  running in the browser, or in the CLI
+ * @param data Special, tables-formatted JSON (see README)
+ * @returns Populated formData
+ */
 export const generateFileUploadForm = (
-  formData: FormData,
+  formData: FormData | NodeFormData,
  data: any
-): FormData => {
+): FormData | NodeFormData => {
  for (const tableName in data) {
+    if (!Array.isArray(data[tableName])) continue
+
    const name = tableName
-    const csv = convertToCSV(data[tableName])
+    const csv = convertToCSV(data, tableName)
+
    if (csv === 'ERROR: LARGE STRING LENGTH') {
      throw new Error(
        'The max length of a string value in SASjs is 32765 characters.'
--- a/src/file/generateTableUploadForm.ts
+++ b/src/file/generateTableUploadForm.ts
@@ -1,22 +1,32 @@
+import * as NodeFormData from 'form-data'
 import { convertToCSV } from '../utils/convertToCsv'
 import { splitChunks } from '../utils/splitChunks'

-export const generateTableUploadForm = (formData: FormData, data: any) => {
+export const generateTableUploadForm = (
+  formData: FormData | NodeFormData,
+  data: any
+) => {
  const sasjsTables = []
  const requestParams: any = {}
  let tableCounter = 0
+
  for (const tableName in data) {
    tableCounter++
+
    sasjsTables.push(tableName)
-    const csv = convertToCSV(data[tableName])
+
+    const csv = convertToCSV(data, tableName)
+
    if (csv === 'ERROR: LARGE STRING LENGTH') {
      throw new Error(
        'The max length of a string value in SASjs is 32765 characters.'
      )
    }
+
    // if csv has length more then 16k, send in chunks
    if (csv.length > 16000) {
      const csvChunks = splitChunks(csv)
+
      // append chunks to form data with same key
      csvChunks.map((chunk) => {
        formData.append(`sasjs${tableCounter}data`, chunk)
@@ -25,6 +35,7 @@ export const generateTableUploadForm = (formData: FormData, data: any) => {
      requestParams[`sasjs${tableCounter}data`] = csv
    }
  }
+
  requestParams['sasjs_tables'] = sasjsTables.join(' ')

  return { formData, requestParams }
--- a/src/file/spec/generateFileUploadForm.spec.ts
+++ b/src/file/spec/generateFileUploadForm.spec.ts
@@ -0,0 +1,55 @@
+import { generateFileUploadForm } from '../generateFileUploadForm'
+
+describe('generateFileUploadForm', () => {
+  beforeAll(() => {
+    function FormDataMock(this: any) {
+      this.append = () => {}
+    }
+
+    const BlobMock = jest.fn()
+
+    ;(global as any).FormData = FormDataMock
+    ;(global as any).Blob = BlobMock
+  })
+
+  it('should generate file upload form from data', () => {
+    const formData = new FormData()
+    const testTable = 'sometable'
+    const testTableWithNullVars: { [key: string]: any } = {
+      [testTable]: [
+        { var1: 'string', var2: 232, nullvar: 'A' },
+        { var1: 'string', var2: 232, nullvar: 'B' },
+        { var1: 'string', var2: 232, nullvar: '_' },
+        { var1: 'string', var2: 232, nullvar: 0 },
+        { var1: 'string', var2: 232, nullvar: 'z' },
+        { var1: 'string', var2: 232, nullvar: null }
+      ],
+      [`$${testTable}`]: { formats: { var1: '$char12.', nullvar: 'best.' } }
+    }
+    const tableName = Object.keys(testTableWithNullVars).filter((key: string) =>
+      Array.isArray(testTableWithNullVars[key])
+    )[0]
+
+    jest.spyOn(formData, 'append').mockImplementation(() => {})
+
+    generateFileUploadForm(formData, testTableWithNullVars)
+
+    expect(formData.append).toHaveBeenCalledOnce()
+    expect(formData.append).toHaveBeenCalledWith(
+      tableName,
+      {},
+      `${tableName}.csv`
+    )
+  })
+
+  it('should throw an error if too large string was provided', () => {
+    const formData = new FormData()
+    const data = { testTable: [{ var1: 'z'.repeat(32765 + 1) }] }
+
+    expect(() => generateFileUploadForm(formData, data)).toThrow(
+      new Error(
+        'The max length of a string value in SASjs is 32765 characters.'
+      )
+    )
+  })
+})
--- a/src/job-execution/Sas9JobExecutor.ts
+++ b/src/job-execution/Sas9JobExecutor.ts
@@ -125,7 +125,8 @@ const generateFileUploadForm = (
 ): NodeFormData => {
  for (const tableName in data) {
    const name = tableName
-    const csv = convertToCSV(data[tableName])
+    const csv = convertToCSV(data, tableName)
+
    if (csv === 'ERROR: LARGE STRING LENGTH') {
      throw new Error(
        'The max length of a string value in SASjs is 32765 characters.'
--- a/src/job-execution/WebJobExecutor.ts
+++ b/src/job-execution/WebJobExecutor.ts
@@ -1,3 +1,4 @@
+import * as NodeFormData from 'form-data'
 import {
  AuthConfig,
  ExtraResponseAttributes,
@@ -108,7 +109,12 @@ export class WebJobExecutor extends BaseJobExecutor {
      ...this.getRequestParams(config)
    }

-    let formData = new FormData()
+    /**
+     * Use the available form data object (FormData in Browser, NodeFormData in
+     *  Node)
+     */
+    let formData =
+      typeof FormData === 'undefined' ? new NodeFormData() : new FormData()

    if (data) {
      const stringifiedData = JSON.stringify(data)
@@ -143,25 +149,36 @@ 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
+
    const requestPromise = new Promise((resolve, reject) => {
-      this.requestClient!.post(apiUrl, formData, authConfig?.access_token)
+      this.requestClient!.post(
+        apiUrl,
+        formData,
+        authConfig?.access_token,
+        contentType
+      )
        .then(async (res: any) => {
+          const parsedSasjsServerLog =
+            this.serverType === ServerType.Sasjs
+              ? res.result.log.map((logLine: any) => logLine.line).join('\n')
+              : res.result.log
+
          const resObj =
            this.serverType === ServerType.Sasjs
              ? {
                  result: res.result._webout,
-                  log: res.result.log
+                  log: parsedSasjsServerLog
                }
              : res
          this.requestClient!.appendRequest(resObj, sasJob, config.debug)

          let jsonResponse = res.result

-          if (this.serverType === ServerType.Sasjs) {
-            const webout = parseWeboutResponse(res.result._webout, apiUrl)
-            jsonResponse = getValidJson(webout)
-          }
-
          if (config.debug) {
            switch (this.serverType) {
              case ServerType.SasViya:
@@ -177,11 +194,21 @@ export class WebJobExecutor extends BaseJobExecutor {
                    ? parseWeboutResponse(res.result, apiUrl)
                    : res.result
                break
+              case ServerType.Sasjs:
+                if (typeof res.result._webout === 'object') {
+                  jsonResponse = res.result._webout
+                } else {
+                  const webout = parseWeboutResponse(res.result._webout, apiUrl)
+                  jsonResponse = getValidJson(webout)
+                }
+                break
            }
+          } else if (this.serverType === ServerType.Sasjs) {
+            jsonResponse = getValidJson(res.result._webout)
          }

          const responseObject = appendExtraResponseAttributes(
-            { result: jsonResponse },
+            { result: jsonResponse, log: parsedSasjsServerLog },
            extraResponseAttributes
          )
          resolve(responseObject)
--- a/src/job-execution/index.ts
+++ b/src/job-execution/index.ts
@@ -1,6 +1,6 @@
 export * from './ComputeJobExecutor'
+export * from './FileUploader'
 export * from './JesJobExecutor'
 export * from './JobExecutor'
 export * from './Sas9JobExecutor'
 export * from './WebJobExecutor'
-export * from './FileUploader'
--- a/src/request/RequestClient.ts
+++ b/src/request/RequestClient.ts
@@ -56,6 +56,7 @@ export interface HttpClient {

 export class RequestClient implements HttpClient {
  private requests: SASjsRequest[] = []
+  private requestsLimit: number = 10

  protected csrfToken: CsrfToken = { headerName: '', value: '' }
  protected fileUploadCsrfToken: CsrfToken | undefined
@@ -63,9 +64,11 @@ export class RequestClient implements HttpClient {

  constructor(
    protected baseUrl: string,
-    httpsAgentOptions?: https.AgentOptions
+    httpsAgentOptions?: https.AgentOptions,
+    requestsLimit?: number
  ) {
    this.createHttpClient(baseUrl, httpsAgentOptions)
+    if (requestsLimit) this.requestsLimit = requestsLimit
  }

  public setConfig(baseUrl: string, httpsAgentOptions?: https.AgentOptions) {
@@ -149,7 +152,7 @@ export class RequestClient implements HttpClient {
      SASWORK: sasWork
    })

-    if (this.requests.length > 20) {
+    if (this.requests.length > this.requestsLimit) {
      this.requests.splice(0, 1)
    }
  }
@@ -195,9 +198,7 @@ export class RequestClient implements HttpClient {
              }
            ),
          debug
-        ).catch((err) => {
-          throw prefixMessage(err, 'Error while handling error. ')
-        })
+        )
      })
  }

@@ -206,7 +207,8 @@ export class RequestClient implements HttpClient {
    data: any,
    accessToken: string | undefined,
    contentType = 'application/json',
-    overrideHeaders: { [key: string]: string | number } = {}
+    overrideHeaders: { [key: string]: string | number } = {},
+    additionalSettings: { [key: string]: string | number } = {}
  ): Promise<{ result: T; etag: string }> {
    const headers = {
      ...this.getHeaders(accessToken, contentType),
@@ -214,9 +216,14 @@ export class RequestClient implements HttpClient {
    }

    return this.httpClient
-      .post<T>(url, data, { headers, withCredentials: true })
+      .post<T>(url, data, {
+        headers,
+        withCredentials: true,
+        ...additionalSettings
+      })
      .then((response) => {
        throwIfError(response)
+
        return this.parseResponse<T>(response)
      })
      .catch(async (e) => {
@@ -466,6 +473,8 @@ export class RequestClient implements HttpClient {

    if (e instanceof LoginRequiredError) {
      this.clearCsrfTokens()
+
+      throw e
    }

    if (response?.status === 403 || response?.status === 449) {
@@ -488,7 +497,8 @@ export class RequestClient implements HttpClient {
      else return
    }

-    throw e
+    if (e.message) throw e
+    else throw prefixMessage(e, 'Error while handling error. ')
  }

  protected parseResponse<T>(response: AxiosResponse<any>) {
@@ -540,8 +550,9 @@ export class RequestClient implements HttpClient {

    this.httpClient = createAxiosInstance(baseUrl, httpsAgent)

-    this.httpClient.defaults.validateStatus = (status) =>
-      status >= 200 && status < 401
+    this.httpClient.defaults.validateStatus = (status) => {
+      return status >= 200 && status <= 401
+    }
  }
 }

@@ -624,7 +635,7 @@ const parseError = (data: string) => {
      if (parts.length > 1) {
        const storedProcessPath = parts[1].split('<i>')[1].split('</i>')[0]
        const message = `Stored process not found: ${storedProcessPath}`
-        return new JobExecutionError(404, message, '')
+        return new JobExecutionError(500, message, '')
      }
    }
  } catch (_) {}
@@ -638,7 +649,7 @@ const parseError = (data: string) => {
      if (parts.length > 1) {
        const log = parts[1].split('<pre>')[1].split('</pre>')[0]
        const message = `This request completed with errors.`
-        return new JobExecutionError(404, message, log)
+        return new JobExecutionError(500, message, log)
      }
    }
  } catch (_) {}
--- a/src/request/SasjsRequestClient.ts
+++ b/src/request/SasjsRequestClient.ts
@@ -13,7 +13,7 @@ export class SasjsRequestClient extends RequestClient {

    headers.Accept = contentType === 'application/json' ? contentType : '*/*'

-    if (!accessToken)
+    if (!accessToken && typeof window !== 'undefined')
      accessToken = localStorage.getItem('accessToken') ?? undefined

    if (accessToken) headers.Authorization = `Bearer ${accessToken}`
--- a/src/test/ContextManager.spec.ts
+++ b/src/test/ContextManager.spec.ts
@@ -423,7 +423,7 @@ describe('ContextManager', () => {
          true
        )
      } catch (error) {
-        editError = error
+        editError = error as Error
      }

      await expect(
@@ -542,7 +542,7 @@ describe('ContextManager', () => {
          true
        )
      } catch (error) {
-        deleteError = error
+        deleteError = error as Error
      }

      await expect(
--- a/src/test/RequestClient.spec.ts
+++ b/src/test/RequestClient.spec.ts
@@ -5,6 +5,14 @@ import { app, mockedAuthResponse } from './SAS_server_app'
 import { ServerType } from '@sasjs/utils'
 import SASjs from '../SASjs'
 import * as axiosModules from '../utils/createAxiosInstance'
+import {
+  LoginRequiredError,
+  AuthorizeError,
+  NotFoundError,
+  InternalServerError
+} from '../types/errors'
+import { prefixMessage } from '@sasjs/utils/error'
+import { RequestClient } from '../request/RequestClient'

 const axiosActual = jest.requireActual('axios')

@@ -55,10 +63,114 @@ describe('RequestClient', () => {
  it('should response the POST method with Unauthorized', async () => {
    await expect(
      adapter.getAccessToken('clientId', 'clientSecret', 'incorrect')
-    ).rejects.toThrow(
-      'Error while getting access token. Request failed with status code 401'
+    ).rejects.toEqual(
+      prefixMessage(
+        new LoginRequiredError(),
+        'Error while getting access token. '
+      )
    )
  })
+
+  describe('handleError', () => {
+    const requestClient = new RequestClient('https://localhost:8009')
+    const randomError = 'some error'
+
+    it('should throw an error if could not get confirmUrl', async () => {
+      const authError = new AuthorizeError('message', 'confirm_url')
+
+      jest
+        .spyOn(requestClient['httpClient'], 'get')
+        .mockImplementation(() => Promise.reject(randomError))
+
+      await expect(
+        requestClient['handleError'](authError, () => {})
+      ).rejects.toEqual(`Error while getting error confirmUrl. ${randomError}`)
+    })
+
+    it('should throw an error if authorize form is required', async () => {
+      const authError = new AuthorizeError('message', 'confirm_url')
+
+      jest
+        .spyOn(requestClient['httpClient'], 'get')
+        .mockImplementation(() =>
+          Promise.resolve({ data: '<form action="(Logon/oauth/authorize")>' })
+        )
+
+      jest
+        .spyOn(requestClient, 'authorize')
+        .mockImplementation(() => Promise.reject(randomError))
+
+      await expect(
+        requestClient['handleError'](authError, () => {})
+      ).rejects.toEqual(`Error while authorizing request. ${randomError}`)
+    })
+
+    it('should throw an error from callback function', async () => {
+      const authError = new AuthorizeError('message', 'confirm_url')
+
+      jest
+        .spyOn(requestClient['httpClient'], 'get')
+        .mockImplementation(() => Promise.resolve({ data: '' }))
+
+      await expect(
+        requestClient['handleError'](authError, () =>
+          Promise.reject(randomError)
+        )
+      ).rejects.toEqual(
+        `Error while executing callback in handleError. ${randomError}`
+      )
+    })
+
+    it('should handle error with 403 response status', async () => {
+      const error = {
+        response: {
+          status: 403,
+          headers: { 'x-csrf-header': 'x-csrf-header' }
+        }
+      }
+
+      await expect(
+        requestClient['handleError'](error, () => Promise.reject(randomError))
+      ).rejects.toEqual(
+        `Error while executing callback in handleError. ${randomError}`
+      )
+
+      error.response.headers = {} as unknown as { 'x-csrf-header': string }
+      requestClient['csrfToken'].headerName = ''
+
+      await expect(
+        requestClient['handleError'](error, () => Promise.reject(randomError))
+      ).rejects.toEqual(error)
+    })
+
+    it('should handle error with 404 response status', async () => {
+      const error = {
+        response: {
+          status: 404,
+          config: { url: 'test url' }
+        }
+      }
+
+      await expect(
+        requestClient['handleError'](error, () => {})
+      ).rejects.toEqual(new NotFoundError(error.response.config.url))
+    })
+
+    it('should handle error with 502 response status', async () => {
+      const error = {
+        response: {
+          status: 502
+        }
+      }
+
+      await expect(
+        requestClient['handleError'](error, () => {}, true)
+      ).rejects.toEqual(new InternalServerError())
+      await expect(
+        requestClient['handleError'](error, () => {}, false)
+      ).resolves.toEqual(undefined)
+    })
+  })
 })

 describe('RequestClient - Self Signed Server', () => {
@@ -132,8 +244,11 @@ describe('RequestClient - Self Signed Server', () => {
  it('should response the POST method with Unauthorized', async () => {
    await expect(
      adapter.getAccessToken('clientId', 'clientSecret', 'incorrect')
-    ).rejects.toThrow(
-      'Error while getting access token. Request failed with status code 401'
+    ).rejects.toEqual(
+      prefixMessage(
+        new LoginRequiredError(),
+        'Error while getting access token. '
+      )
    )
  })
 })
--- a/src/test/SAS_server_app.ts
+++ b/src/test/SAS_server_app.ts
@@ -18,6 +18,7 @@ app.get('/', function (req: any, res: any) {

 app.post('/SASLogon/oauth/token', function (req: any, res: any) {
  let valid = true
+
  // capture the encoded form data
  req.on('data', (data: any) => {
    const resData = data.toString()
--- a/src/test/SessionManager.spec.ts
+++ b/src/test/SessionManager.spec.ts
@@ -89,7 +89,7 @@ describe('SessionManager', () => {
      expect((process as any).logger.info).toHaveBeenCalledTimes(3)
      expect((process as any).logger.info).toHaveBeenNthCalledWith(
        1,
-        'Polling session status...'
+        `Polling: ${process.env.SERVER_URL}`
      )
      expect((process as any).logger.info).toHaveBeenNthCalledWith(
        2,
--- a/src/test/utils/formatDataForRequest.spec.ts
+++ b/src/test/utils/formatDataForRequest.spec.ts
@@ -0,0 +1,95 @@
+import { formatDataForRequest } from '../../utils/formatDataForRequest'
+
+describe('formatDataForRequest', () => {
+  const testTable = 'sometable'
+
+  it('should format table with special missing values', () => {
+    const tableWithMissingValues = {
+      [testTable]: [
+        { var1: 'string', var2: 232, nullvar: 'A' },
+        { var1: 'string', var2: 232, nullvar: 'B' },
+        { var1: 'string', var2: 232, nullvar: '_' },
+        { var1: 'string', var2: 232, nullvar: 0 },
+        { var1: 'string', var2: 232, nullvar: 'z' },
+        { var1: 'string', var2: 232, nullvar: null }
+      ],
+      [`$${testTable}`]: { formats: { var1: '$char12.', nullvar: 'best.' } }
+    }
+
+    const expectedOutput = {
+      sasjs1data: `var1:$char12. var2:best. nullvar:best.\r\nstring,232,.a\r\nstring,232,.b\r\nstring,232,._\r\nstring,232,0\r\nstring,232,.z\r\nstring,232,.`,
+      sasjs_tables: testTable
+    }
+
+    expect(formatDataForRequest(tableWithMissingValues)).toEqual(expectedOutput)
+  })
+
+  it('should return error if string is more than 32765 characters', () => {
+    const data = { testTable: [{ var1: 'z'.repeat(32765 + 1) }] }
+
+    expect(() => formatDataForRequest(data)).toThrow(
+      new Error(
+        'The max length of a string value in SASjs is 32765 characters.'
+      )
+    )
+  })
+
+  it('should return error if string is more than 32765 characters', () => {
+    const charsCount = 16 * 1000 + 1
+    const allChars = 'z'.repeat(charsCount)
+    const data = { [testTable]: [{ var1: allChars }] }
+    const firstChunk = `var1:$char${charsCount}.\r\n`
+    const firstChunkChars = 'z'.repeat(16000 - firstChunk.length)
+    const secondChunkChars = 'z'.repeat(
+      charsCount - (16000 - firstChunk.length)
+    )
+
+    const expectedOutput = {
+      sasjs1data0: 2,
+      sasjs1data1: `${firstChunk}${firstChunkChars}`,
+      sasjs1data2: secondChunkChars,
+      sasjs_tables: testTable
+    }
+
+    expect(formatDataForRequest(data)).toEqual(expectedOutput)
+  })
+
+  it('should throw an error if special missing values is not valid', () => {
+    let tableWithMissingValues = {
+      [testTable]: [{ var: 'AA' }, { var: 0 }],
+      [`$${testTable}`]: { formats: { var: 'best.' } }
+    }
+
+    expect(() => formatDataForRequest(tableWithMissingValues)).toThrow(
+      new Error(
+        'Special missing value can only be a single character from A to Z or _'
+      )
+    )
+  })
+
+  it('should auto-detect special missing values type as best.', () => {
+    const tableWithMissingValues = {
+      [testTable]: [{ var: 'a' }, { var: 'A' }, { var: '_' }, { var: 0 }]
+    }
+
+    const expectedOutput = {
+      sasjs1data: `var:best.\r\n.a\r\n.a\r\n._\r\n0`,
+      sasjs_tables: testTable
+    }
+
+    expect(formatDataForRequest(tableWithMissingValues)).toEqual(expectedOutput)
+  })
+
+  it('should auto-detect values type as $char1.', () => {
+    const tableWithMissingValues = {
+      [testTable]: [{ var: 'a' }, { var: 'A' }, { var: '_' }]
+    }
+
+    const expectedOutput = {
+      sasjs1data: `var:$char1.\r\na\r\nA\r\n_`,
+      sasjs_tables: testTable
+    }
+
+    expect(formatDataForRequest(tableWithMissingValues)).toEqual(expectedOutput)
+  })
+})
--- a/src/types/SASjsConfig.ts
+++ b/src/types/SASjsConfig.ts
@@ -16,7 +16,7 @@ export class SASjsConfig {
   * The location of the STP Process Web Application.  By default the adapter
   * will use '/SASjsApi/stp/execute' on SAS JS.
   */
-  pathSASJS?: string = ''
+  pathSASJS: string = ''
  /**
   * The location of the Stored Process Web Application.  By default the adapter
   * will use '/SASStoredProcess/do' on SAS 9.
@@ -60,7 +60,7 @@ export class SASjsConfig {
   */
  useComputeApi: boolean | null = null
  /**
-   * Optional settings to configure HTTPS Agent.
+   * Optional setting to configure HTTPS Agent.
   * By providing `key`, `cert`, `ca` to connect with server
   * Other options can be set `rejectUnauthorized` and `requestCert`
   */
@@ -69,6 +69,11 @@ export class SASjsConfig {
   * Supported login mechanisms are - Redirected and Default
   */
  loginMechanism: LoginMechanism = LoginMechanism.Default
+  /**
+   * Optional setting to configure request history limit. Increasing this limit
+   * may affect browser performance, especially with debug (logs) enabled.
+   */
+  requestHistoryLimit?: number = 10
 }

 export enum LoginMechanism {
--- a/src/types/system/global.d.ts
+++ b/src/types/system/global.d.ts
@@ -0,0 +1 @@
+import 'jest-extended'
--- a/src/utils/convertToCsv.spec.ts
+++ b/src/utils/convertToCsv.spec.ts
@@ -1,170 +1,228 @@
 import { convertToCSV } from './convertToCsv'

 describe('convertToCsv', () => {
+  const tableName = 'testTable'
+
  it('should convert single quoted values', () => {
-    const data = [
-      { foo: `'bar'`, bar: 'abc' },
-      { foo: 'sadf', bar: 'def' },
-      { foo: 'asd', bar: `'qwert'` }
-    ]
+    const data = {
+      [tableName]: [
+        { foo: `'bar'`, bar: 'abc' },
+        { foo: 'sadf', bar: 'def' },
+        { foo: 'asd', bar: `'qwert'` }
+      ]
+    }

    const expectedOutput = `foo:$char5. bar:$char7.\r\n"'bar'",abc\r\nsadf,def\r\nasd,"'qwert'"`

-    expect(convertToCSV(data)).toEqual(expectedOutput)
+    expect(convertToCSV(data, tableName)).toEqual(expectedOutput)
  })

  it('should convert double quoted values', () => {
-    const data = [
-      { foo: `"bar"`, bar: 'abc' },
-      { foo: 'sadf', bar: 'def' },
-      { foo: 'asd', bar: `"qwert"` }
-    ]
+    const data = {
+      [tableName]: [
+        { foo: `"bar"`, bar: 'abc' },
+        { foo: 'sadf', bar: 'def' },
+        { foo: 'asd', bar: `"qwert"` }
+      ]
+    }

    const expectedOutput = `foo:$char5. bar:$char7.\r\n"""bar""",abc\r\nsadf,def\r\nasd,"""qwert"""`

-    expect(convertToCSV(data)).toEqual(expectedOutput)
+    expect(convertToCSV(data, tableName)).toEqual(expectedOutput)
  })

  it('should convert values with mixed quotes', () => {
-    const data = [{ foo: `'blah'`, bar: `"blah"` }]
+    const data = { [tableName]: [{ foo: `'blah'`, bar: `"blah"` }] }

    const expectedOutput = `foo:$char6. bar:$char6.\r\n"'blah'","""blah"""`

-    expect(convertToCSV(data)).toEqual(expectedOutput)
+    expect(convertToCSV(data, tableName)).toEqual(expectedOutput)
  })

  it('should convert values with mixed quotes', () => {
-    const data = [{ foo: `'blah,"'`, bar: `"blah,blah" "` }]
+    const data = { [tableName]: [{ foo: `'blah,"'`, bar: `"blah,blah" "` }] }

    const expectedOutput = `foo:$char8. bar:$char13.\r\n"'blah,""'","""blah,blah"" """`

-    expect(convertToCSV(data)).toEqual(expectedOutput)
+    expect(convertToCSV(data, tableName)).toEqual(expectedOutput)
  })

  it('should convert values with mixed quotes', () => {
-    const data = [{ foo: `',''`, bar: `","` }]
+    const data = { [tableName]: [{ foo: `',''`, bar: `","` }] }

    const expectedOutput = `foo:$char4. bar:$char3.\r\n"',''",""","""`

-    expect(convertToCSV(data)).toEqual(expectedOutput)
+    expect(convertToCSV(data, tableName)).toEqual(expectedOutput)
  })

  it('should convert values with mixed quotes', () => {
-    const data = [{ foo: `','`, bar: `,"` }]
+    const data = { [tableName]: [{ foo: `','`, bar: `,"` }] }

    const expectedOutput = `foo:$char3. bar:$char2.\r\n"','",","""`

-    expect(convertToCSV(data)).toEqual(expectedOutput)
+    expect(convertToCSV(data, tableName)).toEqual(expectedOutput)
  })

  it('should convert values with mixed quotes', () => {
-    const data = [{ foo: `"`, bar: `'` }]
+    const data = { [tableName]: [{ foo: `"`, bar: `'` }] }

    const expectedOutput = `foo:$char1. bar:$char1.\r\n"""","'"`

-    expect(convertToCSV(data)).toEqual(expectedOutput)
+    expect(convertToCSV(data, tableName)).toEqual(expectedOutput)
  })

  it('should convert values with mixed quotes', () => {
-    const data = [{ foo: `,`, bar: `',` }]
+    const data = { [tableName]: [{ foo: `,`, bar: `',` }] }

    const expectedOutput = `foo:$char1. bar:$char2.\r\n",","',"`

-    expect(convertToCSV(data)).toEqual(expectedOutput)
+    expect(convertToCSV(data, tableName)).toEqual(expectedOutput)
  })

  it('should convert values with number cases 1', () => {
-    const data = [
-      { col1: 42, col2: null, col3: 'x', col4: null },
-      { col1: 42, col2: null, col3: 'x', col4: null },
-      { col1: 42, col2: null, col3: 'x', col4: null },
-      { col1: 42, col2: null, col3: 'x', col4: '' },
-      { col1: 42, col2: null, col3: 'x', col4: '' }
-    ]
+    const data = {
+      [tableName]: [
+        { col1: 42, col2: null, col3: 'x', col4: null },
+        { col1: 42, col2: null, col3: 'x', col4: null },
+        { col1: 42, col2: null, col3: 'x', col4: null },
+        { col1: 42, col2: null, col3: 'x', col4: '' },
+        { col1: 42, col2: null, col3: 'x', col4: '' }
+      ]
+    }

    const expectedOutput = `col1:best. col2:best. col3:$char1. col4:$char1.\r\n42,.,x,\r\n42,.,x,\r\n42,.,x,\r\n42,.,x,\r\n42,.,x,`

-    expect(convertToCSV(data)).toEqual(expectedOutput)
+    expect(convertToCSV(data, tableName)).toEqual(expectedOutput)
  })

  it('should convert values with number cases 2', () => {
-    const data = [
-      { col1: 42, col2: null, col3: 'x', col4: '' },
-      { col1: 42, col2: null, col3: 'x', col4: '' },
-      { col1: 42, col2: null, col3: 'x', col4: '' },
-      { col1: 42, col2: 1.62, col3: 'x', col4: 'x' },
-      { col1: 42, col2: 1.62, col3: 'x', col4: 'x' }
-    ]
+    const data = {
+      [tableName]: [
+        { col1: 42, col2: null, col3: 'x', col4: '' },
+        { col1: 42, col2: null, col3: 'x', col4: '' },
+        { col1: 42, col2: null, col3: 'x', col4: '' },
+        { col1: 42, col2: 1.62, col3: 'x', col4: 'x' },
+        { col1: 42, col2: 1.62, col3: 'x', col4: 'x' }
+      ]
+    }

    const expectedOutput = `col1:best. col2:best. col3:$char1. col4:$char1.\r\n42,.,x,\r\n42,.,x,\r\n42,.,x,\r\n42,1.62,x,x\r\n42,1.62,x,x`

-    expect(convertToCSV(data)).toEqual(expectedOutput)
+    expect(convertToCSV(data, tableName)).toEqual(expectedOutput)
  })

  it('should convert values with common special characters', () => {
-    expect(convertToCSV([{ tab: '\t' }])).toEqual(`tab:$char1.\r\n\"\t\"`)
-    expect(convertToCSV([{ lf: '\n' }])).toEqual(`lf:$char1.\r\n\"\n\"`)
-    expect(convertToCSV([{ semicolon: ';semi' }])).toEqual(
-      `semicolon:$char5.\r\n;semi`
+    expect(convertToCSV({ [tableName]: [{ tab: '\t' }] }, tableName)).toEqual(
+      `tab:$char1.\r\n\"\t\"`
    )
-    expect(convertToCSV([{ percent: '%' }])).toEqual(`percent:$char1.\r\n%`)
-    expect(convertToCSV([{ singleQuote: "'" }])).toEqual(
-      `singleQuote:$char1.\r\n\"'\"`
-    )
-    expect(convertToCSV([{ doubleQuote: '"' }])).toEqual(
-      `doubleQuote:$char1.\r\n""""`
-    )
-    expect(convertToCSV([{ crlf: '\r\n' }])).toEqual(`crlf:$char2.\r\n\"\n\"`)
-    expect(convertToCSV([{ euro: '€euro' }])).toEqual(`euro:$char7.\r\n€euro`)
-    expect(convertToCSV([{ banghash: '!#banghash' }])).toEqual(
-      `banghash:$char10.\r\n!#banghash`
+    expect(convertToCSV({ [tableName]: [{ lf: '\n' }] }, tableName)).toEqual(
+      `lf:$char1.\r\n\"\n\"`
    )
+    expect(
+      convertToCSV({ [tableName]: [{ semicolon: ';semi' }] }, tableName)
+    ).toEqual(`semicolon:$char5.\r\n;semi`)
+    expect(
+      convertToCSV({ [tableName]: [{ percent: '%' }] }, tableName)
+    ).toEqual(`percent:$char1.\r\n%`)
+    expect(
+      convertToCSV({ [tableName]: [{ singleQuote: "'" }] }, tableName)
+    ).toEqual(`singleQuote:$char1.\r\n\"'\"`)
+    expect(
+      convertToCSV({ [tableName]: [{ doubleQuote: '"' }] }, tableName)
+    ).toEqual(`doubleQuote:$char1.\r\n""""`)
+    expect(
+      convertToCSV({ [tableName]: [{ crlf: '\r\n' }] }, tableName)
+    ).toEqual(`crlf:$char2.\r\n\"\n\"`)
+    expect(
+      convertToCSV({ [tableName]: [{ euro: '€euro' }] }, tableName)
+    ).toEqual(`euro:$char7.\r\n€euro`)
+    expect(
+      convertToCSV({ [tableName]: [{ banghash: '!#banghash' }] }, tableName)
+    ).toEqual(`banghash:$char10.\r\n!#banghash`)
  })

  it('should convert values with other special characters', () => {
-    const data = [
-      {
-        speech0: '"speech',
-        pct: '%percent',
-        speech: '"speech',
-        slash: '\\slash',
-        slashWithSpecial: '\\\tslash',
-        macvar: '&sysuserid',
-        chinese: '传/傳chinese',
-        sigma: 'Σsigma',
-        at: '@at',
-        serbian: 'Српски',
-        dollar: '$'
-      }
-    ]
+    const data = {
+      [tableName]: [
+        {
+          speech0: '"speech',
+          pct: '%percent',
+          speech: '"speech',
+          slash: '\\slash',
+          slashWithSpecial: '\\\tslash',
+          macvar: '&sysuserid',
+          chinese: '传/傳chinese',
+          sigma: 'Σsigma',
+          at: '@at',
+          serbian: 'Српски',
+          dollar: '$'
+        }
+      ]
+    }

    const expectedOutput = `speech0:$char7. pct:$char8. speech:$char7. slash:$char6. slashWithSpecial:$char7. macvar:$char10. chinese:$char14. sigma:$char7. at:$char3. serbian:$char12. dollar:$char1.\r\n"""speech",%percent,"""speech",\\slash,\"\\\tslash\",&sysuserid,传/傳chinese,Σsigma,@at,Српски,$`

-    expect(convertToCSV(data)).toEqual(expectedOutput)
+    expect(convertToCSV(data, tableName)).toEqual(expectedOutput)

-    expect(convertToCSV([{ speech: 'menext' }])).toEqual(
-      `speech:$char6.\r\nmenext`
-    )
-    expect(convertToCSV([{ speech: 'me\nnext' }])).toEqual(
-      `speech:$char7.\r\n\"me\nnext\"`
-    )
-    expect(convertToCSV([{ speech: `me'next` }])).toEqual(
-      `speech:$char7.\r\n\"me'next\"`
-    )
-    expect(convertToCSV([{ speech: `me"next` }])).toEqual(
-      `speech:$char7.\r\n\"me""next\"`
-    )
-    expect(convertToCSV([{ speech: `me""next` }])).toEqual(
-      `speech:$char8.\r\n\"me""""next\"`
-    )
-    expect(convertToCSV([{ slashWithSpecial: '\\\tslash' }])).toEqual(
-      `slashWithSpecial:$char7.\r\n\"\\\tslash\"`
-    )
-    expect(convertToCSV([{ slashWithSpecial: '\\ \tslash' }])).toEqual(
-      `slashWithSpecial:$char8.\r\n\"\\ \tslash\"`
-    )
    expect(
-      convertToCSV([{ slashWithSpecialExtra: '\\\ts\tl\ta\ts\t\th\t' }])
+      convertToCSV({ [tableName]: [{ speech: 'menext' }] }, tableName)
+    ).toEqual(`speech:$char6.\r\nmenext`)
+    expect(
+      convertToCSV({ [tableName]: [{ speech: 'me\nnext' }] }, tableName)
+    ).toEqual(`speech:$char7.\r\n\"me\nnext\"`)
+    expect(
+      convertToCSV({ [tableName]: [{ speech: `me'next` }] }, tableName)
+    ).toEqual(`speech:$char7.\r\n\"me'next\"`)
+    expect(
+      convertToCSV({ [tableName]: [{ speech: `me"next` }] }, tableName)
+    ).toEqual(`speech:$char7.\r\n\"me""next\"`)
+    expect(
+      convertToCSV({ [tableName]: [{ speech: `me""next` }] }, tableName)
+    ).toEqual(`speech:$char8.\r\n\"me""""next\"`)
+    expect(
+      convertToCSV(
+        { [tableName]: [{ slashWithSpecial: '\\\tslash' }] },
+        tableName
+      )
+    ).toEqual(`slashWithSpecial:$char7.\r\n\"\\\tslash\"`)
+    expect(
+      convertToCSV(
+        { [tableName]: [{ slashWithSpecial: '\\ \tslash' }] },
+        tableName
+      )
+    ).toEqual(`slashWithSpecial:$char8.\r\n\"\\ \tslash\"`)
+    expect(
+      convertToCSV(
+        { [tableName]: [{ slashWithSpecialExtra: '\\\ts\tl\ta\ts\t\th\t' }] },
+        tableName
+      )
    ).toEqual(`slashWithSpecialExtra:$char13.\r\n\"\\\ts\tl\ta\ts\t\th\t\"`)
  })
+
+  it('should console log error if data has mixed types', () => {
+    const colName = 'var1'
+    const data = { [tableName]: [{ [colName]: 'string' }, { [colName]: 232 }] }
+
+    jest.spyOn(console, 'error').mockImplementation(() => {})
+
+    convertToCSV(data, tableName)
+
+    expect(console.error).toHaveBeenCalledWith(
+      `Row (2), Column (${colName}) has mixed types: ERROR`
+    )
+  })
+
+  it('should throw an error if table was not found in data object', () => {
+    const data = { [tableName]: [{ var1: 'string' }] }
+
+    expect(() => convertToCSV(data, 'wrongTableName')).toThrow(
+      new Error('No table provided to be converted to CSV')
+    )
+  })
+
+  it('should empty string if table is not an array', () => {
+    const data = { [tableName]: true }
+
+    expect(convertToCSV(data, tableName)).toEqual('')
+  })
 })
--- a/src/utils/convertToCsv.ts
+++ b/src/utils/convertToCsv.ts
@@ -2,71 +2,124 @@
 * Converts the given JSON object array to a CSV string.
 * @param data - the array of JSON objects to convert.
 */
-export const convertToCSV = (data: any) => {
-  const replacer = (key: any, value: any) => (value === null ? '' : value)
-  const headerFields = Object.keys(data[0])
-  let csvTest
-  let invalidString = false
-  const headers = headerFields.map((field) => {
-    let firstFoundType: string | null = null
-    let hasMixedTypes: boolean = false
-    let rowNumError: number = -1
-
-    const longestValueForField = data
-      .map((row: any, index: number) => {
-        if (row[field] || row[field] === '') {
-          if (firstFoundType) {
-            let currentFieldType =
-              row[field] === '' || typeof row[field] === 'string'
-                ? 'chars'
-                : 'number'
-
-            if (!hasMixedTypes) {
-              hasMixedTypes = currentFieldType !== firstFoundType
-              rowNumError = hasMixedTypes ? index + 1 : -1
-            }
-          } else {
-            if (row[field] === '') {
-              firstFoundType = 'chars'
-            } else {
-              firstFoundType =
-                typeof row[field] === 'string' ? 'chars' : 'number'
-            }
-          }
-
-          let byteSize
-
-          if (typeof row[field] === 'string') {
-            byteSize = getByteSize(row[field])
-          }
-
-          return byteSize
-        }
-      })
-      .sort((a: number, b: number) => b - a)[0]
-    if (longestValueForField && longestValueForField > 32765) {
-      invalidString = true
-    }
-    if (hasMixedTypes) {
-      console.error(
-        `Row (${rowNumError}), Column (${field}) has mixed types: ERROR`
-      )
-    }
-
-    return `${field}:${firstFoundType === 'chars' ? '$char' : ''}${
-      longestValueForField
-        ? longestValueForField
-        : firstFoundType === 'chars'
-        ? '1'
-        : 'best'
-    }.`
-  })
-
-  if (invalidString) {
-    return 'ERROR: LARGE STRING LENGTH'
+export const convertToCSV = (
+  data: { [key: string]: any },
+  tableName: string
+) => {
+  if (!data[tableName]) {
+    throw new Error('No table provided to be converted to CSV')
  }

-  csvTest = data.map((row: any) => {
+  const table = data[tableName]
+
+  if (!Array.isArray(table)) return ''
+
+  let formats = data[`$${tableName}`]?.formats
+  let headers: string[] = []
+  let csvTest
+  let invalidString = false
+  const specialMissingValueRegExp = /^[a-z_]{1}$/i
+
+  if (formats) {
+    headers = Object.keys(formats).map((key) => `${key}:${formats![key]}`)
+  }
+
+  const headerFields = Object.keys(table[0])
+
+  headerFields.forEach((field) => {
+    if (!formats || !Object.keys(formats).includes(field)) {
+      let hasNullOrNumber = false
+      let hasSpecialMissingString = false
+
+      table.forEach((row: { [key: string]: any }) => {
+        if (row[field] === null || typeof row[field] === 'number') {
+          hasNullOrNumber = true
+        } else if (
+          typeof row[field] === 'string' &&
+          specialMissingValueRegExp.test(row[field])
+        ) {
+          hasSpecialMissingString = true
+        }
+      })
+
+      if (hasNullOrNumber && hasSpecialMissingString) {
+        headers.push(`${field}:best.`)
+
+        if (!formats) formats = {}
+
+        formats[field] = 'best.'
+      } else {
+        let firstFoundType: string | null = null
+        let hasMixedTypes: boolean = false
+        let rowNumError: number = -1
+
+        const longestValueForField = table
+          .map((row: any, index: number) => {
+            if (row[field] || row[field] === '') {
+              if (firstFoundType) {
+                let currentFieldType =
+                  row[field] === '' || typeof row[field] === 'string'
+                    ? 'chars'
+                    : 'number'
+
+                if (!hasMixedTypes) {
+                  hasMixedTypes = currentFieldType !== firstFoundType
+                  rowNumError = hasMixedTypes ? index + 1 : -1
+                }
+              } else {
+                if (row[field] === '') {
+                  firstFoundType = 'chars'
+                } else {
+                  firstFoundType =
+                    typeof row[field] === 'string' ? 'chars' : 'number'
+                }
+              }
+
+              let byteSize
+
+              if (typeof row[field] === 'string') {
+                byteSize = getByteSize(row[field])
+              }
+
+              return byteSize
+            }
+          })
+          .sort((a: any, b: any) => b - a)[0]
+
+        if (longestValueForField && longestValueForField > 32765) {
+          invalidString = true
+        }
+
+        if (hasMixedTypes) {
+          console.error(
+            `Row (${rowNumError}), Column (${field}) has mixed types: ERROR`
+          )
+        }
+
+        headers.push(
+          `${field}:${firstFoundType === 'chars' ? '$char' : ''}${
+            longestValueForField
+              ? longestValueForField
+              : firstFoundType === 'chars'
+              ? '1'
+              : 'best'
+          }.`
+        )
+      }
+    }
+  })
+
+  if (formats) {
+    headers = headers.sort(
+      (a, b) =>
+        headerFields.indexOf(a.replace(/:.*/, '')) -
+        headerFields.indexOf(b.replace(/:.*/, ''))
+    )
+  }
+
+  if (invalidString) return 'ERROR: LARGE STRING LENGTH'
+
+  csvTest = table.map((row: any) => {
    const fields = Object.keys(row).map((fieldName, index) => {
      let value
      const currentCell = row[fieldName]
@@ -76,6 +129,17 @@ export const convertToCSV = (data: any) => {
      // stringify with replacer converts null values to empty strings
      value = currentCell === null ? '' : currentCell

+      if (formats && formats[fieldName] === 'best.') {
+        if (value && !specialMissingValueRegExp.test(value)) {
+          console.log(`🤖[value]🤖`, value)
+          throw new Error(
+            'Special missing value can only be a single character from A to Z or _'
+          )
+        }
+
+        return `.${value.toLowerCase()}`
+      }
+
      // if there any present, it should have preceding (") for escaping
      value = value.replace(/"/g, `""`)

--- a/src/utils/formatDataForRequest.ts
+++ b/src/utils/formatDataForRequest.ts
@@ -7,19 +7,32 @@ export const formatDataForRequest = (data: any) => {
  const result: any = {}

  for (const tableName in data) {
+    if (
+      tableName.match(/^\$.*/) &&
+      Object.keys(data).includes(tableName.replace(/^\$/, ''))
+    ) {
+      continue
+    }
+
    tableCounter++
+
    sasjsTables.push(tableName)
-    const csv = convertToCSV(data[tableName])
+
+    const csv = convertToCSV(data, tableName)
+
    if (csv === 'ERROR: LARGE STRING LENGTH') {
      throw new Error(
        'The max length of a string value in SASjs is 32765 characters.'
      )
    }
+
    // if csv has length more then 16k, send in chunks
    if (csv.length > 16000) {
      const csvChunks = splitChunks(csv)
+
      // append chunks to form data with same key
      result[`sasjs${tableCounter}data0`] = csvChunks.length
+
      csvChunks.forEach((chunk, index) => {
        result[`sasjs${tableCounter}data${index + 1}`] = chunk
      })
@@ -27,6 +40,7 @@ export const formatDataForRequest = (data: any) => {
      result[`sasjs${tableCounter}data`] = csv
    }
  }
+
  result['sasjs_tables'] = sasjsTables.join(' ')

  return result
--- a/src/utils/getValidJson.ts
+++ b/src/utils/getValidJson.ts
@@ -12,6 +12,8 @@ export const getValidJson = (str: string | object): object => {

    if (typeof str === 'object') return str

+    if (str === '') return {}
+
    return JSON.parse(str)
  } catch (e) {
    if (e instanceof JsonParseArrayError) throw e
--- a/src/utils/parseWeboutResponse.ts
+++ b/src/utils/parseWeboutResponse.ts
@@ -10,6 +10,7 @@ export const parseWeboutResponse = (response: string, url?: string): string => {
        .split('>>weboutEND<<')[0]
    } catch (e) {
      if (url) throw new WeboutResponseError(url)
+
      sasResponse = ''
      console.error(e)
    }
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -6,7 +6,8 @@
    "declaration": true,
    "outDir": "./build",
    "strict": true,
-    "sourceMap": true
+    "sourceMap": true,
+    "typeRoots": ["./node_modules/@types", "./src/types/system"]
  },
  "include": ["src"],
  "exclude": ["node_modules"]
Author	SHA1	Message	Date
Yury Shkoda	827c93886a	Merge pull request #668 from sasjs/special-missings fix: special missing values	2022-03-04 11:07:31 +03:00
Yury Shkoda	f6abb61c69	fix(convert-to-csv): return empty string if table is not an array	2022-03-03 17:31:23 +03:00
Yury Shkoda	4f3478c215	chore: Merge branch 'special-missings' of https://github.com/sasjs/adapter into special-missings	2022-03-03 15:13:58 +03:00
Yury Shkoda	5927910a52	refactor(convert-to-csv): change func arguments	2022-03-03 15:07:01 +03:00
Mihajlo	88f1c2f843	chore: added viya web approach test (special missing)	2022-03-03 13:00:14 +01:00
Yury Shkoda	ff5dc5f196	fix(special-missing): fix generateFileUploadForm func	2022-03-03 10:59:27 +03:00
Yury Shkoda	f0f33cee52	chore(sasjs-tests): improve spelling and code readability	2022-03-03 10:58:51 +03:00
Yury Shkoda	82e061a09c	Merge pull request #662 from sasjs/update-dependencies chore(deps): update dependencies	2022-03-02 09:30:58 +03:00
Mihajlo	888a2b9bd3	chore: test special missings with lowercase value	2022-03-01 17:17:11 +01:00
Allan Bowe	b9defdd1dc	Merge pull request #661 from sasjs/issue-660 fix(viya): updated getAccessTokenForViya with headers based on latest docs	2022-03-01 17:53:04 +02:00
Mihajlo	6e8b19eda1	chore: special missings, test assertion improved, added failing test	2022-03-01 15:32:30 +01:00
Vladislav Parhomchik	83350b5dd8	chore(deps): update dependencies	2022-03-01 17:17:06 +03:00
Saad Jutt	2e14d4f28c	test(viya): updated specs for getAccessTokenForViya	2022-03-01 17:53:04 +05:00
Saad Jutt	96cb77da45	fix(viya): updated getAccessTokenForViya with headers based on latest docs	2022-03-01 17:42:28 +05:00
Allan Bowe	1ee07eeecf	Update README.md	2022-02-28 18:04:59 +00:00
Allan Bowe	b4c0946883	Merge pull request #658 from sasjs/return-log-for-web-job-executor fix: WebJobExecutor also returns log along result	2022-02-25 11:59:31 +02:00
Saad Jutt	efcf3b273c	fix: WebJobExecutor also returns log along result	2022-02-24 22:02:17 +05:00
Allan Bowe	761bf8de38	Merge pull request #657 from sasjs/sas9-job-execution-log-fix fix: changed return code in case of job execution error	2022-02-24 15:53:07 +02:00
Saad Jutt	5ccfc18a35	fix: changed return code in case of job execution error	2022-02-24 04:06:18 +05:00
Muhammad Saad	92434e48ad	Merge pull request #655 from sasjs/node-form-data-fix fix: not to use NodeFormData function on web	2022-02-22 17:20:00 +05:00
Saad Jutt	d3c91e143a	fix: parse empty string in res to empty {}	2022-02-22 17:09:47 +05:00
Saad Jutt	872e73b5f0	fix: not to use NodeFormData function on web	2022-02-22 17:06:27 +05:00
Allan Bowe	af4ad3a7af	Merge pull request #654 from sasjs/axios-setting-for-larger-deploy-to-sasjs-server fix: added additional params to axios POST while deploy to SASJS server	2022-02-22 13:21:12 +02:00
Saad Jutt	1ff67ed93c	fix: added additional params to axios POST while deploy to SASJS server	2022-02-22 16:09:15 +05:00
Allan Bowe	d2739d1791	Merge pull request #653 from sasjs/form-data-fix fix: reverted sasjsJobExecutor no need for that	2022-02-22 11:15:16 +02:00
Allan Bowe	487cb489f3	fix: comments and logic tidy up	2022-02-22 08:38:25 +00:00
Saad Jutt	d9cb2db61f	fix: reverted sasjsJobExecutor no need for that	2022-02-22 06:53:29 +05:00
Muhammad Saad	35f37ac796	Merge pull request #650 from sasjs/sasjs-server-webout fix: no need to parse if webout is an object	2022-02-21 15:54:12 +04:00
Saad Jutt	d7ad0288b9	fix: no need to parse if webout is an object	2022-02-21 16:45:41 +05:00
Allan Bowe	9c98cabe6c	Merge pull request #649 from sasjs/sasjs-server-log-parsing fix: adopted new log structure of SASJS server	2022-02-20 23:27:36 +02:00
Saad Jutt	a6f6897543	fix: adopted new log structure of SASJS server	2022-02-20 20:50:38 +05:00
Allan Bowe	2ea3925977	Merge pull request #647 from sasjs/issue-623 feat(sasjs-config): add optional attribute requestHistoryLimit	2022-02-18 16:25:49 +02:00
sabhas	489df78391	chore: lint fix	2022-02-18 15:30:24 +05:00
Allan Bowe	842c7f9b23	chore: adding docs for requestHistoryLimit	2022-02-17 20:46:09 +00:00
sabhas	fe3f6d6287	feat(sasjs-config): add optional attribute requestHistoryLimit	2022-02-17 23:39:55 +05:00
munja	9728ebd98d	chore: reducing dependabot limit to 2 per month	2022-02-17 11:07:03 +00:00
Allan Bowe	8e116d81d7	Merge pull request #641 from sasjs/issue-624 fix(special-missing): fix convertToCSV format object	2022-02-17 13:05:24 +02:00
Yury Shkoda	fbca91144d	test(generateFileUploadForm): add test data	2022-02-17 13:49:21 +03:00
Allan Bowe	c392390147	Merge pull request #642 from sasjs/sasjs-server-job-executor feat: execute job on SASJS server	2022-02-17 12:48:41 +02:00
Yury Shkoda	9b239abda0	test(generateFileUploadForm): add unit test	2022-02-17 13:34:13 +03:00
Allan Bowe	78945d9f45	Merge pull request #638 from sasjs/sasjsconfig-pathsasjs fix: made pathsasjs non optional in sasjs config	2022-02-17 11:39:29 +02:00
Allan Bowe	1e0365de1c	Merge pull request #643 from sasjs/sas9-deploy-bug fix: reverted axios-cookiejar-support package	2022-02-17 11:38:29 +02:00
Saad Jutt	c8d71b0267	fix: reverted axios-cookiejar-support package	2022-02-17 07:20:48 +05:00
Saad Jutt	bfc534da15	feat: execute job on SASJS server	2022-02-17 02:01:19 +05:00
Yury Shkoda	d3dff44918	fix(special-missings): fix convertToCSV format object	2022-02-16 17:13:00 +03:00
Yury Shkoda	4026b03005	Merge pull request #636 from sasjs/cli-issue-1108 feat(executeJobSASjs): add parse _webout in response	2022-02-15 12:46:55 +03:00
Yury Shkoda	eab19a0e6e	chore(deps): bump axios to fix follow-redirects issue	2022-02-15 09:59:26 +03:00
Yury Shkoda	1d7b7d654d	chore(git): Merge remote-tracking branch 'origin/master' into cli-issue-1108	2022-02-15 09:52:05 +03:00
sabhas	2c4152a593	fix: made pathsasjs non optional in sasjs config	2022-02-14 02:02:41 +05:00
Allan Bowe	de51946850	Merge pull request #637 from sasjs/sasjs-server-deployment-with-auth fix(SASJS): sasjs server deployment with auth + refresh token bug	2022-02-11 18:20:35 +02:00
Saad Jutt	ebd55c5b02	chore: provided JSDoc for deployToSASjs	2022-02-11 21:18:18 +05:00
Saad Jutt	f48089cb8c	fix(SASJS): sasjs server deployment with auth + refresh token bug	2022-02-11 21:04:51 +05:00
Yury Shkoda	30a99f9cc5	fix(executeJobSASjs): add parse webout response	2022-02-11 13:10:38 +03:00
Yury Shkoda	b1979f63ef	feat(executeJobSASjs): add _returnLog query option	2022-02-10 16:58:15 +03:00
Yury Shkoda	97c3cfd574	Merge pull request #622 from sasjs/update-dependencies chore: update dependencies	2022-02-01 15:51:40 +03:00
Yury Shkoda	56df578ab2	chore(writeStream): refactor function and improve test	2022-01-31 10:21:20 +03:00
Yury Shkoda	556ab608c5	chore(jest-extended): fix jest-extended import	2022-01-31 10:20:53 +03:00
Yury Shkoda	0633a6de84	chore(deps): fix issues after deps bump	2022-01-31 10:20:05 +03:00
Vladislav Parhomchik	a39f9bb7e8	chore: update dependencies	2022-01-26 14:11:41 +03:00
Yury Shkoda	a0172337ea	Merge pull request #617 from sasjs/axios-bump Fix axios vulnerability	2022-01-18 22:01:35 +03:00
Yury Shkoda	56683bcee2	chore(npm): fixed all dependencies	2022-01-18 20:08:25 +03:00
Yury Shkoda	8d99612695	chore(ci/cd): add check npm audit step	2022-01-18 19:33:18 +03:00
Yury Shkoda	f232fe158c	chore(ci/cd): improve user list for review lottery	2022-01-18 19:32:40 +03:00
Yury Shkoda	11b218702b	fix(dependencies): numped axios	2022-01-18 19:31:24 +03:00
Yury Shkoda	a957e1d359	Merge pull request #615 from sasjs/issue-607 Support special missing values	2022-01-18 14:58:24 +03:00
Allan Bowe	c6b25d2d49	chore(docs): adding SASJS as a valid serverType	2022-01-09 13:47:09 +00:00
Allan Bowe	ca5eb1dbbe	chore(docs): explaining the ability to export types using the webout() macro	2022-01-09 13:45:28 +00:00
Yury Shkoda	c3bc3c051b	chore(git): Merge branch 'issue-607' of https://github.com/sasjs/adapter into issue-607	2022-01-06 16:50:42 +03:00
Yury Shkoda	dbb95b7763	feat: improve convertToCsv function	2022-01-06 16:49:58 +03:00
Allan Bowe	6ca887ba56	chore(docs): fixing missing param	2022-01-06 13:01:31 +00:00
Allan Bowe	70e26c57d9	chore(docs): updating readme with new special missing support. Also adding a .gitpod.yml file for a better gitpod experience.	2022-01-06 12:34:01 +00:00
Yury Shkoda	1a5c84cd0f	test(formatDataForRequest): improved test coverage	2022-01-05 18:35:02 +03:00
Yury Shkoda	fbce35b272	feat(nullVars): add SAS null vars support	2022-01-05 16:54:16 +03:00
Yury Shkoda	84ed3e7d03	chore(sasjs-tests): fixed npm dependencies and scripts	2022-01-05 16:51:00 +03:00
Yury Shkoda	0f7f3e0a11	Merge pull request #614 from sasjs/hot-fix-sasjs-server fix(sasjs): restrict usage of localstorage for node env	2022-01-05 14:51:33 +03:00
Saad Jutt	437bbe114b	fix(sasjs): restrict usage of localstorage for node env	2022-01-05 16:39:59 +05:00
Yury Shkoda	9f7870b804	Merge pull request #608 from sasjs/readme_update chore(readme): support for special missings	2021-12-30 14:32:08 +03:00
munja	9f00cd646e	chore(readme): support for special missings	2021-12-30 09:56:08 +00:00
Yury Shkoda	4e125ce38f	Merge pull request #605 from sasjs/issue-604 Improve error handling and job/session state polling	2021-12-22 19:11:37 +03:00
Yury Shkoda	4a963ffbf5	feat(polling-state): improve logging	2021-12-22 18:46:06 +03:00
Yury Shkoda	f25d9ec09d	test(RequestClient): cover handleError method	2021-12-21 16:41:08 +03:00
Yury Shkoda	4197ad5aa8	test(RequestClient): fix error handling	2021-12-21 11:40:59 +03:00
Yury Shkoda	2ebd6e11ba	test(RequestClient): fix error handling	2021-12-21 11:40:27 +03:00
Yury Shkoda	098e7f8590	fix(errors): fixed error handling function	2021-12-20 10:57:53 +03:00
Yury Shkoda	42aec96410	feat(pollJobState): improved loggging	2021-12-20 10:56:52 +03:00
Allan Bowe	f2905ee169	Merge pull request #602 from sasjs/hot-fix-sasjs-server fix: response from SASJS Server with/without debug on	2021-12-15 17:42:29 +00:00
Saad Jutt	1ba9291746	fix: response from SASJS Server with/without debug on	2021-12-15 21:32:02 +05:00