@sasjs/cli 6.27.0 → 6.27.1

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

@@ -1357,12 +1357,14 @@ const routeRequest = async (request, url) => {
 
     if (!refusal) broadcast({ type: 'sasjs-host-error', path, message })
     // A refusal the API decided on carries its status and, where the route
-    // answers an envelope, the body to send. The drive's routes send the message
-    // itself as plain text - the server answers them with `res.status(code)
-    // .send(err.message)` - so those stay text; everything else keeps the JSON
-    // envelope the other routes already answer with.
+    // answers an envelope, the body to send. The deploy routes state one in the
+    // document - a refusal there is `{status: 'failure', message}` - while the
+    // other drive routes send the message itself as plain text, which is what the
+    // server's `res.status(code).send(err.message)` does.
     if (API.isApiError(e)) {
       if (e.body !== undefined) return json(e.body, e.status)
+      if (/\/SASjsApi\/drive\/deploy(\/|$)/.test(apiPath))
+        return json({ status: 'failure', message: e.message }, e.status)
       if (apiPath.includes('/SASjsApi/drive/')) return text(e.message, e.status)
       return json({ message: e.message }, e.status)
     }

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

@@ -1266,10 +1266,17 @@ describe('service worker host', function () {
                     case 1:
                         empty = _c.sent();
                         expect(empty.status).toBe(400);
+                        // the deploy routes answer a refusal as the envelope the document states for
+                        // them, which is what the corpus pins for the same route
                         _a = expect;
-                        return [4 /*yield*/, empty.text()];
+                        return [4 /*yield*/, empty.json()];
                     case 2:
-                        _a.apply(void 0, [_c.sent()]).toBe('"file" is not present.');
+                        // the deploy routes answer a refusal as the envelope the document states for
+                        // them, which is what the corpus pins for the same route
+                        _a.apply(void 0, [_c.sent()]).toEqual({
+                            status: 'failure',
+                            message: '"file" is not present.'
+                        });
                         form = new FormData();
                         form.set('file', new Blob([new Uint8Array([1, 2, 3])]), 'not-a-zip.zip');
                         return [4 /*yield*/, dispatch('/SASjsApi/drive/deploy/upload', {
@@ -1280,9 +1287,12 @@ describe('service worker host', function () {
                         notZip = _c.sent();
                         expect(notZip.status).toBe(400);
                         _b = expect;
-                        return [4 /*yield*/, notZip.text()];
+                        return [4 /*yield*/, notZip.json()];
                     case 4:
-                        _b.apply(void 0, [_c.sent()]).toBe('The archive is not a zip file.');
+                        _b.apply(void 0, [_c.sent()]).toEqual({
+                            status: 'failure',
+                            message: 'The archive is not a zip file.'
+                        });
                         return [2 /*return*/];
                 }
             });
@@ -2631,7 +2641,7 @@ describe('service worker host', function () {
         }); });
     });
     describe('conformance corpus', function () {
-        var e_5, _a;
+        var e_5, _a, e_6, _b;
         /**
          * 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
@@ -2640,7 +2650,7 @@ describe('service worker host', function () {
          * used to have - and it is a test rather than a review.
          */
         var httpFor = function (testCase) {
-            var e_6, _a;
+            var e_7, _a;
             var _b;
             var _c = __read(testCase.route.split(' '), 2), method = _c[0], routePath = _c[1];
             var query = new URLSearchParams();
@@ -2651,12 +2661,12 @@ describe('service worker host', function () {
                         query.set(key, String(value));
                 }
             }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
             finally {
                 try {
                     if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
                 }
-                finally { if (e_6) throw e_6.error; }
+                finally { if (e_7) throw e_7.error; }
             }
             var suffix = query.toString() ? "?".concat(query) : '';
             var init = { method: method };
@@ -2687,8 +2697,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_7_1;
-            var e_8, _g, e_7, _h;
+            var text, _a, _b, _c, file, contents, _d, _e, _f, file, contents, e_8_1;
+            var e_9, _g, e_8, _h;
             return __generator(this, function (_j) {
                 switch (_j.label) {
                     case 0:
@@ -2700,12 +2710,12 @@ describe('service worker host', function () {
                                     text["/sasjs/drive/files".concat(file)] = contents;
                             }
                         }
-                        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                        catch (e_9_1) { e_9 = { error: e_9_1 }; }
                         finally {
                             try {
                                 if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
                             }
-                            finally { if (e_8) throw e_8.error; }
+                            finally { if (e_9) throw e_9.error; }
                         }
                         return [4 /*yield*/, runtime.load(text)];
                     case 1:
@@ -2728,71 +2738,114 @@ describe('service worker host', function () {
                         return [3 /*break*/, 3];
                     case 6: return [3 /*break*/, 9];
                     case 7:
-                        e_7_1 = _j.sent();
-                        e_7 = { error: e_7_1 };
+                        e_8_1 = _j.sent();
+                        e_8 = { error: e_8_1 };
                         return [3 /*break*/, 9];
                     case 8:
                         try {
                             if (_e && !_e.done && (_h = _d.return)) _h.call(_d);
                         }
-                        finally { if (e_7) throw e_7.error; }
+                        finally { if (e_8) throw e_8.error; }
                         return [7 /*endfinally*/];
                     case 9: return [2 /*return*/];
                 }
             });
         }); };
+        /**
+         * The expectation kinds this harness asserts.
+         *
+         * A case that states one it does not implement fails rather than passing
+         * unproven - `keys`, `shape` and `encoding` are asserted by the package's own
+         * corpus run and not here, and a case that starts using them has to be told
+         * so by this list rather than by silence.
+         */
+        var ASSERTED = ['status', 'error', 'partial', 'body', 'contents'];
+        var assertExpectations = function (response, testCase) { return __awaiter(void 0, void 0, void 0, function () {
+            var unasserted, bytes, _a, _b, text, _c, isJson, body;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        unasserted = Object.keys(testCase.expect).filter(function (kind) { return !ASSERTED.includes(kind); });
+                        if (unasserted.length)
+                            throw new Error("".concat(testCase.id, ": this harness does not assert ").concat(unasserted.join(', ')));
+                        expect(response.status).toBe(testCase.expect.status);
+                        if (!(testCase.expect.contents instanceof Uint8Array)) return [3 /*break*/, 2];
+                        _b = Uint8Array.bind;
+                        return [4 /*yield*/, response.arrayBuffer()];
+                    case 1:
+                        _a = new (_b.apply(Uint8Array, [void 0, _d.sent()]))();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = undefined;
+                        _d.label = 3;
+                    case 3:
+                        bytes = _a;
+                        if (!(bytes === undefined)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, response.text()];
+                    case 4:
+                        _c = _d.sent();
+                        return [3 /*break*/, 6];
+                    case 5:
+                        _c = undefined;
+                        _d.label = 6;
+                    case 6:
+                        text = _c;
+                        isJson = (response.headers.get('content-type') || '').includes('application/json');
+                        if (testCase.expect.error !== undefined) {
+                            // the routes that answer an envelope - the two deploy routes - send
+                            // `{status, message}`; the rest send the message itself as text, which is
+                            // what the server's `res.status(code).send(err.message)` does
+                            if (isJson) {
+                                body = JSON.parse(text);
+                                expect(body.message).toBe(testCase.expect.error);
+                                // a refusal that states the envelope it expects is compared on the whole
+                                // of it, not only on the message
+                                if (testCase.expect.body !== undefined)
+                                    expect(body).toEqual(testCase.expect.body);
+                            }
+                            else {
+                                // a case cannot state an envelope and be answered with text: one of the
+                                // two is wrong, and silence would hide which
+                                if (testCase.expect.body !== undefined)
+                                    throw new Error("".concat(testCase.id, ": the answer is text, so its body cannot be asserted"));
+                                expect(text).toBe(testCase.expect.error);
+                            }
+                            return [2 /*return*/];
+                        }
+                        if (testCase.expect.contents !== undefined) {
+                            if (bytes !== undefined)
+                                expect(bytes).toEqual(testCase.expect.contents);
+                            else
+                                expect(text).toEqual(testCase.expect.contents);
+                            return [2 /*return*/];
+                        }
+                        if (testCase.expect.body !== undefined)
+                            expect(JSON.parse(text)).toEqual(testCase.expect.body);
+                        if (testCase.expect.partial !== undefined)
+                            expect(JSON.parse(text)).toMatchObject(testCase.expect.partial);
+                        return [2 /*return*/];
+                }
+            });
+        }); };
         var _loop_1 = function (testCase) {
             it(testCase.id, function () { return __awaiter(void 0, void 0, void 0, function () {
-                var worker, _a, requestPath, init, response, body, want, _b, _c, _d;
-                return __generator(this, function (_e) {
-                    switch (_e.label) {
+                var worker, _a, requestPath, init, response;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
                         case 0:
                             worker = loadWorker();
                             return [4 /*yield*/, seedDrive(worker.runtime, testCase)];
                         case 1:
-                            _e.sent();
+                            _b.sent();
                             worker.refuseWrites(Boolean(testCase.unwritable));
                             _a = httpFor(testCase), requestPath = _a.path, init = _a.init;
                             return [4 /*yield*/, worker.dispatch(requestPath, init)];
                         case 2:
-                            response = _e.sent();
-                            expect(response.status).toBe(testCase.expect.status);
-                            if (!(testCase.expect.error !== undefined)) return [3 /*break*/, 4];
-                            return [4 /*yield*/, response.text()
-                                // the routes that answer an envelope - the two deploy routes - send
-                                // `{status, message}`; the rest send the message itself as text, which
-                                // is what the server's `res.status(code).send(err.message)` does
-                            ];
+                            response = _b.sent();
+                            return [4 /*yield*/, assertExpectations(response, testCase)];
                         case 3:
-                            body = _e.sent();
-                            // the routes that answer an envelope - the two deploy routes - send
-                            // `{status, message}`; the rest send the message itself as text, which
-                            // is what the server's `res.status(code).send(err.message)` does
-                            if ((response.headers.get('content-type') || '').includes('application/json'))
-                                expect(JSON.parse(body)).toEqual({
-                                    status: 'failure',
-                                    message: testCase.expect.error
-                                });
-                            else
-                                expect(body).toBe(testCase.expect.error);
-                            return [3 /*break*/, 8];
-                        case 4:
-                            want = testCase.expect.contents;
-                            if (!(typeof want === 'string')) return [3 /*break*/, 6];
-                            _b = expect;
-                            return [4 /*yield*/, response.text()];
-                        case 5:
-                            _b.apply(void 0, [_e.sent()]).toBe(want);
-                            return [3 /*break*/, 8];
-                        case 6:
-                            if (!(want !== undefined)) return [3 /*break*/, 8];
-                            _c = expect;
-                            _d = Uint8Array.bind;
-                            return [4 /*yield*/, response.arrayBuffer()];
-                        case 7:
-                            _c.apply(void 0, [new (_d.apply(Uint8Array, [void 0, _e.sent()]))()]).toEqual(want);
-                            _e.label = 8;
-                        case 8: return [2 /*return*/];
+                            _b.sent();
+                            return [2 /*return*/];
                     }
                 });
             }); });
@@ -2810,6 +2863,184 @@ describe('service worker host', function () {
             }
             finally { if (e_5) throw e_5.error; }
         }
+        /**
+         * The deploy route's JSON form and its removal, which is what `sasjs deploy`
+         * sends and what this host's transport carries unchanged.
+         *
+         * The upload route's cases hand over the expanded tree in place of the
+         * archive, which is a host's transport detail rather than an answer: this
+         * worker takes the archive and expands it, so those cases would pin the
+         * corpus's assumption instead of this host's behaviour. The zip cases above
+         * pin that route. The removal cases need an app to remove, so the index is
+         * seeded with the corpus's own - the worker starts with nothing published,
+         * which is the server's state too.
+         *
+         * The state a case leaves is checked too - `expectDrive` - because both deploy
+         * answers are `200` and the difference between replacing a folder and keeping
+         * what is there is only visible in the drive afterwards.
+         */
+        /** The app a removal case names, as the corpus states it. */
+        var CORPUS_APP = {
+            appLoc: '/Public/myApp',
+            streamWebFolder: 'web',
+            publishedAt: '2026-01-01T00:00:00.000Z'
+        };
+        /**
+         * A second app that no removal case names.
+         *
+         * Without it, a removal that ignored the id and deleted whatever was
+         * published would pass both removal cases - the unknown-id one sees an empty
+         * index either way. With it, the assertion after the answer is that the app
+         * the id did *not* name is still listed.
+         */
+        var BYSTANDER = {
+            id: '0b9a1c2d-3e4f-4a5b-8c6d-7e8f9a0b1c2d',
+            name: 'bystander',
+            appLoc: '/Public/bystander',
+            streamWebFolder: 'web',
+            publishedAt: '2026-01-01T00:00:00.000Z'
+        };
+        /**
+         * The index a removal case starts from - built from the id the case asks to
+         * remove, not from the answer it expects, so a host that removed some other
+         * app would answer a different id and fail.
+         */
+        var seedIndex = function (runtime, testCase) { return __awaiter(void 0, void 0, void 0, function () {
+            var id, named, entries;
+            var _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (testCase.route !== 'DELETE /SASjsApi/drive/deploy')
+                            return [2 /*return*/];
+                        id = (_a = testCase.request.body) === null || _a === void 0 ? void 0 : _a.id;
+                        named = (_b = testCase.expect.partial) === null || _b === void 0 ? void 0 : _b.app;
+                        entries = [BYSTANDER];
+                        // the app the case expects to remove is published only when the case names
+                        // the id it removes: the unknown-id case asks for one that is not there, and
+                        // publishing it would make that case pass by accident. It goes in *after* the
+                        // bystander, so a removal that takes the first entry rather than the named
+                        // one removes the bystander and both assertions below fail.
+                        if (id !== undefined && (named === null || named === void 0 ? void 0 : named.id) === id)
+                            entries.push(__assign({ id: id, name: (_c = named.name) !== null && _c !== void 0 ? _c : 'myApp' }, CORPUS_APP));
+                        return [4 /*yield*/, runtime.load({
+                                '/sasjs/drive/files/.sasjs/apps.json': JSON.stringify(entries)
+                            })];
+                    case 1:
+                        _d.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        var _loop_2 = function (testCase) {
+            it(testCase.id, function () { return __awaiter(void 0, void 0, void 0, function () {
+                var worker, _a, requestPath, init, response, listing, ids, _b, _c, path_6, file, e_10_1, _d, _e, path_7, file, e_11_1;
+                var e_10, _f, e_11, _g;
+                var _h, _j, _k;
+                return __generator(this, function (_l) {
+                    switch (_l.label) {
+                        case 0:
+                            worker = loadWorker();
+                            return [4 /*yield*/, seedDrive(worker.runtime, testCase)];
+                        case 1:
+                            _l.sent();
+                            return [4 /*yield*/, seedIndex(worker.runtime, testCase)
+                                // `unwritable` is not passed on here: the case that states it is the
+                                // upload route's, which the filter above keeps out, and the deploy route's
+                                // own `500` is covered by `deploy-refused-by-store` in the drive loop.
+                            ];
+                        case 2:
+                            _l.sent();
+                            _a = httpFor(testCase), requestPath = _a.path, init = _a.init;
+                            return [4 /*yield*/, worker.dispatch(requestPath, init)];
+                        case 3:
+                            response = _l.sent();
+                            return [4 /*yield*/, assertExpectations(response, testCase)
+                                // a removal takes the app the id names, and leaves the rest published
+                            ];
+                        case 4:
+                            _l.sent();
+                            if (!(testCase.route === 'DELETE /SASjsApi/drive/deploy')) return [3 /*break*/, 7];
+                            return [4 /*yield*/, worker.dispatch('/app/apps.json')];
+                        case 5:
+                            listing = _l.sent();
+                            return [4 /*yield*/, listing.json()];
+                        case 6:
+                            ids = (_l.sent()).apps.map(function (app) { return app.id; });
+                            expect(ids).toContain(BYSTANDER.id);
+                            if (response.status === 200)
+                                expect(ids).not.toContain((_h = testCase.request.body) === null || _h === void 0 ? void 0 : _h.id);
+                            _l.label = 7;
+                        case 7:
+                            _l.trys.push([7, 12, 13, 14]);
+                            _b = __values(((_j = testCase.expectDrive) === null || _j === void 0 ? void 0 : _j.present) || []), _c = _b.next();
+                            _l.label = 8;
+                        case 8:
+                            if (!!_c.done) return [3 /*break*/, 11];
+                            path_6 = _c.value;
+                            return [4 /*yield*/, worker.dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent(path_6))];
+                        case 9:
+                            file = _l.sent();
+                            expect({ path: path_6, status: file.status }).toEqual({ path: path_6, status: 200 });
+                            _l.label = 10;
+                        case 10:
+                            _c = _b.next();
+                            return [3 /*break*/, 8];
+                        case 11: return [3 /*break*/, 14];
+                        case 12:
+                            e_10_1 = _l.sent();
+                            e_10 = { error: e_10_1 };
+                            return [3 /*break*/, 14];
+                        case 13:
+                            try {
+                                if (_c && !_c.done && (_f = _b.return)) _f.call(_b);
+                            }
+                            finally { if (e_10) throw e_10.error; }
+                            return [7 /*endfinally*/];
+                        case 14:
+                            _l.trys.push([14, 19, 20, 21]);
+                            _d = __values(((_k = testCase.expectDrive) === null || _k === void 0 ? void 0 : _k.missing) || []), _e = _d.next();
+                            _l.label = 15;
+                        case 15:
+                            if (!!_e.done) return [3 /*break*/, 18];
+                            path_7 = _e.value;
+                            return [4 /*yield*/, worker.dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent(path_7))];
+                        case 16:
+                            file = _l.sent();
+                            expect({ path: path_7, status: file.status }).toEqual({ path: path_7, status: 404 });
+                            _l.label = 17;
+                        case 17:
+                            _e = _d.next();
+                            return [3 /*break*/, 15];
+                        case 18: return [3 /*break*/, 21];
+                        case 19:
+                            e_11_1 = _l.sent();
+                            e_11 = { error: e_11_1 };
+                            return [3 /*break*/, 21];
+                        case 20:
+                            try {
+                                if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
+                            }
+                            finally { if (e_11) throw e_11.error; }
+                            return [7 /*endfinally*/];
+                        case 21: return [2 /*return*/];
+                    }
+                });
+            }); });
+        };
+        try {
+            for (var _c = __values(api_1.DEPLOY_CORPUS.filter(function (entry) { return entry.route !== 'POST /SASjsApi/drive/deploy/upload'; })), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var testCase = _d.value;
+                _loop_2(testCase);
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
     });
     /**
      * The identity and record corpora, over the worker's HTTP surface.
@@ -2820,7 +3051,7 @@ describe('service worker host', function () {
      * are the package's.
      */
     describe('identity and record conformance', function () {
-        var e_9, _a;
+        var e_12, _a;
         /**
          * Boots the worker from a fixture, the way the page does: the case's own
          * identity, and `subject: null` for no implicit caller, so a case that
@@ -2853,7 +3084,7 @@ describe('service worker host', function () {
         };
         /** The request a case describes, as HTTP: path parameters filled, token sent. */
         var httpForCase = function (testCase) {
-            var e_10, _a;
+            var e_13, _a;
             var _b = __read(testCase.route.split(' '), 2), method = _b[0], routePath = _b[1];
             var filled = routePath.replace(/\{(\w+)\}/g, function (_match, name) {
                 return encodeURIComponent(String((testCase.request.params || {})[name]));
@@ -2866,12 +3097,12 @@ describe('service worker host', function () {
                         query.set(key, String(value));
                 }
             }
-            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            catch (e_13_1) { e_13 = { error: e_13_1 }; }
             finally {
                 try {
                     if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                 }
-                finally { if (e_10) throw e_10.error; }
+                finally { if (e_13) throw e_13.error; }
             }
             var suffix = query.toString() ? "?".concat(query) : '';
             var headers = {};
@@ -2965,7 +3196,7 @@ describe('service worker host', function () {
                 }
             });
         }); };
-        var _loop_2 = function (testCase) {
+        var _loop_3 = function (testCase) {
             it("".concat(testCase.id, ": ").concat(testCase.description), function () { return __awaiter(void 0, void 0, void 0, function () {
                 var worker, _a, requestPath, init, _b, _c;
                 return __generator(this, function (_d) {
@@ -2990,15 +3221,15 @@ describe('service worker host', function () {
         try {
             for (var _b = __values(__spreadArray(__spreadArray([], __read(api_1.IDENTITY_CORPUS), false), __read(api_1.RECORD_CORPUS), false)), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var testCase = _c.value;
-                _loop_2(testCase);
+                _loop_3(testCase);
             }
         }
-        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_9) throw e_9.error; }
+            finally { if (e_12) throw e_12.error; }
         }
         it('answers as the fixture administrator when no subject was chosen', function () { return __awaiter(void 0, void 0, void 0, function () {
             var worker, response, rules;

package/package.json

@@ -71,7 +71,7 @@
   },
   "dependencies": {
     "@sasjs/adapter": "6.0.2",
-    "@sasjs/api": "0.27.0",
+    "@sasjs/api": "0.27.1",
     "@sasjs/core": "7.1.12",
     "@sasjs/lint": "5.1.1",
     "@sasjs/utils": "4.11.0",
@@ -125,5 +125,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.27.0"
+  "version": "6.27.1"
 }