@sasjs/cli 6.16.0 → 6.18.0

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

@@ -31,6 +31,31 @@
     if (DEBUG) console.log('[sasjs-mock]', ...args)
   }
 
+  /**
+   * A file's contents, as text or as base64 with a flag.
+   *
+   * An upload is a file, not a string: a PNG, a workbook or an .sas7bdat read
+   * with `text()` arrives as replacement characters, and the drive would store
+   * the damage under a success status. The bytes are decoded as UTF-8 strictly -
+   * if that fails, they are not text by any reading a browser would accept - and
+   * carried as base64, which the worker turns back into the bytes the drive
+   * keeps.
+   */
+  const contentsOf = async (value) => {
+    const bytes = new Uint8Array(await value.arrayBuffer())
+
+    try {
+      return { csv: new TextDecoder('utf-8', { fatal: true }).decode(bytes) }
+    } catch (error) {
+      let binary = ''
+      const chunk = 0x8000
+      for (let i = 0; i < bytes.length; i += chunk)
+        binary += String.fromCharCode.apply(null, bytes.subarray(i, i + chunk))
+
+      return { csv: btoa(binary), binary: true }
+    }
+  }
+
   const readBody = async (body) => {
     const params = {}
     const tables = []
@@ -39,12 +64,16 @@
     if (typeof FormData !== 'undefined' && body instanceof FormData) {
       for (const [key, value] of body.entries()) {
         if (typeof value === 'string') params[key] = value
-        else
+        else {
+          const contents = await contentsOf(value)
+
           tables.push({
             name: key,
             filename: value.name || key + '.csv',
-            csv: await value.text()
+            csv: contents.csv,
+            ...(contents.binary ? { binary: true } : {})
           })
+        }
       }
       return { params, tables }
     }

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

@@ -574,7 +574,15 @@ const readJsonBody = async (request) => {
         name: table.name || `table${index + 1}`,
         filename:
           table.filename || `${table.name || 'table' + (index + 1)}.csv`,
-        contents: table.csv === undefined ? '' : table.csv
+        // A file the bridge could not read as UTF-8 travels as base64 with a
+        // flag: writing its text would replace the bytes and store the damage
+        // under a success status, which is what a binary upload used to do.
+        contents:
+          table.csv === undefined
+            ? ''
+            : table.binary
+              ? toBytes(table.csv)
+              : table.csv
       }))
     }
   }
@@ -859,6 +867,56 @@ const routeRequest = async (request, url) => {
   try {
     await R.ensureReady()
 
+    // The app stream is the server's own web surface rather than part of the
+    // API: the listing, the landing page and the redirect from one to the other
+    // are routes sasjs/server answers, and an interface asks for the listing on
+    // 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.
+    const stream = url.pathname
+
+    if (/^\/AppStream$/i.test(stream))
+      return new Response(null, {
+        status: 301,
+        headers: { location: '/AppStream/' }
+      })
+
+    if (
+      /^\/AppStream\/$/i.test(stream) ||
+      /^\/AppStream\/index\.html$/i.test(stream)
+    )
+      return new Response(
+        [
+          '<!doctype html><html><head><meta charset="utf-8">',
+          '<title>App Stream</title></head><body>',
+          '<h1>SASjs App Stream</h1>',
+          '<p>This browser host serves no apps: nothing is published on a static site.</p>',
+          '</body></html>'
+        ].join(''),
+        { status: 200, headers: { 'content-type': 'text/html; charset=utf-8' } }
+      )
+
+    if (/^\/AppStream\/apps\.json$/i.test(stream)) return json({ apps: [] })
+
+    if (/^\/AppStream\//i.test(stream)) {
+      return json(
+        {
+          message:
+            'This browser host serves no apps: nothing is published on a static site.'
+        },
+        404
+      )
+    }
+
     // 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)
@@ -975,10 +1033,13 @@ self.addEventListener('fetch', (event) => {
     return
   }
 
-  // The API's own paths are answered here, including one the table does not
+  // 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.
-  if (!/^\/(SASjsApi|SASLogon)(\/|$)/i.test(url.pathname)) return
+  // 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(url.pathname)) return
   event.respondWith(handle(event.request, url))
 })
 

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

@@ -472,12 +472,12 @@ var assertSafeOutputFolder = function (outputFolder, projectDir, buildFolder, we
         !isSameOrChild(buildFolder, outputFolder))
         throw refusal('that folder is outside the project');
 };
