Merge pull request #650 from sasjs/sasjs-server-webout

fix: no need to parse if webout is an object

.github/dependabot.yml

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

.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

.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

.gitpod.yml

@@ -0,0 +1,2 @@
+tasks:
+  - init: npm install && npm run build

README.md

@@ -142,6 +142,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,16 +218,29 @@ 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
@@ -170,12 +248,13 @@ run;
 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`.
+* `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.
 * `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).
 

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: [],

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.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.4.7",
+    "jest-extended": "2.0.0",
+    "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.3.0",
+    "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.4",
+    "webpack": "5.66.0",
+    "webpack-cli": "4.7.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.35.0",
+    "axios": "0.26.0",
+    "axios-cookiejar-support": "1.0.1",
+    "form-data": "4.0.0",
+    "https": "1.0.0",
+    "tough-cookie": "4.0.0"
   }
 }

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) %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) %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)
   %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)
   %end;
   %mend;
   %x()

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"
   }
 }

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',

sasjs-tests/src/testSuites/SpecialCases.ts

@@ -79,6 +79,19 @@ const errorAndCsrfData: any = {
   _csrf: [{ col1: 'q', col2: 'w', col3: 'e', col4: 'r' }]
 }
 
+const testTable = 'sometable'
+export 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.' } }
+}
+
 export const specialCaseTests = (adapter: SASjs): TestSuite => ({
   name: 'Special Cases',
   tests: [
@@ -247,6 +260,39 @@ 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', testTableWithNullVars)
+      },
+      assertion: (res: any) => {
+        let assertionRes = true
+
+        testTableWithNullVars[testTable].forEach(
+          (row: { [key: string]: any }, i: number) =>
+            Object.keys(row).forEach((col: string) => {
+              const resValue = res[testTable][i][col.toUpperCase()]
+
+              if (
+                typeof row[col] === 'string' &&
+                testTableWithNullVars[`$${testTable}`].formats[col] ===
+                  'best.' &&
+                row[col].toUpperCase() !== resValue
+              ) {
+                assertionRes = false
+              } else if (
+                typeof row[col] !== 'string' &&
+                row[col] !== resValue
+              ) {
+                assertionRes = false
+              }
+            })
+        )
+
+        return assertionRes
+      }
     }
   ]
 })

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'
@@ -28,6 +27,7 @@ import {
   ComputeJobExecutor,
   JesJobExecutor,
   Sas9JobExecutor,
+  SasJsJobExecutor,
   FileUploader
 } from './job-execution'
 import { ErrorResponse } from './types/errors'
@@ -63,6 +63,7 @@ export default class SASjs {
   private computeJobExecutor: JobExecutor | null = null
   private jesJobExecutor: JobExecutor | null = null
   private sas9JobExecutor: JobExecutor | null = null
+  private sasJsJobExecutor: JobExecutor | null = null
 
   constructor(config?: Partial<SASjsConfig>) {
     this.sasjsConfig = {
@@ -77,6 +78,12 @@ export default class SASjs {
     return this.requestClient?.getCsrfToken(type)
   }
 
+  /**
+   * Executes the sas code against SAS9 server
+   * @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 +98,38 @@ export default class SASjs {
     )
   }
 
+  /**
+   * Executes the sas code against SASViya 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
+    )
+  }
+
   /**
    * Gets compute contexts.
    * @param accessToken - an access token for an authorized user.
@@ -254,38 +293,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.
@@ -676,7 +683,16 @@ export default class SASjs {
     const validationResult = this.validateInput(data)
 
     if (validationResult.status) {
-      if (
+      if (config.serverType === ServerType.Sasjs) {
+        return await this.sasJsJobExecutor!.execute(
+          sasJob,
+          data,
+          config,
+          loginRequiredCallback,
+          authConfig,
+          extraResponseAttributes
+        )
+      } else if (
         config.serverType !== ServerType.Sas9 &&
         config.useComputeApi !== undefined &&
         config.useComputeApi !== null
@@ -736,15 +752,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 +775,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 +791,7 @@ export default class SASjs {
         }
       }
     }
+
     return { status: true, msg: '' }
   }
 
@@ -860,8 +881,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 +1034,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 +1049,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,
@@ -1078,6 +1114,13 @@ export default class SASjs {
       this.sasViyaApiClient!
     )
 
+    this.sasJsJobExecutor = new SasJsJobExecutor(
+      this.sasjsConfig.serverUrl,
+      this.sasjsConfig.serverType!,
+      this.jobsPath,
+      this.requestClient
+    )
+
     this.sas9JobExecutor = new Sas9JobExecutor(
       this.sasjsConfig.serverUrl,
       this.sasjsConfig.serverType!,

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,7 @@ export class SASjsApiClient {
     }>(
       'SASjsApi/drive/deploy',
       { fileTree: members, appLoc: appLoc },
-      undefined
+      access_token
     )
 
     return Promise.resolve(result)
@@ -35,8 +50,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)
   }
 

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. ')
     }
   }
 }

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')
   })

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()
   })
-}

src/file/generateFileUploadForm.ts

@@ -5,8 +5,11 @@ export const generateFileUploadForm = (
   data: any
 ): FormData => {
   for (const tableName in data) {
+    if (!Array.isArray(data[tableName])) continue
+
     const name = 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.'

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.'
+      )
+    )
+  })
+})

src/job-execution/SasJsJobExecutor.ts

@@ -0,0 +1,131 @@
+import {
+  AuthConfig,
+  ExtraResponseAttributes,
+  ServerType
+} from '@sasjs/utils/types'
+import {
+  ErrorResponse,
+  JobExecutionError,
+  LoginRequiredError
+} from '../types/errors'
+import { RequestClient } from '../request/RequestClient'
+import {
+  isRelativePath,
+  appendExtraResponseAttributes,
+  getValidJson
+} from '../utils'
+import { BaseJobExecutor } from './JobExecutor'
+import { parseWeboutResponse } from '../utils/parseWeboutResponse'
+
+export class SasJsJobExecutor extends BaseJobExecutor {
+  constructor(
+    serverUrl: string,
+    serverType: ServerType,
+    private jobsPath: string,
+    private requestClient: RequestClient
+  ) {
+    super(serverUrl, serverType)
+  }
+
+  async execute(
+    sasJob: string,
+    data: any,
+    config: any,
+    loginRequiredCallback?: any,
+    authConfig?: AuthConfig,
+    extraResponseAttributes: ExtraResponseAttributes[] = []
+  ) {
+    const loginCallback = loginRequiredCallback || (() => Promise.resolve())
+    const program = isRelativePath(sasJob)
+      ? config.appLoc
+        ? config.appLoc.replace(/\/?$/, '/') + sasJob.replace(/^\//, '')
+        : sasJob
+      : sasJob
+    let apiUrl = `${config.serverUrl}${this.jobsPath}/?${'_program=' + program}`
+
+    const requestParams = this.getRequestParams(config)
+
+    const requestPromise = new Promise((resolve, reject) => {
+      this.requestClient!.post(
+        apiUrl,
+        { ...requestParams, ...data },
+        authConfig?.access_token
+      )
+        .then(async (res: any) => {
+          const parsedSasjsServerLog = res.result.log
+            .map((logLine: any) => logLine.line)
+            .join('\n')
+
+          const resObj = {
+            result: res.result._webout,
+            log: parsedSasjsServerLog
+          }
+          this.requestClient!.appendRequest(resObj, sasJob, config.debug)
+
+          let jsonResponse = res.result
+
+          if (config.debug) {
+            if (typeof res.result._webout === 'object') {
+              jsonResponse = res.result._webout
+            } else {
+              const webout = parseWeboutResponse(res.result._webout, apiUrl)
+              jsonResponse = getValidJson(webout)
+            }
+          } else {
+            jsonResponse = getValidJson(res.result._webout)
+          }
+
+          const responseObject = appendExtraResponseAttributes(
+            { result: jsonResponse },
+            extraResponseAttributes
+          )
+          resolve(responseObject)
+        })
+        .catch(async (e: Error) => {
+          if (e instanceof JobExecutionError) {
+            this.requestClient!.appendRequest(e, sasJob, config.debug)
+            reject(new ErrorResponse(e?.message, e))
+          }
+
+          if (e instanceof LoginRequiredError) {
+            this.appendWaitingRequest(() => {
+              return this.execute(
+                sasJob,
+                data,
+                config,
+                loginRequiredCallback,
+                authConfig,
+                extraResponseAttributes
+              ).then(
+                (res: any) => {
+                  resolve(res)
+                },
+                (err: any) => {
+                  reject(err)
+                }
+              )
+            })
+
+            await loginCallback()
+          } else {
+            reject(new ErrorResponse(e?.message, e))
+          }
+        })
+    })
+
+    return requestPromise
+  }
+
+  private getRequestParams(config: any): any {
+    const requestParams: any = {}
+
+    if (config.debug) {
+      requestParams['_omittextlog'] = 'false'
+      requestParams['_omitsessionresults'] = 'false'
+
+      requestParams['_debug'] = 131
+    }
+
+    return requestParams
+  }
+}

src/job-execution/WebJobExecutor.ts

@@ -146,11 +146,16 @@ export class WebJobExecutor extends BaseJobExecutor {
     const requestPromise = new Promise((resolve, reject) => {
       this.requestClient!.post(apiUrl, formData, authConfig?.access_token)
         .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)
@@ -173,8 +178,12 @@ export class WebJobExecutor extends BaseJobExecutor {
                     : res.result
                 break
               case ServerType.Sasjs:
-                const webout = parseWeboutResponse(res.result._webout, apiUrl)
-                jsonResponse = getValidJson(webout)
+                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) {

src/job-execution/index.ts

@@ -1,6 +1,7 @@
 export * from './ComputeJobExecutor'
+export * from './FileUploader'
 export * from './JesJobExecutor'
 export * from './JobExecutor'
 export * from './Sas9JobExecutor'
+export * from './SasJsJobExecutor'
 export * from './WebJobExecutor'
-export * from './FileUploader'

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)
     }
   }

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}`

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(

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)
+  })
+})

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 {

src/types/system/global.d.ts

@@ -0,0 +1 @@
+import 'jest-extended'

src/utils/convertToCsv.spec.ts

@@ -167,4 +167,17 @@ describe('convertToCsv', () => {
       convertToCSV([{ slashWithSpecialExtra: '\\\ts\tl\ta\ts\t\th\t' }])
     ).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 = [{ [colName]: 'string' }, { [colName]: 232 }]
+
+    jest.spyOn(console, 'error').mockImplementation(() => {})
+
+    convertToCSV(data)
+
+    expect(console.error).toHaveBeenCalledWith(
+      `Row (2), Column (${colName}) has mixed types: ERROR`
+    )
+  })
 })

