@sasjs/cli 6.4.1 → 6.4.3

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

@@ -44,9 +44,11 @@ var path_1 = __importDefault(require("path"));
 var test_1 = require("../../../utils/test");
 var utils_1 = require("@sasjs/utils");
 var initFiles_1 = require("./initFiles");
-var create_1 = require("../../create/create");
 var init_1 = require("../init");
 var utils_2 = require("../../../utils");
+var config_1 = require("../../../utils/config");
+var compile_1 = require("../../compile/compile");
+var create_1 = require("../../create/create");
 describe('sasjs init', function () {
     beforeAll(function () {
         dotenv_1.default.config();
@@ -56,103 +58,290 @@ describe('sasjs init', function () {
             switch (_a.label) {
                 case 0:
                     if (!process.projectDir) return [3 /*break*/, 2];
-                    return [4 /*yield*/, (0, utils_1.deleteFolder)(process.projectDir)];
+                    return [4 /*yield*/, (0, utils_1.deleteFolder)(process.projectDir)
+                        // The compile spec sets these; leaving them set would hand later specs a
+                        // configuration and build folders belonging to a deleted project.
+                    ];
                 case 1:
                     _a.sent();
                     _a.label = 2;
-                case 2: return [2 /*return*/];
+                case 2:
+                    // The compile spec sets these; leaving them set would hand later specs a
+                    // configuration and build folders belonging to a deleted project.
+                    process.currentDir = '';
+                    process.sasjsConfig = undefined;
+                    return [2 /*return*/];
             }
         });
     }); });
-    it('should initialise with default app in the current folder', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var appName;
+    it('should initialise in an empty current folder', function () { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0:
-                    appName = "test-app-init-".concat((0, test_1.generateUniqueTimestamp)());
-                    process.projectDir = path_1.default.join(__dirname, appName);
-                    return [4 /*yield*/, (0, utils_2.setConstants)()];
+                case 0: return [4 /*yield*/, setupProjectFolder('test-app-init-')];
                 case 1:
                     _a.sent();
-                    return [4 /*yield*/, (0, utils_1.createFolder)(process.projectDir)];
+                    return [4 /*yield*/, expect((0, init_1.init)()).toResolve()];
                 case 2:
                     _a.sent();
-                    return [4 /*yield*/, expect((0, create_1.create)('.', '')).toResolve()];
+                    return [4 /*yield*/, verifyInit()];
                 case 3:
                     _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should add SASjs to an existing npm project', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var packageJsonPath, existingPackageJson, packageJson, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, setupProjectFolder('test-app-init-npm-')];
+                case 1:
+                    _c.sent();
+                    packageJsonPath = path_1.default.join(process.projectDir, 'package.json');
+                    existingPackageJson = {
+                        name: 'my-existing-project',
+                        version: '1.0.0',
+                        scripts: { build: 'exit 0' }
+                    };
+                    return [4 /*yield*/, (0, utils_1.createFile)(packageJsonPath, JSON.stringify(existingPackageJson, null, 2))];
+                case 2:
+                    _c.sent();
                     return [4 /*yield*/, expect((0, init_1.init)()).toResolve()];
-                case 4:
-                    _a.sent();
+                case 3:
+                    _c.sent();
                     return [4 /*yield*/, verifyInit()];
+                case 4:
+                    _c.sent();
+                    _b = (_a = JSON).parse;
+                    return [4 /*yield*/, (0, utils_1.readFile)(packageJsonPath)];
                 case 5:
-                    _a.sent();
+                    packageJson = _b.apply(_a, [_c.sent()]);
+                    expect(packageJson.name).toEqual('my-existing-project');
+                    expect(packageJson.scripts.build).toEqual('exit 0');
                     return [2 /*return*/];
             }
         });
     }); });
