@sasjs/cli 4.18.1 → 4.18.2

package/build/commands/compile/internal/compileTestFile.d.ts

@@ -1,5 +1,23 @@
 import { CompileTree, Target } from '@sasjs/utils';
 import { TestFlow } from '../../../types';
+/**
+ * Resolves the relative destination fragment for a compiled test file inside
+ * `sasjsbuild/tests` - either just the file's basename (saveToRoot, used for
+ * testSetUp/testTearDown), or the path fragment following the build
+ * destination folder name (used for service/job test files).
+ *
+ * `filePath` for testSetUp/testTearDown comes straight from a user's
+ * sasjsconfig.json, which conventionally uses forward slashes for
+ * portability - it is not guaranteed to match the current OS's separator.
+ * Splitting on both `/` and `\` (instead of only `path.sep`) means this
+ * works whether the config was authored with POSIX-style paths and the CLI
+ * is running on Windows (`path.sep === '\\'`) or vice versa. Splitting on
+ * `path.sep` alone silently no-ops when the string contains none of that
+ * separator, leaving the whole config path intact and producing a nested
+ * `sasjsbuild/tests/sasjs/tests/testsetup.sas` instead of a flat
+ * `sasjsbuild/tests/testsetup.sas`.
+ */
+export declare const getTestFileDestinationFragment: (filePath: string, buildDestinationFolderName: string | undefined, saveToRoot: boolean) => string;
 export declare function compileTestFile(target: Target, filePath: string, testVar: string | undefined, saveToRoot: boolean | undefined, removeOriginalFile: boolean | undefined, compileTree: CompileTree, destinationPath?: string): Promise<void>;
 export declare function copyTestMacroFiles(folderAbsolutePath: string): Promise<void>;
 export declare const compileTestFlow: (target: Target) => Promise<TestFlow | undefined>;

package/build/commands/compile/internal/compileTestFile.js

@@ -64,7 +64,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileTestFlow = exports.copyTestMacroFiles = exports.compileTestFile = void 0;
+exports.compileTestFlow = exports.copyTestMacroFiles = exports.compileTestFile = exports.getTestFileDestinationFragment = void 0;
 var utils_1 = require("@sasjs/utils");
 var chalk_1 = __importDefault(require("chalk"));
 var path_1 = __importDefault(require("path"));
@@ -73,6 +73,37 @@ var config_1 = require("../../../utils/config");
 var file_1 = require("../../../utils/file");
 var _1 = require("./");
 var getFileName = function (filePath) { return path_1.default.parse(filePath).base; };
