@sasjs/cli 6.19.4 → 6.21.0

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

@@ -125,8 +125,11 @@
     xhr.dispatchEvent(new ProgressEvent('loadend'))
   }
 
+  // `/api` is the short spelling of the API and `/SASjsApi` the canonical one:
+  // the build bridges both, so a caller that uses either reaches the mock.
   const isSasjs = (url) =>
-    typeof url === 'string' && url.indexOf('/SASjsApi/') >= 0
+    typeof url === 'string' &&
+    (url.indexOf('/SASjsApi/') >= 0 || url.indexOf('/api/') >= 0)
 
   const proto = XMLHttpRequest.prototype
   const nativeOpen = proto.open

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

@@ -327,6 +327,15 @@ const RUNTIME = new BrowserRuntime()
  */
 const BASE = (self.location.pathname || '').replace(/\/sw\.js.*$/, '')
 
+/**
+ * The short spelling of the App Stream landing page.
+ *
+ * It is the default: the interface links to `/app`, and sasjs/server serves it
+ * there while keeping `/AppStream` as a redirect. The worker mirrors that, so a
+ * link the interface builds reaches the same page on the static demo.
+ */
+const SHORT_APP_STREAM_PATH = '/app'
+
 const withoutBase = (pathname) =>
   BASE && pathname.startsWith(BASE)
     ? pathname.slice(BASE.length) || '/'
