@sasjs/cli 6.4.6 → 6.4.7

package/build/commands/help/help.js

@@ -353,7 +353,7 @@ function printHelpText() {
                 { name: 'help', aliases: ['h'] },
                 { name: 'request', aliases: ['rq'] },
                 { name: 'run', aliases: ['r'] },
-                { name: 'version', aliases: ['v'] },
+                { name: 'version', aliases: ['v', '-v', '--version'] },
                 { name: 'web', aliases: ['w'] }
             ];
             outputCommands = "".concat(commands

package/build/commands/version/spec/version.spec.js

@@ -35,17 +35,63 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         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 fs_1 = require("fs");
+var os_1 = require("os");
+var path_1 = __importDefault(require("path"));
 var version_1 = require("../version");
+var writePackage = function (dir, version) {
+    (0, fs_1.mkdirSync)(dir, { recursive: true });
+    (0, fs_1.writeFileSync)(path_1.default.join(dir, 'package.json'), JSON.stringify({ version: version }));
+};
+var tempRoot = function () { return (0, fs_1.mkdtempSync)(path_1.default.join((0, os_1.tmpdir)(), 'sasjs-version-')); };
+var packageRoot = function () { return path_1.default.join(tempRoot(), 'node_modules', '@sasjs', 'cli'); };
 describe('printVersion', function () {
-    it('should return sasjs version', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('reports the package that is running, with no global install involved', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var message;
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, expect((0, version_1.printVersion)()).toResolve()];
+                case 0: return [4 /*yield*/, (0, version_1.printVersion)()];
                 case 1:
-                    _a.sent();
+                    message = _a.sent();
+                    expect(message).toContain(path_1.default.resolve(__dirname, '../../../..'));
+                    expect(message).toMatch(/^You are using (SASjs CLI v|a linked version)/);
                     return [2 /*return*/];
             }
         });
     }); });
 });
+describe('versionMessage', function () {
+    it('reports an installed version', function () {
+        var root = packageRoot();
+        writePackage(root, '6.4.6');
+        expect((0, version_1.versionMessage)(root)).toEqual('You are using SASjs CLI v6.4.6');
+    });
+    it('reports a source checkout as a linked version', function () {
+        var root = path_1.default.join(tempRoot(), 'cli');
+        writePackage(root, '6.4.7-alpha.1');
+        expect((0, version_1.versionMessage)(root)).toEqual("You are using a linked version of SASjs CLI (v6.4.7-alpha.1) running from sources at ".concat(root));
+    });
+    it('leaves the version out of a source checkout that has none', function () {
+        var root = path_1.default.join(tempRoot(), 'cli');
+        writePackage(root, undefined);
+        expect((0, version_1.versionMessage)(root)).toEqual("You are using a linked version of SASjs CLI running from sources at ".concat(root));
+    });
+    it('reports the whole version string, not a fragment of it', function () {
+        var root = packageRoot();
+        writePackage(root, '1.2.3-beta.4');
+        expect((0, version_1.versionMessage)(root)).toEqual('You are using SASjs CLI v1.2.3-beta.4');
+    });
+    it('throws an actionable error when the package.json is missing', function () {
+        var root = packageRoot();
+        expect(function () { return (0, version_1.versionMessage)(root); }).toThrow(/Unable to read the CLI version from/);
+    });
+    it('throws when an installed package carries no version', function () {
+        var root = packageRoot();
+        writePackage(root, undefined);
+        expect(function () { return (0, version_1.versionMessage)(root); }).toThrow(/has no version in its package.json/);
+    });
+});

package/build/commands/version/version.d.ts