+/**
+ * Resolves the relative destination fragment for a compiled test file inside
+ * `sasjsbuild/tests` - either just the file's basename (saveToRoot, used for
+ * testSetUp/testTearDown), or the path fragment following the build
+ * destination folder name (used for service/job test files).
+ *
+ * `filePath` for testSetUp/testTearDown comes straight from a user's
+ * sasjsconfig.json, which conventionally uses forward slashes for
+ * portability - it is not guaranteed to match the current OS's separator.
+ * Splitting on both `/` and `\` (instead of only `path.sep`) means this
+ * works whether the config was authored with POSIX-style paths and the CLI
+ * is running on Windows (`path.sep === '\\'`) or vice versa. Splitting on
+ * `path.sep` alone silently no-ops when the string contains none of that
+ * separator, leaving the whole config path intact and producing a nested
+ * `sasjsbuild/tests/sasjs/tests/testsetup.sas` instead of a flat
+ * `sasjsbuild/tests/testsetup.sas`.
+ */
+var getTestFileDestinationFragment = function (filePath, buildDestinationFolderName, saveToRoot) {
+    var segments = filePath.split(/[\\/]/);
+    var destinationFragment = saveToRoot
+        ? segments.pop() || ''
+        : segments
+            .reduce(function (acc, item, i, arr) {
+            return acc.length
+                ? __spreadArray(__spreadArray([], __read(acc), false), [item], false) : arr[i - 1] === buildDestinationFolderName
+                ? __spreadArray(__spreadArray([], __read(acc), false), [item], false) : acc;
+        }, [])
+            .join(path_1.default.sep);
+    return destinationFragment;
+};
+exports.getTestFileDestinationFragment = getTestFileDestinationFragment;
 function compileTestFile(target, filePath, testVar, saveToRoot, removeOriginalFile, compileTree, destinationPath) {
     if (testVar === void 0) { testVar = ''; }
     if (saveToRoot === void 0) { saveToRoot = true; }
@@ -100,16 +131,7 @@ function compileTestFile(target, filePath, testVar, saveToRoot, removeOriginalFi
                         .pop();
                     destinationPath =
                         destinationPath ||
-                            path_1.default.join(buildDestinationTestFolder, saveToRoot
-                                ? filePath.split(path_1.default.sep).pop() || ''
-                                : filePath
-                                    .split(path_1.default.sep)
-                                    .reduce(function (acc, item, i, arr) {
-                                    return acc.length
-                                        ? __spreadArray(__spreadArray([], __read(acc), false), [item], false) : arr[i - 1] === buildDestinationFolderName
-                                        ? __spreadArray(__spreadArray([], __read(acc), false), [item], false) : acc;
-                                }, [])
-                                    .join(path_1.default.sep));
+                            path_1.default.join(buildDestinationTestFolder, (0, exports.getTestFileDestinationFragment)(filePath, buildDestinationFolderName, saveToRoot));
                     return [4 /*yield*/, (0, utils_1.createFile)(destinationPath, dependencies)];
                 case 4:
                     _d.sent();

package/build/commands/compile/internal/spec/compileTestFile.spec.js

@@ -56,6 +56,31 @@ var test_1 = require("../../../../utils/test");
 var path_1 = __importDefault(require("path"));
 var compile_1 = require("../../compile");
 var chalk_1 = __importDefault(require("chalk"));
+describe('getTestFileDestinationFragment', function () {
+    // sasjsconfig.json testConfig paths (testSetUp/testTearDown) are conventionally
+    // forward-slash, regardless of the OS the CLI is running on - these tests pin
+    // that a Windows-style host separator doesn't break the flattening/reduce logic
+    // when the config value itself uses forward slashes (see PLAN-windows-testsetup-path.md).
+    describe('saveToRoot = true (testSetUp/testTearDown)', function () {
+        it('flattens a forward-slash config path to its basename', function () {
+            expect((0, __1.getTestFileDestinationFragment)('sasjs/tests/testsetup.sas', 'tests', true)).toEqual('testsetup.sas');
+        });
+        it('flattens a backslash (Windows-native) path to its basename', function () {
+            expect((0, __1.getTestFileDestinationFragment)('sasjs\\tests\\testsetup.sas', 'tests', true)).toEqual('testsetup.sas');
+        });
+        it('returns an empty string for a path ending in a separator', function () {
+            expect((0, __1.getTestFileDestinationFragment)('sasjs/tests/', 'tests', true)).toEqual('');
+        });
+    });
+    describe('saveToRoot = false (service/job test files)', function () {
+        it('keeps the path fragment after the build destination folder name, for a forward-slash path', function () {
+            expect((0, __1.getTestFileDestinationFragment)('sasjsbuild/tests/services/admin/random.test.sas', 'tests', false)).toEqual(['services', 'admin', 'random.test.sas'].join(path_1.default.sep));
+        });
+        it('keeps the path fragment after the build destination folder name, for a backslash path', function () {
+            expect((0, __1.getTestFileDestinationFragment)('sasjsbuild\\tests\\services\\admin\\random.test.sas', 'tests', false)).toEqual(['services', 'admin', 'random.test.sas'].join(path_1.default.sep));
+        });
+    });
+});
 describe('compileTestFile', function () {
     var appName = "cli-tests-compile-test-file-".concat((0, utils_1.generateTimestamp)());
     var temp = (0, test_1.generateTestTarget)(appName, '/Public/app', {
@@ -159,6 +184,57 @@ describe('compileTestFile', function () {
                 }
             });
         }); });
+        it('should use default testVar/saveToRoot when omitted', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var compileTree;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, compile_1.compile)(target)];
+                    case 1:
+                        _a.sent();
+                        compileTree = (0, __1.getCompileTree)(target);
+                        return [4 /*yield*/, expect((0, __1.compileTestFile)(target, target.testConfig.testSetUp, undefined, undefined, false, compileTree)).toResolve()];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should prepend a non-empty testVar to the compiled test file', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var compileTree, testVar, compiledTestSetUpPath, compiledContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, compile_1.compile)(target)];
+                    case 1:
+                        _a.sent();
+                        compileTree = (0, __1.getCompileTree)(target);
+                        testVar = '%let some_var=some_value;';
+                        return [4 /*yield*/, (0, __1.compileTestFile)(target, target.testConfig.testSetUp, testVar, true, false, compileTree)];
+                    case 2:
+                        _a.sent();
+                        compiledTestSetUpPath = path_1.default.join(buildPath, 'tests', 'testsetup.sas');
+                        return [4 /*yield*/, (0, utils_1.readFile)(compiledTestSetUpPath)];
+                    case 3:
+                        compiledContent = _a.sent();
+                        expect(compiledContent.indexOf(testVar)).toEqual(0);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should skip copying a macro test file that is already present in the build folder', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var macroFolderAbsolutePath;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, compile_1.compile)(target)];
+                    case 1:
+                        _a.sent();
+                        macroFolderAbsolutePath = path_1.default.join(__dirname, appName, 'sasjs', 'macros');
+                        return [4 /*yield*/, expect((0, __1.copyTestMacroFiles)(macroFolderAbsolutePath)).toResolve()];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
     describe('compileTestFlow', function () {
         it('should compile test flow', function () { return __awaiter(void 0, void 0, void 0, function () {
@@ -198,6 +274,47 @@ describe('compileTestFile', function () {
                 }
             });
         }); });
+        it('should return no tests when the tests folder is empty', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var testsFolderPath, testFlow;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, compile_1.compile)(target)];
+                    case 1:
+                        _a.sent();
+                        testsFolderPath = path_1.default.join(buildPath, 'tests');
+                        return [4 /*yield*/, (0, utils_1.deleteFolder)(testsFolderPath)];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, (0, utils_1.createFolder)(testsFolderPath)];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, (0, __1.compileTestFlow)(target)];
+                    case 4:
+                        testFlow = _a.sent();
+                        expect(testFlow.tests).toEqual([]);
+                        expect(testFlow.testSetUp).toBeUndefined();
+                        expect(testFlow.testTearDown).toBeUndefined();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should not set testSetUp/testTearDown when the configured file is not among the compiled tests', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var targetWithBogusSetup, testFlow;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, compile_1.compile)(target)];
+                    case 1:
+                        _a.sent();
+                        targetWithBogusSetup = new utils_1.Target(__assign(__assign({}, target.toJson()), { testConfig: __assign(__assign({}, target.testConfig), { testSetUp: 'does-not-exist-setup.sas', testTearDown: 'does-not-exist-teardown.sas' }) }));
+                        return [4 /*yield*/, (0, __1.compileTestFlow)(targetWithBogusSetup)];
+                    case 2:
+                        testFlow = _a.sent();
+                        expect(testFlow.testSetUp).toBeUndefined();
+                        expect(testFlow.testTearDown).toBeUndefined();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
         it('should log coverage', function () { return __awaiter(void 0, void 0, void 0, function () {
             var expectedHeader, expectedData;
             return __generator(this, function (_a) {

package/build/commands/create/spec/create.spec.js

@@ -68,10 +68,13 @@ describe('sasjs create', function () {
     afterEach(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_1.deleteFolder)(path_1.default.join(__dirname, 'test-app-create-*'))];
+                case 0:
+                    if (!process.projectDir) return [3 /*break*/, 2];
+                    return [4 /*yield*/, (0, utils_1.deleteFolder)(process.projectDir)];
                 case 1:
                     _a.sent();
-                    return [2 /*return*/];
+                    _a.label = 2;
+                case 2: return [2 /*return*/];
             }
         });
     }); });

