@sasjs/cli 6.4.2 → 6.4.3

package/build/commands/help/help.js

@@ -52,7 +52,8 @@ function printHelpText() {
                     description: [
                         "Creates the 'sasjs' folder and doxy subfolder (with content files + configuration) for docs",
                         "- Inserted in the current working directory.",
-                        "- If an existing NPM project, package.json is updated with the @sasjs/core dependency."
+                        "- If an existing NPM project, package.json is updated with the @sasjs/core dependency.",
+                        "- Aborts without changing anything if this folder already contains sasjs/sasjsconfig.json."
                     ]
                 },
                 {

package/build/commands/init/init.d.ts

@@ -1,7 +1,22 @@
+export declare class AlreadyInitialisedError extends Error {
+    constructor(message: string);
+}
 export declare function init(): Promise<void>;
+/**
+ * Creates the macro folder that the generated `macroFolders` points at.
+ * `sasjs compile` fails with ENOENT when that folder is absent, so an
+ * initialised project compiles before the user has written a macro.
+ * The folder carries a `.gitkeep` because git does not track empty directories -
+ * without it the folder disappears on clone and compilation breaks again.
+ * @param {string} parentFolderName- the name of the project folder.
+ */
+export declare const createMacroFolder: (parentFolderName: string) => Promise<void>;
 /**
  * Creates a SASjs configuration file.
  * Its name will be of the form 'sasjsconfig.json'
+ * The target's `serverUrl` is empty rather than a placeholder URL: an empty
+ * value reads as "not configured yet", while any non-empty placeholder has to
+ * pass URL validation every time the config is read.
  * @param {string} parentFolderName- the name of the project folder.
  */
 export declare const createConfigFile: (parentFolderName: string) => Promise<void>;

package/build/commands/init/init.js

@@ -1,4 +1,19 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 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) {
@@ -39,49 +54,104 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConfigFile = void 0;
+exports.createConfigFile = exports.createMacroFolder = exports.AlreadyInitialisedError = void 0;
 exports.init = init;
 var path_1 = __importDefault(require("path"));
 var utils_1 = require("../../utils/utils");
 var utils_2 = require("@sasjs/utils");
 var createLintConfigFile_1 = require("../shared/createLintConfigFile");
+var AlreadyInitialisedError = /** @class */ (function (_super) {
+    __extends(AlreadyInitialisedError, _super);
+    function AlreadyInitialisedError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.name = 'AlreadyInitialisedError';
+        // The build targets ES5, where extending a built-in does not repair the
+        // prototype chain - without this, `instanceof` is false at runtime.
+        Object.setPrototypeOf(_this, AlreadyInitialisedError.prototype);
+        return _this;
+    }
+    return AlreadyInitialisedError;
+}(Error));
+exports.AlreadyInitialisedError = AlreadyInitialisedError;
 function init() {
     return __awaiter(this, void 0, void 0, function () {
-        var parentFolderName, lintConfigPath;
+        var parentFolderName, existingConfigPath, lintConfigPath;
         var _a;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
                     (_a = process.logger) === null || _a === void 0 ? void 0 : _a.info('Initialising SASjs...');
                     parentFolderName = '.';
-                    return [4 /*yield*/, (0, utils_1.setupNpmProject)(parentFolderName)];
+                    existingConfigPath = path_1.default.join(process.projectDir, parentFolderName, 'sasjs', 'sasjsconfig.json');
+                    return [4 /*yield*/, (0, utils_2.fileExists)(existingConfigPath)];
                 case 1:
+                    if (_b.sent()) {
+                        throw new AlreadyInitialisedError('This folder is already a SASjs project (sasjs/sasjsconfig.json exists). Aborting without making changes.');
+                    }
+                    return [4 /*yield*/, (0, utils_1.setupNpmProject)(parentFolderName)];
+                case 2:
                     _b.sent();
                     return [4 /*yield*/, (0, utils_1.setupGitIgnore)(parentFolderName)];
-                case 2:
+                case 3:
                     _b.sent();
                     return [4 /*yield*/, (0, utils_1.setupDoxygen)(parentFolderName)];
-                case 3:
+                case 4:
                     _b.sent();
                     return [4 /*yield*/, (0, exports.createConfigFile)(parentFolderName)];
-                case 4:
+                case 5:
+                    _b.sent();
+                    return [4 /*yield*/, (0, exports.createMacroFolder)(parentFolderName)];
+                case 6:
                     _b.sent();
                     lintConfigPath = path_1.default.join(process.projectDir, parentFolderName, '.sasjslint');
                     return [4 /*yield*/, (0, utils_2.fileExists)(lintConfigPath)];
-                case 5:
-                    if (!!(_b.sent())) return [3 /*break*/, 7];
+                case 7:
+                    if (!!(_b.sent())) return [3 /*break*/, 9];
                     return [4 /*yield*/, (0, createLintConfigFile_1.createLintConfigFile)(parentFolderName)];
-                case 6:
+                case 8:
                     _b.sent();
-                    _b.label = 7;
-                case 7: return [2 /*return*/];
+                    _b.label = 9;
+                case 9: return [2 /*return*/];
             }
         });
     });
 }