@@ -889,6 +898,11 @@ const contentsResponse = (answer, path) => {
 
 const routeRequest = async (request, url) => {
   const path = withoutBase(url.pathname).replace(/\/+$/, '') || '/'
+  // `/api` is the short spelling of the API, and `/SASjsApi` the canonical one:
+  // both are answered, so the alias is stripped once here and everything below -
+  // the route lookup, the drive routes' plain-text refusals, the log - works
+  // from one path.
+  const apiPath = path.replace(/^\/api(?=\/|$)/i, '/SASjsApi')
   const query = {}
   for (const [k, v] of url.searchParams.entries()) query[k] = v
 
@@ -901,27 +915,31 @@ const routeRequest = async (request, url) => {
     // every visit. Unanswered, those requests reach the static host and the page
     // parses this site's index.html as JSON.
     //
-    // The answers mirror the server's, because a caller cannot tell the two
-    // hosts apart otherwise: `/AppStream` redirects to `/AppStream/`, the landing
-    // page is served, and only a name under it is missing. The listing is empty
-    // rather than read from `registry()`, which records this deployment's own
-    // folder so the delete route has something to remove: the stream really does
-    // serve nothing at `/AppStream/<name>/` here, and a listing that named it
-    // would offer a tile that 404s.
-    // `path` has its trailing slashes stripped, and these four answers differ by
-    // exactly that, so they are decided on the request's own pathname - minus
-    // the folder the site is served from, which the four patterns do not name.
+    // `/app` is the spelling the interface links to and the server serves; the
+    // canonical `/AppStream` still answers, because a client built before the
+    // short paths existed asks for it. The answers are the same either way, so
+    // `/AppStream` redirects to `/app` - exactly as the server redirects it -
+    // and the landing page, the listing and the missing-name refusal are decided
+    // on both.
+    //
+    // The listing is empty rather than read from `registry()`, which records this
+    // deployment's own folder so the delete route has something to remove: the
+    // stream really does serve nothing at `/app/<name>/` here, and a listing that
+    // named it would offer a tile that 404s.
+    // `path` has its trailing slashes stripped, and the landing answers differ by
+    // exactly that, so they are decided on the request's own pathname - minus the
+    // folder the site is served from, which the patterns do not name.
     const stream = withoutBase(url.pathname)
 
     if (/^\/AppStream$/i.test(stream))
       return new Response(null, {
         status: 301,
-        headers: { location: `${BASE}/AppStream/` }
+        headers: { location: `${BASE}${SHORT_APP_STREAM_PATH}` }
       })
 
     if (
-      /^\/AppStream\/$/i.test(stream) ||
-      /^\/AppStream\/index\.html$/i.test(stream)
+      /^\/(app|AppStream)\/?$/i.test(stream) ||
+      /^\/(app|AppStream)\/index\.html$/i.test(stream)
     )
       return new Response(
         [
@@ -934,9 +952,10 @@ const routeRequest = async (request, url) => {
         { status: 200, headers: { 'content-type': 'text/html; charset=utf-8' } }
       )
 
-    if (/^\/AppStream\/apps\.json$/i.test(stream)) return json({ apps: [] })
+    if (/^\/(app|AppStream)\/apps\.json$/i.test(stream))
+      return json({ apps: [] })
 
-    if (/^\/AppStream\//i.test(stream)) {
+    if (/^\/(app|AppStream)\//i.test(stream)) {
       return json(
         {
           message:
@@ -948,8 +967,9 @@ const routeRequest = async (request, url) => {
 
     // The package's own matcher, so a route is recognised however its path is
     // cased and its parameters are read the way the document states them.
-    const matched = API.findRoute(request.method, path)
-    if (!matched) return json({ message: 'Not part of the API: ' + path }, 404)
+    const matched = API.findRoute(request.method, apiPath)
+    if (!matched)
+      return json({ message: 'Not part of the API: ' + apiPath }, 404)
 
     const routeId = matched.route.id
     const subject = await subjectOf(request, query)
@@ -1023,7 +1043,7 @@ const routeRequest = async (request, url) => {
     // envelope the other routes already answer with.
     if (API.isApiError(e)) {
       if (e.body !== undefined) return json(e.body, e.status)
-      if (path.includes('/SASjsApi/drive/')) return text(e.message, e.status)
+      if (apiPath.includes('/SASjsApi/drive/')) return text(e.message, e.status)
       return json({ message: e.message }, e.status)
     }
     return json(
@@ -1079,10 +1099,17 @@ self.addEventListener('fetch', (event) => {
   // The host's own paths are answered here, including one the table does not
   // have - falling through to the static host would put the SPA's index.html
   // behind a typo in a caller's URL, or behind a listing an interface parses as
-  // JSON. `/AppStream` is one of those: the package serves app deployments, but
-  // the listing is the server's web route, and an interface that lists apps asks
-  // for it on every visit.
-  if (!/^\/(SASjsApi|SASLogon|AppStream)(\/|$)/i.test(path)) return
+  // JSON. `/app` is one of those: the package serves app deployments, but the
+  // listing is the server's web route, and an interface that lists apps asks for
+  // it on every visit.
+  //
+  // `/api` and `/api/` on their own are the API's documentation page - a file
+  // the build copies into the site - so the worker stays out of the way there
+  // and the static host answers it. Every other `/api/...` is an API call on the
+  // short spelling, which routeRequest canonicalises to `/SASjsApi`.
+  if (/^\/api\/?$/i.test(path)) return
+
+  if (!/^\/(SASjsApi|SASLogon|AppStream|api|app)(\/|$)/i.test(path)) return
   event.respondWith(handle(event.request, url))
 })
 

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

@@ -173,13 +173,34 @@ describe('page-side bridge', function () {
             fetchImpl = jest.fn();
             XHR = loadBridge(fetchImpl).XHR;
             xhr = new XHR();
-            xhr.open('GET', '/api/health');
+            xhr.open('GET', '/health');
             xhr.send();
             expect(xhr.sentWith).toBeUndefined();
             expect(fetchImpl).not.toHaveBeenCalled();
             return [2 /*return*/];
         });
     }); });
+    it('bridges the short API spelling as well as the canonical one', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var fetchImpl, XHR, xhr, _a, url;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    fetchImpl = jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, jsonResponse('{"status":"ok"}')];
+                    }); }); });
+                    XHR = loadBridge(fetchImpl).XHR;
+                    xhr = new XHR();
+                    return [4 /*yield*/, run(xhr, 'GET', '/api/info')];
+                case 1:
+                    _b.sent();
+                    _a = __read(fetchImpl.mock.calls[0], 1), url = _a[0];
+                    expect(url).toBe('/api/info');
+                    expect(xhr.status).toBe(200);
+                    expect(xhr.responseText).toBe('{"status":"ok"}');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('converts a multipart body to JSON and replays the response onto the XHR', function () { return __awaiter(void 0, void 0, void 0, function () {
         var fetchImpl, XHR, form, xhr, _a, init;
         return __generator(this, function (_b) {
@@ -286,7 +307,7 @@ describe('page-side bridge', function () {
         expect(second.XHR.prototype).not.toBe(first.XHR.prototype);
         expect(Object.getPrototypeOf(second.XHR.prototype)).toBe(FakeXHR.prototype);
         var xhr = new second.XHR();
-        xhr.open('GET', '/api/health');
+        xhr.open('GET', '/health');
         xhr.send();
         expect(xhr.nativeSendCount).toBe(1);
     });

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

@@ -35,6 +35,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -51,17 +62,6 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -898,51 +898,59 @@ describe('service worker host', function () {
             });
         }); });
         it('answers every route under the folder the site is published in', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var worker, info, _a, page, folder, stream, landing, apps, _b;
-            var _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var worker, info, _a, page, folder, stream, landing, apps, _b, aliased, _c;
+            var _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         worker = loadWorker('/demo');
-                        worker.runtime.load((_c = {},
-                            _c[drivePath('services/public/getdata.js')] = '_webout = "seeded";',
-                            _c));
+                        worker.runtime.load((_d = {},
+                            _d[drivePath('services/public/getdata.js')] = '_webout = "seeded";',
+                            _d));
                         return [4 /*yield*/, worker.dispatch('/demo/SASjsApi/info')];
                     case 1:
-                        info = _d.sent();
+                        info = _e.sent();
                         expect(info.status).toBe(200);
                         _a = expect;
                         return [4 /*yield*/, info.json()];
                     case 2:
-                        _a.apply(void 0, [(_d.sent()).mode]).toBe('desktop');
+                        _a.apply(void 0, [(_e.sent()).mode]).toBe('desktop');
                         return [4 /*yield*/, worker.dispatch('/demo/')];
                     case 3:
-                        page = _d.sent();
+                        page = _e.sent();
                         expect(page.status).toBe(200);
                         expect(page.headers.get('content-type')).toContain('text/html');
                         return [4 /*yield*/, worker.dispatch('/demo')];
                     case 4:
-                        folder = _d.sent();
+                        folder = _e.sent();
                         expect(folder.status).toBe(200);
                         expect(folder.headers.get('content-type')).toContain('text/html');
                         return [4 /*yield*/, worker.dispatch('/demo/AppStream')];
                     case 5:
-                        stream = _d.sent();
+                        stream = _e.sent();
                         expect(stream.status).toBe(301);
-                        expect(stream.headers.get('location')).toBe('/demo/AppStream/');
-                        return [4 /*yield*/, worker.dispatch('/demo/AppStream/')];
+                        expect(stream.headers.get('location')).toBe('/demo/app');
+                        return [4 /*yield*/, worker.dispatch('/demo/app')];
                     case 6:
-                        landing = _d.sent();
+                        landing = _e.sent();
                         expect(landing.status).toBe(200);
                         expect(landing.headers.get('content-type')).toContain('text/html');
-                        return [4 /*yield*/, worker.dispatch('/demo/AppStream/apps.json')];
+                        return [4 /*yield*/, worker.dispatch('/demo/app/apps.json')];
                     case 7:
-                        apps = _d.sent();
+                        apps = _e.sent();
                         expect(apps.status).toBe(200);
                         _b = expect;
                         return [4 /*yield*/, apps.json()];
                     case 8:
-                        _b.apply(void 0, [_d.sent()]).toEqual({ apps: [] });
+                        _b.apply(void 0, [_e.sent()]).toEqual({ apps: [] });
+                        return [4 /*yield*/, worker.dispatch('/demo/api/info')];
+                    case 9:
+                        aliased = _e.sent();
+                        expect(aliased.status).toBe(200);
+                        _c = expect;
+                        return [4 /*yield*/, aliased.json()];
+                    case 10:
+                        _c.apply(void 0, [(_e.sent()).mode]).toBe('desktop');
                         // a path outside the folder is not the site's to answer
                         expect(worker.dispatch('/other/SASjsApi/info')).toBeUndefined();
                         return [2 /*return*/];
@@ -1333,42 +1341,157 @@ describe('service worker host', function () {
             }
         });
     }); });