-    it("should initialise with 'sasonly' app in the current folder", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var appName;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    appName = "test-app-init-sasonly-".concat((0, test_1.generateUniqueTimestamp)());
-                    process.projectDir = path_1.default.join(__dirname, appName);
-                    return [4 /*yield*/, (0, utils_2.setConstants)()];
+    it('should produce a project that compiles straight away', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, target;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, setupProjectFolder('test-app-init-compile-')];
                 case 1:
-                    _a.sent();
-                    return [4 /*yield*/, (0, utils_1.createFolder)(process.projectDir)];
+                    _b.sent();
+                    return [4 /*yield*/, expect((0, init_1.init)()).toResolve()
+                        // Reading the target validates its serverUrl, and compile() reads every
+                        // folder the config names - the two things that stopped a freshly
+                        // initialised project from compiling.
+                        // compile() reads process.sasjsConfig and the build folders, which the CLI
+                        // sets up from its target command - do the same from a test.
+                    ];
                 case 2:
-                    _a.sent();
+                    _b.sent();
+                    // Reading the target validates its serverUrl, and compile() reads every
+                    // folder the config names - the two things that stopped a freshly
+                    // initialised project from compiling.
+                    // compile() reads process.sasjsConfig and the build folders, which the CLI
+                    // sets up from its target command - do the same from a test.
+                    process.currentDir = process.projectDir;
+                    _a = process;
+                    return [4 /*yield*/, (0, config_1.getLocalConfig)()];
+                case 3:
+                    _a.sasjsConfig = _b.sent();
+                    return [4 /*yield*/, (0, utils_2.setConstants)()];
+                case 4:
+                    _b.sent();
+                    return [4 /*yield*/, (0, config_1.findTargetInConfiguration)('mytarget')];
+                case 5:
+                    target = (_b.sent()).target;
+                    return [4 /*yield*/, expect((0, compile_1.compile)(target)).toResolve()];
+                case 6:
+                    _b.sent();
+                    return [4 /*yield*/, expect((0, utils_1.fileExists)(path_1.default.join(process.projectDir, 'sasjsbuild'))).resolves.toEqual(true)];
+                case 7:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should abort over a template scaffold that ships its own config', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var configPath, templateConfig, _a, _b, error, _c, _d, _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0: return [4 /*yield*/, setupProjectFolder('test-app-init-sasonly-')
+                    // The templates carry their own sasjs/sasjsconfig.json, so they reach the
+                    // guard by a different route than createFileStructure does.
+                ];
+                case 1:
+                    _f.sent();
+                    // The templates carry their own sasjs/sasjsconfig.json, so they reach the
+                    // guard by a different route than createFileStructure does.
                     return [4 /*yield*/, expect((0, create_1.create)('.', 'sasonly')).toResolve()];
+                case 2:
+                    // The templates carry their own sasjs/sasjsconfig.json, so they reach the
+                    // guard by a different route than createFileStructure does.
+                    _f.sent();
+                    configPath = path_1.default.join(process.projectDir, 'sasjs', 'sasjsconfig.json');
+                    _b = (_a = JSON).parse;
+                    return [4 /*yield*/, (0, utils_1.readFile)(configPath)];
                 case 3:
-                    _a.sent();
-                    return [4 /*yield*/, expect((0, init_1.init)()).toResolve()];
+                    templateConfig = _b.apply(_a, [_f.sent()]);
+                    return [4 /*yield*/, (0, init_1.init)().catch(function (err) { return err; })];
                 case 4:
-                    _a.sent();
-                    return [4 /*yield*/, verifyInit()];
+                    error = _f.sent();
+                    expect(error).toBeInstanceOf(init_1.AlreadyInitialisedError);
+                    _c = expect;
+                    _e = (_d = JSON).parse;
+                    return [4 /*yield*/, (0, utils_1.readFile)(configPath)];
                 case 5:
-                    _a.sent();
+                    _c.apply(void 0, [_e.apply(_d, [_f.sent()])]).toEqual(templateConfig);
                     return [2 /*return*/];
             }
         });
     }); });