src/utils/convertToCsv.ts

@@ -2,70 +2,115 @@
  * 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])
+export const convertToCSV = (
+  data: any[],
+  sasFormats?: { formats: { [key: string]: string } }
+) => {
+  let formats = sasFormats?.formats
+  let headers: string[] = []
   let csvTest
   let invalidString = false
-  const headers = headerFields.map((field) => {
-    let firstFoundType: string | null = null
-    let hasMixedTypes: boolean = false
-    let rowNumError: number = -1
+  const specialMissingValueRegExp = /^[a-z_]{1}$/i
 
-    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 (formats) {
+    headers = Object.keys(formats).map((key) => `${key}:${formats![key]}`)
+  }
 
-            if (!hasMixedTypes) {
-              hasMixedTypes = currentFieldType !== firstFoundType
-              rowNumError = hasMixedTypes ? index + 1 : -1
-            }
-          } else {
-            if (row[field] === '') {
-              firstFoundType = 'chars'
-            } else {
-              firstFoundType =
-                typeof row[field] === 'string' ? 'chars' : 'number'
-            }
-          }
+  const headerFields = Object.keys(data[0])
 
-          let byteSize
+  headerFields.forEach((field) => {
+    if (!formats || !Object.keys(formats).includes(field)) {
+      let hasNullOrNumber = false
+      let hasSpecialMissingString = false
 
-          if (typeof row[field] === 'string') {
-            byteSize = getByteSize(row[field])
-          }
-
-          return byteSize
+      data.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
         }
       })
-      .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 (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 = 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: 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 (invalidString) {
-    return 'ERROR: LARGE STRING LENGTH'
+  if (sasFormats) {
+    headers = headers.sort(
+      (a, b) =>
+        headerFields.indexOf(a.replace(/:.*/, '')) -
+        headerFields.indexOf(b.replace(/:.*/, ''))
+    )
   }
 
+  if (invalidString) return 'ERROR: LARGE STRING LENGTH'
+
   csvTest = data.map((row: any) => {
     const fields = Object.keys(row).map((fieldName, index) => {
       let value
@@ -76,6 +121,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, `""`)
 

src/utils/formatDataForRequest.ts

@@ -7,9 +7,17 @@ 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], data[`$${tableName}`])
+
     if (csv === 'ERROR: LARGE STRING LENGTH') {
       throw new Error(
         'The max length of a string value in SASjs is 32765 characters.'
@@ -27,6 +35,7 @@ export const formatDataForRequest = (data: any) => {
       result[`sasjs${tableCounter}data`] = csv
     }
   }
+
   result['sasjs_tables'] = sasjsTables.join(' ')
 
   return result

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)
     }

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"]