-    it('answers the app stream as the server does, with nothing in it', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var dispatch, listing, _a, root, landing, _b, app, _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
+    it('answers the app stream on the short path, and the canonical one as an alias', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, _a, _b, path_2, listing, _c, e_1_1, _d, _e, path_3, landing, _f, e_2_1, root, canonicalLanding, _g, _h, _j, path_4, app, _k, e_3_1;
+        var e_1, _l, e_2, _m, e_3, _o;
+        return __generator(this, function (_p) {
+            switch (_p.label) {
                 case 0:
                     dispatch = seeded().dispatch;
-                    return [4 /*yield*/, dispatch('/AppStream/apps.json')];
+                    _p.label = 1;
                 case 1:
-                    listing = _d.sent();
-                    expect(listing.status).toBe(200);
-                    _a = expect;
-                    return [4 /*yield*/, listing.json()];
+                    _p.trys.push([1, 7, 8, 9]);
+                    _a = __values(['/app/apps.json', '/AppStream/apps.json']), _b = _a.next();
+                    _p.label = 2;
                 case 2:
-                    _a.apply(void 0, [_d.sent()]).toEqual({ apps: [] });
-                    return [4 /*yield*/, dispatch('/AppStream')];
+                    if (!!_b.done) return [3 /*break*/, 6];
+                    path_2 = _b.value;
+                    return [4 /*yield*/, dispatch(path_2)];
                 case 3:
-                    root = _d.sent();
-                    expect(root.status).toBe(301);
-                    expect(root.headers.get('location')).toBe('/AppStream/');
-                    return [4 /*yield*/, dispatch('/AppStream/')];
+                    listing = _p.sent();
+                    expect(listing.status).toBe(200);
+                    _c = expect;
+                    return [4 /*yield*/, listing.json()];
                 case 4:
-                    landing = _d.sent();
+                    _c.apply(void 0, [_p.sent()]).toEqual({ apps: [] });
+                    _p.label = 5;
+                case 5:
+                    _b = _a.next();
+                    return [3 /*break*/, 2];
+                case 6: return [3 /*break*/, 9];
+                case 7:
+                    e_1_1 = _p.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 9];
+                case 8:
+                    try {
+                        if (_b && !_b.done && (_l = _a.return)) _l.call(_a);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 9:
+                    _p.trys.push([9, 15, 16, 17]);
+                    _d = __values(['/app', '/app/', '/app/index.html']), _e = _d.next();
+                    _p.label = 10;
+                case 10:
+                    if (!!_e.done) return [3 /*break*/, 14];
+                    path_3 = _e.value;
+                    return [4 /*yield*/, dispatch(path_3)];
+                case 11:
+                    landing = _p.sent();
                     expect(landing.status).toBe(200);
                     expect(landing.headers.get('content-type')).toContain('text/html');
-                    _b = expect;
+                    _f = expect;
                     return [4 /*yield*/, landing.text()];
-                case 5:
-                    _b.apply(void 0, [_d.sent()]).toContain('serves no apps');
-                    return [4 /*yield*/, dispatch('/AppStream/Demo/')];
-                case 6:
-                    app = _d.sent();
+                case 12:
+                    _f.apply(void 0, [_p.sent()]).toContain('serves no apps');
+                    _p.label = 13;
+                case 13:
+                    _e = _d.next();
+                    return [3 /*break*/, 10];
+                case 14: return [3 /*break*/, 17];
+                case 15:
+                    e_2_1 = _p.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 17];
+                case 16:
+                    try {
+                        if (_e && !_e.done && (_m = _d.return)) _m.call(_d);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                    return [7 /*endfinally*/];
+                case 17: return [4 /*yield*/, dispatch('/AppStream')];
+                case 18:
+                    root = _p.sent();
+                    expect(root.status).toBe(301);
+                    expect(root.headers.get('location')).toBe('/app');
+                    return [4 /*yield*/, dispatch('/AppStream/')];
+                case 19:
+                    canonicalLanding = _p.sent();
+                    expect(canonicalLanding.status).toBe(200);
+                    _g = expect;
+                    return [4 /*yield*/, canonicalLanding.text()];
+                case 20:
+                    _g.apply(void 0, [_p.sent()]).toContain('serves no apps');
+                    _p.label = 21;
+                case 21:
+                    _p.trys.push([21, 27, 28, 29]);
+                    _h = __values(['/app/Demo/', '/AppStream/Demo/']), _j = _h.next();
+                    _p.label = 22;
+                case 22:
+                    if (!!_j.done) return [3 /*break*/, 26];
+                    path_4 = _j.value;
+                    return [4 /*yield*/, dispatch(path_4)];
+                case 23:
+                    app = _p.sent();
                     expect(app.status).toBe(404);
-                    _c = expect;
+                    _k = expect;
                     return [4 /*yield*/, app.json()];
-                case 7:
-                    _c.apply(void 0, [(_d.sent()).message]).toContain('serves no apps');
+                case 24:
+                    _k.apply(void 0, [(_p.sent()).message]).toContain('serves no apps');
+                    _p.label = 25;
+                case 25:
+                    _j = _h.next();
+                    return [3 /*break*/, 22];
+                case 26: return [3 /*break*/, 29];
+                case 27:
+                    e_3_1 = _p.sent();
+                    e_3 = { error: e_3_1 };
+                    return [3 /*break*/, 29];
+                case 28:
+                    try {
+                        if (_j && !_j.done && (_o = _h.return)) _o.call(_h);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                    return [7 /*endfinally*/];
+                case 29: return [2 /*return*/];
+            }
+        });
+    }); });
+    it('answers the API on /api as well as on /SASjsApi', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, canonical, short, _a, _b, _c, missing, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    return [4 /*yield*/, dispatch('/SASjsApi/info')];
+                case 1:
+                    canonical = _e.sent();
+                    return [4 /*yield*/, dispatch('/api/info')];
+                case 2:
+                    short = _e.sent();
+                    expect(short.status).toBe(200);
+                    _b = expect;
+                    return [4 /*yield*/, short.json()];
+                case 3:
+                    _c = (_a = _b.apply(void 0, [_e.sent()])).toEqual;
+                    return [4 /*yield*/, canonical.json()];
+                case 4:
+                    _c.apply(_a, [_e.sent()]);
+                    return [4 /*yield*/, dispatch('/api/drive/file?_filePath=' + encodeURIComponent('/missing.txt'))];
+                case 5:
+                    missing = _e.sent();
+                    expect(missing.status).toBe(404);
+                    expect(missing.headers.get('content-type')).toContain('text/plain');
+                    _d = expect;
+                    return [4 /*yield*/, missing.text()];
+                case 6:
+                    _d.apply(void 0, [_e.sent()]).toBe("File doesn't exist.");
+                    // The documentation page is a file the build copies into the site, so the
+                    // worker leaves `/api` and `/api/` to the static host instead of answering
+                    // them as routes.
+                    expect(dispatch('/api')).toBeUndefined();
+                    expect(dispatch('/api/')).toBeUndefined();
                     return [2 /*return*/];
             }
         });
