@sasjs/cli 6.28.0 → 6.30.0

package/build/commands/build/internal/mockSite/assets/sw.js

@@ -946,6 +946,58 @@ const homeService = API.createHomeService(async () => {
   }
 })
 
+/**
+ * The lint rules a SAS file is linted against: the nearest `.sasjslint` at or
+ * above its folder on the drive.
+ *
+ * This is the server's rule, applied here so the demo behaves like the
+ * installation it demonstrates: a folder in the tree carries rules for
+ * everything beneath it, and changing a rule is a plain edit of that file. It
+ * is why the build seeds a `.sasjslint` at the drive root - a file that is
+ * displayed but never read would be worse than absent.
+ *
+ * Paths go through the package's own normaliser, so a backslashed or escaping
+ * path resolves the way the drive routes resolve it rather than by a second set
+ * of string rules that could disagree with them.
+ *
+ * A file that is missing, is not JSON, or parses to something that is not an
+ * object is skipped and the walk continues upwards - a broken rules file must
+ * never break linting or formatting. A walk that reaches the root with nothing
+ * to show returns undefined, which lints against the linter's own defaults: the
+ * answer for a drive with no rules file at all.
+ */
+const LINT_CONFIG_FILE = '.sasjslint'
+
+const lintConfig = async (filePath) => {
+  // A path that escapes the drive has no folder to walk from, and a buffer that
+  // names no file has none either: both take the drive root's rules, which is
+  // what a server answers for each - a refused path there falls back to the
+  // root file rather than to the linter's defaults.
+  let folder = API.dirname(API.normaliseDrivePath(filePath) ?? '/')
+  for (;;) {
+    const configPath =
+      folder === '/' ? `/${LINT_CONFIG_FILE}` : `${folder}/${LINT_CONFIG_FILE}`
+    const contents = await DRIVE_STORE.read(configPath).catch(() => null)
+    const parsed = parseLintConfig(contents)
+    if (parsed) return new CODE.LintConfig(parsed)
+    if (folder === '/') return undefined
+    folder = API.dirname(folder)
+  }
+}
+
+/** A `.sasjslint` as the object a configuration is built from, or null. */
+const parseLintConfig = (contents) => {
+  if (contents === null || contents === undefined) return null
+  const text =
+    typeof contents === 'string' ? contents : new TextDecoder().decode(contents)
+  try {
+    const parsed = JSON.parse(text)
+    return parsed && typeof parsed === 'object' ? parsed : null
+  } catch (e) {
+    return null
+  }
+}
+
 const SERVICES = {
   drive: API.createDriveService(DRIVE_STORE),
   // The package's browser fixture states one run time; this host serves two, and
@@ -970,10 +1022,11 @@ const SERVICES = {
   directory: API.createDirectoryService(IDENTITY_STORE, directorySource),
   appStream: APP_STREAM,
   home: homeService,
-  // the package's own code service over the bundled linter; the host passes no
-  // lint config, so a buffer is linted against the linter's defaults - a mock
-  // has no `.sasjslint` tree to resolve one from
-  code: CODE.createCodeService({})
+  // the package's own code service over the bundled linter, with the drive's
+  // own rules: a buffer is linted and formatted against the nearest
+  // `.sasjslint` at or above its folder, so editing that file changes the
+  // editor here exactly as it does on a server
+  code: CODE.createCodeService({ lintConfig })
 }
 
 /** The routes this host performs itself, because the answer is not JSON. */

package/build/commands/build/internal/mockSite/mockSite.js

@@ -130,10 +130,11 @@ var toPosix = function (value) { return value.split(path_1.default.sep).join('/'
  * configuration by walking a filesystem - but the linter's core (`lintText`,
  * `formatText`) reads only the text it is given and the configuration it is
  * passed, so the two can run anywhere the module graph can be built. This
- * bundle is that graph: the package's own code service, the linter it wraps, and
- * shims for the four node modules reached at import time (`path` and `os` for
- * resolution, `fs` and `@sasjs/utils/file` for the config lookup that a mock
- * never makes, because it hands the linter the default configuration).
+ * bundle is that graph: the package's own code service, the configuration class
+ * a host builds from its own rules file, the linter behind both, and shims for
+ * the four node modules reached at import time (`path` and `os` for resolution,
+ * `fs` and `@sasjs/utils/file` for the linter's own filesystem lookup, which
+ * this host never makes - it hands the routes the rules it read from the drive).
  *
  * It is built from the installed @sasjs/api and @sasjs/lint on every mock
  * build, so the rules a client sees are the version the CLI resolved - a
@@ -142,8 +143,8 @@ var toPosix = function (value) { return value.split(path_1.default.sep).join('/'
 var LINT_BUNDLE_FILES = {
     'entry.js': [
         "import './process.js'",
-        "import { createCodeService } from '@sasjs/api/code'",
-        'globalThis.SASjsCode = { createCodeService }'
+        "import { createCodeService, LintConfig } from '@sasjs/api/code'",
+        'globalThis.SASjsCode = { createCodeService, LintConfig }'
     ].join('\n'),
     'process.js': [
         '// the linter reads process.env for a default and process.cwd() for a root;',

package/build/commands/build/internal/mockSite/spec/mockSite.spec.js

@@ -297,6 +297,7 @@ describe('browser-hosted build', function () {
                     vm.createContext(realm);
                     vm.runInContext(bundle, realm);
                     expect(typeof realm.SASjsCode.createCodeService).toBe('function');
+                    expect(typeof realm.SASjsCode.LintConfig).toBe('function');
                     return [2 /*return*/];
             }
         });

package/build/commands/build/internal/mockSite/spec/sw.spec.js

@@ -1412,6 +1412,285 @@ describe('service worker host', function () {
                 }
             });
         }); });
