Merge pull request #190 from sasjs/issue-186

feat: listFolder and improvements

.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

@@ -1,4 +1,6 @@
 node_modules
 build
 
-.env
+.env
+
+/coverage

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",
+    "test": "jest --silent --coverage",
     "prepublishOnly": "cp -r ./build/* . && rm -rf ./build",
     "postpublish": "git clean -fd",
     "semantic-release": "semantic-release",
@@ -36,31 +36,31 @@
   },
   "license": "ISC",
   "devDependencies": {
-    "@types/isomorphic-fetch": "0.0.35",
-    "@types/jest": "^26.0.15",
+    "@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.0",
+    "semantic-release": "^17.3.9",
     "terser-webpack-plugin": "^4.2.3",
     "ts-jest": "^25.5.1",
-    "ts-loader": "^8.0.11",
+    "ts-loader": "^8.0.17",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0",
-    "typedoc": "^0.17.8",
-    "typedoc-neo-theme": "^1.0.10",
-    "typedoc-plugin-external-module-name": "^4.0.3",
-    "typescript": "^3.9.7",
-    "webpack": "^4.44.2",
-    "webpack-cli": "^4.2.0"
+    "typedoc": "^0.19.2",
+    "typedoc-neo-theme": "^1.1.0",
+    "typedoc-plugin-external-module-name": "^4.0.6",
+    "typescript": "^3.9.9",
+    "webpack": "^5.21.2",
+    "webpack-cli": "^4.5.0"
   },
   "main": "index.js",
   "dependencies": {
-    "@sasjs/utils": "^1.5.0",
-    "es6-promise": "^4.2.8",
+    "axios": "^0.21.1",
+    "@sasjs/utils": "^2.5.0",
     "form-data": "^3.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.1.0",
     "@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/src/testSuites/Basic.ts

@@ -1,15 +1,17 @@
-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 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 +19,7 @@ const customConfig = {
   pathSAS9: "sas9",
   pathSASViya: "viya",
   appLoc: "/Public/seedapp",
-  serverType: ServerType.SAS9,
+  serverType: ServerType.Sas9,
   debug: false
 };
 
@@ -39,11 +41,12 @@ 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

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

@@ -0,0 +1,450 @@
+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 = [
+    'CAS Formats service compute context',
+    'Data Mining compute context',
+    'Import 9 service compute context',
+    'SAS Job Execution compute context',
+    'SAS Model Manager compute context',
+    'SAS Studio compute context',
+    'SAS Visual Forecasting compute context'
+  ]
+  private defaultLauncherContexts = [
+    'CAS Formats service launcher context',
+    'Data Mining launcher context',
+    'Import 9 service launcher context',
+    'Job Flow Execution launcher context',
+    'SAS Job Execution launcher context',
+    'SAS Model Manager launcher context',
+    'SAS Studio launcher context',
+    'SAS Visual Forecasting launcher context'
+  ]
+
+  get getDefaultComputeContexts() {
+    return this.defaultComputeContexts
+  }
+  get getDefaultLauncherContexts() {
+    return this.defaultLauncherContexts
+  }
+
+  constructor(private serverUrl: string, private requestClient: RequestClient) {
+    if (serverUrl) isUrl(serverUrl)
+  }
+
+  public async getComputeContexts(accessToken?: string) {
+    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 : []
+
+    return contextsList.map((context: any) => ({
+      createdBy: context.createdBy,
+      id: context.id,
+      name: context.name,
+      version: context.version,
+      attributes: {}
+    }))
+  }
+
+  public async getLauncherContexts(accessToken?: string) {
+    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 : []
+
+    return contextsList.map((context: any) => ({
+      createdBy: context.createdBy,
+      id: context.id,
+      name: context.name,
+      version: context.version,
+      attributes: {}
+    }))
+  }
+
+  public async createComputeContext(
+    contextName: string,
+    launchContextName: string,
+    sharedAccountId: string,
+    autoExecLines: string[],
+    accessToken?: string,
+    authorizedUsers?: string[]
+  ) {
+    this.validateContextName(contextName)
+
+    this.isDefaultContext(
+      contextName,
+      this.defaultComputeContexts,
+      `Compute context '${contextName}' already exists.`
+    )
+
+    const existingComputeContexts = await this.getComputeContexts(accessToken)
+
+    if (
+      existingComputeContexts.find((context) => context.name === contextName)
+    ) {
+      throw new Error(`Compute context '${contextName}' already exists.`)
+    }
+
+    if (launchContextName) {
+      if (!this.defaultLauncherContexts.includes(launchContextName)) {
+        const launcherContexts = await this.getLauncherContexts(accessToken)
+
+        if (
+          !launcherContexts.find(
+            (context) => context.name === launchContextName
+          )
+        ) {
+          const description = `The launcher context for ${launchContextName}`
+          const launchType = 'direct'
+
+          const newLauncherContext = await this.createLauncherContext(
+            launchContextName,
+            description,
+            launchType,
+            accessToken
+          ).catch((err) => {
+            throw new Error(`Error while creating launcher context. ${err}`)
+          })
+
+          if (newLauncherContext && newLauncherContext.name) {
+            launchContextName = newLauncherContext.name
+          } else {
+            throw new Error('Error while creating launcher context.')
+          }
+        }
+      }
+    }
+
+    const headers: any = {
+      'Content-Type': 'application/json'
+    }
+
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`
+    }
+
+    let attributes = { reuseServerProcesses: true } as object
+
+    if (sharedAccountId)
+      attributes = { ...attributes, runServerAs: sharedAccountId }
+
+    const requestBody: any = {
+      name: contextName,
+      launchContext: {
+        contextName: launchContextName || ''
+      },
+      attributes
+    }
+
+    if (authorizedUsers && authorizedUsers.length) {
+      requestBody['authorizedUsers'] = authorizedUsers
+    } else {
+      requestBody['authorizeAllAuthenticatedUsers'] = true
+    }
+
+    if (autoExecLines) {
+      requestBody.environment = { autoExecLines }
+    }
+
+    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
+  }
+
+  public async createLauncherContext(
+    contextName: string,
+    description: string,
+    launchType = 'direct',
+    accessToken?: string
+  ) {
+    if (!contextName) {
+      throw new Error('Context name is required.')
+    }
+
+    this.isDefaultContext(
+      contextName,
+      this.defaultLauncherContexts,
+      `Launcher context '${contextName}' already exists.`
+    )
+
+    const existingLauncherContexts = await this.getLauncherContexts(accessToken)
+
+    if (
+      existingLauncherContexts.find((context) => context.name === contextName)
+    ) {
+      throw new Error(`Launcher context '${contextName}' already exists.`)
+    }
+
+    const headers: any = {
+      'Content-Type': 'application/json'
+    }
+
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`
+    }
+
+    const requestBody: any = {
+      name: contextName,
+      description: description,
+      launchType
+    }
+
+    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
+  }
+
+  public async editComputeContext(
+    contextName: string,
+    editedContext: EditContextInput,
+    accessToken?: string
+  ) {
+    this.validateContextName(contextName)
+
+    this.isDefaultContext(
+      contextName,
+      this.defaultComputeContexts,
+      'Editing default SAS compute contexts is not allowed.',
+      true
+    )
+
+    let originalContext
+
+    originalContext = await this.getComputeContextByName(
+      contextName,
+      accessToken
+    )
+
+    // Try to find context by id, when context name has been changed.
+    if (!originalContext) {
+      originalContext = await this.getComputeContextById(
+        editedContext.id!,
+        accessToken
+      )
+    }
+
+    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
+      })
+
+    // 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
+    return await this.requestClient.put<Context>(
+      `/compute/contexts/${context.id}`,
+      {
+        ...context,
+        ...editedContext,
+        attributes: { ...context.attributes, ...editedContext.attributes }
+      },
+      accessToken,
+      { 'If-Match': etag }
+    )
+  }
+
+  public async getComputeContextByName(
+    contextName: string,
+    accessToken?: string
+  ): Promise<Context> {
+    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(
+        `The context '${contextName}' was not found at '${this.serverUrl}'.`
+      )
+    }
+
+    return contexts.items[0]
+  }
+
+  public async getComputeContextById(
+    contextId: string,
+    accessToken?: string
+  ): Promise<ContextAllAttributes> {
+    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
+  }
+
+  public async getExecutableContexts(
+    executeScript: Function,
+    accessToken?: string
+  ) {
+    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[] = []
+
+    const promises = contextsList.map((context: any) => {
+      const linesOfCode = ['%put &=sysuserid;']
+
+      return () =>
+        executeScript(
+          `test-${context.name}`,
+          linesOfCode,
+          context.name,
+          accessToken,
+          null,
+          false,
+          true,
+          true
+        ).catch((err: any) => err)
+    })
+
+    let results: any[] = []
+
+    for (const promise of promises) results.push(await promise())
+
+    results.forEach((result: any, index: number) => {
+      if (result && result.log) {
+        try {
+          const resultParsed = result.log
+          let sysUserId = ''
+
+          const sysUserIdLog = resultParsed
+            .split('\n')
+            .find((line: string) => line.startsWith('SYSUSERID='))
+
+          if (sysUserIdLog) {
+            sysUserId = sysUserIdLog.replace('SYSUSERID=', '')
+
+            executableContexts.push({
+              createdBy: contextsList[index].createdBy,
+              id: contextsList[index].id,
+              name: contextsList[index].name,
+              version: contextsList[index].version,
+              attributes: {
+                sysUserId
+              }
+            })
+          }
+        } catch (error) {
+          throw error
+        }
+      }
+    })
+
+    return executableContexts
+  }
+
+  public async deleteComputeContext(contextName: string, accessToken?: string) {
+    this.validateContextName(contextName)
+
+    this.isDefaultContext(
+      contextName,
+      this.defaultComputeContexts,
+      'Deleting default SAS compute contexts is not allowed.',
+      true
+    )
+
+    const headers: any = {
+      'Content-Type': 'application/json'
+    }
+
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`
+    }
+
+    const context = await this.getComputeContextByName(contextName, accessToken)
+
+    return await this.requestClient.delete<Context>(
+      `${this.serverUrl}/compute/contexts/${context.id}`,
+      accessToken
+    )
+  }
+
+  // TODO: implement editLauncherContext method
+
+  // TODO: implement deleteLauncherContext method
+
+  private validateContextName(name: string) {
+    if (!name) throw new Error('Context name is required.')
+  }
+
+  public isDefaultContext(
+    context: string,
+    defaultContexts: string[] = this.defaultComputeContexts,
+    errorMessage = '',
+    listDefaults = false
+  ) {
+    if (defaultContexts.includes(context)) {
+      throw new Error(
+        `${errorMessage}${
+          listDefaults
+            ? '\nDefault contexts:' +
+              defaultContexts.map((context, i) => `\n${i + 1}. ${context}`)
+            : ''
+        }`
+      )
+    }
+  }
+}

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'
+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,15 +15,18 @@ 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,
+    state: ''
+  }
 
   public get debug() {
     return this._debug
@@ -54,15 +58,8 @@ 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)
       })
@@ -94,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)
 
@@ -115,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
@@ -162,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, _) => {
@@ -175,24 +172,27 @@ export class SessionManager {
         sessionState === ''
       ) {
         if (stateLink) {
-          if (this.debug) {
-            console.log('Polling session status... \n') // ?
+          if (this.debug && !this.printedSessionState.printed) {
+            console.log('Polling session status...')
+
+            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
           })
 
           sessionState = state.trim()
 
-          if (this.debug) {
-            console.log(`Current state is '${sessionState}'\n`)
+          if (this.debug && this.printedSessionState.state !== sessionState) {
+            console.log(`Current session state is '${sessionState}'`)
+
+            this.printedSessionState.state = sessionState
+            this.printedSessionState.printed = false
           }
 
           // There is an internal error present in SAS Viya 3.5
@@ -214,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,156 @@
+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() {
+    const { result: loginResponse } = await this.requestClient.get<string>(
+      this.loginUrl.replace('.do', ''),
+      undefined,
+      'text/plain'
+    )
+    const responseText = loginResponse
+    const isLoggedIn = /<button.+onClick.+logout/gm.test(responseText)
+    let loginForm: any = null
+
+    if (!isLoggedIn) {
+      loginForm = await this.getLoginForm(responseText)
+    }
+
+    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)