package/build/commands/docs/generateDocs.js

@@ -95,7 +95,7 @@ var getDocConfig_1 = require("./internal/getDocConfig");
 function generateDocs(target, config, outDirectory) {
     var _a, _b;
     return __awaiter(this, void 0, void 0, function () {
-        var _c, serverUrl, newOutDirectory, enableLineage, doxyContentFromConfig, _d, macroCoreFolders, macroFolders, programFolders, serviceFolders, jobFolders, combinedFolders, PROJECT_NAME, PROJECT_BRIEF, packageJsonContent, packageJson, e_1, doxyContent, layoutFilePath, LAYOUT_FILE, doxyParams, doxyConfigPath, spinner, pathExists, _e, stderr, code, foldersListForDot;
+        var _c, serverUrl, newOutDirectory, enableLineage, doxyContentFromConfig, _d, macroCoreFolders, macroFolders, programFolders, serviceFolders, jobFolders, combinedFolders, PROJECT_NAME, PROJECT_BRIEF, packageJsonContent, packageJson, e_1, doxyContent, layoutFilePath, LAYOUT_FILE, readMePath, doxyParams, doxyConfigPath, spinner, pathExists, _e, stderr, code, foldersListForDot;
         var _this = this;
         return __generator(this, function (_f) {
             switch (_f.label) {
@@ -153,12 +153,20 @@ function generateDocs(target, config, outDirectory) {
                                         return [2 /*return*/, tmpFilePath];
                                 }
                             });
-                        }); })];
+                        }); })
+                        // Doxygen matches USE_MDFILE_AS_MAINPAGE against the file's path exactly as it
+                        // appears in INPUT - a bare name like "README.md" no longer matches an absolute
+                        // INPUT path on newer Doxygen versions (see doxygen/doxygen#10110), which silently
+                        // drops the README content instead of using it as the main page. Passing the same
+                        // absolute path to both keeps them in sync regardless of Doxygen version.
+                    ];
                 case 5:
                     LAYOUT_FILE = _f.sent();