-var countJsPrograms = function (files) {
+var countPrograms = function (files, extension) {
     return Object.keys(files).filter(function (key) {
         var inProgramFolder = PROGRAM_FOLDERS.some(function (folder) {
             return key.includes("/".concat(folder, "/"));
         });
-        return inProgramFolder && key.toLowerCase().endsWith('.js');
+        return inProgramFolder && key.toLowerCase().endsWith(extension);
     }).length;
 };
 /** The script-tag attributes that change how an app's script runs. */
@@ -646,11 +646,11 @@ var patchIndexHtml = function (html, version) {
  */
 function buildMockSite(target) {
     return __awaiter(this, void 0, void 0, function () {
-        var projectDir, appLocRaw, appLoc, buildFolder, webSourceRaw, webFolder, outputFolder, streamConfig, excluded, _a, seed, skipped, jsPrograms, driveEntries, webFileCount, hostFolder, _b, _c, asset, hostVersion, swPath, snapshotSource, hasSnapshot, indexPath, _d, patched, warnings;
+        var projectDir, appLocRaw, appLoc, buildFolder, webSourceRaw, webFolder, outputFolder, streamConfig, excluded, _a, seed, skipped, jsPrograms, sasPrograms, driveEntries, webFileCount, hostFolder, _b, _c, asset, hostVersion, swPath, snapshotSource, hasSnapshot, indexPath, _d, patched, warnings;
         var e_8, _e;
-        var _f, _g, _h;
-        return __generator(this, function (_j) {
-            switch (_j.label) {
+        var _f, _g, _h, _j, _k;
+        return __generator(this, function (_l) {
+            switch (_l.label) {
                 case 0:
                     projectDir = process.projectDir || process.cwd();
                     appLocRaw = target.appLoc;
@@ -662,7 +662,7 @@ function buildMockSite(target) {
                         path_1.default.join(projectDir, 'sasjsbuild');
                     return [4 /*yield*/, (0, utils_1.folderExists)(buildFolder)];
                 case 1:
-                    if (!(_j.sent())) {
+                    if (!(_l.sent())) {
                         throw new Error("Build folder not found: ".concat(buildFolder, ". Run `sasjs compile` first."));
                     }
                     webSourceRaw = (_f = target.streamConfig) === null || _f === void 0 ? void 0 : _f.webSourcePath;
@@ -672,7 +672,7 @@ function buildMockSite(target) {
                     webFolder = path_1.default.resolve(projectDir, webSourceRaw);
                     return [4 /*yield*/, (0, utils_1.folderExists)(webFolder)];
                 case 2:
-                    if (!(_j.sent())) {
+                    if (!(_l.sent())) {
                         throw new Error("Web source folder not found: ".concat(webFolder, ". Check streamConfig.webSourcePath - build the frontend first."));
                     }
                     if (!fs_1.default.existsSync(path_1.default.join(webFolder, 'index.html'))) {
@@ -690,11 +690,24 @@ function buildMockSite(target) {
                         excluded.push("/sasjs/drive/files".concat(appLoc, "/services/").concat(streamConfig.streamWebFolder, "/"));
                     }
                     _a = seedFromBuild(buildFolder, appLoc, excluded, [outputFolder]), seed = _a.files, skipped = _a.skipped;
-                    jsPrograms = countJsPrograms(seed);
+                    jsPrograms = countPrograms(seed, '.js');
+                    sasPrograms = countPrograms(seed, '.sas');
                     driveEntries = Object.keys(seed).length;
-                    if (jsPrograms === 0) {
-                        throw new Error("No .js programs in ".concat(buildFolder, "/services, /jobs or /tests. This target builds SAS code, which cannot run in a browser. ") +
-                            'Build a target whose services are JavaScript (typically a mocks project).');
+                    // A build whose services are SAS is still a site worth having, and it is built:
+                    // the programs are seeded on the drive, where a visitor can open them in Studio
+                    // and read them - which is how a deployment's own backend code is inspected
+                    // without a SAS licence and without a login. What they cannot do is run here,
+                    // so the build says so rather than letting a Run button be the surprise.
+                    if (jsPrograms === 0 && sasPrograms > 0) {
+                        (_h = process.logger) === null || _h === void 0 ? void 0 : _h.warn("".concat(sasPrograms, " SAS program(s) and no JavaScript in ").concat(buildFolder, ": they are placed on the drive to read, and cannot run in a browser."));
+                    }
+                    // No PROGRAMS is a different thing again: a compile that produced nothing, or
+                    // a stale sasjsbuild from an unrelated command - `sasjs doc` leaves a folder
+                    // behind that is not a program folder but does reach the drive, so the count
+                    // that decides this is of programs, not of files.
+                    if (jsPrograms + sasPrograms === 0) {
+                        (_j = process.logger) === null || _j === void 0 ? void 0 : _j.warn("No compiled programs in ".concat(buildFolder, ": this site ships with an empty drive. ") +
+                            'That is expected for an interface with no services; for anything else, check that compile wrote the target.');
                     }
                     // The package supplies the drive rules the worker answers with, so an install
                     // without its browser build is a build that cannot run. Checked here, with the
@@ -706,7 +719,7 @@ function buildMockSite(target) {
                             'or check that @sasjs/api still publishes build/browser.js.');
                     }
                     if (skipped.length) {
-                        (_h = process.logger) === null || _h === void 0 ? void 0 : _h.warn("Left ".concat(skipped.length, " file(s) off the mock drive, over the ").concat(megabytes(exports.MAX_BINARY_SEED_BYTES), " per-file or ").concat(megabytes(exports.MAX_SEED_BYTES), " total the browser build seeds: ") +
+                        (_k = process.logger) === null || _k === void 0 ? void 0 : _k.warn("Left ".concat(skipped.length, " file(s) off the mock drive, over the ").concat(megabytes(exports.MAX_BINARY_SEED_BYTES), " per-file or ").concat(megabytes(exports.MAX_SEED_BYTES), " total the browser build seeds: ") +
                             "".concat(skipped
                                 .slice(0, 3)
                                 .map(function (file) {
@@ -753,7 +766,7 @@ function buildMockSite(target) {
                 case 3:
                     // 2. the linter, bundled from the installed packages so the code routes answer
                     // with the rules this CLI resolved rather than a second implementation
-                    _j.sent();
+                    _l.sent();
                     // sw.js sits at the site root: a worker can only control the folder it is
                     // served from, and the app has to be controlled from /
                     fs_1.default.copyFileSync(path_1.default.join(ASSETS_FOLDER, 'sw.js'), path_1.default.join(outputFolder, 'sw.js'));

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

@@ -210,6 +210,32 @@ describe('page-side bridge', function () {
             }
         });
     }); });
+    it('carries a binary file as base64 rather than as damaged text', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var fetchImpl, XHR, bytes, form, xhr, _a, init, payload;
+        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":"success"}')];
+                    }); }); });
+                    XHR = loadBridge(fetchImpl).XHR;
+                    bytes = new Uint8Array([
+                        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a
+                    ]);
+                    form = new FormData();
+                    form.append('file', new Blob([bytes], { type: 'image/png' }), 'logo.png');
+                    xhr = new XHR();
+                    return [4 /*yield*/, run(xhr, 'POST', '/SASjsApi/drive/file', form)];
+                case 1:
+                    _b.sent();
+                    _a = __read(fetchImpl.mock.calls[0], 2), init = _a[1];
+                    payload = JSON.parse(init.body);
+                    expect(payload.tables[0].binary).toBe(true);
+                    expect(payload.tables[0].csv).toBe(btoa('‰PNG\r\n\n'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('parses the response when the app asked for json', function () { return __awaiter(void 0, void 0, void 0, function () {
         var XHR, xhr;
         return __generator(this, function (_a) {

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

@@ -667,25 +667,121 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
-    it('refuses a target whose services are SAS, and keeps the previous site', function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
-                case 1:
-                    _a.sent();
-                    write(path_1.default.join(out(), 'stale.txt'), 'previous');
+    /**
+     * A SAS backend does not run in a browser, but the programs are still worth
+     * shipping: the drive holds them, so a visitor can open them in Studio and
+     * read what a deployment's services do. The build warns and carries on.
+     */
+    it('builds a target whose services are SAS, and warns they cannot run', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var warn, result, seed;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
                     fs_1.default.rmSync(path_1.default.join(root, 'sasjsbuild', 'services'), {
                         recursive: true,
                         force: true
                     });
                     write(path_1.default.join(root, 'sasjsbuild', 'services', 'public', 'getdata.sas'), '%put sas;\n');
-                    return [4 /*yield*/, expect((0, mockSite_1.buildMockSite)(target())).rejects.toThrow(/No \.js programs/)
-                        // the failure is not allowed to take the last good site with it
+                    warn = jest.spyOn((_a = process.logger) !== null && _a !== void 0 ? _a : console, 'warn');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _b.sent();
+                    expect(result.jsPrograms).toBe(0);
+                    expect(result.driveEntries).toBeGreaterThan(0);
+                    expect(warn).toHaveBeenCalledWith(expect.stringContaining('cannot run in a browser'));
+                    seed = readSeed();
+                    expect(Object.keys(seed.files).some(function (key) { return key.endsWith('/getdata.sas'); })).toBe(true);
+                    warn.mockRestore();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * The case this build exists for: an interface with no services at all.
+     * sasjs/server's own frontend compiles to nothing, and the worker answers its
+     * API - so the target must build, ship the web app, and say out loud that the
+     * drive it ships is empty.
+     */
+    it('builds an interface that has no services, and says the drive is empty', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _b, folder, warn, result;
+        var e_4, _c;
+        var _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    try {
+                        // nothing a drive could be seeded from: no services, no sync folder
+                        for (_a = __values(['services', 'mock-storage']), _b = _a.next(); !_b.done; _b = _a.next()) {
+                            folder = _b.value;
+                            fs_1.default.rmSync(path_1.default.join(root, 'sasjsbuild', folder), {
+                                recursive: true,
+                                force: true
+                            });
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                    warn = jest.spyOn((_d = process.logger) !== null && _d !== void 0 ? _d : console, 'warn');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _e.sent();
+                    expect(result.jsPrograms).toBe(0);
+                    expect(result.driveEntries).toBe(0);
+                    expect(fs_1.default.existsSync(path_1.default.join(out(), 'index.html'))).toBe(true);
+                    expect(warn).toHaveBeenCalledWith(expect.stringContaining('ships with an empty drive'));
+                    warn.mockRestore();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * A stale build folder is the case the warning exists for: `sasjs doc` and
+     * other commands leave folders behind that are not program folders, so a count
+     * of files on the drive says nothing about whether anything was compiled.
+     */
+    it('warns when the build folder holds only folders that are not programs', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _b, folder, warn, result;
+        var e_5, _c;
+        var _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    try {
+                        for (_a = __values(['services', 'mock-storage']), _b = _a.next(); !_b.done; _b = _a.next()) {
+                            folder = _b.value;
+                            fs_1.default.rmSync(path_1.default.join(root, 'sasjsbuild', folder), {
+                                recursive: true,
+                                force: true
+                            });
+                        }
+                    }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                    }
+                    write(path_1.default.join(root, 'sasjsbuild', 'docs', 'index.html'), '<html></html>');
+                    warn = jest.spyOn((_d = process.logger) !== null && _d !== void 0 ? _d : console, 'warn');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())
+                        // the drive is NOT empty - the docs folder reaches it - so the file count
+                        // alone would have kept quiet
                     ];
-                case 2:
-                    _a.sent();
-                    // the failure is not allowed to take the last good site with it
-                    expect(fs_1.default.readFileSync(path_1.default.join(out(), 'stale.txt'), 'utf8')).toBe('previous');
+                case 1:
+                    result = _e.sent();
+                    // the drive is NOT empty - the docs folder reaches it - so the file count
+                    // alone would have kept quiet
+                    expect(result.driveEntries).toBeGreaterThan(0);
+                    expect(result.jsPrograms).toBe(0);
+                    expect(warn).toHaveBeenCalledWith(expect.stringContaining('No compiled programs'));
+                    warn.mockRestore();
                     return [2 /*return*/];
             }
         });
@@ -773,8 +869,8 @@ describe('browser-hosted build', function () {
         });
     }); });
     it('refuses a mockWebFolder that would delete the project or its inputs', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var _a, _b, mockWebFolder, e_4_1;
-        var e_4, _c;
+        var _a, _b, mockWebFolder, e_6_1;
+        var e_6, _c;
         return __generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
@@ -805,14 +901,14 @@ describe('browser-hosted build', function () {
                     return [3 /*break*/, 1];
                 case 4: return [3 /*break*/, 7];
                 case 5:
-                    e_4_1 = _d.sent();
-                    e_4 = { error: e_4_1 };
+                    e_6_1 = _d.sent();
+                    e_6 = { error: e_6_1 };
                     return [3 /*break*/, 7];
                 case 6:
                     try {
                         if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                     }
-                    finally { if (e_4) throw e_4.error; }
+                    finally { if (e_6) throw e_6.error; }
                     return [7 /*endfinally*/];
                 case 7:
                     expect(fs_1.default.existsSync(path_1.default.join(root, 'client', 'dist', 'index.html'))).toBe(true);

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

@@ -1139,6 +1139,46 @@ describe('service worker host', function () {
             });
         }); });
     });
+    it('writes a binary upload as its bytes, not as the text it decodes to', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, image, created, read, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    image = new Uint8Array([
+                        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a
+                    ]);
+                    return [4 /*yield*/, dispatch('/SASjsApi/drive/file', {
+                            method: 'POST',
+                            headers: { 'content-type': 'application/json' },
+                            body: JSON.stringify({
+                                params: { filePath: '/Public/logo.png' },
+                                tables: [
+                                    {
+                                        name: 'file',
+                                        filename: 'logo.png',
+                                        csv: btoa(String.fromCharCode.apply(null, Array.from(image))),
+                                        binary: true
+                                    }
+                                ]
+                            })
+                        })];
+                case 1:
+                    created = _c.sent();
+                    expect(created.status).toBe(200);
+                    return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/Public/logo.png'))];
+                case 2:
+                    read = _c.sent();
+                    expect(read.status).toBe(200);
+                    _a = expect;
+                    _b = Uint8Array.bind;
+                    return [4 /*yield*/, read.arrayBuffer()];
+                case 3:
+                    _a.apply(void 0, [new (_b.apply(Uint8Array, [void 0, _c.sent()]))()]).toEqual(image);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('answers 404 for a drive file the drive does not hold', function () { return __awaiter(void 0, void 0, void 0, function () {
         var dispatch, response, _a;
         return __generator(this, function (_b) {
@@ -1157,6 +1197,46 @@ 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) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    return [4 /*yield*/, dispatch('/AppStream/apps.json')];
+                case 1:
+                    listing = _d.sent();
+                    expect(listing.status).toBe(200);
+                    _a = expect;
+                    return [4 /*yield*/, listing.json()];
+                case 2:
+                    _a.apply(void 0, [_d.sent()]).toEqual({ apps: [] });
+                    return [4 /*yield*/, dispatch('/AppStream')];
+                case 3:
+                    root = _d.sent();
+                    expect(root.status).toBe(301);
+                    expect(root.headers.get('location')).toBe('/AppStream/');
+                    return [4 /*yield*/, dispatch('/AppStream/')];
+                case 4:
+                    landing = _d.sent();
+                    expect(landing.status).toBe(200);
+                    expect(landing.headers.get('content-type')).toContain('text/html');
+                    _b = 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();
+                    expect(app.status).toBe(404);
+                    _c = expect;
+                    return [4 /*yield*/, app.json()];
+                case 7:
+                    _c.apply(void 0, [(_d.sent()).message]).toContain('serves no apps');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('leaves a request to another origin alone', function () {
         var dispatch = seeded().dispatch;
         expect(dispatch('https://other.example.com/SASjsApi/info')).toBeUndefined();

package/package.json

@@ -125,5 +125,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.16.0"
+  "version": "6.18.0"
 }