@sasjs/cli 6.30.0 → 6.30.1

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

@@ -147,7 +147,11 @@ var loadWorker = function (base, options) {
         }
     };
     global.self = self;
+    // what the worker pulled into itself, so a test can assert that a script it
+    // does not need at boot is not fetched at boot
+    var imported = [];
     global.importScripts = function (path) {
+        imported.push(path);
         if (path.includes('md5'))
             return;
         if (path.includes('api-browser'))
@@ -185,7 +189,7 @@ var loadWorker = function (base, options) {
     };
     require('../assets/sw.js');
     global.fetch = jest.fn(function (input) { return __awaiter(void 0, void 0, void 0, function () {
-        var target, fixture, fixture;
+        var target, fixture, fixture, shards, piece, id, requested, shards_1;
         var _a;
         return __generator(this, function (_b) {
             target = typeof input === 'string' ? input : (input && input.url) || String(input);
@@ -222,7 +226,29 @@ var loadWorker = function (base, options) {
                             userId: mockSite_1.WEBOUT_SENTINELS.userId,
                             apiServerUrl: mockSite_1.WEBOUT_SENTINELS.apiServerUrl
                         })
-                    })];
+                    })
+                    // a sharded drive, when a test sets one up: the index answers the snapshot
+                    // URL and each piece answers its own file, so the worker's fetch of a shard
+                    // is the same request it makes against a static host
+                ];
+            shards = global.__sasjsShards;
+            if (shards && target.includes('vfs-snapshot')) {
+                piece = /vfs-snapshot-(\d+)\.json/.exec(target);
+                if (piece) {
+                    id = Number(piece[1]);
+                    requested = (global.__sasjsShardFetches =
+                        global.__sasjsShardFetches || []);
+                    requested.push(id);
+                    return [2 /*return*/, jsonResponse({ format: mockSite_1.DRIVE_FORMAT, files: shards[id] || {} })];
+                }
+                return [2 /*return*/, jsonResponse(shards.index)];
+            }
+            if (target.includes('mock-config')) {
+                shards_1 = global.__sasjsShards;
+                return [2 /*return*/, jsonResponse(__assign({ appLoc: appLoc }, (shards_1
+                        ? { snapshotShards: (shards_1.index.shards || []).length }
+                        : {})))];
+            }
             return [2 /*return*/, target.includes('vfs-seed')
                     ? jsonResponse({
                         files: (_a = {},
@@ -266,6 +292,7 @@ var loadWorker = function (base, options) {
         dispatch: dispatch,
         message: message,
         lifecycle: lifecycle,
+        imported: imported,
         self: self,
         refuseWrites: function (value) {
             refusingWrites = value;
@@ -308,6 +335,8 @@ describe('service worker host', function () {
         delete global.importScripts;
         delete global.fetch;
         delete global.__sasjsIdentity;
+        delete global.__sasjsShards;
+        delete global.__sasjsShardFetches;
         delete global.__mockHostClients;
     });
     var seeded = function () {
@@ -1412,6 +1441,161 @@ describe('service worker host', function () {
                 }
             });
         }); });
+        /**
+         * The linter is not part of the install.
+         *
+         * The page cannot make its first request until the worker has installed, so
+         * anything the worker imports at boot is on the critical path of every
+         * visit. The linter answers two routes; it is fetched when one of them is
+         * called.
+         */
+        it('fetches the linter on the first code route, not at boot', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        worker = seeded();
+                        expect(worker.imported.some(function (path) { return path.includes('lint-browser'); })).toBe(false);
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/code/lint', runRequest({ code: 'data a;\nrun;\n' }))];
+                    case 1:
+                        response = _a.sent();
+                        expect(response.status).toBe(200);
+                        expect(worker.imported.some(function (path) { return path.includes('lint-browser'); })).toBe(true);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        /**
+         * A route that resolves a path from the drive is not left with a hole.
+         *
+         * The rules an edited file is linted against are found by walking up from
+         * the file, so the request names neither path. The read that fails says
+         * which piece it needs, and the request is answered again with it - the body
+         * re-read from the copy taken before the first attempt.
+         */
+        it('fetches the piece a route resolves from the drive, not the one it names', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, longLine, response, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        ;
+                        global.__sasjsShards = {
+                            index: {
+                                format: mockSite_1.DRIVE_FORMAT,
+                                sharded: true,
+                                boot: 0,
+                                entries: {
+                                    '/sasjs/drive/files/.sasjslint': { shard: 1, bytes: 20 },
+                                    '/sasjs/drive/files/Public/app/test/prog.sas': {
+                                        shard: 0,
+                                        bytes: 12
+                                    }
+                                },
+                                shards: [
+                                    { id: 0, file: 'host/vfs-snapshot-0.json' },
+                                    { id: 1, file: 'host/vfs-snapshot-1.json' }
+                                ]
+                            },
+                            0: { '/sasjs/drive/files/Public/app/test/prog.sas': 'data a; run;' },
+                            1: {
+                                '/sasjs/drive/files/.sasjslint': JSON.stringify({
+                                    maxLineLength: 200
+                                })
+                            }
+                        };
+                        global.__sasjsShardFetches = [];
+                        worker = loadWorker();
+                        return [4 /*yield*/, worker.runtime.load({})];
+                    case 1:
+                        _d.sent();
+                        longLine = 'x'.repeat(150);
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/code/lint', runRequest({
+                                code: "data _null_;\n".concat(longLine, "\nrun;\n"),
+                                filePath: '/Public/app/test/prog.sas'
+                            }))];
+                    case 2:
+                        response = _d.sent();
+                        expect(response.status).toBe(200);
+                        // the line is over the linter's default 80 and under this drive's 200, so
+                        // the answer proves the rules file was read - from a piece the request
+                        // never named
+                        _a = expect;
+                        _c = (_b = JSON).stringify;
+                        return [4 /*yield*/, response.json()];
+                    case 3:
+                        // the line is over the linter's default 80 and under this drive's 200, so
+                        // the answer proves the rules file was read - from a piece the request
+                        // never named
+                        _a.apply(void 0, [_c.apply(_b, [_d.sent()])]).not.toContain('Line exceeds');
+                        expect(global.__sasjsShardFetches).toEqual([0, 1]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        /**
+         * A request that needs a second piece is answered, body and all.
+         *
+         * The first retry fetches the piece the failed read named; a request that
+         * reads two pieces one after another reaches the second retry, which fetches
+         * the rest. Either way the body has to arrive again - a Request's body can
+         * only be read once, so the first attempt keeps an unread copy and each
+         * attempt after it is made from a copy of that.
+         */
+        it('replays a request that needs two pieces, with its body intact', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var near, far, worker, longLine, response, findings, _a, _b;
+            var _c, _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        near = '/sasjs/drive/files/Public/app/test/.sasjslint';
+                        far = '/sasjs/drive/files/.sasjslint';
+                        global.__sasjsShards = {
+                            index: {
+                                format: mockSite_1.DRIVE_FORMAT,
+                                sharded: true,
+                                boot: 0,
+                                entries: (_c = {},
+                                    _c[near] = { shard: 1, bytes: 20 },
+                                    _c[far] = { shard: 2, bytes: 20 },
+                                    _c),
+                                shards: [
+                                    { id: 0, file: 'host/vfs-snapshot-0.json' },
+                                    { id: 1, file: 'host/vfs-snapshot-1.json' },
+                                    { id: 2, file: 'host/vfs-snapshot-2.json' }
+                                ]
+                            },
+                            0: {},
+                            // the nearest rules file is unreadable as a config, so the walk goes on
+                            // to the drive root's - a second piece, in a second shard
+                            1: (_d = {}, _d[near] = 'not json', _d),
+                            2: (_e = {}, _e[far] = JSON.stringify({ maxLineLength: 200 }), _e)
+                        };
+                        global.__sasjsShardFetches = [];
+                        worker = loadWorker();
+                        return [4 /*yield*/, worker.runtime.load({})];
+                    case 1:
+                        _f.sent();
+                        longLine = 'x'.repeat(150);
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/code/lint', runRequest({
+                                code: "data _null_;\n".concat(longLine, "\nrun;\n"),
+                                filePath: '/Public/app/test/prog.sas'
+                            }))];
+                    case 2:
+                        response = _f.sent();
+                        expect(response.status).toBe(200);
+                        _b = (_a = JSON).stringify;
+                        return [4 /*yield*/, response.json()];
+                    case 3:
+                        findings = _b.apply(_a, [_f.sent()]);
+                        // the code arrived on the second attempt and the root rules applied: both
+                        // halves of the claim
+                        expect(findings).toContain('Doxygen');
+                        expect(findings).not.toContain('Line exceeds');
+                        expect(global.__sasjsShardFetches).toEqual([0, 1, 2]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
         /**
          * The rules are the drive's, not the linter's defaults.
          *
@@ -2264,6 +2448,119 @@ describe('service worker host', function () {
             }
         });
     }); });
+    /**
+     * A sharded drive supplies the piece a request names, and only that one.
+     *
+     * The build splits a captured drive so the first page does not download every
+     * app's bundle. That makes it the host's job to fetch the piece holding the
+     * path a route reads - here a drive file, named in `_filePath` - and to leave
+     * the pieces nobody asked for on the site.
+     */
+    it('fetches the piece a drive request names, and leaves the rest', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var small, large, worker, response, _a;
+        var _b, _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    small = '/sasjs/drive/files/config.json';
+                    large = '/sasjs/drive/files/data/large.csv';
+                    global.__sasjsShards = {
+                        index: {
+                            format: mockSite_1.DRIVE_FORMAT,
+                            sharded: true,
+                            boot: 0,
+                            entries: (_b = {},
+                                _b[small] = { shard: 0, bytes: 2 },
+                                _b[large] = { shard: 1, bytes: 64 },
+                                _b),
+                            shards: [
+                                { id: 0, file: 'host/vfs-snapshot-0.json' },
+                                { id: 1, file: 'host/vfs-snapshot-1.json' }
+                            ]
+                        },
+                        0: (_c = {}, _c[small] = '{}', _c),
+                        1: (_d = {}, _d[large] = 'a,b\n1,2\n3,4\n', _d)
+                    };
+                    global.__sasjsShardFetches = [];
+                    worker = loadWorker();
+                    return [4 /*yield*/, worker.runtime.load({})
+                        // the boot shard arrived with the drive; the second piece did not
+                    ];
+                case 1:
+                    _e.sent();
+                    // the boot shard arrived with the drive; the second piece did not
+                    expect(global.__sasjsShardFetches).toEqual([0]);
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/large.csv'))];
+                case 2:
+                    response = _e.sent();
+                    expect(response.status).toBe(200);
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 3:
+                    _a.apply(void 0, [_e.sent()]).toContain('a,b');
+                    expect(global.__sasjsShardFetches).toEqual([0, 1]);
+                    // a second read of the same piece is answered from memory
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/large.csv'))];
+                case 4:
+                    // a second read of the same piece is answered from memory
+                    _e.sent();
+                    expect(global.__sasjsShardFetches).toEqual([0, 1]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * An export is the whole drive, not the part in memory.
+     *
+     * `window.SASjsMock.download()` writes the file a project ships as
+     * `mock-snapshot.json`, so a sharded drive must be fetched before it is
+     * dumped - otherwise the next build ships a snapshot that has quietly lost
+     * every app the visitor never opened.
+     */
+    it('exports every piece of a sharded drive, not only the loaded ones', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var small, large, worker, _a, replies, pending, exported;
+        var _b, _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    small = '/sasjs/drive/files/config.json';
+                    large = '/sasjs/drive/files/data/large.csv';
+                    global.__sasjsShards = {
+                        index: {
+                            format: mockSite_1.DRIVE_FORMAT,
+                            sharded: true,
+                            boot: 0,
+                            entries: (_b = {},
+                                _b[small] = { shard: 0, bytes: 2 },
+                                _b[large] = { shard: 1, bytes: 8 },
+                                _b),
+                            shards: [
+                                { id: 0, file: 'host/vfs-snapshot-0.json' },
+                                { id: 1, file: 'host/vfs-snapshot-1.json' }
+                            ]
+                        },
+                        0: (_c = {}, _c[small] = '{}', _c),
+                        1: (_d = {}, _d[large] = 'a,b\n1,2\n', _d)
+                    };
+                    global.__sasjsShardFetches = [];
+                    worker = loadWorker();
+                    return [4 /*yield*/, worker.runtime.load({})];
+                case 1:
+                    _e.sent();
+                    _a = worker.message({ type: 'sasjs-snapshot' }), replies = _a.replies, pending = _a.pending;
+                    return [4 /*yield*/, pending
+                        // the piece nobody read was fetched for the export
+                    ];
+                case 2:
+                    _e.sent();
+                    // the piece nobody read was fetched for the export
+                    expect(global.__sasjsShardFetches).toEqual([0, 1]);
+                    exported = replies.find(function (reply) { return reply.type === 'sasjs-snapshot'; });
+                    expect(Object.keys(exported.files).sort()).toEqual([large, small].sort());
+                    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) {
@@ -2835,16 +3132,23 @@ describe('service worker host', function () {
                     expect(seed.replies[0]).toEqual(expect.objectContaining({ type: 'sasjs-seed-ack' }));
                     runtime.load(files);
                     snapshot = message({ type: 'sasjs-snapshot' });
+                    // the reply waits for the drive to be whole, so a sharded site's export is
+                    // not the part of it that happens to be in memory
+                    return [4 /*yield*/, snapshot.pending];
+                case 3:
+                    // the reply waits for the drive to be whole, so a sharded site's export is
+                    // not the part of it that happens to be in memory
+                    _c.sent();
                     expect(snapshot.replies[0].type).toBe('sasjs-snapshot');
                     expect(Object.keys(snapshot.replies[0].files).length).toBe(1);
                     reset = message({ type: 'sasjs-reset' });
                     return [4 /*yield*/, reset.pending];
-                case 3:
+                case 4:
                     _c.sent();
                     expect(reset.replies[0]).toEqual(expect.objectContaining({ type: 'sasjs-reset-ack' }));
                     stats = message({ type: 'sasjs-stats' });
                     return [4 /*yield*/, stats.pending];
-                case 4:
+                case 5:
                     _c.sent();
                     expect(stats.replies[0]).toEqual(expect.objectContaining({ type: 'sasjs-stats' }));
                     return [2 /*return*/];

package/package.json

@@ -125,5 +125,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.30.0"
+  "version": "6.30.1"
 }