@sasjs/cli 4.18.2 → 4.18.3

package/build/utils/setConstants.js

@@ -69,13 +69,17 @@ var setConstants = function (isLocal, target, configuration) {
                     buildDestinationDocsFolder = path_1.default.join(buildDestinationFolder, 'docs');
                     macroCorePath = (_a = process.env.macroCorePath) !== null && _a !== void 0 ? _a : '';
                     if (!(macroCorePath === '')) return [3 /*break*/, 2];
-                    return [4 /*yield*/, (0, utils_1.getNodeModulePath)('@sasjs/core')];
+                    return [4 /*yield*/, (0, utils_1.getNodeModulePath)('@sasjs/core', process.projectDir)];
                 case 1:
-                    // If no environment variable is set/populated then check for an installed
-                    // @sasjs/core in locations known to node.
                     macroCorePath = _b.sent();
                     _b.label = 2;
                 case 2:
+                    if (!(macroCorePath === '')) return [3 /*break*/, 4];
+                    return [4 /*yield*/, (0, utils_1.getNodeModulePath)('@sasjs/core')];
+                case 3:
+                    macroCorePath = _b.sent();
+                    _b.label = 4;
+                case 4:
                     buildDestinationResultsFolder = (0, utils_2.getAbsolutePath)(buildResultsFolder, isLocal ? process.projectDir : homeDir);
                     buildDestinationResultsLogsFolder = path_1.default.join(buildDestinationResultsFolder, 'logs');
                     sas9CredentialsError = 'The following attributes were not found:' +

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

@@ -179,7 +179,7 @@ describe('setConstants', function () {
             }
         });
     }); });
-    test('should call getNodeModulePath once when environment variable macroCorePath is undefined', function () { return __awaiter(void 0, void 0, void 0, function () {
+    test('should look up @sasjs/core scoped to process.projectDir, then fall back unscoped, when environment variable macroCorePath is undefined', function () { return __awaiter(void 0, void 0, void 0, function () {
         var getNodeModulePathSpy;
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -187,18 +187,20 @@ describe('setConstants', function () {
                     process.env.macroCorePath = undefined;
                     getNodeModulePathSpy = jest
                         .spyOn(utils, 'getNodeModulePath')
-                        .mockImplementation(function (packageName) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        .mockImplementation(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
                         return [2 /*return*/, Promise.resolve('')];
                     }); }); });
                     return [4 /*yield*/, (0, setConstants_1.setConstants)()];
                 case 1:
                     _a.sent();
-                    expect(getNodeModulePathSpy).toHaveBeenCalledOnceWith('@sasjs/core');
+                    expect(getNodeModulePathSpy).toHaveBeenNthCalledWith(1, '@sasjs/core', process.projectDir);
+                    expect(getNodeModulePathSpy).toHaveBeenNthCalledWith(2, '@sasjs/core');
+                    expect(getNodeModulePathSpy).toHaveBeenCalledTimes(2);
                     return [2 /*return*/];
             }
         });
     }); });
-    test('should call getNodeModulePath once when environment variable macroCorePath is blank', function () { return __awaiter(void 0, void 0, void 0, function () {
+    test('should look up @sasjs/core scoped to process.projectDir, then fall back unscoped, when environment variable macroCorePath is blank', function () { return __awaiter(void 0, void 0, void 0, function () {
         var getNodeModulePathSpy;
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -206,13 +208,15 @@ describe('setConstants', function () {
                     process.env.macroCorePath = '';
                     getNodeModulePathSpy = jest
                         .spyOn(utils, 'getNodeModulePath')
-                        .mockImplementation(function (packageName) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        .mockImplementation(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
                         return [2 /*return*/, Promise.resolve('')];
                     }); }); });
                     return [4 /*yield*/, (0, setConstants_1.setConstants)()];
                 case 1:
                     _a.sent();
-                    expect(getNodeModulePathSpy).toHaveBeenCalledOnceWith('@sasjs/core');
+                    expect(getNodeModulePathSpy).toHaveBeenNthCalledWith(1, '@sasjs/core', process.projectDir);
+                    expect(getNodeModulePathSpy).toHaveBeenNthCalledWith(2, '@sasjs/core');
+                    expect(getNodeModulePathSpy).toHaveBeenCalledTimes(2);
                     return [2 /*return*/];
             }
         });
@@ -236,6 +240,54 @@ describe('setConstants', function () {
             }
         });
     }); });
