@sasjs/cli 6.19.3 → 6.19.4

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

@@ -575,6 +575,19 @@ const payloadTooLarge = (limit) => {
  */
 const readJsonBody = async (request) => {
   const body = await readJson(request)
+
+  // The bridge forwards a JSON body as `json` - a request the page made with
+  // `JSON.stringify` has no fields for the envelope it wraps everything in, so
+  // the payload is the whole point of the message. Reading only `params` here
+  // dropped it: `code/execute` and `code/lint` arrived with no code.
+  if (
+    body &&
+    typeof body === 'object' &&
+    body.json &&
+    typeof body.json === 'object'
+  )
+    return { body: body.json, files: [] }
+
   if (
     body &&
     typeof body === 'object' &&
@@ -988,8 +1001,21 @@ const routeRequest = async (request, url) => {
     return json(answer.body, answer.status)
   } catch (e) {
     const message = (e && e.stack) || String(e)
-    logEntry(`${request.method} ${path} ERROR ${(e && e.message) || message}`)
-    broadcast({ type: 'sasjs-host-error', path, message })
+    const status = (e && e.status) || 500
+    const refusal = status >= 400 && status < 500
+
+    // A 4xx is an ANSWER: the API decided, the caller was told, and a client
+    // that expected it (Studio creates its default program and accepts the 409)
+    // has already handled it. Broadcasting it put four console errors on a page
+    // whose only fault was opening a file that was already there. A 5xx is the
+    // host failing, and that is worth reporting to the page.
+    logEntry(
+      `${request.method} ${path} ${refusal ? 'refused' : 'ERROR'} ${
+        (e && e.message) || message
+      }`
+    )
+
+    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)

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

@@ -115,9 +115,14 @@ var loadWorker = function (base) {
             handlers[type].push(fn);
         },
         skipWaiting: function () { },
-        clients: { claim: function () { }, matchAll: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                return [2 /*return*/, []];
-            }); }); } }
+        // a test can put a client here to observe what the host broadcasts; with
+        // none, a message reaches nobody and nothing can be asserted about it
+        clients: {
+            claim: function () { },
+            matchAll: function () { return __awaiter(void 0, void 0, void 0, function () { var _a; return __generator(this, function (_b) {
+                return [2 /*return*/, (_a = global.__mockHostClients) !== null && _a !== void 0 ? _a : []];
+            }); }); }
+        }
     };
     global.self = self;
     global.importScripts = function (path) {
@@ -1233,6 +1238,83 @@ describe('service worker host', function () {
             }
         });
     }); });
+    /**
+     * A refusal is the API's answer, and the page that asked gets it. Reporting it
+     * as a host error put console errors on screens that had handled the refusal
+     * themselves - Studio's 409 being the one that started this.
+     */
+    it('reports a host failure to the page, and stays quiet about a refusal', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, messages, write, hostErrors, failed, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    worker = seeded();
+                    messages = [];
+                    global.__mockHostClients = [
+                        { postMessage: function (message) { return messages.push(message); } }
+                    ];
+                    write = function () {
+                        var form = new FormData();
+                        form.set('file', new Blob(['x']), 'new.txt');
+                        return worker.dispatch('/SASjsApi/drive/file?_filePath=' +
+                            encodeURIComponent('/Public/new.txt'), { method: 'POST', body: form });
+                    };
+                    hostErrors = function () {
+                        return messages.filter(function (message) { return message.type === 'sasjs-host-error'; }).length;
+                    };
+                    // a drive that cannot be written: a failure of the host, not an answer
+                    worker.refuseWrites(true);
+                    return [4 /*yield*/, write()];
+                case 1:
+                    failed = _c.sent();
+                    expect(failed.status).toBeGreaterThanOrEqual(500);
+                    expect(hostErrors()).toBe(1);
+                    // a create over a file that is already there: the API answered, and the
+                    // caller handles it
+                    messages.length = 0;
+                    worker.refuseWrites(false);
+                    _a = expect;
+                    return [4 /*yield*/, write()];
+                case 2:
+                    _a.apply(void 0, [(_c.sent()).status]).toBe(200);
+                    _b = expect;
+                    return [4 /*yield*/, write()];
+                case 3:
+                    _b.apply(void 0, [(_c.sent()).status]).toBe(409);
+                    expect(hostErrors()).toBe(0);
+                    delete global.__mockHostClients;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('keeps the payload of a JSON body the page bridge forwarded', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, body, response, findings;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    body = JSON.stringify({
+                        params: {},
+                        tables: [],
+                        json: { code: 'data _null_;\n  x = 1; \nrun;\n', filePath: '/a.sas' }
+                    });
+                    return [4 /*yield*/, dispatch('/SASjsApi/code/lint', {
+                            method: 'POST',
+                            headers: { 'content-type': 'application/json' },
+                            body: body
+                        })];
+                case 1:
+                    response = _a.sent();
+                    expect(response.status).toBe(200);
+                    return [4 /*yield*/, response.json()];
+                case 2:
+                    findings = _a.sent();
+                    expect(Array.isArray(findings)).toBe(true);
+                    expect(JSON.stringify(findings)).toContain('trailing spaces');
+                    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) {

package/package.json

@@ -125,5 +125,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.19.3"
+  "version": "6.19.4"
 }