@@ -2223,7 +2346,7 @@ describe('service worker host', function () {
         }); });
     });
     describe('conformance corpus', function () {
-        var e_1, _a;
+        var e_4, _a;
         /**
          * The corpus is what "the same API" means: the cases @sasjs/api runs against
          * its own services, and against a live sasjs/server, run here against this
@@ -2232,7 +2355,7 @@ describe('service worker host', function () {
          * used to have - and it is a test rather than a review.
          */
         var httpFor = function (testCase) {
-            var e_2, _a;
+            var e_5, _a;
             var _b;
             var _c = __read(testCase.route.split(' '), 2), method = _c[0], routePath = _c[1];
             var query = new URLSearchParams();
@@ -2243,12 +2366,12 @@ describe('service worker host', function () {
                         query.set(key, String(value));
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
             finally {
                 try {
                     if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
                 }
-                finally { if (e_2) throw e_2.error; }
+                finally { if (e_5) throw e_5.error; }
             }
             var suffix = query.toString() ? "?".concat(query) : '';
             var init = { method: method };
@@ -2279,8 +2402,8 @@ describe('service worker host', function () {
          * does.
          */
         var seedDrive = function (runtime, testCase) { return __awaiter(void 0, void 0, void 0, function () {
-            var text, _a, _b, _c, file, contents, _d, _e, _f, file, contents, e_3_1;
-            var e_4, _g, e_3, _h;
+            var text, _a, _b, _c, file, contents, _d, _e, _f, file, contents, e_6_1;
+            var e_7, _g, e_6, _h;
             return __generator(this, function (_j) {
                 switch (_j.label) {
                     case 0:
@@ -2292,12 +2415,12 @@ describe('service worker host', function () {
                                     text["/sasjs/drive/files".concat(file)] = contents;
                             }
                         }
-                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        catch (e_7_1) { e_7 = { error: e_7_1 }; }
                         finally {
                             try {
                                 if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
                             }
-                            finally { if (e_4) throw e_4.error; }
+                            finally { if (e_7) throw e_7.error; }
                         }
                         return [4 /*yield*/, runtime.load(text)];
                     case 1:
@@ -2320,14 +2443,14 @@ describe('service worker host', function () {
                         return [3 /*break*/, 3];
                     case 6: return [3 /*break*/, 9];
                     case 7:
-                        e_3_1 = _j.sent();
-                        e_3 = { error: e_3_1 };
+                        e_6_1 = _j.sent();
+                        e_6 = { error: e_6_1 };
                         return [3 /*break*/, 9];
                     case 8:
                         try {
                             if (_e && !_e.done && (_h = _d.return)) _h.call(_d);
                         }
-                        finally { if (e_3) throw e_3.error; }
+                        finally { if (e_6) throw e_6.error; }
                         return [7 /*endfinally*/];
                     case 9: return [2 /*return*/];
                 }
@@ -2395,12 +2518,12 @@ describe('service worker host', function () {
                 _loop_1(testCase);
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
         finally {
             try {
                 if (DRIVE_CORPUS_1_1 && !DRIVE_CORPUS_1_1.done && (_a = DRIVE_CORPUS_1.return)) _a.call(DRIVE_CORPUS_1);
             }
-            finally { if (e_1) throw e_1.error; }
+            finally { if (e_4) throw e_4.error; }
         }
     });
 });

package/build/commands/help/help.js

@@ -323,7 +323,8 @@ function printHelpText() {
                     name: 'lint',
                     title: 'lint',
                     description: [
-                        "Provides the capability to identify, for SAS file, whether there are any ERRORs or WARNINGs present and if so, which line number they are on."
+                        "Provides the capability to identify, for SAS file, whether there are any ERRORs or WARNINGs present and if so, which line number they are on.",
+                        "[2spaces]command example: sasjs lint --fail-on warning"
                     ]
                 },
                 {

package/build/commands/lint/lintCommand.js

@@ -50,6 +50,31 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LintCommand = void 0;
 var initLint_1 = require("./initLint");
@@ -57,15 +82,35 @@ var processLint_1 = require("./processLint");
 var command_1 = require("../../types/command");
 var types_1 = require("../../types");
 var utils_1 = require("../../utils");
+var subCommands = ['init', 'fix', 'find'];
+var failOnValues = ['error', 'warning'];
 var syntax = 'lint <subCommand> [filterStrings..]';
-var usage = 'sasjs lint [ find | fix | init ]';
+var usage = 'sasjs lint [ find | fix | init ] [--fail-on error|warning]';
 var description = "Provides the capability to identify, for SAS file, whether there are any ERRORs or WARNINGs present and if so, which line number they are on.";
+/**
+ * Inserts the default `find` subcommand unless the first argument is already a
+ * subcommand, so `sasjs lint --fail-on warning` and `sasjs lint src/app.sas`
+ * both report rather than fail to parse. The check is made on the arguments
+ * rather than on their number, because an option and its value count as
+ * arguments and used to push the subcommand out of position.
+ */
+var withDefaultSubCommand = function (args) {
+    var firstPositional = args.slice(3).find(function (arg) { return !arg.startsWith('-'); });
+    return firstPositional && subCommands.includes(firstPositional)
+        ? args
+        : __spreadArray(__spreadArray(__spreadArray([], __read(args.slice(0, 3)), false), ['find'], false), __read(args.slice(3)), false);
+};
 var examples = [
     {
         command: 'sasjs lint',
         description: 'Lints all .sas files in the current project.\n' +
             'All the exceptions (along with line / column numbers) will be shown in the console.'
     },
+    {
+        command: 'sasjs lint --fail-on warning',
+        description: 'Lints all .sas files in the current project and fails on a warning as well as an error.\n' +
+            'The same can be set for every run by adding `"default": "error"` to `severityLevel` in `.sasjslint`.'
+    },
     {
         command: 'sasjs lint find mf_a mf_b',
         description: 'Lints all .sas files starting from mf_a or mf_b in the current project.\n' +
@@ -109,23 +154,32 @@ var examples = [
 var LintCommand = /** @class */ (function (_super) {
     __extends(LintCommand, _super);
     function LintCommand(args) {
-        if (args.length < 4) {
-            args.splice(3, 0, 'find');
-        }
-        return _super.call(this, args, {
+        return _super.call(this, withDefaultSubCommand(args), {
             syntax: syntax,
             usage: usage,
             description: description,
-            examples: examples
+            examples: examples,
+            parseOptions: {
+                'fail-on': {
+                    type: 'string',
+                    description: "Lowest severity that fails the command: ".concat(failOnValues.join(', '), ". Defaults to error, so a warning is reported without failing. Applies to the report run, not to lint fix.")
+                }
+            }
         }) || this;
     }
     LintCommand.prototype.execute = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, subCommand, filterStrings;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var _a, subCommand, filterStrings, failOn, failOnSeverity;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
-                        _a = this.parsed, subCommand = _a.subCommand, filterStrings = _a.filterStrings;
+                        _a = this.parsed, subCommand = _a.subCommand, filterStrings = _a.filterStrings, failOn = _a.failOn;
+                        if (failOn !== undefined && !failOnValues.includes(failOn)) {
+                            (0, utils_1.displayError)(new Error("Invalid value for --fail-on: ".concat(failOn, ". Use one of ").concat(failOnValues.join(', '), ".")));
+                            return [2 /*return*/, command_1.ReturnCode.InvalidCommand];
+                        }
+                        failOnSeverity = (_b = failOn) !== null && _b !== void 0 ? _b : 'error';
                         if (!(subCommand === 'init')) return [3 /*break*/, 2];
                         return [4 /*yield*/, (0, initLint_1.initLint)()
                                 .then(function (res) {
@@ -139,7 +193,7 @@ var LintCommand = /** @class */ (function (_super) {
                                 (0, utils_1.displayError)(err, 'An error has occurred whilst initialising SASjs Lint.');
                                 return command_1.ReturnCode.InternalError;
                             })];
-                    case 1: return [2 /*return*/, _b.sent()];
+                    case 1: return [2 /*return*/, _c.sent()];
                     case 2:
                         if (!(subCommand === 'fix')) return [3 /*break*/, 4];
                         return [4 /*yield*/, (0, processLint_1.lintFix)(filterStrings)
@@ -148,13 +202,20 @@ var LintCommand = /** @class */ (function (_super) {
                                 (0, utils_1.displayError)(err, 'An error has occurred while running SASjs Lint Fix.');
                                 return command_1.ReturnCode.LintError;
                             })];
-                    case 3: return [2 /*return*/, _b.sent()];
+                    case 3: return [2 /*return*/, _c.sent()];
                     case 4: return [4 /*yield*/, (0, processLint_1.processLint)(filterStrings)
                             .then(function (result) {
                             if (result.errors) {
                                 (0, utils_1.displayError)('Please fix the identified lint errors.');
                                 return command_1.ReturnCode.LintError;
                             }
+                            if (result.warnings && failOnSeverity === 'warning') {
+                                var count = result.warningCount;
+                                (0, utils_1.displayError)(count === 1
+                                    ? '1 lint warning treated as an error because of --fail-on warning. Please fix it.'
+                                    : "".concat(count, " lint warnings treated as errors because of --fail-on warning. Please fix them."));
+                                return command_1.ReturnCode.LintError;
+                            }
                             if (result.warnings) {
                                 process.logger.warn('Please fix the identified lint warnings.');
                                 return command_1.ReturnCode.Success;
@@ -166,7 +227,7 @@ var LintCommand = /** @class */ (function (_super) {
                             (0, utils_1.displayError)(err, 'An error has occurred when processing lint operation.');
                             return command_1.ReturnCode.InternalError;
                         })];
-                    case 5: return [2 /*return*/, _b.sent()];
+                    case 5: return [2 /*return*/, _c.sent()];
                 }
             });
         });

package/build/commands/lint/processLint.d.ts

@@ -1,6 +1,10 @@
 interface LintResult {
     warnings: boolean;
     errors: boolean;
+    /** Number of WARNING diagnostics found, across every linted file. */
+    warningCount: number;
+    /** Number of ERROR diagnostics found, across every linted file. */
+    errorCount: number;
 }
 /**
  * Fixes lint violations in all .sas files in the current project if no filterArray is provided

package/build/commands/lint/processLint.js

@@ -70,6 +70,12 @@ var path_1 = __importDefault(require("path"));
 var chalk_1 = __importDefault(require("chalk"));
 var lint_1 = require("@sasjs/lint");
 var utils_1 = require("@sasjs/utils");
+/**
+ * `sasjs lint` is documented to work without a `sasjsconfig.json`, and loading
+ * that file is the only thing that sets `process.projectDir` - so a filter
+ * string is resolved against the current directory when no project was loaded.
+ */
+var getProjectDir = function () { return process.projectDir || process.cwd(); };
 /**
  * Fixes lint violations in all .sas files in the current project if no filterArray is provided
  * Otherwise fixes lint violations of only those .sas files which matches filter array
@@ -125,7 +131,7 @@ function lintFix() {
                         .map(function (pattern) { return "(".concat(pattern, ")"); })
                         .join('|');
                     regex_1 = new RegExp(regexPattern);
-                    return [4 /*yield*/, (0, utils_1.listSasFilesInFolder)(process.projectDir, true, [
+                    return [4 /*yield*/, (0, utils_1.listSasFilesInFolder)(getProjectDir(), true, [
                             'node_modules'
                         ])];
                 case 2:
@@ -194,7 +200,12 @@ function processLint() {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    found = { warnings: false, errors: false };
+                    found = {
+                        warnings: false,
+                        errors: false,
+                        warningCount: 0,
+                        errorCount: 0
+                    };
                     sasjsDiagnosticsMap = new Map();
                     if (!filterArray.length) return [3 /*break*/, 5];
                     absoluteFilePaths = filterArray.filter(function (pattern) {
@@ -226,7 +237,7 @@ function processLint() {
                         .map(function (pattern) { return "(".concat(pattern, ")"); })
                         .join('|');
                     regex_2 = new RegExp(regexPattern);
-                    return [4 /*yield*/, (0, utils_1.listSasFilesInFolder)(process.projectDir, true, [
+                    return [4 /*yield*/, (0, utils_1.listSasFilesInFolder)(getProjectDir(), true, [
                             'node_modules'
                         ])];
                 case 2:
@@ -237,7 +248,7 @@ function processLint() {
                             return __generator(this, function (_d) {
                                 switch (_d.label) {
                                     case 0:
-                                        filePath = path_1.default.join(process.projectDir, file);
+                                        filePath = path_1.default.join(getProjectDir(), file);
                                         _b = (_a = sasjsDiagnosticsMap).set;
                                         _c = [filePath];
                                         return [4 /*yield*/, (0, lint_1.lintFile)(filePath)];
@@ -258,12 +269,10 @@ function processLint() {
                     _a.label = 7;
                 case 7:
                     sasjsDiagnosticsMap.forEach(function (sasjsDiagnostics, filePath) {
-                        found.warnings =
-                            found.warnings ||
-                                !!sasjsDiagnostics.find(function (d) { return d.severity === lint_1.Severity.Warning; });
-                        found.errors =
-                            found.errors ||
-                                !!sasjsDiagnostics.find(function (d) { return d.severity === lint_1.Severity.Error; });
+                        found.warningCount += sasjsDiagnostics.filter(function (d) { return d.severity === lint_1.Severity.Warning; }).length;
+                        found.errorCount += sasjsDiagnostics.filter(function (d) { return d.severity === lint_1.Severity.Error; }).length;
+                        found.warnings = found.warnings || found.warningCount > 0;
+                        found.errors = found.errors || found.errorCount > 0;
                         if (sasjsDiagnostics.length) {
                             displayDiagnostics(filePath, sasjsDiagnostics);
                         }

package/build/commands/lint/spec/lintCommand.spec.js

@@ -138,10 +138,13 @@ describe('LintCommand', function () {
             switch (_a.label) {
                 case 0:
                     args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint'], false);
-                    jest
-                        .spyOn(processModule, 'processLint')
-                        .mockImplementation(function () {
-                        return Promise.resolve({ warnings: true, errors: false });
+                    jest.spyOn(processModule, 'processLint').mockImplementation(function () {
+                        return Promise.resolve({
+                            warnings: true,
+                            errors: false,
+                            warningCount: 3,
+                            errorCount: 0
+                        });
                     });
                     command = new lintCommand_1.LintCommand(args);
                     return [4 /*yield*/, command.execute()];
@@ -178,10 +181,13 @@ describe('LintCommand', function () {
             switch (_a.label) {
                 case 0:
                     args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint'], false);
-                    jest
-                        .spyOn(processModule, 'processLint')
-                        .mockImplementation(function () {
-                        return Promise.resolve({ warnings: false, errors: true });
+                    jest.spyOn(processModule, 'processLint').mockImplementation(function () {
+                        return Promise.resolve({
+                            warnings: false,
+                            errors: true,
+                            warningCount: 0,
+                            errorCount: 1
+                        });
                     });
                     command = new lintCommand_1.LintCommand(args);
                     return [4 /*yield*/, command.execute()];
@@ -193,6 +199,111 @@ describe('LintCommand', function () {
             }
         });
     }); });
+    it('should default the subcommand when --fail-on comes before the filter', function () {
+        var args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint', '--fail-on', 'warning', 'appinit'], false);
+        var command = new lintCommand_1.LintCommand(args);
+        expect(command.name).toEqual('lint');
+        expect(command.subCommand).toEqual('find');
+    });
+    it('should default the subcommand when only --fail-on is given', function () {
+        var args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint', '--fail-on=warning'], false);
+        var command = new lintCommand_1.LintCommand(args);
+        expect(command.name).toEqual('lint');
+        expect(command.subCommand).toEqual('find');
+    });
+    it('should keep an explicit subcommand ahead of --fail-on', function () {
+        var args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint', 'find', '--fail-on', 'warning'], false);
+        var command = new lintCommand_1.LintCommand(args);
+        expect(command.subCommand).toEqual('find');
+    });
+    it('should fail on warnings when --fail-on warning is passed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var args, command, returnCode;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint', '--fail-on', 'warning'], false);
+                    jest.spyOn(processModule, 'processLint').mockImplementation(function () {
+                        return Promise.resolve({
+                            warnings: true,
+                            errors: false,
+                            warningCount: 2,
+                            errorCount: 0
+                        });
+                    });
+                    command = new lintCommand_1.LintCommand(args);
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    returnCode = _a.sent();
+                    expect(returnCode).toEqual(command_1.ReturnCode.LintError);
+                    expect(process.logger.error).toHaveBeenCalledWith('', '2 lint warnings treated as errors because of --fail-on warning. Please fix them.');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should word a single warning as one error', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var args, command, returnCode;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint', '--fail-on', 'warning'], false);
+                    jest.spyOn(processModule, 'processLint').mockImplementation(function () {
+                        return Promise.resolve({
+                            warnings: true,
+                            errors: false,
+                            warningCount: 1,
+                            errorCount: 0
+                        });
+                    });
+                    command = new lintCommand_1.LintCommand(args);
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    returnCode = _a.sent();
+                    expect(returnCode).toEqual(command_1.ReturnCode.LintError);
+                    expect(process.logger.error).toHaveBeenCalledWith('', '1 lint warning treated as an error because of --fail-on warning. Please fix it.');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not fail on warnings when --fail-on error is passed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var args, command, returnCode;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint', '--fail-on', 'error'], false);
+                    jest.spyOn(processModule, 'processLint').mockImplementation(function () {
+                        return Promise.resolve({
+                            warnings: true,
+                            errors: false,
+                            warningCount: 2,
+                            errorCount: 0
+                        });
+                    });
+                    command = new lintCommand_1.LintCommand(args);
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    returnCode = _a.sent();
+                    expect(returnCode).toEqual(command_1.ReturnCode.Success);
+                    expect(process.logger.warn).toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should reject an unknown --fail-on value', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var args, command, returnCode;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint', '--fail-on', 'note'], false);
+                    command = new lintCommand_1.LintCommand(args);
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    returnCode = _a.sent();
+                    expect(returnCode).toEqual(command_1.ReturnCode.InvalidCommand);
+                    expect(processModule.processLint).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });
 describe('LintCommand - fix', function () {
     beforeEach(function () {
@@ -295,10 +406,13 @@ var setupMocks = function () {
     jest.resetAllMocks();
     jest.mock('../processLint');
     jest.mock('../initLint');
-    jest
-        .spyOn(processModule, 'processLint')
-        .mockImplementation(function () {
-        return Promise.resolve({ warnings: false, errors: false });
+    jest.spyOn(processModule, 'processLint').mockImplementation(function () {
+        return Promise.resolve({
+            warnings: false,
+            errors: false,
+            warningCount: 0,
+            errorCount: 0
+        });
     });
     jest
         .spyOn(processModule, 'lintFix')

package/build/commands/lint/spec/processLint.spec.d.ts

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

package/build/commands/lint/spec/processLint.spec.js

@@ -0,0 +1,127 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = __importDefault(require("fs"));
+var os_1 = __importDefault(require("os"));
+var path_1 = __importDefault(require("path"));
+var processLint_1 = require("../processLint");
+/**
+ * `sasjs lint` is documented to run without a `sasjsconfig.json`, and loading
+ * that file is the only thing that sets `process.projectDir` - so these cases
+ * run with it empty, the way a project directory without a config does.
+ */
+describe('processLint', function () {
+    var originalCwd = process.cwd();
+    var tmpDir;
+    beforeEach(function () {
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'sasjs-lint-'));
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'trailing.sas'), "%put 'hello';  \n");
+        process.chdir(tmpDir);
+        process.projectDir = '';
+    });
+    afterEach(function () {
+        process.chdir(originalCwd);
+        process.projectDir = '';
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('should resolve a filter string against the current directory when no project is loaded', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, processLint_1.processLint)(['trailing'])];
+                case 1:
+                    result = _a.sent();
+                    expect(result.warnings).toEqual(true);
+                    expect(result.warningCount).toBeGreaterThan(0);
+                    expect(result.errors).toEqual(false);
+                    expect(result.errorCount).toEqual(0);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should still accept an absolute path when no project is loaded', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, processLint_1.processLint)([path_1.default.join(tmpDir, 'trailing.sas')])];
+                case 1:
+                    result = _a.sent();
+                    expect(result.warningCount).toBeGreaterThan(0);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should report no findings when the filter matches nothing', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, processLint_1.processLint)(['no-such-file'])];
+                case 1:
+                    result = _a.sent();
+                    expect(result).toEqual({
+                        warnings: false,
+                        errors: false,
+                        warningCount: 0,
+                        errorCount: 0
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should count errors separately from warnings', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'password.sas'), "%put '{SASENC}';  \n");
+                    return [4 /*yield*/, (0, processLint_1.processLint)(['password'])];
+                case 1:
+                    result = _a.sent();
+                    expect(result.errorCount).toBe(1);
+                    expect(result.errors).toEqual(true);
+                    // The trailing spaces and the missing header are both warnings, so the
+                    // counts stay independent of the error.
+                    expect(result.warningCount).toBeGreaterThanOrEqual(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/package.json

@@ -73,7 +73,7 @@
     "@sasjs/adapter": "5.1.3",
     "@sasjs/api": "0.23.0",
     "@sasjs/core": "6.1.1",
-    "@sasjs/lint": "5.0.1",
+    "@sasjs/lint": "^5.1.0",
     "@sasjs/utils": "4.9.0",
     "axios": "1.20.0",
     "chalk": "4.1.2",
@@ -125,5 +125,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.19.4"
+  "version": "6.21.0"
 }