+                    readMePath = path_1.default.join(doxyContent.path, doxyContent.readMe);
                     doxyParams = setVariableCmd({
                         DOXY_HTML_OUTPUT: newOutDirectory,
-                        DOXY_INPUT: "\"".concat(path_1.default.join(doxyContent.path, doxyContent.readMe), "\" ").concat(combinedFolders),
+                        DOXY_INPUT: "\"".concat(readMePath, "\" ").concat(combinedFolders),
+                        DOXY_MAINPAGE: readMePath,
                         HTML_EXTRA_FILES: "\"".concat(path_1.default.join(doxyContent.path, doxyContent.favIcon), "\""),
                         HTML_EXTRA_STYLESHEET: "\"".concat(path_1.default.join(doxyContent.path, doxyContent.stylesheet), "\""),
                         HTML_FOOTER: path_1.default.join(doxyContent.path, doxyContent.footer),

package/build/commands/docs/spec/generateDocs.spec.js

@@ -51,6 +51,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var path_1 = __importDefault(require("path"));
+var shelljs_1 = __importDefault(require("shelljs"));
 var test_1 = require("../../../utils/test");
 var utils_1 = require("@sasjs/utils");
 var generateDocs_1 = require("../generateDocs");
@@ -454,4 +455,99 @@ describe('sasjs doc', function () {
             }
         });
     }); });