-    it('should initialise in an empty current folder', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var appName;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    appName = "test-app-init-.-".concat((0, test_1.generateUniqueTimestamp)());
-                    process.projectDir = path_1.default.join(__dirname, appName);
-                    return [4 /*yield*/, (0, utils_2.setConstants)()];
+    it('should abort over a project sasjs create has just scaffolded', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var configPath, createdConfig, _a, _b, error, _c, _d, _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0: return [4 /*yield*/, setupProjectFolder('test-app-init-created-')];
                 case 1:
-                    _a.sent();
-                    return [4 /*yield*/, (0, utils_1.createFolder)(process.projectDir)];
+                    _f.sent();
+                    return [4 /*yield*/, expect((0, create_1.create)('.', '')).toResolve()
+                        // create() writes a fuller config than init does, so running init over it
+                        // must not replace that configuration.
+                    ];
                 case 2:
-                    _a.sent();
-                    return [4 /*yield*/, expect((0, init_1.init)()).toResolve()];
+                    _f.sent();
+                    configPath = path_1.default.join(process.projectDir, 'sasjs', 'sasjsconfig.json');
+                    _b = (_a = JSON).parse;
+                    return [4 /*yield*/, (0, utils_1.readFile)(configPath)];
                 case 3:
-                    _a.sent();
-                    return [4 /*yield*/, verifyInit()];
+                    createdConfig = _b.apply(_a, [_f.sent()]);
+                    expect(createdConfig.defaultTarget).not.toEqual('mytarget');
+                    return [4 /*yield*/, (0, init_1.init)().catch(function (err) { return err; })];
                 case 4:
-                    _a.sent();
+                    error = _f.sent();
+                    expect(error).toBeInstanceOf(init_1.AlreadyInitialisedError);
+                    _c = expect;
+                    _e = (_d = JSON).parse;
+                    return [4 /*yield*/, (0, utils_1.readFile)(configPath)];
+                case 5:
+                    _c.apply(void 0, [_e.apply(_d, [_f.sent()])]).toEqual(createdConfig);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should abort without changes when the folder is already a SASjs project', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var sasjsFolderPath, configPath, existingConfig, error, _a, _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, setupProjectFolder('test-app-init-existing-')];
+                case 1:
+                    _d.sent();
+                    sasjsFolderPath = path_1.default.join(process.projectDir, 'sasjs');
+                    configPath = path_1.default.join(sasjsFolderPath, 'sasjsconfig.json');
+                    existingConfig = {
+                        defaultTarget: 'myTarget',
+                        targets: [
+                            {
+                                name: 'myTarget',
+                                serverType: 'SAS9',
+                                serverUrl: 'https://my.server.com',
+                                appLoc: '/User Folders/my app'
+                            }
+                        ]
+                    };
+                    return [4 /*yield*/, (0, utils_1.createFolder)(sasjsFolderPath)];
+                case 2:
+                    _d.sent();
+                    return [4 /*yield*/, (0, utils_1.createFile)(configPath, JSON.stringify(existingConfig, null, 2))];
+                case 3:
+                    _d.sent();
+                    return [4 /*yield*/, (0, init_1.init)().catch(function (err) { return err; })];
+                case 4:
+                    error = _d.sent();
+                    expect(error).toBeInstanceOf(init_1.AlreadyInitialisedError);
+                    expect(error.message).toMatch(/already a SASjs project \(sasjs\/sasjsconfig\.json exists\)/);
+                    // Nothing is written before the abort, so the existing project is untouched.
+                    _a = expect;
+                    _c = (_b = JSON).parse;
+                    return [4 /*yield*/, (0, utils_1.readFile)(configPath)];
+                case 5:
+                    // Nothing is written before the abort, so the existing project is untouched.
+                    _a.apply(void 0, [_c.apply(_b, [_d.sent()])]).toEqual(existingConfig);
+                    return [4 /*yield*/, expect((0, utils_1.fileExists)(path_1.default.join(process.projectDir, 'package.json'))).resolves.toEqual(false)];
+                case 6:
+                    _d.sent();
+                    return [4 /*yield*/, expect((0, utils_1.fileExists)(path_1.default.join(process.projectDir, '.gitignore'))).resolves.toEqual(false)];
+                case 7:
+                    _d.sent();
+                    return [4 /*yield*/, expect((0, utils_1.fileExists)(path_1.default.join(sasjsFolderPath, 'doxy'))).resolves.toEqual(false)];
+                case 8:
+                    _d.sent();
                     return [2 /*return*/];
             }
         });
     }); });
 });
