@sasjs/cli 6.1.0 → 6.2.0

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

@@ -83,7 +83,7 @@ var loadWorker = function () {
     var runtime = self.SASjsMockRuntime;
     var dispatch = function (path, init) {
         if (init === void 0) { init = {}; }
-        var request = new Request(origin + path, init);
+        var request = new Request(path.startsWith('http') ? path : origin + path, init);
         var event = {
             request: request,
             respondWith: function (response) {
@@ -155,6 +155,339 @@ describe('service worker host', function () {
             }
         });
     }); });
+    /**
+     * A worker whose drive holds one service that answers with a download, the
+     * way a streaming service does on the server: the body goes to the webout
+     * fileref and the headers file says what it is.
+     */
+    var streaming = function (code) {
+        var _a;
+        var worker = loadWorker();
+        worker.runtime.load((_a = {},
+            _a[drivePath('services/public/download.js')] = code,
+            _a));
+        return worker;
+    };
+    var downloadPath = function (query) {
+        if (query === void 0) { query = ''; }
+        return '/SASjsApi/stp/execute?_program=' +
+            encodeURIComponent("".concat(appLoc, "/services/public/download")) +
+            query;
+    };
+    it('applies the content type and disposition a service declared', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dispatch = streaming([
+                        'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, \'Content-type: text/csv \\n Content-Disposition: attachment;filename="users.csv"\')',
+                        "_webout = 'a,b\\n1,2'"
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _b.sent();
+                    expect(response.status).toBe(200);
+                    expect(response.headers.get('content-type')).toBe('text/csv');
+                    expect(response.headers.get('content-disposition')).toBe('attachment;filename="users.csv"');
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toBe('a,b\n1,2');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('serves a byte body as bytes, under the name the service chose', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    dispatch = streaming([
+                        'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, \'Content-type: application/zip\\nContent-Disposition: attachment;filename="pack.zip"\')',
+                        'fs.writeFileSync(weboutPath, Uint8Array.from([80, 75, 3, 4]))'
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _c.sent();
+                    expect(response.headers.get('content-type')).toBe('application/zip');
+                    expect(response.headers.get('content-disposition')).toBe('attachment;filename="pack.zip"');
+                    _a = expect;
+                    _b = Uint8Array.bind;
+                    return [4 /*yield*/, response.arrayBuffer()];
+                case 2:
+                    _a.apply(void 0, [new (_b.apply(Uint8Array, [void 0, _c.sent()]))()]).toEqual(new Uint8Array([80, 75, 3, 4]));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('serves a byte body with no declared type as an opaque download', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    dispatch = streaming('fs.writeFileSync(weboutPath, Uint8Array.from([1, 2, 3]))').dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _c.sent();
+                    expect(response.headers.get('content-type')).toBe('application/octet-stream');
+                    _a = expect;
+                    _b = Uint8Array.bind;
+                    return [4 /*yield*/, response.arrayBuffer()];
+                case 2:
+                    _a.apply(void 0, [new (_b.apply(Uint8Array, [void 0, _c.sent()]))()]).toEqual(new Uint8Array([1, 2, 3]));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('keeps a debug reply text, as the body is the framed log', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dispatch = streaming([
+                        'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, \'Content-type: application/zip\\nContent-Disposition: attachment;filename="pack.zip"\')',
+                        'fs.writeFileSync(weboutPath, Uint8Array.from([80, 75, 3, 4]))'
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath('&_debug=log'))];
+                case 1:
+                    response = _b.sent();
+                    expect(response.headers.get('content-type')).toBe('text/plain');
+                    expect(response.headers.get('content-disposition')).toBeNull();
+                    // the body is still bytes, framed with the log rather than corrupted by it
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    // the body is still bytes, framed with the log rather than corrupted by it
+                    _a.apply(void 0, [_b.sent()]).toBe(['UEsDBA==', LOGS_SEPARATOR, '', LOGS_SEPARATOR].join('\n'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('applies nothing it was not asked for, and drops an unusable value', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dispatch = streaming([
+                        "fs.writeFileSync(_SASJS_WEBOUT_HEADERS, 'Cache-Control: no-store\\nContent-type: text/html\\u0000')",
+                        "_webout = 'plain'"
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _b.sent();
+                    expect(response.status).toBe(200);
+                    expect(response.headers.get('cache-control')).toBeNull();
+                    // a NUL would make Response throw, so the header is dropped and the body
+                    // keeps its default type
+                    expect(response.headers.get('content-type')).toBe('text/plain;charset=UTF-8');
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toBe('plain');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('serves a byte file off the drive as bytes', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, runtime, dispatch, response, _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _a = seeded(), runtime = _a.runtime, dispatch = _a.dispatch;
+                    runtime.run({
+                        code: "fs.writeFileSync('/sasjs/drive/files/data.bin', Uint8Array.from([1, 2, 3]))"
+                    });
+                    return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data.bin'))];
+                case 1:
+                    response = _d.sent();
+                    expect(response.headers.get('content-type')).toBe('application/octet-stream');
+                    _b = expect;
+                    _c = Uint8Array.bind;
+                    return [4 /*yield*/, response.arrayBuffer()];
+                case 2:
+                    _b.apply(void 0, [new (_c.apply(Uint8Array, [void 0, _d.sent()]))()]).toEqual(new Uint8Array([1, 2, 3]));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('keeps a tab inside a header value, as HTTP allows it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    dispatch = streaming([
+                        'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, \'Content-Disposition: attachment;\\tfilename="a.zip"\')',
+                        '_webout = "x"'
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _a.sent();
+                    expect(response.headers.get('content-disposition')).toBe('attachment;\tfilename="a.zip"');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('lets the last line for a header win, and an unusable one remove it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var replaced, _a, removed, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    replaced = streaming([
+                        "fs.writeFileSync(_SASJS_WEBOUT_HEADERS, 'Content-type: text/plain\\nContent-type: application/json')",
+                        '_webout = "x"'
+                    ].join('\n'));
+                    _a = expect;
+                    return [4 /*yield*/, replaced.dispatch(downloadPath())];
+                case 1:
+                    _a.apply(void 0, [(_c.sent()).headers.get('content-type')]).toBe('application/json');
+                    removed = streaming([
+                        "fs.writeFileSync(_SASJS_WEBOUT_HEADERS, 'Content-type: text/plain\\nContent-type: text/html\\u0000')",
+                        '_webout = "x"'
+                    ].join('\n'));
+                    _b = expect;
+                    return [4 /*yield*/, removed.dispatch(downloadPath())];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).headers.get('content-type')]).toBe('text/plain;charset=UTF-8');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('normalises header names and ignores a line that is not a header', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dispatch = streaming([
+                        'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, \'CONTENT-TYPE: text/plain\\nnot a header\\n: no name\\nContent-Disposition: attachment;filename="a.txt"\')',
+                        "_webout = 'x'"
+                    ].join('\n')).dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _b.sent();
+                    expect(response.headers.get('content-type')).toBe('text/plain');
+                    expect(response.headers.get('content-disposition')).toBe('attachment;filename="a.txt"');
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toBe('x');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('serves a service that declares a type but writes no body', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, response, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    dispatch = streaming("fs.writeFileSync(_SASJS_WEBOUT_HEADERS, 'Content-type: application/json')").dispatch;
+                    return [4 /*yield*/, dispatch(downloadPath())];
+                case 1:
+                    response = _b.sent();
+                    expect(response.headers.get('content-type')).toBe('application/json');
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    _a.apply(void 0, [_b.sent()]).toBe('');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('answers the session state, and names a route it does not implement', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, session, _a, unknown, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    return [4 /*yield*/, dispatch('/SASjsApi/session')];
+                case 1:
+                    session = _c.sent();
+                    _a = expect;
+                    return [4 /*yield*/, session.json()];
+                case 2:
+                    _a.apply(void 0, [_c.sent()]).toEqual({ state: 'completed' });
+                    return [4 /*yield*/, dispatch('/SASjsApi/unknown/route')];
+                case 3:
+                    unknown = _c.sent();
+                    expect(unknown.status).toBe(404);
+                    _b = expect;
+                    return [4 /*yield*/, unknown.json()];
+                case 4:
+                    _b.apply(void 0, [(_c.sent()).message]).toContain('Not implemented');
+                    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) {
+            switch (_b.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/missing.txt'))];
+                case 1:
+                    response = _b.sent();
+                    expect(response.status).toBe(404);
+                    _a = expect;
+                    return [4 /*yield*/, response.json()];
+                case 2:
+                    _a.apply(void 0, [(_b.sent()).message]).toBe('File not found');
+                    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();
+    });
+    it('passes a latin1 header value through as written, and drops one Response cannot carry', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var accented, kept, beyond, dropped;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    accented = streaming([
+                        'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, \'Content-Disposition: attachment;filename="r\\u00e9sum\\u00e9.csv"\')',
+                        "_webout = 'x'"
+                    ].join('\n'));
+                    return [4 /*yield*/, accented.dispatch(downloadPath())];
+                case 1:
+                    kept = _a.sent();
+                    expect(kept.headers.get('content-disposition')).toBe('attachment;filename="r\u00e9sum\u00e9.csv"');
+                    beyond = streaming([
+                        'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, \'Content-Disposition: attachment;filename="\\u{1F600}.csv"\')',
+                        "_webout = 'x'"
+                    ].join('\n'));
+                    return [4 /*yield*/, beyond.dispatch(downloadPath())];
+                case 2:
+                    dropped = _a.sent();
+                    expect(dropped.status).toBe(200);
+                    expect(dropped.headers.get('content-disposition')).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('answers 500 when a byte entry on the drive is not valid base64', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, response, _a;
+        var _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    worker = loadWorker();
+                    worker.runtime.load((_b = {},
+                        _b[drivePath('data.bin')] = '\u0000base64:!!!not base64!!!',
+                        _b));
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/drive/file?_filePath=' +
+                            encodeURIComponent("".concat(appLoc, "/data.bin")))];
+                case 1:
+                    response = _c.sent();
+                    expect(response.status).toBe(500);
+                    _a = expect;
+                    return [4 /*yield*/, response.json()];
+                case 2:
+                    _a.apply(void 0, [(_c.sent()).message]).toContain('Corrupt binary entry');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('frames the log behind the separator when _debug is set', function () { return __awaiter(void 0, void 0, void 0, function () {
         var dispatch, response, _a;
         return __generator(this, function (_b) {
@@ -349,6 +682,28 @@ describe('service worker host', function () {
             }
         });
     }); });
+    it('reports a corrupt entry in the stats reply rather than leaving the page waiting', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, stats;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    worker = loadWorker();
+                    worker.runtime.load((_a = {},
+                        _a[drivePath('data.bin')] = '\u0000base64:!!!not base64!!!',
+                        _a));
+                    stats = worker.message({ type: 'sasjs-stats' });
+                    return [4 /*yield*/, stats.pending];
+                case 1:
+                    _b.sent();
+                    expect(stats.replies[0]).toEqual(expect.objectContaining({
+                        type: 'sasjs-stats',
+                        error: expect.stringContaining('Corrupt binary entry')
+                    }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('claims the clients on install and activate', function () {
         var lifecycle = seeded().lifecycle;
         expect(function () { return lifecycle('install'); }).not.toThrow();

package/package.json

@@ -126,5 +126,5 @@
   "peerDependencies": {
     "@sasjs/lint": "^4.3.0"
   },
-  "version": "6.1.0"
+  "version": "6.2.0"
 }