@@ -1 +1,14 @@
+/**
+ * The message `sasjs version` prints for a given package root.
+ *
+ * Reads the version from the package.json of the package that is running, so
+ * it works for every install shape - global, project-local, `npx`, a temp
+ * prefix, or embedded as a dependency. A package root outside a
+ * `node_modules` folder is a source checkout (an `npm link`, or a local
+ * build), and is reported as such; a source checkout carries no version until
+ * semantic-release writes one, so the version is left out when it is absent.
+ *
+ * @param packageRoot - the folder holding the package.json of the running CLI.
+ */
+export declare const versionMessage: (packageRoot: string) => string;
 export declare function printVersion(): Promise<string>;

package/build/commands/version/version.js

@@ -35,22 +35,55 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         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 });
+exports.versionMessage = void 0;
 exports.printVersion = printVersion;
-var shell_1 = require("../../utils/shell");
+var fs_1 = require("fs");
+var path_1 = __importDefault(require("path"));
+/**
+ * The message `sasjs version` prints for a given package root.
+ *
+ * Reads the version from the package.json of the package that is running, so
+ * it works for every install shape - global, project-local, `npx`, a temp
+ * prefix, or embedded as a dependency. A package root outside a
+ * `node_modules` folder is a source checkout (an `npm link`, or a local
+ * build), and is reported as such; a source checkout carries no version until
+ * semantic-release writes one, so the version is left out when it is absent.
+ *
+ * @param packageRoot - the folder holding the package.json of the running CLI.
+ */
+var versionMessage = function (packageRoot) {
+    var version;
+    try {
+        version = JSON.parse((0, fs_1.readFileSync)(path_1.default.join(packageRoot, 'package.json'), 'utf8')).version;
+    }
+    catch (err) {
+        throw new Error("Unable to read the CLI version from ".concat(packageRoot, ": ").concat(err, ". ") +
+            "Reinstall the CLI - 'npm i -g @sasjs/cli@latest'.");
+    }
+    var fromSources = !packageRoot.split(path_1.default.sep).includes('node_modules');
+    if (fromSources) {
+        return version
+            ? "You are using a linked version of SASjs CLI (v".concat(version, ") running from sources at ").concat(packageRoot)
+            : "You are using a linked version of SASjs CLI running from sources at ".concat(packageRoot);
+    }
+    if (!version) {
+        throw new Error("The installed CLI at ".concat(packageRoot, " has no version in its package.json. ") +
+            "Reinstall it - 'npm i -g @sasjs/cli@latest'.");
+    }
+    return "You are using SASjs CLI v".concat(version);
+};
+exports.versionMessage = versionMessage;
 function printVersion() {
     return __awaiter(this, void 0, void 0, function () {
-        var stdout, line, version, message;
+        var packageRoot, message;
         var _a;
         return __generator(this, function (_b) {
-            stdout = (0, shell_1.exec)("npm list -g @sasjs/cli", { silent: true }).stdout;
-            line = stdout.split('\n').find(function (l) { return l.includes('@sasjs/cli'); }) || '';
-            version = line.split('@')[2].trim();
-            message = version.includes('->')
-                ? "You are using a linked version of SASjs CLI running from sources at ".concat(version
-                    .replace('->', '')
-                    .trim())
-                : "You are using SASjs CLI v".concat(version);
+            packageRoot = path_1.default.resolve(__dirname, '../../..');
+            message = (0, exports.versionMessage)(packageRoot);
             (_a = process.logger) === null || _a === void 0 ? void 0 : _a.info(message);
             return [2 /*return*/, message];
         });

package/build/types/command/commandAliases.js

@@ -12,7 +12,7 @@ exports.aliasMap = new Map([
     ['help', ['h']],
     ['request', ['rq']],
     ['run', ['r']],
-    ['version', ['v']],
+    ['version', ['v', '-v', '--version']],
     ['web', ['w']]
 ]);
 var getAllSupportedAliases = function () { return exports.aliasMap.keys(); };

package/build/types/command/parse.d.ts

@@ -1,2 +1,8 @@
 import { CommandBase } from './commandBase';
+/**
+ * Rewrites a version flag in the command position to the `version` command.
+ *
+ * @param args - the process arguments, as `[node, sasjs, ...]`.
+ */
+export declare const normaliseArgs: (args: string[]) => string[];
 export declare const parse: (args: string[]) => CommandBase;

package/build/types/command/parse.js

@@ -1,15 +1,57 @@
 "use strict";
+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 });
-exports.parse = void 0;
+exports.parse = exports.normaliseArgs = void 0;
 var getBaseCommand_1 = require("../../utils/getBaseCommand");
 var commandFactory_1 = require("./commandFactory");
+// `sasjs version`, `sasjs v`, `sasjs -v` and `sasjs --version` all mean the
+// same thing. yargs reads a leading `-v`/`--version` as an option rather than
+// a command, and its own version handling is switched off, so the token is
+// rewritten to the command name before dispatch.
+var versionFlags = ['-v', '--version'];
+/**
+ * Rewrites a version flag in the command position to the `version` command.
+ *
+ * @param args - the process arguments, as `[node, sasjs, ...]`.
+ */
+var normaliseArgs = function (args) {
+    var _a = __read(args, 3), command = _a[2];
+    return versionFlags.includes(command)
+        ? __spreadArray(__spreadArray(__spreadArray([], __read(args.slice(0, 2)), false), ['version'], false), __read(args.slice(3)), false) : args;
+};
+exports.normaliseArgs = normaliseArgs;
 var parse = function (args) {
     var _a;
-    var baseCommand = (0, getBaseCommand_1.getBaseCommand)(args);
+    var commandArgs = (0, exports.normaliseArgs)(args);
+    var baseCommand = (0, getBaseCommand_1.getBaseCommand)(commandArgs);
     if (!Array.from(commandFactory_1.commandFactory.keys()).includes(baseCommand.name)) {
         (_a = process.logger) === null || _a === void 0 ? void 0 : _a.error('Invalid SASjs command! Run `sasjs help` for a full list of available commands.');
         process.exit(1);
     }
-    return commandFactory_1.commandFactory.get(baseCommand.name)(args);
+    return commandFactory_1.commandFactory.get(baseCommand.name)(commandArgs);
 };
 exports.parse = parse;

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

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

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var versionCommand_1 = require("../../../commands/version/versionCommand");
+var parse_1 = require("../parse");
+describe('parse', function () {
+    it.each(['version', 'v', '-v', '--version'])('resolves `sasjs %s` to the version command', function (token) {
+        var command = (0, parse_1.parse)(['node', 'sasjs', token]);
+        expect(command).toBeInstanceOf(versionCommand_1.VersionCommand);
+        expect(command.name).toEqual('version');
+    });
+    it('leaves another command as it is', function () {
+        var command = (0, parse_1.parse)(['node', 'sasjs', 'help']);
+        expect(command.name).toEqual('help');
+    });
+});
+describe('normaliseArgs', function () {
+    it.each(['-v', '--version'])('rewrites %s in the command position', function (flag) {
+        expect((0, parse_1.normaliseArgs)(['node', 'sasjs', flag])).toEqual([
+            'node',
+            'sasjs',
+            'version'
+        ]);
+    });
+    it('keeps the arguments that follow the flag', function () {
+        expect((0, parse_1.normaliseArgs)(['node', 'sasjs', '--version', 'extra'])).toEqual([
+            'node',
+            'sasjs',
+            'version',
+            'extra'
+        ]);
+    });
+    it('does not rewrite a flag that is not in the command position', function () {
+        var args = ['node', 'sasjs', 'run', 'program.sas', '-v'];
+        expect((0, parse_1.normaliseArgs)(args)).toEqual(args);
+    });
+    it('leaves the command name alone', function () {
+        var args = ['node', 'sasjs', 'version'];
+        expect((0, parse_1.normaliseArgs)(args)).toEqual(args);
+    });
+});

package/package.json

@@ -123,5 +123,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.4.6"
+  "version": "6.4.7"
 }