+    test('should prefer @sasjs/core resolved relative to process.projectDir over the CLI-relative fallback', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var projectCorePath, getNodeModulePathSpy;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    process.env.macroCorePath = undefined;
+                    projectCorePath = path_1.default.join('some', 'project', 'node_modules', '@sasjs', 'core');
+                    getNodeModulePathSpy = jest
+                        .spyOn(utils, 'getNodeModulePath')
+                        .mockImplementation(function (_packageName, fromDir) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, Promise.resolve(fromDir ? projectCorePath : 'cli-relative-core-path')];
+                    }); }); });
+                    return [4 /*yield*/, (0, setConstants_1.setConstants)()
+                        // found on the first, project-scoped lookup - the unscoped fallback
+                        // should never be reached
+                    ];
+                case 1:
+                    _a.sent();
+                    // found on the first, project-scoped lookup - the unscoped fallback
+                    // should never be reached
+                    expect(getNodeModulePathSpy).toHaveBeenCalledTimes(1);
+                    expect(process.sasjsConstants.macroCorePath).toEqual(projectCorePath);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('should fall back to the CLI-relative @sasjs/core when the project has none installed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var fallbackCorePath, getNodeModulePathSpy;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    process.env.macroCorePath = undefined;
+                    fallbackCorePath = path_1.default.join('cli', 'node_modules', '@sasjs', 'core');
+                    getNodeModulePathSpy = jest
+                        .spyOn(utils, 'getNodeModulePath')
+                        .mockImplementation(function (_packageName, fromDir) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, Promise.resolve(fromDir ? '' : fallbackCorePath)];
+                    }); }); });
+                    return [4 /*yield*/, (0, setConstants_1.setConstants)()];
+                case 1:
+                    _a.sent();
+                    expect(getNodeModulePathSpy).toHaveBeenNthCalledWith(1, '@sasjs/core', process.projectDir);
+                    expect(getNodeModulePathSpy).toHaveBeenNthCalledWith(2, '@sasjs/core');
+                    expect(process.sasjsConstants.macroCorePath).toEqual(fallbackCorePath);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });
 var verifySasjsConstants = function (appFolder, hasSasjsCore, isLocal) {
     if (hasSasjsCore === void 0) { hasSasjsCore = false; }

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

@@ -493,6 +493,48 @@ describe('utils', function () {
                 }
             });
         }); });