-var verifyInit = function () { return __awaiter(void 0, void 0, void 0, function () {
-    var gitIgnoreFilePath, gitIgnoreContent;
+var setupProjectFolder = function (prefix) { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, (0, test_1.verifyFolder)(initFiles_1.initFiles)];
+            case 0:
+                process.projectDir = path_1.default.join(__dirname, "".concat(prefix).concat((0, test_1.generateUniqueTimestamp)()));
+                return [4 /*yield*/, (0, utils_2.setConstants)()];
             case 1:
                 _a.sent();
+                return [4 /*yield*/, (0, utils_1.createFolder)(process.projectDir)];
+            case 2:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+var verifyInit = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var gitIgnoreFilePath, gitIgnoreContent, configPath, config, _a, _b, macroFolderPath, lintConfigPath, packageJson, _c, _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0: return [4 /*yield*/, (0, test_1.verifyFolder)(initFiles_1.initFiles)];
+            case 1:
+                _e.sent();
                 gitIgnoreFilePath = path_1.default.join(process.projectDir, '.gitignore');
                 return [4 /*yield*/, (0, utils_1.readFile)(gitIgnoreFilePath)];
             case 2:
-                gitIgnoreContent = _a.sent();
+                gitIgnoreContent = _e.sent();
                 expect(gitIgnoreContent.match(/^sasjsbuild/gm).length).toEqual(1);
                 expect(gitIgnoreContent.match(/^node_modules/gm).length).toEqual(1);
+                configPath = path_1.default.join(process.projectDir, 'sasjs', 'sasjsconfig.json');
+                _b = (_a = JSON).parse;
+                return [4 /*yield*/, (0, utils_1.readFile)(configPath)];
+            case 3:
+                config = _b.apply(_a, [_e.sent()]);
+                expect(config.$schema).toEqual('https://cli.sasjs.io/sasjsconfig-schema.json');
+                expect(config.macroFolders).toEqual(['sasjs/macros']);
+                expect(config.defaultTarget).toEqual('mytarget');
+                expect(config.targets.length).toEqual(1);
+                expect(config.targets[0]).toEqual({
+                    name: 'mytarget',
+                    serverType: 'SASJS',
+                    serverUrl: '',
+                    appLoc: '/Public/apps/myapp'
+                });
+                macroFolderPath = path_1.default.join(process.projectDir, 'sasjs', 'macros');
+                return [4 /*yield*/, expect((0, utils_1.fileExists)(macroFolderPath)).resolves.toEqual(true)];
+            case 4:
+                _e.sent();
+                return [4 /*yield*/, expect((0, utils_1.fileExists)(path_1.default.join(macroFolderPath, '.gitkeep'))).resolves.toEqual(true)];
+            case 5:
+                _e.sent();
+                lintConfigPath = path_1.default.join(process.projectDir, '.sasjslint');
+                return [4 /*yield*/, expect((0, utils_1.fileExists)(lintConfigPath)).resolves.toEqual(true)];
+            case 6:
+                _e.sent();
+                _d = (_c = JSON).parse;
+                return [4 /*yield*/, (0, utils_1.readFile)(path_1.default.join(process.projectDir, 'package.json'))];
+            case 7:
+                packageJson = _d.apply(_c, [_e.sent()]);
+                expect(packageJson.dependencies['@sasjs/core']).toBeDefined();
                 return [2 /*return*/];
         }
     });

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

@@ -146,6 +146,28 @@ describe('InitCommand', function () {
             }
         });
     }); });
+    it('should report an already-initialised folder on one line', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var message, args, command, returnCode;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    message = 'This folder is already a SASjs project (sasjs/sasjsconfig.json exists). Aborting without making changes.';
+                    jest
+                        .spyOn(initModule, 'init')
+                        .mockImplementation(function () {
+                        return Promise.reject(new initModule.AlreadyInitialisedError(message));
+                    });
+                    args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['init'], false);
+                    command = new initCommand_1.InitCommand(args);
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    returnCode = _a.sent();
+                    expect(returnCode).toEqual(command_1.ReturnCode.AlreadyInitialised);
+                    expect(process.logger.error).toHaveBeenCalledWith(message);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });
 var setupMocks = function () {
     jest.resetAllMocks();

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

@@ -13,6 +13,11 @@ exports.initFiles = {
             folderName: 'sasjs',
             files: [{ fileName: 'sasjsconfig.json' }],
             subFolders: [
+                {
+                    folderName: 'macros',
+                    files: [{ fileName: '.gitkeep' }],
+                    subFolders: []
+                },
                 {
                     folderName: 'doxy',
                     files: [

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

@@ -2,5 +2,6 @@ export declare enum ReturnCode {
     Success = 0,
     InvalidCommand = 1,
     InternalError = 2,
-    LintError = 3
+    LintError = 3,
+    AlreadyInitialised = 4
 }

package/build/types/command/returnCode.js

@@ -7,4 +7,8 @@ var ReturnCode;
     ReturnCode[ReturnCode["InvalidCommand"] = 1] = "InvalidCommand";
     ReturnCode[ReturnCode["InternalError"] = 2] = "InternalError";
     ReturnCode[ReturnCode["LintError"] = 3] = "LintError";
+    // `init` refusing a folder that is already a SASjs project. Distinct from
+    // InvalidCommand, which also covers unparseable arguments, so a script can
+    // tell a refusal from a bad invocation.
+    ReturnCode[ReturnCode["AlreadyInitialised"] = 4] = "AlreadyInitialised";
 })(ReturnCode || (exports.ReturnCode = ReturnCode = {}));

package/build/utils/spec/config.folders.spec.d.ts

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