+    it('should throw when no macro/program/service/job folders are configured', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var emptyTarget;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    emptyTarget = new utils_1.Target({
+                        name: 'no-folders',
+                        appLoc: '/Public/test/',
+                        serverType: utils_1.ServerType.SasViya,
+                        docConfig: { displayMacroCore: false }
+                    });
+                    return [4 /*yield*/, expect((0, generateDocs_1.generateDocs)(emptyTarget, {
+                            docConfig: { displayMacroCore: false }
+                        })).rejects.toThrow('Unable to locate folders for generating docs.')];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not toggle the spinner when LOG_LEVEL is Debug', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var originalLogLevel;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    originalLogLevel = process.env.LOG_LEVEL;
+                    process.env.LOG_LEVEL = 'Debug';
+                    return [4 /*yield*/, expect((0, generateDocs_1.generateDocs)(defaultTarget, defaultConfig)).resolves.toEqual({
+                            outDirectory: docOutputDefault
+                        })];
+                case 1:
+                    _a.sent();
+                    process.env.LOG_LEVEL = originalLogLevel;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should fall back to the default project name when package.json has none', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var packageJsonPath, originalPackageJson, packageJson;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    packageJsonPath = path_1.default.join(__dirname, appName, 'package.json');
+                    return [4 /*yield*/, (0, utils_1.readFile)(packageJsonPath)];
+                case 1:
+                    originalPackageJson = _a.sent();
+                    packageJson = JSON.parse(originalPackageJson);
+                    delete packageJson.name;
+                    return [4 /*yield*/, (0, utils_1.createFile)(packageJsonPath, JSON.stringify(packageJson))];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, expect((0, generateDocs_1.generateDocs)(defaultTarget, defaultConfig)).resolves.toEqual({
+                            outDirectory: docOutputDefault
+                        })];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, (0, utils_1.createFile)(packageJsonPath, originalPackageJson)];
+                case 4:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should throw a Doxygen-specific error when the shell command fails with an "error: " stderr', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jest.spyOn(shelljs_1.default, 'exec').mockReturnValueOnce({
+                        code: 1,
+                        stderr: 'error: bad config',
+                        stdout: ''
+                    });
+                    return [4 /*yield*/, expect((0, generateDocs_1.generateDocs)(defaultTarget, defaultConfig)).rejects.toThrow('\nerror: bad config')];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should throw a generic Doxygen-not-installed error for any other shell failure', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jest.spyOn(shelljs_1.default, 'exec').mockReturnValueOnce({
+                        code: 1,
+                        stderr: 'command not found',
+                        stdout: ''
+                    });
+                    return [4 /*yield*/, expect((0, generateDocs_1.generateDocs)(defaultTarget, defaultConfig)).rejects.toThrow("The Doxygen application is not installed or configured.")];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

package/build/commands/init/spec/init.spec.js

@@ -54,10 +54,13 @@ describe('sasjs init', function () {
     afterEach(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_1.deleteFolder)(path_1.default.join(__dirname, 'test-app-init-*'))];
+                case 0:
+                    if (!process.projectDir) return [3 /*break*/, 2];
+                    return [4 /*yield*/, (0, utils_1.deleteFolder)(process.projectDir)];
                 case 1:
                     _a.sent();
-                    return [2 /*return*/];
+                    _a.label = 2;
+                case 2: return [2 /*return*/];
             }
         });
     }); });

package/build/commands/job/spec/jobCommand.spec.js

@@ -392,6 +392,19 @@ describe('JobCommand', function () {
                 }
             });
         }); });
+        it('should log deprecation warning if returnStatusOnly flag is present', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest.spyOn(process.logger, 'warn');
+                        return [4 /*yield*/, executeCommandWrapper([jobPath, '--returnStatusOnly'])];
+                    case 1:
+                        _a.sent();
+                        expect(process.logger.warn).toHaveBeenCalledWith('--returnStatusOnly (-r) flag is deprecated.');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
     describe('for server type sas9', function () {
         beforeEach(function () {
@@ -549,19 +562,6 @@ describe('JobCommand', function () {
             });
         }); });
     });