+        /**
+         * The rules are the drive's, not the linter's defaults.
+         *
+         * The Studio shows a visitor the drive's `.sasjslint` and invites them to
+         * edit it, so a rules file nothing read would be a displayed lie. Each case
+         * below changes a rule and reads the answer back through the route the
+         * editor calls, because "the resolver was passed" is not the claim - "the
+         * squiggle went away" is.
+         */
+        describe('the drive’s .sasjslint', function () {
+            var rootConfig = '/sasjs/drive/files/.sasjslint';
+            /** 81 characters: over the default 80, under the 100 these cases set. */
+            var longLine = 'x'.repeat(81);
+            var code = "data _null_;\n".concat(longLine, "\nrun;\n");
+            var tooLong = function (diagnostics) {
+                return diagnostics.filter(function (diagnostic) {
+                    return String(diagnostic.message).startsWith('Line exceeds maximum length');
+                });
+            };
+            var lint = function (worker, body) { return __awaiter(void 0, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, worker.dispatch('/SASjsApi/code/lint', runRequest(body))];
+                        case 1:
+                            response = _a.sent();
+                            expect(response.status).toBe(200);
+                            return [2 /*return*/, response.json()];
+                    }
+                });
+            }); };
+            it('lints against the rules file at the drive root', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var worker, _a, _b, _c, _d;
+                var _e, _f;
+                return __generator(this, function (_g) {
+                    switch (_g.label) {
+                        case 0:
+                            worker = seeded();
+                            return [4 /*yield*/, worker.runtime.load((_e = {},
+                                    _e[rootConfig] = JSON.stringify({ maxLineLength: 100 }),
+                                    _e[drivePath('program.sas')] = code,
+                                    _e))];
+                        case 1:
+                            _g.sent();
+                            _a = expect;
+                            _b = tooLong;
+                            return [4 /*yield*/, lint(worker, { code: code, filePath: appLoc + '/program.sas' })];
+                        case 2:
+                            _a.apply(void 0, [_b.apply(void 0, [_g.sent()])]).toHaveLength(0);
+                            // the same buffer with the default 80 in place: the finding the rule
+                            // exists to report
+                            return [4 /*yield*/, worker.runtime.load((_f = {},
+                                    _f[rootConfig] = JSON.stringify({ maxLineLength: 80 }),
+                                    _f[drivePath('program.sas')] = code,
+                                    _f))];
+                        case 3:
+                            // the same buffer with the default 80 in place: the finding the rule
+                            // exists to report
+                            _g.sent();
+                            _c = expect;
+                            _d = tooLong;
+                            return [4 /*yield*/, lint(worker, { code: code, filePath: appLoc + '/program.sas' })];
+                        case 4:
+                            _c.apply(void 0, [_d.apply(void 0, [_g.sent()])]).toHaveLength(1);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it('re-reads the rules per request, so an edit takes effect', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var worker, path, _a, _b, form, patched, _c, _d;
+                var _e;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
+                        case 0:
+                            worker = seeded();
+                            path = appLoc + '/program.sas';
+                            return [4 /*yield*/, worker.runtime.load((_e = {},
+                                    _e[rootConfig] = JSON.stringify({ maxLineLength: 80 }),
+                                    _e[drivePath('program.sas')] = code,
+                                    _e))];
+                        case 1:
+                            _f.sent();
+                            _a = expect;
+                            _b = tooLong;
+                            return [4 /*yield*/, lint(worker, { code: code, filePath: path })];
+                        case 2:
+                            _a.apply(void 0, [_b.apply(void 0, [_f.sent()])]).toHaveLength(1);
+                            form = new FormData();
+                            form.set('file', new Blob([JSON.stringify({ maxLineLength: 100 })], {
+                                type: 'application/json'
+                            }), '.sasjslint');
+                            return [4 /*yield*/, worker.dispatch("/SASjsApi/drive/file?_filePath=".concat(encodeURIComponent('/.sasjslint')), { method: 'PATCH', body: form })];
+                        case 3:
+                            patched = _f.sent();
+                            expect(patched.status).toBe(200);
+                            _c = expect;
+                            _d = tooLong;
+                            return [4 /*yield*/, lint(worker, { code: code, filePath: path })];
+                        case 4:
+                            _c.apply(void 0, [_d.apply(void 0, [_f.sent()])]).toHaveLength(0);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it('gives a folder its own rules for everything beneath it', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var worker, _a, _b, _c, _d;
+                var _e;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
+                        case 0:
+                            worker = seeded();
+                            return [4 /*yield*/, worker.runtime.load((_e = {},
+                                    _e[rootConfig] = JSON.stringify({ maxLineLength: 80 }),
+                                    // the nearer file relaxes the rule for this folder alone
+                                    _e["/sasjs/drive/files".concat(appLoc, "/.sasjslint")] = JSON.stringify({
+                                        maxLineLength: 200
+                                    }),
+                                    _e))];
+                        case 1:
+                            _f.sent();
+                            _a = expect;
+                            _b = tooLong;
+                            return [4 /*yield*/, lint(worker, {
+                                    code: code,
+                                    filePath: "".concat(appLoc, "/services/public/program.sas")
+                                })];
+                        case 2:
+                            _a.apply(void 0, [_b.apply(void 0, [_f.sent()])]).toHaveLength(0);
+                            // outside that folder the root file still applies
+                            _c = expect;
+                            _d = tooLong;
+                            return [4 /*yield*/, lint(worker, {
+                                    code: code,
+                                    filePath: '/home/sasjsadmin/program.sas'
+                                })];
+                        case 3:
+                            // outside that folder the root file still applies
+                            _c.apply(void 0, [_d.apply(void 0, [_f.sent()])]).toHaveLength(1);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it('finds the rules for a path spelled the way a Windows client sends it', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var worker, _a, _b;
+                var _c;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            worker = seeded();
+                            return [4 /*yield*/, worker.runtime.load((_c = {},
+                                    _c["/sasjs/drive/files".concat(appLoc, "/.sasjslint")] = JSON.stringify({
+                                        maxLineLength: 100
+                                    }),
+                                    _c))];
+                        case 1:
+                            _d.sent();
+                            _a = expect;
+                            _b = tooLong;
+                            return [4 /*yield*/, lint(worker, {
+                                    code: code,
+                                    filePath: "".concat(appLoc, "\\services\\public\\program.sas")
+                                })];
+                        case 2:
+                            _a.apply(void 0, [_b.apply(void 0, [_d.sent()])]).toHaveLength(0);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it('skips a rules file that does not parse and uses the one above', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var worker, _a, _b;
+                var _c;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            worker = seeded();
+                            return [4 /*yield*/, worker.runtime.load((_c = {},
+                                    _c[rootConfig] = JSON.stringify({ maxLineLength: 100 }),
+                                    _c["/sasjs/drive/files".concat(appLoc, "/.sasjslint")] = '{ this is not json',
+                                    _c))
+                                // a broken near file must not break linting, and must not silently
+                                // replace the rules that were working
+                            ];
+                        case 1:
+                            _d.sent();
+                            // a broken near file must not break linting, and must not silently
+                            // replace the rules that were working
+                            _a = expect;
+                            _b = tooLong;
+                            return [4 /*yield*/, lint(worker, {
+                                    code: code,
+                                    filePath: "".concat(appLoc, "/services/public/program.sas")
+                                })];
+                        case 2:
+                            // a broken near file must not break linting, and must not silently
+                            // replace the rules that were working
+                            _a.apply(void 0, [_b.apply(void 0, [_d.sent()])]).toHaveLength(0);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it('takes the drive root rules for a buffer with no file, and for a path that escapes the drive', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var worker, _a, _b, _c, _d;
+                var _e;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
+                        case 0:
+                            worker = seeded();
+                            return [4 /*yield*/, worker.runtime.load((_e = {},
+                                    _e[rootConfig] = JSON.stringify({ maxLineLength: 100 }),
+                                    _e))];
+                        case 1:
+                            _f.sent();
+                            _a = expect;
+                            _b = tooLong;
+                            return [4 /*yield*/, lint(worker, { code: code })];
+                        case 2:
+                            _a.apply(void 0, [_b.apply(void 0, [_f.sent()])]).toHaveLength(0);
+                            _c = expect;
+                            _d = tooLong;
+                            return [4 /*yield*/, lint(worker, {
+                                    code: code,
+                                    filePath: '../../outside/program.sas'
+                                })];
+                        case 3:
+                            _c.apply(void 0, [_d.apply(void 0, [_f.sent()])]).toHaveLength(0);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it('falls back to the linter defaults when the drive has no rules file', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var worker, _a, _b;
+                var _c;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            worker = seeded();
+                            return [4 /*yield*/, worker.runtime.load((_c = {}, _c[drivePath('program.sas')] = code, _c))];
+                        case 1:
+                            _d.sent();
+                            _a = expect;
+                            _b = tooLong;
+                            return [4 /*yield*/, lint(worker, {
+                                    code: code,
+                                    filePath: "".concat(appLoc, "/program.sas")
+                                })];
+                        case 2:
+                            _a.apply(void 0, [_b.apply(void 0, [_d.sent()])]).toHaveLength(1);
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            it('formats with the rules file too', function () { return __awaiter(void 0, void 0, void 0, function () {
+                var worker, formatted, _a;
+                var _b;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            worker = seeded();
+                            return [4 /*yield*/, worker.runtime.load((_b = {},
+                                    _b[rootConfig] = JSON.stringify({
+                                        hasDoxygenHeader: true,
+                                        defaultHeader: '/**\n  @brief the drive header\n**/'
+                                    }),
+                                    _b))];
+                        case 1:
+                            _c.sent();
+                            return [4 /*yield*/, worker.dispatch('/SASjsApi/code/format', runRequest({ code: code, filePath: '/home/sasjsadmin/program.sas' }))];
+                        case 2:
+                            formatted = _c.sent();
+                            expect(formatted.status).toBe(200);
+                            _a = expect;
+                            return [4 /*yield*/, formatted.text()];
+                        case 3:
+                            _a.apply(void 0, [_c.sent()]).toContain('@brief the drive header');
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        });
         it('keeps an app’s URL and tiles inside the folder the site is served from', function () { return __awaiter(void 0, void 0, void 0, function () {
             var worker, archive, form, published, app, listing, apps, landing, _a, page, _b;
             return __generator(this, function (_c) {

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

@@ -44,11 +44,9 @@ var path_1 = __importDefault(require("path"));
 var test_1 = require("../../../utils/test");
 var utils_1 = require("@sasjs/utils");
 var config_1 = require("../../../utils/config");
-var minimalAppFiles_1 = require("./minimalAppFiles");
-var reactAppFiles_1 = require("./reactAppFiles");
-var angularAppFiles_1 = require("./angularAppFiles");
 var create_1 = require("../create");
 var utils_2 = require("../../../utils");
+var utils_3 = require("../../../utils/utils");
 describe('sasjs create', function () {
     beforeAll(function () {
         dotenv_1.default.config();
@@ -249,28 +247,34 @@ describe('sasjs create', function () {
     }); });
 });
 var verifyCreateWeb = function (appName, appType) { return __awaiter(void 0, void 0, void 0, function () {
-    var fileStructure;
+    var template, docsCandidates, present;
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0:
-                fileStructure = appType === 'minimal'
-                    ? minimalAppFiles_1.minimalAppFiles
-                    : appType === 'react'
-                        ? reactAppFiles_1.reactAppFiles
-                        : appType === 'angular'
-                            ? angularAppFiles_1.angularAppFiles
-                            : minimalAppFiles_1.minimalAppFiles;
-                fileStructure.folderName = appName;
-                return [4 /*yield*/, (0, test_1.verifyFolder)(fileStructure)];
+            case 0: return [4 /*yield*/, (0, test_1.getTemplateFileTree)(utils_3.seedAppUrls[appType])];
             case 1:
+                template = _a.sent();
+                template.folderName = appName;
+                return [4 /*yield*/, (0, test_1.verifyFolder)(template)];
+            case 2:
                 _a.sent();
                 return [4 /*yield*/, (0, test_1.verifyPackageJsonContent)(appName)
-                    // A seed app carries its dependencies in the template's package.json, so the
-                    // command create issues for it is a plain install - the same trade as above:
-                    // the stub writes what npm would, and this asserts the CLI asked for it.
+                    // The docs are a submodule fetched after the archive, and the archive carries
+                    // the folder empty - so the derived tree can only assert that the folder is
+                    // there. A create whose docs download silently failed used to pass; assert
+                    // the site itself arrived. Every template gets the docs (create routes all
+                    // three through a create*App that passes the docs URL), and the path differs:
+                    // react keeps them under `public`, the others at the root.
                 ];
-            case 2:
+            case 3:
                 _a.sent();
+                docsCandidates = [
+                    path_1.default.join(process.projectDir, appName, 'public', 'docs', 'index.html'),
+                    path_1.default.join(process.projectDir, appName, 'docs', 'index.html')
+                ];
+                return [4 /*yield*/, Promise.all(docsCandidates.map(function (candidate) { return (0, utils_1.fileExists)(candidate); }))];
+            case 4:
+                present = _a.sent();
+                expect(present.some(Boolean)).toEqual(true);
                 // A seed app carries its dependencies in the template's package.json, so the
                 // command create issues for it is a plain install - the same trade as above:
                 // the stub writes what npm would, and this asserts the CLI asked for it.