@sasjs/cli 3.19.6 → 3.20.1

package/build/commands/fs/spec/executeCode.spec.js

@@ -0,0 +1,197 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var node_1 = __importDefault(require("@sasjs/adapter/node"));
+var utils_1 = require("@sasjs/utils");
+var executeCode_1 = require("../internal/executeCode");
+var configUtils = __importStar(require("../../../utils/config"));
+var utilsModule = __importStar(require("../../../utils/utils"));
+var targetConfig = {
+    name: 'test',
+    appLoc: '/Public/test/',
+    serverType: utils_1.ServerType.Sasjs
+};
+var authConfig = {
+    access_token: '',
+    refresh_token: '',
+    client: '',
+    secret: ''
+};
+var mockedResponse = {
+    log: 'mocked response'
+};
+describe('executeCode', function () {
+    beforeAll(function () {
+        process.projectDir = __dirname;
+    });
+    describe('on viya', function () {
+        var target = new utils_1.Target(__assign(__assign({}, targetConfig), { serverType: utils_1.ServerType.SasViya }));
+        beforeEach(function () {
+            mockGetSASjsAndAuthConfig(target);
+            jest
+                .spyOn(node_1.default.prototype, 'executeScript')
+                .mockImplementation(function () { return Promise.resolve(mockedResponse); });
+        });
+        it('should execute code on SASViya', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, executeCode_1.executeCode)(target, '')];
+                    case 1:
+                        result = _a.sent();
+                        expect(result).toEqual(mockedResponse);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('on sas9', function () {
+        var target = new utils_1.Target(__assign(__assign({}, targetConfig), { serverType: utils_1.ServerType.Sas9 }));
+        beforeEach(function () {
+            mockExecuteScript();
+            jest.spyOn(configUtils, 'getSASjsAndAuthConfig').mockImplementation(function () {
+                return Promise.resolve({
+                    sasjs: configUtils.getSASjs(target),
+                    authConfigSas9: {
+                        userName: '',
+                        password: ''
+                    }
+                });
+            });
+        });
+        it('should execute code on SAS9', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, executeCode_1.executeCode)(target, '')];
+                    case 1:
+                        result = _a.sent();
+                        expect(result).toEqual(mockedResponse);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('on sasjs', function () {
+        var target = new utils_1.Target(__assign(__assign({}, targetConfig), { serverType: utils_1.ServerType.Sasjs }));
+        beforeEach(function () {
+            mockExecuteScript();
+        });
+        it('should execute code on SASjs Server when running in desktop mode', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest
+                            .spyOn(utilsModule, 'isSasJsServerInServerMode')
+                            .mockImplementation(function () { return Promise.resolve(false); });
+                        return [4 /*yield*/, (0, executeCode_1.executeCode)(target, '')];
+                    case 1:
+                        result = _a.sent();
+                        expect(result).toEqual(mockedResponse);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should execute code on SASjs Server when running in server mode', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest
+                            .spyOn(utilsModule, 'isSasJsServerInServerMode')
+                            .mockImplementation(function () { return Promise.resolve(true); });
+                        jest
+                            .spyOn(configUtils, 'getAuthConfig')
+                            .mockImplementation(function () { return Promise.resolve(authConfig); });
+                        return [4 /*yield*/, (0, executeCode_1.executeCode)(target, '')];
+                    case 1:
+                        result = _a.sent();
+                        expect(result).toEqual(mockedResponse);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});
+var mockExecuteScript = function () {
+    jest
+        .spyOn(node_1.default.prototype, 'executeScript')
+        .mockImplementation(function () { return Promise.resolve(mockedResponse.log); });
+};
+var mockGetSASjsAndAuthConfig = function (target) {
+    jest.spyOn(configUtils, 'getSASjsAndAuthConfig').mockImplementation(function () {
+        return Promise.resolve({
+            sasjs: configUtils.getSASjs(target),
+            authConfig: authConfig
+        });
+    });
+};

package/build/commands/fs/spec/extractHashArray.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/commands/fs/spec/extractHashArray.spec.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var extractHashArray_1 = require("../internal/extractHashArray");
+var log = "\n>>weboutBEGIN<<\n{\n  \"hashes\": [{\n    \"FILE_HASH\": \"someCharacters\",\n    \"FILE_PATH\": \"path/to/folder/file\"\n  }]\n}\n>>weboutEND<<\n";
+var logWithInvalidJsonInWebout = "\n>>weboutBEGIN<<\n{\n  \"invalid Json\"\n}\n>>weboutEND<<\n";
+describe('extractHashArray', function () {
+    it('should extract hashed array from webout', function () {
+        var hashes = (0, extractHashArray_1.extractHashArray)(log);
+        expect(hashes).toBeArrayOfSize(1);
+    });
+    it('should throw error when log does not contain webout', function () {
+        expect(function () { return (0, extractHashArray_1.extractHashArray)(logWithInvalidJsonInWebout); }).toThrow('An error occurred while extracting hashes array from webout.');
+    });
+});

package/build/commands/fs/spec/fsCommand.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/commands/fs/spec/fsCommand.spec.js

@@ -0,0 +1,297 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@sasjs/utils");
+var command_1 = require("../../../types/command");
+var fsCommand_1 = require("../fsCommand");
+var utils_2 = require("../../../utils");
+var FSModule = __importStar(require("@sasjs/utils/fs"));
+var FileModule = __importStar(require("@sasjs/utils/file"));
+var configUtils = __importStar(require("../../../utils/config"));
+var executeCodeModule = __importStar(require("../internal/executeCode"));
+var extractHashArrayModule = __importStar(require("../internal/extractHashArray"));
+var defaultArgs = ['node', 'sasjs', 'fs'];
+var target = new utils_1.Target({
+    name: 'test',
+    appLoc: '/Public/test/',
+    serverType: utils_1.ServerType.Sasjs
+});
+describe('FSCommand', function () {
+    beforeAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, utils_2.setConstants)()];
+                case 1:
+                    _a.sent();
+                    process.projectDir = __dirname;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    describe('compile', function () {
+        beforeEach(function () {
+            jest
+                .spyOn(FSModule, 'generateCompileProgram')
+                .mockImplementation(function () { return Promise.resolve(''); });
+            process.logger = new utils_1.Logger(utils_1.LogLevel.Off);
+            jest.spyOn(process.logger, 'error');
+        });
+        it('should compile a sas program for creating a copy of local folder on remote server', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var returnCode;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest
+                            .spyOn(FileModule, 'createFile')
+                            .mockImplementation(function () { return Promise.resolve(); });
+                        return [4 /*yield*/, executeCommandWrapper([
+                                'compile',
+                                'localFolder',
+                                '-o',
+                                'compiledProgram'
+                            ])];
+                    case 1:
+                        returnCode = _a.sent();
+                        expect(returnCode).toEqual(command_1.ReturnCode.Success);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should display an error message', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var returnCode;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest
+                            .spyOn(FileModule, 'createFile')
+                            .mockImplementation(function () { return Promise.reject(); });
+                        return [4 /*yield*/, executeCommandWrapper(['compile', 'localFolder'])];
+                    case 1:
+                        returnCode = _a.sent();
+                        expect(returnCode).toEqual(command_1.ReturnCode.InternalError);
+                        expect(process.logger.error).toHaveBeenCalledWith('An error has occurred when creating program file.\n');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('sync', function () {
+        beforeEach(function () {
+            process.logger = new utils_1.Logger(utils_1.LogLevel.Off);
+            jest.spyOn(process.logger, 'info');
+            jest
+                .spyOn(FileModule, 'createFile')
+                .mockImplementation(function () { return Promise.resolve(); });
+            jest
+                .spyOn(configUtils, 'findTargetInConfiguration')
+                .mockImplementation(function () {
+                return Promise.resolve({ target: target, isLocal: true });
+            });
+            jest
+                .spyOn(FSModule, 'generateProgramToGetRemoteHash')
+                .mockImplementation(function () { return Promise.resolve(''); });
+            jest
+                .spyOn(FSModule, 'generateProgramToSyncHashDiff')
+                .mockImplementation(function () { return Promise.resolve(''); });
+            jest
+                .spyOn(executeCodeModule, 'executeCode')
+                .mockImplementation(function () { return Promise.resolve({ log: '' }); });
+            jest.spyOn(FSModule, 'getHash').mockImplementation(function () {
+                return Promise.resolve({
+                    absolutePath: '',
+                    relativePath: '',
+                    hash: '',
+                    isFile: false,
+                    members: []
+                });
+            });
+            jest.spyOn(FSModule, 'compareHashes').mockImplementation(function () { return ({
+                absolutePath: '',
+                relativePath: '',
+                hash: '',
+                isFile: false,
+                members: []
+            }); });
+        });
+        it('should sync a local folder with folder on remote server', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var returnCode;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest
+                            .spyOn(extractHashArrayModule, 'extractHashArray')
+                            .mockImplementationOnce(function () { return [
+                            {
+                                FILE_PATH: 'mocked-file',
+                                FILE_HASH: 'hashOfMockedFile'
+                            }
+                        ]; });
+                        jest
+                            .spyOn(extractHashArrayModule, 'extractHashArray')
+                            .mockImplementationOnce(function () { return [
+                            {
+                                FILE_PATH: 'synced-file',
+                                FILE_HASH: 'hashOfSyncedFile'
+                            }
+                        ]; });
+                        return [4 /*yield*/, executeCommandWrapper([
+                                'sync',
+                                'localFolder',
+                                'remoteFolder'
+                            ])];
+                    case 1:
+                        returnCode = _a.sent();
+                        expect(returnCode).toEqual(command_1.ReturnCode.Success);
+                        expect(process.logger.info).toHaveBeenCalledWith('generating program to get remote hash');
+                        expect(process.logger.info).toHaveBeenCalledWith('executing program to get remote hash');
+                        expect(process.logger.info).toHaveBeenCalledWith('extracting hashes from log');
+                        expect(process.logger.info).toHaveBeenCalledWith('creating the hash of local folder');
+                        expect(process.logger.info).toHaveBeenCalledWith('Extract differences from local and remote hash');
+                        expect(process.logger.info).toHaveBeenCalledWith('generating program to sync differences');
+                        expect(process.logger.info).toHaveBeenCalledWith('executing program to sync differences');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should not execute sync program when local and remote folders are already in sync', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var returnCode;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest
+                            .spyOn(extractHashArrayModule, 'extractHashArray')
+                            .mockImplementation(function () { return [
+                            {
+                                FILE_PATH: 'mocked-file',
+                                FILE_HASH: 'hashOfMockedFile'
+                            }
+                        ]; });
+                        jest.spyOn(FSModule, 'getHash').mockImplementation(function () {
+                            return Promise.resolve({
+                                absolutePath: '',
+                                relativePath: FileModule.getRelativePath('remoteFolder', 'mocked-file'),
+                                hash: 'hashOfMockedFile',
+                                isFile: true,
+                                members: []
+                            });
+                        });
+                        return [4 /*yield*/, executeCommandWrapper([
+                                'sync',
+                                'localFolder',
+                                'remoteFolder'
+                            ])];
+                    case 1:
+                        returnCode = _a.sent();
+                        expect(returnCode).toEqual(command_1.ReturnCode.Success);
+                        expect(process.logger.info).toHaveBeenCalledWith('There are no differences between Remote and Local directory. Already synced.');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('invalid subCommand', function () {
+        it('should return ReturnCode.InvalidCommand when subCommand is unknown', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var returnCode;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, executeCommandWrapper(['subCommand'])];
+                    case 1:
+                        returnCode = _a.sent();
+                        expect(returnCode).toEqual(command_1.ReturnCode.InvalidCommand);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});
+var executeCommandWrapper = function (additionalParams) { return __awaiter(void 0, void 0, void 0, function () {
+    var args, command;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                args = __spreadArray(__spreadArray([], __read(defaultArgs), false), __read(additionalParams), false);
+                command = new fsCommand_1.FSCommand(args);
+                return [4 /*yield*/, command.execute()];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };

package/build/commands/help/help.js

@@ -246,6 +246,20 @@ function printHelpText() {
                         "[2spaces]command example: sasjs folder move /Public/sourceFolder /Public/targetFolder --target targetName"
                     ]
                 },
+                {
+                    name: 'fs',
+                    title: 'fs <command>',
+                    description: [
+                        "Handles operations around file system synchronisation.",
+                        "* ".concat(chalk_1.default.cyanBright('sync'), " - Synchronise the remote SAS file system with the local project folder according to the target 'syncDirectories' array."),
+                        "[2spaces]command example: sasjs fs sync /Public/localFolder /Public/remoteFolder",
+                        "",
+                        "* ".concat(chalk_1.default.cyanBright('compile'), " - Compiles a SAS program with the contents of a local directory."),
+                        "[2spaces]command example: sasjs fs compile /Public/folder --output ./outputProgram",
+                        "",
+                        "[2spaces]NOTE: If output flag (-o or --output) is not provided, output will be stored in './fs-compile/{timestamp}' directory relative to working directory."
+                    ]
+                },
                 {
                     name: 'job',
                     title: 'job <command>',

package/build/commands/job/internal/execute/sas9.d.ts

@@ -9,6 +9,6 @@ import SASjs from '@sasjs/adapter/node';
  * @param {string | undefined} source - An optional path to a JSON file containing input macro variables.
  */
 export declare function executeJobSas9(sasjs: SASjs, config: {
-    username: string;
+    userName: string;
     password: string;
 }, jobPath: string, logFile?: string, output?: string, source?: string): Promise<any>;

package/build/commands/job/internal/execute/sasjs.d.ts

@@ -1,6 +1,5 @@
-import SASjs from '@sasjs/adapter/node';
-import { AuthConfig } from '@sasjs/utils';
-export declare function executeJobSasjs(sasjs: SASjs, jobPath: string, logFile?: string, output?: string, authConfig?: AuthConfig): Promise<{
+import { Target } from '@sasjs/utils';
+export declare function executeJobSasjs(target: Target, jobPath: string, logFile?: string, output?: string): Promise<{
     result: any;
     log: any;
-} | undefined>;
+}>;

package/build/commands/job/internal/execute/sasjs.js

@@ -37,31 +37,47 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeJobSasjs = void 0;
-var utils_1 = require("../utils");
-function executeJobSasjs(sasjs, jobPath, logFile, output, authConfig) {
+var node_1 = require("@sasjs/adapter/node");
+var utils_1 = require("../../../../utils");
+var utils_2 = require("../utils");
+function executeJobSasjs(target, jobPath, logFile, output) {
+    var _a;
     return __awaiter(this, void 0, void 0, function () {
-        var response;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, sasjs.executeJobSASjs({
-                        _program: jobPath
-                    }, authConfig)];
+        var authConfig, _b, sasjsApiClient, response;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, (0, utils_1.isSasJsServerInServerMode)(target)];
                 case 1:
-                    response = _a.sent();
-                    if (!response) return [3 /*break*/, 5];
-                    process.logger.success('Job executed successfully!');
-                    if (!(!!logFile && response.log)) return [3 /*break*/, 3];
-                    return [4 /*yield*/, (0, utils_1.saveLog)(response.log, logFile, jobPath, false)];
+                    if (!(_c.sent())) return [3 /*break*/, 3];
+                    return [4 /*yield*/, (0, utils_1.getAuthConfig)(target)];
                 case 2:
-                    _a.sent();
-                    _a.label = 3;
+                    _b = _c.sent();
+                    return [3 /*break*/, 4];
                 case 3:
-                    if (!(!!output && response.result)) return [3 /*break*/, 5];
-                    return [4 /*yield*/, (0, utils_1.saveOutput)(response.result, output, false)];
+                    _b = undefined;
+                    _c.label = 4;
                 case 4:
-                    _a.sent();
-                    _a.label = 5;
-                case 5: return [2 /*return*/, response];
+                    authConfig = _b;
+                    sasjsApiClient = new node_1.SASjsApiClient(new node_1.SasjsRequestClient(target.serverUrl, target.httpsAgentOptions));
+                    return [4 /*yield*/, sasjsApiClient.executeJob({
+                            _program: jobPath
+                        }, target.appLoc, authConfig)];
+                case 5:
+                    response = _c.sent();
+                    if (!response) return [3 /*break*/, 9];
+                    (_a = process.logger) === null || _a === void 0 ? void 0 : _a.success('Job executed successfully!');
+                    if (!(!!logFile && response.log)) return [3 /*break*/, 7];
+                    return [4 /*yield*/, (0, utils_2.saveLog)(response.log, logFile, jobPath, false)];
+                case 6:
+                    _c.sent();
+                    _c.label = 7;
+                case 7:
+                    if (!(!!output && response.result)) return [3 /*break*/, 9];
+                    return [4 /*yield*/, (0, utils_2.saveOutput)(response.result, output, false)];
+                case 8:
+                    _c.sent();
+                    _c.label = 9;
+                case 9: return [2 /*return*/, response];
             }
         });
     });

package/build/commands/job/jobCommand.d.ts

@@ -1,15 +1,11 @@
-import SASjs from '@sasjs/adapter/node';
-import { AuthConfig, Target } from '@sasjs/utils';
+import { Target } from '@sasjs/utils';
 import { ReturnCode } from '../../types/command';
 import { TargetCommand } from '../../types/command/targetCommand';
 export declare class JobCommand extends TargetCommand {
     private jobSubCommands;
     constructor(args: string[]);
     execute(): Promise<ReturnCode>;
-    executeJobSasjs(sasjs: SASjs, target: Target, authConfig: AuthConfig | undefined): Promise<ReturnCode>;
-    executeJobSas9(sasjs: SASjs, target: Target, config: {
-        username: string;
-        password: string;
-    }): Promise<ReturnCode>;
-    executeJobViya(target: Target, sasjs: SASjs, authConfig: AuthConfig): Promise<ReturnCode>;
+    executeJobSasjs(target: Target): Promise<ReturnCode>;
+    executeJobSas9(target: Target): Promise<ReturnCode>;
+    executeJobViya(target: Target): Promise<ReturnCode>;
 }