chore(*): update typedoc docs

Issue 309

.github/workflows/npmpublish.yml

@@ -25,3 +25,5 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - name: Send Slack message
+        run: curl -X POST --data-urlencode "payload={\"channel\":\"#sasjs\", \"username\":\"GitHub CI\", \"text\":\"New version of @sasjs/adapter has been released! \n Please deploy and run `dctests` with new adapter to make sure everything is still in place.\", \"icon_emoji\":\":rocket:\"}" ${{ secrets.SLACK_WEBHOOK }}

.gitignore

@@ -3,4 +3,6 @@ build
 
 .env
 
-/coverage
+/coverage
+
+.DS_Store

README.md

@@ -6,7 +6,7 @@ SASjs is a open-source framework for building Web Apps on SAS® platforms. You c
 
 1 - `npm install @sasjs/adapter` - for use in a node project
 
-2 - [Download](https://cdn.jsdelivr.net/npm/@sasjs/adapter@1/index.js) and use a copy of the latest JS file
+2 - [Download](https://cdn.jsdelivr.net/npm/@sasjs/adapter@2/index.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.
 
@@ -41,8 +41,165 @@ parmcards4;
 
 You now have a simple web app with a backend service!
 
+## Detailed Overview
+
+The SASjs adapter is a JS library and a set of SAS Macros that handle the communication between the frontend app and backend SAS services.
+
+There are three parts to consider:
+
+1. JS request / response
+2. SAS inputs / outputs
+3. Configuration
+
+### JS Request / Response
+
+To install the library you can simply run `npm i @sasjs/adapter` or include a `<script>` tag with a reference to our [CDN](https://www.jsdelivr.com/package/npm/@sasjs/adapter).
+
+Full technical documentation is available [here](https://adapter.sasjs.io).  The main parts are:
+
+### Instantiation
+The following code will instantiate an instance of the adapter:
+
+```javascript
+let sasJs = new SASjs.default(
+  {
+    appLoc: "/Your/SAS/Folder",
+    serverType:"SAS9"
+  }
+);
+```
+If you've installed it via NPM, you can import it as a default import like so:
+```
+  import SASjs from '@sasjs/adapter';
+```
+You can then instantiate it with:
+```
+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.
+
+```javascript
+sasJs.logIn('USERNAME','PASSWORD'
+  ).then((response) => {
+  if (response.isLoggedIn === true) {
+    console.log('do stuff')
+  } else {
+    console.log('do other stuff')
+  }
+}
+```
+
+###  Request / Response
+A simple request can be sent to SAS in the following fashion:
+
+```javascript
+sasJs.request("/path/to/my/service", dataObject)
+  .then((response) => {
+    // all tables are in the response object, eg:
+    console.log(response.tablewith2cols1row[0].COL1.value)
+  })
+```
+We supply the path to the SAS service, and a data object.  The data object can be null (for services with no input), or can contain one or more tables in the following format:
+
+```javascript
+let dataObject={
+	"tablewith2cols1row": [{
+		"col1": "val1",
+		"col2": 42
+	}],
+	"tablewith1col2rows": [{
+		"col": "row1"
+	}, {
+		"col": "row2"
+	}]
+};
+```
+
+There are optional parameters such as a config object and a callback login function.
+
+The response object will contain returned tables and columns.  Table names are always lowercase, and column names uppercase.
+
+The adapter will also cache the logs (if debug enabled) and even the work tables.  For performance, it is best to keep debug mode off.
+
+## SAS Inputs / Outputs
+
+The SAS side is handled by a number of macros in the [macro core](https://github.com/sasjs/core) library.
+
+The following snippet shows the process of SAS tables arriving / leaving:
+```sas
+/* fetch all input tables sent from frontend - they arrive as work tables */
+%webout(FETCH)
+
+/* some sas code */
+data some sas tables;
+  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 */
+
+```
+
+## 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`.
+* `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.
+* `useComputeApi` - if `true` and the serverType is `SASVIYA` then the REST APIs will be called directly (rather than using the JES web service).
+* `contextName` - if missing or blank, and `useComputeApi` is `true` and `serverType` is `SASVIYA` then the JES API will be used.
+
+The adapter supports a number of approaches for interfacing with Viya (`serverType` is `SASVIYA`).  For maximum performance, be sure to [configure your compute context](https://sasjs.io/guide-viya/#shared-account-and-server-re-use) with `reuseServerProcesses` as `true` and a system account in `runServerAs`.  This functionality is available since Viya 3.5.  This configuration is supported when [creating contexts using the CLI](https://sasjs.io/sasjs-cli-context/#sasjs-context-create).
+
+### Using JES Web App
+
+In this setup, all requests are routed through the JES web app, at `YOURSERVER/SASJobExecution`.  This is the most reliable method, and also the slowest.  One request is made to the JES app, and remaining requests (getting job uri, session spawning, passing parameters, running the program, fetching the log) are made on the SAS server by the JES app.
+
+```
+{
+  appLoc:"/Your/Path",
+  serverType:"SASVIYA"
+}
+```
+
+### Using the JES API
+Here we are running Jobs using the Job Execution Service except this time we are making the requests directly using the REST API instead of through the JES Web App.  This is helpful when we need to call web services outside of a browser (eg with the SASjs CLI or other commandline tools).  To save one network request, the adapter prefetches the JOB URIs and passes them in the `__job` parameter.
+
+```
+{
+  appLoc:"/Your/Path",
+  serverType:"SASVIYA",
+  useComputeApi: true
+}
+```
+
+### Using the Compute API
+This approach is by far the fastest, as a result of the optimisations we have built into the adapter.  With this configuration, in the first sasjs request, we take a URI map of the services in the target folder, and create a session manager - which spawns an extra session.  The next time a request is made, the adapter will use the 'hot' session.  Sessions are deleted after every use, which actually makes this _less_ resource intensive than a typical JES web app, in which all sessions are kept alive by default for 15 minutes.
+
+```
+{
+  appLoc:"/Your/Path",
+  serverType:"SASVIYA",
+  useComputeApi: true,
+  contextName: 'yourComputeContext'
+}
+```
+
+
 # More resources
 
-For more information and examples specific to this adapter you can check out the [user guide](https://sasjs.io/sasjs-adapter/) or the [technical](http://adapter.sasjs.io/) documentation.
+For more information and examples specific to this adapter you can check out the [user guide](https://sasjs.io/sasjs-adapter/) or the [technical](http://adapter.sasjs.io/) documentation. 
 
 For more information on building web apps in general, check out these [resources](https://sasjs.io/training/resources/) or contact the [author](https://www.linkedin.com/in/allanbowe/) directly.
+
+If you are a SAS 9 or SAS Viya customer you can also request a copy of [Data Controller](https://datacontroller.io) - free for up to 5 users, this tool makes use of all parts of the SASjs framework.

cypress.json

@@ -1,13 +0,0 @@
-{
-  "defaultCommandTimeout": 10000,
-  "chromeWebSecurity": false,
-  "screenshotOnRunFailure": false,
-  "env": {
-    "serverUrl": "",
-    "appLoc": "/Public/app",
-    "serverType": "SAS9",
-    "debug": false,
-    "username": "",
-    "password": ""
-  }
-}

jest.config.js

@@ -1,10 +1,184 @@
+// For a detailed explanation regarding each configuration property, visit:
+// https://jestjs.io/docs/en/configuration.html
+
 module.exports = {
-  roots: ["<rootDir>/src"],
-  testMatch: [
-    "**/__tests__/**/*.+(ts|tsx|js)",
-    "**/?(*.)+(spec|test).+(ts|tsx|js)"
-  ],
+  testTimeout: 90000,
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 1,
+
+  // Respect "browser" field in package.json when resolving modules
+  // browser: false,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/private/var/folders/7y/nmqg1srj29q6210rs9dfsdzc0000gn/T/jest_dx",
+
+  // Automatically clear mock calls and instances between every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  // collectCoverage: false,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: 'coverage',
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "json",
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names that allow to stub out resources with a single module
+  moduleNameMapper: {},
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  preset: 'ts-jest/presets/js-with-ts',
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state between every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state between every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  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'],
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  testMatch: ['**/*spec.[j|t]s?(x)'],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  testPathIgnorePatterns: ['/node_modules/', '/build'],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jasmine2",
+
+  // This option sets the URL for the jsdom environment. It is reflected in properties such as location.href
+  // testURL: "http://localhost",
+
+  // Setting this value to "fake" allows the use of fake timers for functions such as "setTimeout"
+  // timers: "real",
+
+  // A map from regular expressions to paths to transformers
   transform: {
-    "^.+\\.(ts|tsx)$": "ts-jest"
+    '^.+\\.ts?$': 'ts-jest'
   }
-};
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   '**/test/**/*.ts?(x)',
+  //   '**/?(*.)+(spec|test).ts?(x)'
+  // ]
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+}

package.json

@@ -7,7 +7,7 @@
     "publish:lib": "npm run build && cd build && npm publish",
     "lint:fix": "npx prettier --write 'src/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}'",
     "lint": "npx prettier --check 'src/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}'",
-    "test": "jest --coverage",
+    "test": "jest --silent --coverage",
     "prepublishOnly": "cp -r ./build/* . && rm -rf ./build",
     "postpublish": "git clean -fd",
     "semantic-release": "semantic-release",
@@ -36,32 +36,31 @@
   },
   "license": "ISC",
   "devDependencies": {
-    "@types/isomorphic-fetch": "0.0.35",
     "@types/jest": "^26.0.20",
     "cp": "^0.2.0",
     "dotenv": "^8.2.0",
-    "jest": "^25.5.4",
+    "jest": "^26.6.3",
+    "jest-extended": "^0.11.5",
     "path": "^0.12.7",
     "rimraf": "^3.0.2",
-    "semantic-release": "^17.3.1",
+    "semantic-release": "^17.4.1",
     "terser-webpack-plugin": "^4.2.3",
     "ts-jest": "^25.5.1",
-    "ts-loader": "^8.0.14",
+    "ts-loader": "^8.0.17",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0",
-    "typedoc": "^0.19.2",
-    "typedoc-neo-theme": "^1.0.10",
+    "typedoc": "^0.20.30",
+    "typedoc-neo-theme": "^1.1.0",
     "typedoc-plugin-external-module-name": "^4.0.6",
-    "typescript": "^3.9.7",
-    "webpack": "^5.13.0",
-    "webpack-cli": "^4.3.1"
+    "typescript": "^3.9.9",
+    "webpack": "^5.24.4",
+    "webpack-cli": "^4.5.0"
   },
   "main": "index.js",
   "dependencies": {
-    "@sasjs/utils": "^2.0.2",
-    "es6-promise": "^4.2.8",
+    "@sasjs/utils": "^2.6.3",
+    "axios": "^0.21.1",
     "form-data": "^3.0.0",
-    "https": "^1.0.0",
-    "isomorphic-fetch": "^2.2.1"
+    "https": "^1.0.0"
   }
 }

sasjs-tests/package.json

@@ -4,21 +4,18 @@
   "homepage": ".",
   "private": true,
   "dependencies": {
-    "@sasjs/adapter": "^1.18.2",
+    "@sasjs/adapter": "^2.2.4",
     "@sasjs/test-framework": "^1.4.0",
-    "@testing-library/jest-dom": "^4.2.4",
-    "@testing-library/react": "^9.5.0",
-    "@testing-library/user-event": "^7.2.1",
-    "@types/jest": "^26.0.3",
-    "@types/node": "^14.0.14",
-    "@types/react": "^16.9.41",
-    "@types/react-dom": "^16.9.8",
-    "@types/react-router-dom": "^5.1.5",
-    "react": "^16.13.1",
-    "react-dom": "^16.13.1",
+    "@types/jest": "^26.0.20",
+    "@types/node": "^14.14.25",
+    "@types/react": "^17.0.1",
+    "@types/react-dom": "^17.0.0",
+    "@types/react-router-dom": "^5.1.7",
+    "react": "^17.0.1",
+    "react-dom": "^17.0.1",
     "react-router-dom": "^5.2.0",
-    "react-scripts": "3.4.1",
-    "typescript": "^3.9.6"
+    "react-scripts": "^4.0.2",
+    "typescript": "^4.1.3"
   },
   "scripts": {
     "start": "react-scripts start",
@@ -45,6 +42,6 @@
     ]
   },
   "devDependencies": {
-    "node-sass": "^4.14.1"
+    "node-sass": "^5.0.0"
   }
 }

sasjs-tests/public/config.json

@@ -6,7 +6,7 @@
     "appLoc": "/Public/app",
     "serverType": "SASVIYA",
     "debug": false,
-    "contextName": "SharedCompute",
+    "contextName": "sasjs adapter compute context",
     "useComputeApi": true
   }
 }

sasjs-tests/src/testSuites/Basic.ts

@@ -1,15 +1,19 @@
-import SASjs, { ServerType, SASjsConfig } from "@sasjs/adapter";
+import SASjs, { SASjsConfig } from "@sasjs/adapter";
 import { TestSuite } from "@sasjs/test-framework";
+import { ServerType } from "@sasjs/utils/types";
+
+const stringData: any = { table1: [{ col1: "first col value" }] };
 
 const defaultConfig: SASjsConfig = {
   serverUrl: window.location.origin,
-  pathSAS9: '/SASStoredProcess/do',
-  pathSASViya: '/SASJobExecution',
-  appLoc: '/Public/seedapp',
-  serverType: ServerType.SASViya,
+  pathSAS9: "/SASStoredProcess/do",
+  pathSASViya: "/SASJobExecution",
+  appLoc: "/Public/seedapp",
+  serverType: ServerType.SasViya,
   debug: false,
-  contextName: 'SAS Job Execution compute context',
-  useComputeApi: false
+  contextName: "SAS Job Execution compute context",
+  useComputeApi: false,
+  allowInsecureRequests: false
 };
 
 const customConfig = {
@@ -17,7 +21,7 @@ const customConfig = {
   pathSAS9: "sas9",
   pathSASViya: "viya",
   appLoc: "/Public/seedapp",
-  serverType: ServerType.SAS9,
+  serverType: ServerType.Sas9,
   debug: false
 };
 
@@ -39,15 +43,46 @@ export const basicTests = (
     },
     {
       title: "Multiple Log in attempts",
-      description: "Should fail on first attempt and should log the user in on second attempt",
+      description:
+        "Should fail on first attempt and should log the user in on second attempt",
       test: async () => {
-        await adapter.logOut()
-        await adapter.logIn('invalid', 'invalid')
-        return adapter.logIn(userName, password)
+        await adapter.logOut();
+        await adapter.logIn("invalid", "invalid");
+        return adapter.logIn(userName, password);
       },
       assertion: (response: any) =>
         response && response.isLoggedIn && response.userName === userName
     },
+    {
+      title: "Trigger login callback",
+      description:
+        "Should trigger required login callback and after successful login, it should finish the request",
+      test: async () => {
+        await adapter.logOut();
+        
+        return await adapter.request("common/sendArr", stringData, null, () => {
+          adapter.logIn(userName, password);
+        });
+      },
+      assertion: (response: any) => {
+        return response.table1[0][0] === stringData.table1[0].col1;
+      }
+    },
+    {
+      title: "Request with debug on",
+      description:
+        "Should complete successful request with debugging switched on",
+      test: async () => {
+        const config = {
+          debug: true
+        }
+
+        return await adapter.request("common/sendArr", stringData, config)
+      },
+      assertion: (response: any) => {
+        return response.table1[0][0] === stringData.table1[0].col1;
+      }
+    },
     {
       title: "Default config",
       description:

sasjs-tests/src/testSuites/Compute.ts

@@ -12,7 +12,7 @@ export const computeTests = (adapter: SASjs): TestSuite => ({
         return adapter.startComputeJob("/Public/app/common/sendArr", data);
       },
       assertion: (res: any) => {
-        const expectedProperties = ["id", "applicationName", "attributes"]
+        const expectedProperties = ["id", "applicationName", "attributes"];
         return validate(expectedProperties, res);
       }
     },
@@ -21,11 +21,22 @@ export const computeTests = (adapter: SASjs): TestSuite => ({
       description: "Should start a compute job and return the job",
       test: () => {
         const data: any = { table1: [{ col1: "first col value" }] };
-        return adapter.startComputeJob("/Public/app/common/sendArr", data, {}, "", true);
+        return adapter.startComputeJob(
+          "/Public/app/common/sendArr",
+          data,
+          {},
+          "",
+          true
+        );
       },
       assertion: (res: any) => {
-        const expectedProperties = ["id", "state", "creationTimeStamp", "jobConditionCode"]
-        return validate(expectedProperties, res.result);
+        const expectedProperties = [
+          "id",
+          "state",
+          "creationTimeStamp",
+          "jobConditionCode"
+        ];
+        return validate(expectedProperties, res.job);
       }
     },
     {
@@ -38,19 +49,19 @@ export const computeTests = (adapter: SASjs): TestSuite => ({
           `output;`,
           `end;`,
           `run;`
-        ]
-        
+        ];
+
         return adapter.executeScriptSASViya(
-          'sasCode.sas',
+          "sasCode.sas",
           fileLines,
-          'SAS Studio compute context',
+          "SAS Studio compute context",
           undefined,
           true
-        )
+        );
       },
       assertion: (res: any) => {
-        const expectedLogContent = `1    data;\\n2    do x=1 to 100;\\n3    output;\\n4    end;\\n5    run;\\n\\n`
-        
+        const expectedLogContent = `1    data;\\n2    do x=1 to 100;\\n3    output;\\n4    end;\\n5    run;\\n\\n`;
+
         return validateLog(expectedLogContent, res.log);
       }
     },
@@ -58,21 +69,21 @@ export const computeTests = (adapter: SASjs): TestSuite => ({
       title: "Execute Script Viya - failed job",
       description: "Should execute sas file and return log",
       test: () => {
-        const fileLines = [
-          `%abort;`
-        ]
-        
-        return adapter.executeScriptSASViya(
-          'sasCode.sas',
-          fileLines,
-          'SAS Studio compute context',
-          undefined,
-          true
-        ).catch((err: any) => err )
+        const fileLines = [`%abort;`];
+
+        return adapter
+          .executeScriptSASViya(
+            "sasCode.sas",
+            fileLines,
+            "SAS Studio compute context",
+            undefined,
+            true
+          )
+          .catch((err: any) => err);
       },
       assertion: (res: any) => {
-        const expectedLogContent = `1    %abort;\\nERROR: The %ABORT statement is not valid in open code.\\n`
-        
+        const expectedLogContent = `1    %abort;\\nERROR: The %ABORT statement is not valid in open code.\\n`;
+
         return validateLog(expectedLogContent, res.log);
       }
     }
@@ -80,16 +91,16 @@ export const computeTests = (adapter: SASjs): TestSuite => ({
 });
 
 const validateLog = (text: string, log: string): boolean => {
-  const isValid = JSON.stringify(log).includes(text)
+  const isValid = JSON.stringify(log).includes(text);
 
-  return isValid
-}
+  return isValid;
+};
 
 const validate = (expectedProperties: string[], data: any): boolean => {
   const actualProperties = Object.keys(data);
 
-  const isValid = expectedProperties.every(
-    (property) => actualProperties.includes(property)
+  const isValid = expectedProperties.every((property) =>
+    actualProperties.includes(property)
   );
-  return isValid
-}
+  return isValid;
+};

sasjs-tests/src/testSuites/RequestData.ts

@@ -185,7 +185,8 @@ export const sendObjTests = (adapter: SASjs): TestSuite => ({
         };
         return adapter.request("common/sendObj", invalidData).catch((e) => e);
       },
-      assertion: (error: any) => !!error && !!error.error && !!error.error.message
+      assertion: (error: any) =>
+        !!error && !!error.error && !!error.error.message
     },
     {
       title: "Single string value",

sasjs-tests/src/testSuites/SasjsRequests.ts

@@ -23,26 +23,23 @@ export const sasjsRequestTests = (adapter: SASjs): TestSuite => ({
     },
     {
       title: "Make error and capture log",
-      description: "Should make an error and capture log, in the same time it is testing if debug override is working",
+      description:
+        "Should make an error and capture log, in the same time it is testing if debug override is working",
       test: async () => {
-        return new Promise(async (resolve, reject) => {
-          adapter
-            .request("common/makeErr", data, {debug: true})
-            .then((res) => {
-              //no action here, this request must throw error
-            })
-            .catch((err) => {
-              let sasRequests = adapter.getSasRequests();
-              let makeErrRequest: any =
-                sasRequests.find((req) =>
-                  req.serviceLink.includes("makeErr")
-                ) || null;
+        return adapter
+          .request("common/makeErr", data, { debug: true })
+          .catch(() => {
+            const sasRequests = adapter.getSasRequests();
+            const makeErrRequest: any =
+              sasRequests.find((req) => req.serviceLink.includes("makeErr")) ||
+              null;
 
-              if (!makeErrRequest) resolve(false)
+            if (!makeErrRequest) return false;
 
-              resolve(!!(makeErrRequest.logFile && makeErrRequest.logFile.length > 0));
-            });
-        });
+            return !!(
+              makeErrRequest.logFile && makeErrRequest.logFile.length > 0
+            );
+          });
       },
       assertion: (response) => {
         return response;

sasjs-tests/tsconfig.json

@@ -17,7 +17,8 @@
     "resolveJsonModule": true,
     "isolatedModules": true,
     "noEmit": true,
-    "jsx": "react"
+    "jsx": "react-jsx",
+    "noFallthroughCasesInSwitch": true
   },
   "include": [
     "src"

src/ContextManager.ts

@@ -1,12 +1,7 @@
-import {
-  Context,
-  CsrfToken,
-  EditContextInput,
-  ContextAllAttributes
-} from './types'
-import { makeRequest, isUrl } from './utils'
-import { SASViyaApiClient } from './SASViyaApiClient'
+import { Context, EditContextInput, ContextAllAttributes } from './types'
+import { isUrl } from './utils'
 import { prefixMessage } from '@sasjs/utils/error'
+import { RequestClient } from './request/RequestClient'
 
 export class ContextManager {
   private defaultComputeContexts = [
@@ -29,8 +24,6 @@ export class ContextManager {
     'SAS Visual Forecasting launcher context'
   ]
 
-  private csrfToken: CsrfToken | null = null
-
   get getDefaultComputeContexts() {
     return this.defaultComputeContexts
   }
@@ -38,28 +31,19 @@ export class ContextManager {
     return this.defaultLauncherContexts
   }
 
-  constructor(
-    private serverUrl: string,
-    private setCsrfToken: (csrfToken: CsrfToken) => void
-  ) {
+  constructor(private serverUrl: string, private requestClient: RequestClient) {
     if (serverUrl) isUrl(serverUrl)
   }
 
   public async getComputeContexts(accessToken?: string) {
-    const headers: any = {
-      'Content-Type': 'application/json'
-    }
-
-    if (accessToken) {
-      headers.Authorization = `Bearer ${accessToken}`
-    }
-
-    const { result: contexts } = await this.request<{ items: Context[] }>(
-      `${this.serverUrl}/compute/contexts?limit=10000`,
-      { headers }
-    ).catch((err) => {
-      throw prefixMessage(err, 'Error while getting compute contexts. ')
-    })
+    const { result: contexts } = await this.requestClient
+      .get<{ items: Context[] }>(
+        `${this.serverUrl}/compute/contexts?limit=10000`,
+        accessToken
+      )
+      .catch((err) => {
+        throw prefixMessage(err, 'Error while getting compute contexts. ')
+      })
 
     const contextsList = contexts && contexts.items ? contexts.items : []
 
@@ -73,20 +57,14 @@ export class ContextManager {
   }
 
   public async getLauncherContexts(accessToken?: string) {
-    const headers: any = {
-      'Content-Type': 'application/json'
-    }
-
-    if (accessToken) {
-      headers.Authorization = `Bearer ${accessToken}`
-    }
-
-    const { result: contexts } = await this.request<{ items: Context[] }>(
-      `${this.serverUrl}/launcher/contexts?limit=10000`,
-      { headers }
-    ).catch((err) => {
-      throw prefixMessage(err, 'Error while getting launcher contexts. ')
-    })
+    const { result: contexts } = await this.requestClient
+      .get<{ items: Context[] }>(
+        `${this.serverUrl}/launcher/contexts?limit=10000`,
+        accessToken
+      )
+      .catch((err) => {
+        throw prefixMessage(err, 'Error while getting launcher contexts. ')
+      })
 
     const contextsList = contexts && contexts.items ? contexts.items : []
 
@@ -184,18 +162,15 @@ export class ContextManager {
       requestBody.environment = { autoExecLines }
     }
 
-    const createContextRequest: RequestInit = {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(requestBody)
-    }
-
-    const { result: context } = await this.request<Context>(
-      `${this.serverUrl}/compute/contexts`,
-      createContextRequest
-    ).catch((err) => {
-      throw prefixMessage(err, 'Error while creating compute context. ')
-    })
+    const { result: context } = await this.requestClient
+      .post<Context>(
+        `${this.serverUrl}/compute/contexts`,
+        requestBody,
+        accessToken
+      )
+      .catch((err) => {
+        throw prefixMessage(err, 'Error while creating compute context. ')
+      })
 
     return context
   }
@@ -238,18 +213,15 @@ export class ContextManager {
       launchType
     }
 
-    const createContextRequest: RequestInit = {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(requestBody)
-    }
-
-    const { result: context } = await this.request<Context>(
-      `${this.serverUrl}/launcher/contexts`,
-      createContextRequest
-    ).catch((err) => {
-      throw prefixMessage(err, 'Error while creating launcher context. ')
-    })
+    const { result: context } = await this.requestClient
+      .post<Context>(
+        `${this.serverUrl}/launcher/contexts`,
+        requestBody,
+        accessToken
+      )
+      .catch((err) => {
+        throw prefixMessage(err, 'Error while creating launcher context. ')
+      })
 
     return context
   }
@@ -268,14 +240,6 @@ export class ContextManager {
       true
     )
 
-    const headers: any = {
-      'Content-Type': 'application/json'
-    }
-
-    if (accessToken) {
-      headers.Authorization = `Bearer ${accessToken}`
-    }
-
     let originalContext
 
     originalContext = await this.getComputeContextByName(
@@ -291,39 +255,33 @@ export class ContextManager {
       )
     }
 
-    const { result: context, etag } = await this.request<Context>(
-      `${this.serverUrl}/compute/contexts/${originalContext.id}`,
-      {
-        headers
-      }
-    ).catch((err) => {
-      if (err && err.status === 404) {
-        throw new Error(
-          `The context '${contextName}' was not found on this server.`
-        )
-      }
+    const { result: context, etag } = await this.requestClient
+      .get<Context>(
+        `${this.serverUrl}/compute/contexts/${originalContext.id}`,
+        accessToken
+      )
+      .catch((err) => {
+        if (err && err.status === 404) {
+          throw new Error(
+            `The context '${contextName}' was not found on this server.`
+          )
+        }
 
-      throw err
-    })
+        throw err
+      })
 
     // An If-Match header with the value of the last ETag for the context
     // is required to be able to update it
     // https://developer.sas.com/apis/rest/Compute/#update-a-context-definition
-    headers['If-Match'] = etag
-
-    const updateContextRequest: RequestInit = {
-      method: 'PUT',
-      headers,
-      body: JSON.stringify({
+    return await this.requestClient.put<Context>(
+      `/compute/contexts/${context.id}`,
+      {
         ...context,
         ...editedContext,
         attributes: { ...context.attributes, ...editedContext.attributes }
-      })
-    }
-
-    return await this.request<Context>(
-      `${this.serverUrl}/compute/contexts/${context.id}`,
-      updateContextRequest
+      },
+      accessToken,
+      { 'If-Match': etag }
     )
   }
 
@@ -331,20 +289,17 @@ export class ContextManager {
     contextName: string,
     accessToken?: string
   ): Promise<Context> {
-    const headers: any = {
-      'Content-Type': 'application/json'
-    }
-
-    if (accessToken) {
-      headers.Authorization = `Bearer ${accessToken}`
-    }
-
-    const { result: contexts } = await this.request<{ items: Context[] }>(
-      `${this.serverUrl}/compute/contexts?filter=eq(name, "${contextName}")`,
-      { headers }
-    ).catch((err) => {
-      throw prefixMessage(err, 'Error while getting compute context by name. ')
-    })
+    const { result: contexts } = await this.requestClient
+      .get<{ items: Context[] }>(
+        `${this.serverUrl}/compute/contexts?filter=eq(name, "${contextName}")`,
+        accessToken
+      )
+      .catch((err) => {
+        throw prefixMessage(
+          err,
+          'Error while getting compute context by name. '
+        )
+      })
 
     if (!contexts || !(contexts.items && contexts.items.length)) {
       throw new Error(
@@ -359,20 +314,16 @@ export class ContextManager {
     contextId: string,
     accessToken?: string
   ): Promise<ContextAllAttributes> {
-    const headers: any = {
-      'Content-Type': 'application/json'
-    }
-
-    if (accessToken) {
-      headers.Authorization = `Bearer ${accessToken}`
-    }
-
-    const { result: context } = await this.request<ContextAllAttributes>(
-      `${this.serverUrl}/compute/contexts/${contextId}`,
-      { headers }
-    ).catch((err) => {
-      throw prefixMessage(err, 'Error while getting compute context by id. ')
-    })
+    const {
+      result: context
+    } = await this.requestClient
+      .get<ContextAllAttributes>(
+        `${this.serverUrl}/compute/contexts/${contextId}`,
+        accessToken
+      )
+      .catch((err) => {
+        throw prefixMessage(err, 'Error while getting compute context by id. ')
+      })
 
     return context
   }
@@ -381,20 +332,14 @@ export class ContextManager {
     executeScript: Function,
     accessToken?: string
   ) {
-    const headers: any = {
-      'Content-Type': 'application/json'
-    }
-
-    if (accessToken) {
-      headers.Authorization = `Bearer ${accessToken}`
-    }
-
-    const { result: contexts } = await this.request<{ items: Context[] }>(
-      `${this.serverUrl}/compute/contexts?limit=10000`,
-      { headers }
-    ).catch((err) => {
-      throw prefixMessage(err, 'Error while fetching compute contexts.')
-    })
+    const { result: contexts } = await this.requestClient
+      .get<{ items: Context[] }>(
+        `${this.serverUrl}/compute/contexts?limit=10000`,
+        accessToken
+      )
+      .catch((err) => {
+        throw prefixMessage(err, 'Error while fetching compute contexts.')
+      })
 
     const contextsList = contexts.items || []
     const executableContexts: any[] = []
@@ -471,14 +416,9 @@ export class ContextManager {
 
     const context = await this.getComputeContextByName(contextName, accessToken)
 
-    const deleteContextRequest: RequestInit = {
-      method: 'DELETE',
-      headers
-    }
-
-    return await this.request<Context>(
+    return await this.requestClient.delete<Context>(
       `${this.serverUrl}/compute/contexts/${context.id}`,
-      deleteContextRequest
+      accessToken
     )
   }
 
@@ -486,34 +426,6 @@ export class ContextManager {
 
   // TODO: implement deleteLauncherContext method
 
-  private async request<T>(
-    url: string,
-    options: RequestInit,
-    contentType: 'text' | 'json' = 'json'
-  ) {
-    if (this.csrfToken) {
-      options.headers = {
-        ...options.headers,
-        [this.csrfToken.headerName]: this.csrfToken.value
-      }
-    }
-
-    return await makeRequest<T>(
-      url,
-      options,
-      (token) => {
-        this.csrfToken = token
-        this.setCsrfToken(token)
-      },
-      contentType
-    ).catch((err) => {
-      throw prefixMessage(
-        err,
-        'Error while making request in Context Manager. '
-      )
-    })
-  }
-
   private validateContextName(name: string) {
     if (!name) throw new Error('Context name is required.')
   }

src/FileUploader.ts

@@ -1,115 +1,70 @@
-import { isLogInRequired, needsRetry, isUrl } from './utils'
-import { CsrfToken } from './types/CsrfToken'
+import { isUrl } from './utils'
 import { UploadFile } from './types/UploadFile'
-import { ErrorResponse } from './types'
-
-const requestRetryLimit = 5
+import { ErrorResponse, LoginRequiredError } from './types/errors'
+import { RequestClient } from './request/RequestClient'
 
 export class FileUploader {
   constructor(
     private appLoc: string,
-    private serverUrl: string,
+    serverUrl: string,
     private jobsPath: string,
-    private setCsrfTokenWeb: any,
-    private csrfToken: CsrfToken | null = null
+    private requestClient: RequestClient
   ) {
     if (serverUrl) isUrl(serverUrl)
   }
 
-  private retryCount = 0
-
   public uploadFile(sasJob: string, files: UploadFile[], params: any) {
-    return new Promise((resolve, reject) => {
-      if (files?.length < 1)
-        reject(new ErrorResponse('At least one file must be provided.'))
-      if (!sasJob || sasJob === '')
-        reject(new ErrorResponse('sasJob must be provided.'))
+    if (files?.length < 1)
+      return Promise.reject(
+        new ErrorResponse('At least one file must be provided.')
+      )
+    if (!sasJob || sasJob === '')
+      return Promise.reject(new ErrorResponse('sasJob must be provided.'))
 
-      let paramsString = ''
+    let paramsString = ''
 
-      for (let param in params) {
-        if (params.hasOwnProperty(param)) {
-          paramsString += `&${param}=${params[param]}`
+    for (let param in params) {
+      if (params.hasOwnProperty(param)) {
+        paramsString += `&${param}=${params[param]}`
+      }
+    }
+
+    const program = this.appLoc
+      ? this.appLoc.replace(/\/?$/, '/') + sasJob.replace(/^\//, '')
+      : sasJob
+    const uploadUrl = `${this.jobsPath}/?${
+      '_program=' + program
+    }${paramsString}`
+
+    const formData = new FormData()
+
+    for (let file of files) {
+      formData.append('file', file.file, file.fileName)
+    }
+
+    const csrfToken = this.requestClient.getCsrfToken('file')
+    if (csrfToken) formData.append('_csrf', csrfToken.value)
+
+    const headers = {
+      'cache-control': 'no-cache',
+      Accept: '*/*',
+      'Content-Type': 'text/plain'
+    }
+
+    return this.requestClient
+      .post(uploadUrl, formData, undefined, 'application/json', headers)
+      .then((res) =>
+        typeof res.result === 'string' ? JSON.parse(res.result) : res.result
+      )
+      .catch((err: Error) => {
+        if (err instanceof LoginRequiredError) {
+          return Promise.reject(
+            new ErrorResponse('You must be logged in to upload a file.', err)
+          )
         }
-      }
-
-      const program = this.appLoc
-        ? this.appLoc.replace(/\/?$/, '/') + sasJob.replace(/^\//, '')
-        : sasJob
-      const uploadUrl = `${this.serverUrl}${this.jobsPath}/?${
-        '_program=' + program
-      }${paramsString}`
-
-      const headers = {
-        'cache-control': 'no-cache'
-      }
-
-      const formData = new FormData()
-
-      for (let file of files) {
-        formData.append('file', file.file, file.fileName)
-      }
-
-      if (this.csrfToken) formData.append('_csrf', this.csrfToken.value)
-
-      fetch(uploadUrl, {
-        method: 'POST',
-        body: formData,
-        referrerPolicy: 'same-origin',
-        headers
+        return Promise.reject(
+          new ErrorResponse('File upload request failed.', err)
+        )
       })
-        .then(async (response) => {
-          if (!response.ok) {
-            if (response.status === 403) {
-              const tokenHeader = response.headers.get('X-CSRF-HEADER')
-
-              if (tokenHeader) {
-                const token = response.headers.get(tokenHeader)
-                this.csrfToken = {
-                  headerName: tokenHeader,
-                  value: token || ''
-                }
-
-                this.setCsrfTokenWeb(this.csrfToken)
-              }
-            }
-          }
-
-          return response.text()
-        })
-        .then((responseText) => {
-          if (isLogInRequired(responseText))
-            reject(new ErrorResponse('You must be logged in to upload a file.'))
-
-          if (needsRetry(responseText)) {
-            if (this.retryCount < requestRetryLimit) {
-              this.retryCount++
-              this.uploadFile(sasJob, files, params).then(
-                (res: any) => resolve(res),
-                (err: any) => reject(err)
-              )
-            } else {
-              this.retryCount = 0
-              reject(responseText)
-            }
-          } else {
-            this.retryCount = 0
-
-            try {
-              resolve(JSON.parse(responseText))
-            } catch (e) {
-              reject(
-                new ErrorResponse(
-                  'Error while parsing json from upload response.',
-                  e
-                )
-              )
-            }
-          }
-        })
-        .catch((err: any) => {
-          reject(new ErrorResponse('Upload request failed.', err))
-        })
-    })
   }
 }

src/SAS9ApiClient.ts

@@ -1,3 +1,4 @@
+import axios, { AxiosInstance } from 'axios'
 import { isUrl } from './utils'
 
 /**
@@ -5,8 +6,11 @@ import { isUrl } from './utils'
  *
  */
 export class SAS9ApiClient {
+  private httpClient: AxiosInstance
+
   constructor(private serverUrl: string) {
     if (serverUrl) isUrl(serverUrl)
+    this.httpClient = axios.create({ baseURL: this.serverUrl })
   }
 
   /**
@@ -38,18 +42,18 @@ export class SAS9ApiClient {
     repositoryName: string
   ) {
     const requestPayload = linesOfCode.join('\n')
-    const executeScriptRequest = {
-      method: 'PUT',
-      headers: {
-        Accept: 'application/json'
-      },
-      body: `command=${requestPayload}`
-    }
-    const executeScriptResponse = await fetch(
-      `${this.serverUrl}/sas/servers/${serverName}/cmd?repositoryName=${repositoryName}`,
-      executeScriptRequest
-    ).then((res) => res.text())
 
-    return executeScriptResponse
+    const executeScriptResponse = await this.httpClient.put(
+      `/sas/servers/${serverName}/cmd?repositoryName=${repositoryName}`,
+      `command=${requestPayload}`,
+      {
+        headers: {
+          Accept: 'application/json'
+        },
+        responseType: 'text'
+      }
+    )
+
+    return executeScriptResponse.data
   }
 }

src/SessionManager.ts

@@ -1,6 +1,7 @@
 import { Session, Context, CsrfToken, SessionVariable } from './types'
-import { asyncForEach, makeRequest, isUrl } from './utils'
+import { asyncForEach, isUrl } from './utils'
 import { prefixMessage } from '@sasjs/utils/error'
+import { RequestClient } from './request/RequestClient'
 
 const MAX_SESSION_COUNT = 1
 const RETRY_LIMIT: number = 3
@@ -14,14 +15,13 @@ export class SessionManager {
   constructor(
     private serverUrl: string,
     private contextName: string,
-    private setCsrfToken: (csrfToken: CsrfToken) => void
+    private requestClient: RequestClient
   ) {
     if (serverUrl) isUrl(serverUrl)
   }
 
   private sessions: Session[] = []
   private currentContext: Context | null = null
-  private csrfToken: CsrfToken | null = null
   private _debug: boolean = false
   private printedSessionState = {
     printed: false,
@@ -58,20 +58,13 @@ export class SessionManager {
   }
 
   async clearSession(id: string, accessToken?: string) {
-    const deleteSessionRequest = {
-      method: 'DELETE',
-      headers: this.getHeaders(accessToken)
-    }
-
-    return await this.request<Session>(
-      `${this.serverUrl}/compute/sessions/${id}`,
-      deleteSessionRequest
-    )
+    return await this.requestClient
+      .delete<Session>(`/compute/sessions/${id}`, accessToken)
       .then(() => {
         this.sessions = this.sessions.filter((s) => s.id !== id)
       })
       .catch((err) => {
-        throw err
+        throw prefixMessage(err, 'Error while deleting session. ')
       })
   }
 
@@ -98,17 +91,20 @@ export class SessionManager {
   }
 
   private async createAndWaitForSession(accessToken?: string) {
-    const createSessionRequest = {
-      method: 'POST',
-      headers: this.getHeaders(accessToken)
-    }
-
-    const { result: createdSession, etag } = await this.request<Session>(
-      `${this.serverUrl}/compute/contexts/${this.currentContext!.id}/sessions`,
-      createSessionRequest
-    ).catch((err) => {
-      throw err
-    })
+    const {
+      result: createdSession,
+      etag
+    } = await this.requestClient
+      .post<Session>(
+        `${this.serverUrl}/compute/contexts/${
+          this.currentContext!.id
+        }/sessions`,
+        {},
+        accessToken
+      )
+      .catch((err) => {
+        throw err
+      })
 
     await this.waitForSession(createdSession, etag, accessToken)
 
@@ -119,13 +115,13 @@ export class SessionManager {
 
   private async setCurrentContext(accessToken?: string) {
     if (!this.currentContext) {
-      const { result: contexts } = await this.request<{
-        items: Context[]
-      }>(`${this.serverUrl}/compute/contexts?limit=10000`, {
-        headers: this.getHeaders(accessToken)
-      }).catch((err) => {
-        throw err
-      })
+      const { result: contexts } = await this.requestClient
+        .get<{
+          items: Context[]
+        }>(`${this.serverUrl}/compute/contexts?limit=10000`, accessToken)
+        .catch((err) => {
+          throw err
+        })
 
       const contextsList =
         contexts && contexts.items && contexts.items.length
@@ -166,10 +162,7 @@ export class SessionManager {
     accessToken?: string
   ) {
     let sessionState = session.state
-    const headers: any = {
-      ...this.getHeaders(accessToken),
-      'If-None-Match': etag
-    }
+
     const stateLink = session.links.find((l: any) => l.rel === 'state')
 
     return new Promise(async (resolve, _) => {
@@ -185,12 +178,10 @@ export class SessionManager {
             this.printedSessionState.printed = true
           }
 
-          const { result: state } = await this.requestSessionStatus<string>(
+          const state = await this.getSessionState(
             `${this.serverUrl}${stateLink.href}?wait=30`,
-            {
-              headers
-            },
-            'text'
+            etag!,
+            accessToken
           ).catch((err) => {
             throw err
           })
@@ -223,73 +214,33 @@ export class SessionManager {
     })
   }
 
-  private async request<T>(
+  private async getSessionState(
     url: string,
-    options: RequestInit,
-    contentType: 'text' | 'json' = 'json'
+    etag: string,
+    accessToken?: string
   ) {
-    if (this.csrfToken) {
-      options.headers = {
-        ...options.headers,
-        [this.csrfToken.headerName]: this.csrfToken.value
-      }
-    }
+    return await this.requestClient
+      .get(url, accessToken, 'text/plain', { 'If-None-Match': etag })
+      .then((res) => res.result as string)
+      .catch((err) => {
+        if (err.status === INTERNAL_SAS_ERROR.status)
+          return INTERNAL_SAS_ERROR.message
 
-    return await makeRequest<T>(
-      url,
-      options,
-      (token) => {
-        this.csrfToken = token
-        this.setCsrfToken(token)
-      },
-      contentType
-    ).catch((err) => {
-      throw err
-    })
-  }
-
-  private async requestSessionStatus<T>(
-    url: string,
-    options: RequestInit,
-    contentType: 'text' | 'json' = 'json'
-  ) {
-    if (this.csrfToken) {
-      options.headers = {
-        ...options.headers,
-        [this.csrfToken.headerName]: this.csrfToken.value
-      }
-    }
-
-    return await makeRequest<T>(
-      url,
-      options,
-      (token) => {
-        this.csrfToken = token
-        this.setCsrfToken(token)
-      },
-      contentType
-    ).catch((err) => {
-      if (err.status === INTERNAL_SAS_ERROR.status)
-        return { result: INTERNAL_SAS_ERROR.message }
-
-      throw err
-    })
+        throw err
+      })
   }
 
   async getVariable(sessionId: string, variable: string, accessToken?: string) {
-    const getSessionVariable = {
-      method: 'GET',
-      headers: this.getHeaders(accessToken)
-    }
-
-    return await this.request<SessionVariable>(
-      `${this.serverUrl}/compute/sessions/${sessionId}/variables/${variable}`,
-      getSessionVariable
-    ).catch((err) => {
-      throw prefixMessage(
-        err,
-        `Error while fetching session variable '${variable}'.`
+    return await this.requestClient
+      .get<SessionVariable>(
+        `${this.serverUrl}/compute/sessions/${sessionId}/variables/${variable}`,
+        accessToken
       )
-    })
+      .catch((err) => {
+        throw prefixMessage(
+          err,
+          `Error while fetching session variable '${variable}'.`
+        )
+      })
   }
 }

src/__mocks__/axios.ts

@@ -0,0 +1,7 @@
+import { AxiosStatic } from 'axios'
+
+const mockAxios = jest.genMockFromModule('axios') as AxiosStatic
+
+mockAxios.create = jest.fn(() => mockAxios)
+
+export default mockAxios

src/auth/AuthManager.ts

@@ -0,0 +1,172 @@
+import { ServerType } from '@sasjs/utils/types'
+import { isAuthorizeFormRequired } from '.'
+import { RequestClient } from '../request/RequestClient'
+import { serialize } from '../utils'
+
+export class AuthManager {
+  public userName = ''
+  private loginUrl: string
+  private logoutUrl: string
+  constructor(
+    private serverUrl: string,
+    private serverType: ServerType,
+    private requestClient: RequestClient,
+    private loginCallback: () => Promise<void>
+  ) {
+    this.loginUrl = `/SASLogon/login`
+    this.logoutUrl =
+      this.serverType === ServerType.Sas9
+        ? '/SASLogon/logout?'
+        : '/SASLogon/logout.do?'
+  }
+
+  /**
+   * Logs into the SAS server with the supplied credentials.
+   * @param username - a string representing the username.
+   * @param password - a string representing the password.
+   */
+  public async logIn(username: string, password: string) {
+    const loginParams: any = {
+      _service: 'default',
+      username,
+      password
+    }
+
+    this.userName = loginParams.username
+
+    const { isLoggedIn, loginForm } = await this.checkSession()
+    if (isLoggedIn) {
+      await this.loginCallback()
+
+      return {
+        isLoggedIn,
+        userName: this.userName
+      }
+    }
+
+    for (const key in loginForm) {
+      loginParams[key] = loginForm[key]
+    }
+    const loginParamsStr = serialize(loginParams)
+
+    const { result: loginResponse } = await this.requestClient.post<string>(
+      this.loginUrl,
+      loginParamsStr,
+      undefined,
+      'text/plain',
+      {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        Accept: '*/*'
+      }
+    )
+
+    let loggedIn = isLogInSuccess(loginResponse)
+
+    if (!loggedIn) {
+      const currentSession = await this.checkSession()
+      loggedIn = currentSession.isLoggedIn
+    }
+
+    if (loggedIn) {
+      this.loginCallback()
+    }
+
+    return {
+      isLoggedIn: !!loggedIn,
+      userName: this.userName
+    }
+  }
+
+  /**
+   * Checks whether a session is active, or login is required.
+   * @returns - a promise which resolves with an object containing two values - a boolean `isLoggedIn`, and a string `userName`.
+   */
+  public async checkSession() {
+    //For VIYA we will send request on API endpoint. Which is faster then pinging SASJobExecution.
+    //For SAS9 we will send request on SASStoredProcess
+    const url =
+      this.serverType === 'SASVIYA'
+        ? `${this.serverUrl}/identities`
+        : `${this.serverUrl}/SASStoredProcess`
+
+    const { result: loginResponse } = await this.requestClient
+      .get<string>(url, undefined, 'text/plain')
+      .catch((err: any) => {
+        return { result: 'authErr' }
+      })
+
+    const isLoggedIn = loginResponse !== 'authErr'
+    let loginForm = null
+
+    if (!isLoggedIn) {
+      //We will logout to make sure cookies are removed and login form is presented
+      this.logOut()
+
+      const { result: formResponse } = await this.requestClient.get<string>(
+        this.loginUrl.replace('.do', ''),
+        undefined,
+        'text/plain'
+      )
+
+      loginForm = await this.getLoginForm(formResponse)
+    }
+
+    return Promise.resolve({
+      isLoggedIn,
+      userName: this.userName,
+      loginForm
+    })
+  }
+
+  private getLoginForm(response: any) {
+    const pattern: RegExp = /<form.+action="(.*Logon[^"]*).*>/
+    const matches = pattern.exec(response)
+    const formInputs: any = {}
+
+    if (matches && matches.length) {
+      this.setLoginUrl(matches)
+      const inputs = response.match(/<input.*"hidden"[^>]*>/g)
+
+      if (inputs) {
+        inputs.forEach((inputStr: string) => {
+          const valueMatch = inputStr.match(/name="([^"]*)"\svalue="([^"]*)/)
+
+          if (valueMatch && valueMatch.length) {
+            formInputs[valueMatch[1]] = valueMatch[2]
+          }
+        })
+      }
+    }
+
+    return Object.keys(formInputs).length ? formInputs : null
+  }
+
+  private setLoginUrl = (matches: RegExpExecArray) => {
+    let parsedURL = matches[1].replace(/\?.*/, '')
+    if (parsedURL[0] === '/') {
+      parsedURL = parsedURL.substr(1)
+
+      const tempLoginLink = this.serverUrl
+        ? `${this.serverUrl}/${parsedURL}`
+        : `${parsedURL}`
+
+      const loginUrl = tempLoginLink
+
+      this.loginUrl =
+        this.serverType === ServerType.SasViya
+          ? tempLoginLink
+          : loginUrl.replace('.do', '')
+    }
+  }
+
+  /**
+   * Logs out of the configured SAS server.
+   */
+  public logOut() {
+    this.requestClient.clearCsrfTokens()
+    return this.requestClient.get(this.logoutUrl, undefined).then(() => true)
+  }
+}
+
+const isLogInSuccess = (response: string): boolean =>
+  /You have signed in/gm.test(response)

src/auth/index.ts

@@ -0,0 +1,3 @@
+export * from './AuthManager'
+export * from './isAuthorizeFormRequired'
+export * from './isLoginRequired'

src/auth/spec/AuthManager.spec.ts

@@ -0,0 +1,195 @@
+import { AuthManager } from '../AuthManager'
+import * as dotenv from 'dotenv'
+import { ServerType } from '@sasjs/utils/types'
+import axios from 'axios'
+import {
+  mockLoginAuthoriseRequiredResponse,
+  mockLoginSuccessResponse
+} from './mockResponses'
+import { serialize } from '../../utils'
+import { RequestClient } from '../../request/RequestClient'
+jest.mock('axios')
+const mockedAxios = axios as jest.Mocked<typeof axios>
+
+describe('AuthManager', () => {
+  const authCallback = jest.fn().mockImplementation(() => Promise.resolve())
+  const serverUrl = 'http://test-server.com'
+  const serverType = ServerType.SasViya
+  const userName = 'test-username'
+  const password = 'test-password'
+  const requestClient = new RequestClient(serverUrl)
+
+  beforeAll(() => {
+    dotenv.config()
+    jest.restoreAllMocks()
+  })
+
+  it('should instantiate and set the correct URLs for a Viya server', () => {
+    const authManager = new AuthManager(
+      serverUrl,
+      serverType,
+      requestClient,
+      authCallback
+    )
+
+    expect(authManager).toBeTruthy()
+    expect((authManager as any).serverUrl).toEqual(serverUrl)
+    expect((authManager as any).serverType).toEqual(serverType)
+    expect((authManager as any).loginUrl).toEqual(`/SASLogon/login`)
+    expect((authManager as any).logoutUrl).toEqual('/SASLogon/logout.do?')
+  })
+
+  it('should instantiate and set the correct URLs for a SAS9 server', () => {
+    const authCallback = () => Promise.resolve()
+    const serverType = ServerType.Sas9
+
+    const authManager = new AuthManager(
+      serverUrl,
+      serverType,
+      requestClient,
+      authCallback
+    )
+
+    expect(authManager).toBeTruthy()
+    expect((authManager as any).serverUrl).toEqual(serverUrl)
+    expect((authManager as any).serverType).toEqual(serverType)
+    expect((authManager as any).loginUrl).toEqual(`/SASLogon/login`)
+    expect((authManager as any).logoutUrl).toEqual('/SASLogon/logout?')
+  })
+
+  it('should call the auth callback and return when already logged in', async (done) => {
+    const authManager = new AuthManager(
+      serverUrl,
+      serverType,
+      requestClient,
+      authCallback
+    )
+    jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
+      Promise.resolve({
+        isLoggedIn: true,
+        userName: 'test',
+        loginForm: 'test'
+      })
+    )
+
+    const loginResponse = await authManager.logIn(userName, password)
+
+    expect(loginResponse.isLoggedIn).toBeTruthy()
+    expect(loginResponse.userName).toEqual(userName)
+    expect(authCallback).toHaveBeenCalledTimes(1)
+    done()
+  })
+
+  it('should post a login request to the server if not logged in', async (done) => {
+    const authManager = new AuthManager(
+      serverUrl,
+      serverType,
+      requestClient,
+      authCallback
+    )
+    jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
+      Promise.resolve({
+        isLoggedIn: false,
+        userName: 'test',
+        loginForm: { name: 'test' }
+      })
+    )
+    mockedAxios.post.mockImplementation(() =>
+      Promise.resolve({ data: mockLoginSuccessResponse })
+    )
+
+    const loginResponse = await authManager.logIn(userName, password)
+
+    expect(loginResponse.isLoggedIn).toBeTruthy()
+    expect(loginResponse.userName).toEqual(userName)
+
+    const loginParams = serialize({
+      _service: 'default',
+      username: userName,
+      password,
+      name: 'test'
+    })
+    expect(mockedAxios.post).toHaveBeenCalledWith(
+      `/SASLogon/login`,
+      loginParams,
+      {
+        withCredentials: true,
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+          Accept: '*/*'
+        }
+      }
+    )
+    expect(authCallback).toHaveBeenCalledTimes(1)
+    done()
+  })
+
+  it('should parse and submit the authorisation form when necessary', async (done) => {
+    const authManager = new AuthManager(
+      serverUrl,
+      serverType,
+      requestClient,
+      authCallback
+    )
+    jest
+      .spyOn(requestClient, 'authorize')
+      .mockImplementation(() => Promise.resolve())
+    jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
+      Promise.resolve({
+        isLoggedIn: false,
+        userName: 'test',
+        loginForm: { name: 'test' }
+      })
+    )
+    mockedAxios.post.mockImplementationOnce(() =>
+      Promise.resolve({
+        data: mockLoginAuthoriseRequiredResponse,
+        config: { url: 'https://test.com/SASLogon/login' },
+        request: { responseURL: 'https://test.com/OAuth/authorize' }
+      })
+    )
+
+    mockedAxios.get.mockImplementationOnce(() =>
+      Promise.resolve({
+        data: mockLoginAuthoriseRequiredResponse
+      })
+    )
+
+    await authManager.logIn(userName, password)
+
+    expect(requestClient.authorize).toHaveBeenCalledWith(
+      mockLoginAuthoriseRequiredResponse
+    )
+    done()
+  })
+
+  it('should check and return session information if logged in', async (done) => {
+    const authManager = new AuthManager(
+      serverUrl,
+      serverType,
+      requestClient,
+      authCallback
+    )
+    mockedAxios.get.mockImplementation(() =>
+      Promise.resolve({ data: '<button onClick="logout">' })
+    )
+
+    const response = await authManager.checkSession()
+    expect(response.isLoggedIn).toBeTruthy()
+    expect(mockedAxios.get).toHaveBeenNthCalledWith(
+      1,
+      `http://test-server.com/identities`,
+      {
+        withCredentials: true,
+        responseType: 'text',
+        transformResponse: undefined,
+        headers: {
+          Accept: '*/*',
+          'Content-Type': 'text/plain'
+        }
+      }
+    )
+
+    done()
+  })
+})