-    it('should log deprecation warning if returnStatusOnly flag is present', function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    jest.spyOn(process.logger, 'warn');
-                    return [4 /*yield*/, executeCommandWrapper([jobPath, '--returnStatusOnly'])];
-                case 1:
-                    _a.sent();
-                    expect(process.logger.warn).toHaveBeenCalledWith('--returnStatusOnly (-r) flag is deprecated.');
-                    return [2 /*return*/];
-            }
-        });
-    }); });
 });
 var setupMocksForViya = function () {
     jest.resetAllMocks();

package/build/doxy/Doxyfile

@@ -22,7 +22,7 @@ INHERIT_DOCS           = NO
 INLINE_INFO            = NO
 INPUT                  = $(DOXY_INPUT)
 LAYOUT_FILE            = $(LAYOUT_FILE)
-USE_MDFILE_AS_MAINPAGE = README.md
+USE_MDFILE_AS_MAINPAGE = $(DOXY_MAINPAGE)
 MAX_INITIALIZER_LINES  = 0
 PROJECT_NAME           = $(PROJECT_NAME)
 PROJECT_LOGO           = $(PROJECT_LOGO)

package/build/types/command/spec/targetCommand.spec.d.ts

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

package/build/types/command/spec/targetCommand.spec.js

@@ -0,0 +1,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@sasjs/utils");
+var configUtils = __importStar(require("../../../utils/config"));
+var loadEnvVariablesModule = __importStar(require("../../../utils/loadEnvVariables"));
+var test_1 = require("../../../utils/test");
+var targetCommand_1 = require("../targetCommand");
+var returnCode_1 = require("../returnCode");
+describe('TargetCommand.getTargetInfo', function () {
+    beforeEach(function () {
+        process.logger = new utils_1.Logger(utils_1.LogLevel.Off);
+        jest.spyOn(process.logger, 'error');
+    });
+    it('exits with an internal error when target env variables fail to load', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var processExitSpy, command;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    processExitSpy = (0, test_1.mockProcessExit)();
+                    jest
+                        .spyOn(loadEnvVariablesModule, 'loadTargetEnvVariables')
+                        .mockImplementation(function () { return Promise.reject(new Error('env file missing')); });
+                    command = new targetCommand_1.TargetCommand(['node', 'sasjs', 'job'], {
+                        strict: false
+                    });
+                    return [4 /*yield*/, command.getTargetInfo()];
+                case 1:
+                    _a.sent();
+                    expect(process.logger.error).toHaveBeenCalledWith(expect.stringContaining('Error loading environment variables'), expect.any(Error));
+                    expect(processExitSpy).toHaveBeenCalledWith(returnCode_1.ReturnCode.InternalError);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('exits with an internal error when the target cannot be found in configuration', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var processExitSpy, command;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    processExitSpy = (0, test_1.mockProcessExit)();
+                    jest
+                        .spyOn(loadEnvVariablesModule, 'loadTargetEnvVariables')
+                        .mockImplementation(function () { return Promise.resolve(); });
+                    jest
+                        .spyOn(configUtils, 'findTargetInConfiguration')
+                        .mockImplementation(function () { return Promise.reject(new Error('target not found')); });
+                    command = new targetCommand_1.TargetCommand(['node', 'sasjs', 'job'], {
+                        strict: false
+                    });
+                    return [4 /*yield*/, command.getTargetInfo()];
+                case 1:
+                    _a.sent();
+                    expect(process.logger.error).toHaveBeenCalledWith('Error reading target from configuration: ', expect.any(Error));
+                    expect(processExitSpy).toHaveBeenCalledWith(returnCode_1.ReturnCode.InternalError);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/build/utils/spec/utils.spec.js

@@ -52,6 +52,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var utils_1 = require("../utils");
 var test_1 = require("../test");
+var axios_1 = __importDefault(require("axios"));
 var utils_2 = require("@sasjs/utils");
 var node_1 = __importDefault(require("@sasjs/adapter/node"));
 var path_1 = __importDefault(require("path"));
@@ -230,6 +231,27 @@ describe('utils', function () {
                 }
             });
         }); });
+        it('should populate all default rules when an existing .gitignore file is empty', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var gitIgnoreContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, utils_2.createFile)(gitFilePath, '')];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, expect((0, utils_1.setupGitIgnore)(folderPath)).toResolve()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, (0, utils_2.readFile)(gitFilePath)];
+                    case 3:
+                        gitIgnoreContent = _a.sent();
+                        expect(gitIgnoreContent).toEqual('node_modules\nsasjsbuild\nsasjsresults\n.env*\n');
+                        return [4 /*yield*/, (0, utils_2.deleteFile)(gitFilePath)];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
     describe('chunk', function () {
         it('should return an array with only one element that is equal to text itself if text size is less than max length', function () {
@@ -384,4 +406,173 @@ describe('utils', function () {
             });
         }); }, 600000);
     });