+/**
+ * Creates the macro folder that the generated `macroFolders` points at.
+ * `sasjs compile` fails with ENOENT when that folder is absent, so an
+ * initialised project compiles before the user has written a macro.
+ * The folder carries a `.gitkeep` because git does not track empty directories -
+ * without it the folder disappears on clone and compilation breaks again.
+ * @param {string} parentFolderName- the name of the project folder.
+ */
+var createMacroFolder = function (parentFolderName) { return __awaiter(void 0, void 0, void 0, function () {
+    var macroFolderPath, gitKeepPath;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                macroFolderPath = path_1.default.join(process.projectDir, parentFolderName, 'sasjs', 'macros');
+                return [4 /*yield*/, (0, utils_2.createFolder)(macroFolderPath)];
+            case 1:
+                _a.sent();
+                gitKeepPath = path_1.default.join(macroFolderPath, '.gitkeep');
+                return [4 /*yield*/, (0, utils_2.fileExists)(gitKeepPath)];
+            case 2:
+                if (!!(_a.sent())) return [3 /*break*/, 4];
+                return [4 /*yield*/, (0, utils_2.createFile)(gitKeepPath, '')];
+            case 3:
+                _a.sent();
+                _a.label = 4;
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+exports.createMacroFolder = createMacroFolder;
 /**
  * Creates a SASjs configuration file.
  * Its name will be of the form 'sasjsconfig.json'
+ * The target's `serverUrl` is empty rather than a placeholder URL: an empty
+ * value reads as "not configured yet", while any non-empty placeholder has to
+ * pass URL validation every time the config is read.
  * @param {string} parentFolderName- the name of the project folder.
  */
 var createConfigFile = function (parentFolderName) { return __awaiter(void 0, void 0, void 0, function () {
@@ -97,7 +167,7 @@ var createConfigFile = function (parentFolderName) { return __awaiter(void 0, vo
                         {
                             name: 'mytarget',
                             serverType: 'SASJS',
-                            serverUrl: ' ',
+                            serverUrl: '',
                             appLoc: '/Public/apps/myapp'
                         }
                     ]

package/build/commands/init/initCommand.js

@@ -85,8 +85,15 @@ var InitCommand = /** @class */ (function (_super) {
                             return command_1.ReturnCode.Success;
                         })
                             .catch(function (err) {
-                            var _a;
-                            (_a = process.logger) === null || _a === void 0 ? void 0 : _a.error('Error initialising SASjs: ', err);
+                            var _a, _b;
+                            // Refusing an already-initialised folder is an expected outcome, not a
+                            // crash: report it on one line, and exit with a code a script can tell
+                            // apart from a genuine failure.
+                            if (err instanceof init_1.AlreadyInitialisedError) {
+                                (_a = process.logger) === null || _a === void 0 ? void 0 : _a.error(err.message);
+                                return command_1.ReturnCode.AlreadyInitialised;
+                            }
+                            (_b = process.logger) === null || _b === void 0 ? void 0 : _b.error('Error initialising SASjs: ', err);
                             return command_1.ReturnCode.InternalError;
                         })];
                     case 1: return [2 /*return*/, _a.sent()];

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/package.json

@@ -123,5 +123,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.4.2"
+  "version": "6.4.3"
 }