+        it('should prefer a module installed under the given fromDir over default resolution', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var fakeModuleName, fromDir, fakeModuleDir, resolvedPath;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fakeModuleName = "sasjs-test-fake-module-".concat((0, utils_2.generateTimestamp)());
+                        fromDir = path_1.default.join(require('os').tmpdir(), "getNodeModulePath-".concat((0, utils_2.generateTimestamp)()));
+                        fakeModuleDir = path_1.default.join(fromDir, 'node_modules', fakeModuleName);
+                        return [4 /*yield*/, (0, utils_2.createFolder)(fakeModuleDir)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, (0, utils_2.createFile)(path_1.default.join(fakeModuleDir, 'package.json'), JSON.stringify({ name: fakeModuleName, version: '1.0.0' }))
+                            // not resolvable at all without fromDir - it only exists in fromDir's
+                            // own node_modules, nowhere on the default resolution path
+                        ];
+                    case 2:
+                        _a.sent();
+                        // not resolvable at all without fromDir - it only exists in fromDir's
+                        // own node_modules, nowhere on the default resolution path
+                        return [4 /*yield*/, expect((0, utils_1.getNodeModulePath)(fakeModuleName)).resolves.toEqual('')];
+                    case 3:
+                        // not resolvable at all without fromDir - it only exists in fromDir's
+                        // own node_modules, nowhere on the default resolution path
+                        _a.sent();
+                        return [4 /*yield*/, (0, utils_1.getNodeModulePath)(fakeModuleName, fromDir)
+                            // compare tails rather than exact paths: require.resolve returns the
+                            // real (symlink-resolved) path, which can differ from os.tmpdir()'s
+                            // raw value (e.g. /var vs /private/var on macOS)
+                        ];
+                    case 4:
+                        resolvedPath = _a.sent();
+                        // compare tails rather than exact paths: require.resolve returns the
+                        // real (symlink-resolved) path, which can differ from os.tmpdir()'s
+                        // raw value (e.g. /var vs /private/var on macOS)
+                        expect(resolvedPath.endsWith(path_1.default.join('node_modules', fakeModuleName))).toEqual(true);
+                        return [4 /*yield*/, (0, utils_2.deleteFolder)(fromDir)];
+                    case 5:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
     describe('getUniqServicesObj', function () {
         it('should return an empty object when services is falsy', function () {

package/build/utils/utils.d.ts

@@ -42,5 +42,23 @@ export declare const terminateProcess: (status: number) => never;
  * @returns boolean
  */
 export declare const isSASjsProject: () => Promise<boolean>;
-export declare const getNodeModulePath: (module: string) => Promise<string>;
+/**
+ * Locates an installed npm module and returns its root folder.
+ *
+ * Without `fromDir`, `require.resolve` searches relative to *this file's own*
+ * location on disk - i.e. wherever @sasjs/cli itself is installed - not the
+ * user's project. That's fine for CLI-internal dependencies, but wrong for
+ * anything the user is expected to manage in their own project's
+ * node_modules (e.g. @sasjs/core): since @sasjs/cli also depends on that
+ * same package, default resolution finds the CLI's own bundled copy first
+ * and never reaches the project's. Passing `fromDir` anchors the search at
+ * that directory instead (Node's `paths` option replaces, rather than
+ * extends, the default resolution paths), so callers that need
+ * project-first resolution should pass `process.projectDir` and fall back to
+ * an unscoped call if that returns nothing.
+ * @param {string} module - the name of the npm module to locate.
+ * @param {string} fromDir - optional directory to resolve `module` from,
+ * instead of this file's own location.
+ */
+export declare const getNodeModulePath: (module: string, fromDir?: string) => Promise<string>;
 export declare const isSasJsServerInServerMode: (target: Target) => Promise<boolean>;

package/build/utils/utils.js

@@ -699,12 +699,30 @@ var isSASjsProject = function () { return __awaiter(void 0, void 0, void 0, func
     });
 }); };
 exports.isSASjsProject = isSASjsProject;
-var getNodeModulePath = function (module) { return __awaiter(void 0, void 0, void 0, function () {
+/**
+ * Locates an installed npm module and returns its root folder.
+ *
+ * Without `fromDir`, `require.resolve` searches relative to *this file's own*
+ * location on disk - i.e. wherever @sasjs/cli itself is installed - not the
+ * user's project. That's fine for CLI-internal dependencies, but wrong for
+ * anything the user is expected to manage in their own project's
+ * node_modules (e.g. @sasjs/core): since @sasjs/cli also depends on that
+ * same package, default resolution finds the CLI's own bundled copy first
+ * and never reaches the project's. Passing `fromDir` anchors the search at
+ * that directory instead (Node's `paths` option replaces, rather than
+ * extends, the default resolution paths), so callers that need
+ * project-first resolution should pass `process.projectDir` and fall back to
+ * an unscoped call if that returns nothing.
+ * @param {string} module - the name of the npm module to locate.
+ * @param {string} fromDir - optional directory to resolve `module` from,
+ * instead of this file's own location.
+ */
+var getNodeModulePath = function (module, fromDir) { return __awaiter(void 0, void 0, void 0, function () {
     var nodePackagePath;
     return __generator(this, function (_a) {
         // Look for ${module}/package.json, then return only the path
         try {
-            nodePackagePath = path_1.default.dirname(require.resolve(path_1.default.join(module, 'package.json')));
+            nodePackagePath = path_1.default.dirname(require.resolve(path_1.default.join(module, 'package.json'), fromDir ? { paths: [fromDir] } : undefined));
             if (nodePackagePath)
                 return [2 /*return*/, nodePackagePath];
         }

package/package.json

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