+    describe('prefixAppLoc', function () {
+        it('should return null when path is falsy', function () {
+            expect((0, utils_1.prefixAppLoc)('/my/app', '')).toEqual(null);
+        });
+        it('should prepend a leading slash to appLoc if missing', function () {
+            expect((0, utils_1.prefixAppLoc)('my/app', 'program1')).toEqual('/my/app/program1');
+        });
+        it('should keep an already-absolute path unchanged', function () {
+            expect((0, utils_1.prefixAppLoc)('/my/app', '/absolute/path')).toEqual('/absolute/path');
+        });
+        it('should join an array path before prefixing each segment', function () {
+            expect((0, utils_1.prefixAppLoc)('/my/app', ['program1', 'program2'])).toEqual('/my/app/program1 /my/app/program2');
+        });
+    });
+    describe('isSASjsProject', function () {
+        it('should return true when sasjs/sasjsconfig.json exists under projectDir', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var projectDir, originalProjectDir;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        projectDir = path_1.default.join(__dirname, "is-sasjs-project-".concat((0, utils_2.generateTimestamp)()));
+                        originalProjectDir = process.projectDir;
+                        return [4 /*yield*/, (0, utils_2.createFolder)(path_1.default.join(projectDir, 'sasjs'))];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, (0, utils_2.createFile)(path_1.default.join(projectDir, 'sasjs', 'sasjsconfig.json'), '{}')];
+                    case 2:
+                        _a.sent();
+                        process.projectDir = projectDir;
+                        return [4 /*yield*/, expect((0, utils_1.isSASjsProject)()).resolves.toEqual(true)];
+                    case 3:
+                        _a.sent();
+                        process.projectDir = originalProjectDir;
+                        return [4 /*yield*/, (0, utils_2.deleteFolder)(projectDir)];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should return false when no sasjsconfig.json is found in any parent folder', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var projectDir, originalProjectDir;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        projectDir = path_1.default.join(require('os').tmpdir(), "not-a-sasjs-project-".concat((0, utils_2.generateTimestamp)()));
+                        originalProjectDir = process.projectDir;
+                        return [4 /*yield*/, (0, utils_2.createFolder)(projectDir)];
+                    case 1:
+                        _a.sent();
+                        process.projectDir = projectDir;
+                        return [4 /*yield*/, expect((0, utils_1.isSASjsProject)()).resolves.toEqual(false)];
+                    case 2:
+                        _a.sent();
+                        process.projectDir = originalProjectDir;
+                        return [4 /*yield*/, (0, utils_2.deleteFolder)(projectDir)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('getNodeModulePath', function () {
+        it('should return the folder path of an installed module', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var modulePath;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, utils_1.getNodeModulePath)('@sasjs/utils')];
+                    case 1:
+                        modulePath = _a.sent();
+                        expect(modulePath).not.toEqual('');
+                        expect(modulePath.endsWith(path_1.default.join('@sasjs', 'utils'))).toEqual(true);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should return an empty string when the module cannot be found', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, expect((0, utils_1.getNodeModulePath)('sasjs-nonexistent-module-xyz')).resolves.toEqual('')];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('getUniqServicesObj', function () {
+        it('should return an empty object when services is falsy', function () {
+            expect((0, utils_1.getUniqServicesObj)(undefined)).toEqual({});
+        });
+        it('should key services by their basename, keeping the first of any duplicates', function () {
+            expect((0, utils_1.getUniqServicesObj)(['a/b/service1', 'x/service2', 'y/service1'])).toEqual({
+                service1: 'a/b/service1',
+                service2: 'x/service2'
+            });
+        });
+    });
+    describe('convertToSASStatements', function () {
+        it('should convert macroVars to %let statements', function () {
+            expect((0, utils_1.convertToSASStatements)({
+                macroVars: { var1: 'val1', var2: 'val2' }
+            })).toEqual('%let var1=val1;\n%let var2=val2;\n');
+        });
+        it('should return an empty string when there are no macroVars', function () {
+            expect((0, utils_1.convertToSASStatements)({ macroVars: {} })).toEqual('');
+        });
+    });
+    describe('terminateProcess', function () {
+        it('should exit the process with the given status code', function () {
+            var mockExit = (0, test_1.mockProcessExit)();
+            (0, utils_1.terminateProcess)(2);
+            expect(mockExit).toHaveBeenCalledWith(2);
+        });
+    });
+    describe('isSasJsServerInServerMode', function () {
+        var target = new utils_2.Target({
+            name: 'test',
+            appLoc: '/Public/test/',
+            serverType: utils_2.ServerType.Sasjs,
+            serverUrl: 'https://sasjsserver.com'
+        });
+        afterEach(function () {
+            jest.restoreAllMocks();
+        });
+        it('should return true when the server reports server mode', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest
+                            .spyOn(axios_1.default, 'get')
+                            .mockImplementation(function () { return Promise.resolve({ data: { mode: 'server' } }); });
+                        return [4 /*yield*/, expect((0, utils_1.isSasJsServerInServerMode)(target)).resolves.toEqual(true)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should return false when the server does not report server mode', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest
+                            .spyOn(axios_1.default, 'get')
+                            .mockImplementation(function () {
+                            return Promise.resolve({ data: { mode: 'desktop' } });
+                        });
+                        return [4 /*yield*/, expect((0, utils_1.isSasJsServerInServerMode)(target)).resolves.toEqual(false)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should throw when the server info request fails', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest.spyOn(axios_1.default, 'get').mockImplementation(function () { return Promise.reject(); });
+                        return [4 /*yield*/, expect((0, utils_1.isSasJsServerInServerMode)(target)).rejects.toThrow("An error occurred while fetching server info from ".concat(target.serverUrl, "/SASjsApi/info"))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
 });

package/build/utils/utils.js

@@ -182,16 +182,23 @@ function createTemplateApp(folderPath, template) {
         var _this = this;
         return __generator(this, function (_a) {
             return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
-                    var _a, stdout, stderr, code;
+                    var probeFile, _a, stderr, code;
                     return __generator(this, function (_b) {
-                        _a = downloadFile("https://username:password@github.com/sasjs/template_".concat(template), 'response.txt'), stdout = _a.stdout, stderr = _a.stderr, code = _a.code;
-                        if (stderr.includes('404: Not Found') || code) {
-                            return [2 /*return*/, reject(new Error("Template \"".concat(template, "\" is not a SASjs template")))];
+                        switch (_b.label) {
+                            case 0:
+                                probeFile = 'response.txt';
+                                _a = downloadFile("https://username:password@github.com/sasjs/template_".concat(template), probeFile), stderr = _a.stderr, code = _a.code;
+                                return [4 /*yield*/, (0, utils_1.deleteFile)(probeFile).catch(function () { })];
+                            case 1:
+                                _b.sent();
+                                if (stderr.includes('404: Not Found') || code) {
+                                    return [2 /*return*/, reject(new Error("Template \"".concat(template, "\" is not a SASjs template")))];
+                                }
+                                createApp(folderPath, "https://github.com/sasjs/template_".concat(template), 'https://github.com/sasjs/docs', function (err) {
+                                    return reject(new Error(err));
+                                });
+                                return [2 /*return*/, resolve()];
                         }
-                        createApp(folderPath, "https://github.com/sasjs/template_".concat(template), 'https://github.com/sasjs/docs', function (err) {
-                            return reject(new Error(err));
-                        });
-                        return [2 /*return*/, resolve()];
                     });
                 }); })];
         });
@@ -274,14 +281,23 @@ var loadDocsSubmodule = function (docsUrl, folderPath, zipPath) { return __await
 }); };
 function downloadFile(url, filename) {
     if ((0, utils_1.isLinux)()) {
-        return shelljs_1.default.exec("wget ".concat(url), { silent: true });
+        // -O <filename> writes to the given name; without it, wget defaults to the
+        // remote URL's basename, which silently ignores the caller's `filename` and
+        // can leave an unexpectedly-named file behind (e.g. a repo-existence probe
+        // meant to be discarded as `response.txt` instead landing as the repo name).
+        return shelljs_1.default.exec("wget ".concat(url).concat(filename ? ' -O ' + filename : ''), {
+            silent: true
+        });
     }
     else if ((0, utils_1.isWindows)()) {
         // First We set TLS12 & then we invoke request to download file.
         return shelljs_1.default.exec("powershell.exe \"[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; Invoke-WebRequest ".concat(url, " ").concat(filename ? '-O ' + filename : '', "\""), { silent: true });
     }
     else {
-        return shelljs_1.default.exec("curl ".concat(url, " -LO -f"), { silent: true });
+        // -o <filename> writes to the given name; -O (used previously) instead saves
+        // under the remote URL's basename, ignoring `filename` - see the wget comment
+        // above for the same issue.
+        return shelljs_1.default.exec("curl ".concat(url, " -L -f").concat(filename ? ' -o ' + filename : ' -O'), { silent: true });
     }
 }
 function setupNpmProject(folderName) {

package/package.json

@@ -122,5 +122,5 @@
   "overrides": {
     "ws": "8.21.0"
   },
-  "version": "4.18.1"
+  "version": "4.18.2"
 }