@sasjs/cli 6.30.0 → 6.30.1

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

@@ -100,9 +100,11 @@ var loadBoot = function (specs, options) {
     };
     var listeners = {};
     var controller = options.controller || 'present';
+    var timelineAtRegister = [];
     var navigator = {
         serviceWorker: {
             register: function (url, init) {
+                timelineAtRegister = timeline.slice();
                 registered.push(url + ' ' + JSON.stringify(init));
                 return options.registerFails
                     ? Promise.reject(new Error('nope'))
@@ -127,7 +129,11 @@ var loadBoot = function (specs, options) {
     global.navigator = navigator;
     global.window = options.bootError
         ? { __sasjsMockReady: Promise.resolve({ error: options.bootError }) }
-        : {};
+        : options.driveError
+            ? {
+                __sasjsMockReady: Promise.resolve({ driveError: options.driveError })
+            }
+            : {};
     global.sessionStorage = {
         getItem: function (key) { return (key in stored ? stored[key] : null); },
         setItem: function (key, value) {
@@ -146,7 +152,7 @@ var loadBoot = function (specs, options) {
         late = true;
         (listeners['controllerchange'] || []).forEach(function (fn) { return fn(); });
     };
-    return { appended: appended, timeline: timeline, registered: registered, stored: stored, claim: claim };
+    return { appended: appended, timeline: timeline, registered: registered, stored: stored, claim: claim, timelineAtRegister: timelineAtRegister };
 };
 var settle = function () { return __awaiter(void 0, void 0, void 0, function () {
     var i;
@@ -336,6 +342,29 @@ describe('the boot loader', function () {
             }
         });
     }); });
+    it('starts the drive restore before the worker is registered', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var timelineAtRegister;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    timelineAtRegister = loadBoot([{ src: 'sasjs.js' }]).timelineAtRegister;
+                    return [4 /*yield*/, settle()
+                        // persist.js reads the page's own IndexedDB and hands the drive to the
+                        // worker as soon as there is one, so nothing about it needs the worker to be
+                        // ready: sequenced after the registration it is another download plus a
+                        // store read on top of the install, which is what made a first visit slow
+                    ];
+                case 1:
+                    _a.sent();
+                    // persist.js reads the page's own IndexedDB and hands the drive to the
+                    // worker as soon as there is one, so nothing about it needs the worker to be
+                    // ready: sequenced after the registration it is another download plus a
+                    // store read on top of the install, which is what made a first visit slow
+                    expect(timelineAtRegister).toEqual(['host/persist.js']);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('keeps the attributes an app relies on', function () { return __awaiter(void 0, void 0, void 0, function () {
         var appended, app;
         return __generator(this, function (_a) {
@@ -430,6 +459,21 @@ describe('the boot loader', function () {
             }
         });
     }); });
+    it('reports a drive that was restored from less than the whole capture', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // the page still runs - a missing piece only fails the file that needed it -
+                    // so the error is the only thing that says the drive is incomplete
+                    loadBoot([], { driveError: 'the drive index answered 500' });
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _a.sent();
+                    expect(console.error).toHaveBeenCalledWith(expect.stringContaining('the drive index answered 500'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('refuses a boot config it cannot read instead of guessing', function () { return __awaiter(void 0, void 0, void 0, function () {
         var timeline;
         return __generator(this, function (_a) {
@@ -527,7 +571,10 @@ describe('the boot loader', function () {
                     // into the next test's globals
                     _b.sent();
                     expect(stored['mock-sw-reloaded']).toEqual('1');
-                    expect(timeline).toEqual(['reload']);
+                    // the drive restore is requested before the registration (it overlaps the
+                    // install), so it is already in flight when the page decides to reload; the
+                    // reload discards it, which costs nothing the cache does not already hold
+                    expect(timeline).toEqual(['host/persist.js', 'reload']);
                     return [2 /*return*/];
             }
         });

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

@@ -140,6 +140,12 @@ describe('browser-hosted build', function () {
     var readConfig = function () {
         return JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'mock-config.json'), 'utf8'));
     };
+    var readIndex = function () {
+        return JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'vfs-snapshot.json'), 'utf8'));
+    };
+    var readShard = function (id) {
+        return JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', "vfs-snapshot-".concat(id, ".json")), 'utf8')).files;
+    };
     beforeEach(function () {
         root = fs_1.default.mkdtempSync(path_1.default.join(require('os').tmpdir(), 'sasjs-mock-'));
         createProject(root);
@@ -558,6 +564,66 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
+    /**
+     * The loader replays the app's tags only once the worker controls the page.
+     * Right for answerability, but it also puts the largest asset on the site
+     * behind the largest prerequisite - so a classic script is hinted in the head,
+     * where the parser reaches it before the loader runs.
+     */
+    it('hints a classic app script so it downloads while the worker installs', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var html, hint;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    write(path_1.default.join(root, 'client', 'dist', 'index.html'), [
+                        '<!doctype html><html><head><title>App</title></head><body>',
+                        "<sasjs serverurl=\"https://sas.example.com\" apploc=\"".concat(appLoc, "\" servertype=\"SASJS\"></sasjs>"),
+                        '<script src="main.abc123.js"></script>',
+                        '<script src="deferred.js" type="module"></script>',
+                        '</body></html>'
+                    ].join('\n'));
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    hint = html.match(/<link rel="preload" as="script" href="([^"]+)" \/>/);
+                    expect(hint).not.toBeNull();
+                    // the hint names the URL the replayed tag carries, version query included: a
+                    // mismatch is a second download rather than a warm cache
+                    expect(hint[1]).toMatch(/^main\.abc123\.js\?v=[0-9a-f]{10}$/);
+                    expect(html).toContain("\"src\":\"".concat(hint[1], "\""));
+                    // and it has to be in the head, ahead of the loader that replays the tag
+                    expect(html.indexOf('rel="preload"')).toBeLessThan(html.indexOf('host/boot.js'));
+                    // a module is fetched with different credentials semantics, so a script hint
+                    // would not match its tag - it is replayed without one
+                    expect(html).not.toMatch(/as="script" href="deferred/);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves a script this build does not own unhinted', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var html;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // a page may load a script from somewhere else; a version guess or a
+                    // cross-origin hint only breaks it
+                    write(path_1.default.join(root, 'client', 'dist', 'index.html'), [
+                        '<!doctype html><html><head><title>App</title></head><body>',
+                        "<sasjs serverurl=\"https://sas.example.com\" apploc=\"".concat(appLoc, "\" servertype=\"SASJS\"></sasjs>"),
+                        '<script src="https://cdn.example.com/lib.js"></script>',
+                        '<script src="not-in-this-build.js"></script>',
+                        '</body></html>'
+                    ].join('\n'));
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    expect(html).not.toContain('rel="preload"');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it("leaves a stylesheet alone when the file is not this build's", function () { return __awaiter(void 0, void 0, void 0, function () {
         var html, specs;
         return __generator(this, function (_a) {
@@ -889,7 +955,7 @@ describe('browser-hosted build', function () {
         });
     }); });
     it('ships a captured drive snapshot when the project has one', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var snapshot, result, shipped;
+        var snapshot, result, index;
         var _a;
         return __generator(this, function (_b) {
             switch (_b.label) {
@@ -905,11 +971,73 @@ describe('browser-hosted build', function () {
                 case 1:
                     result = _b.sent();
                     expect(result.snapshot).toBe(true);
-                    shipped = JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'vfs-snapshot.json'), 'utf8'));
-                    expect(Object.keys(shipped.files).length).toBe(2);
+                    index = readIndex();
+                    expect(index.sharded).toBe(true);
+                    expect(Object.keys(index.entries).length).toBe(2);
+                    // two small files under one folder: one boot shard, no request of their own
+                    expect(result.snapshotShards).toBe(1);
+                    expect(index.boot).toBe(0);
+                    expect(readShard(0)).toEqual(snapshot.files);
                     // the runtime prefers a snapshot over the seed, so it must not be mistaken
                     // for one of the seeded folders
                     expect(readConfig().snapshot).toBe(true);
+                    expect(readConfig().snapshotShards).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * A captured drive is not one download.
+     *
+     * The first page of a demonstration site reads a listing and a handful of
+     * logos; the bundles behind the tiles are opened by whoever clicks them. One
+     * file for the lot makes every visitor pay for all of it before the page
+     * renders, so the build splits it: small files in the boot shard, an app's
+     * bundle in its own.
+     */
+    it('ships a large capture as a boot shard plus a piece per bundle', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var bundle, capture, result, index, bundlePath, bundleShard, bootBytes, total;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    bundle = 'x'.repeat(mockSite_1.SHARD_FILE_BYTES + 1024);
+                    capture = {
+                        files: (_a = {
+                                '/sasjs/drive/files/.sasjs/apps.json': '{"apps":[]}'
+                            },
+                            _a["/sasjs/drive/files/Public/app/demo/logo.png"] = 'not really a png',
+                            _a["/sasjs/drive/files/Public/app/demo/services/web/index.bundle.js"] = bundle,
+                            _a)
+                    };
+                    write(path_1.default.join(root, 'sasjsbuild', 'mock-snapshot.json'), JSON.stringify(capture));
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _b.sent();
+                    index = readIndex();
+                    expect(result.snapshotShards).toBe(2);
+                    // what a first page reads is in the boot shard
+                    expect(index.entries['/sasjs/drive/files/.sasjs/apps.json'].shard).toBe(0);
+                    expect(index.entries["/sasjs/drive/files/Public/app/demo/logo.png"].shard).toBe(0);
+                    bundlePath = "/sasjs/drive/files/Public/app/demo/services/web/index.bundle.js";
+                    bundleShard = index.entries[bundlePath].shard;
+                    expect(bundleShard).not.toBe(0);
+                    expect(readShard(bundleShard)[bundlePath]).toBe(bundle);
+                    bootBytes = index.shards[0].bytes;
+                    total = Object.keys(index.entries).reduce(function (sum, key) { return sum + index.entries[key].bytes; }, 0);
+                    expect(bootBytes).toBeLessThan(total / 10);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('refuses a capture written by a runtime of another format', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    write(path_1.default.join(root, 'sasjsbuild', 'mock-snapshot.json'), JSON.stringify({ format: mockSite_1.DRIVE_FORMAT + 1, files: {} }));
+                    return [4 /*yield*/, expect((0, mockSite_1.buildMockSite)(target())).rejects.toThrow(/format/)];
+                case 1:
+                    _a.sent();
                     return [2 /*return*/];
             }
         });

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

@@ -213,6 +213,10 @@ var loadPersist = function (options) {
         // the identity row lives beside the drive, under its own key
         if (options.seededIdentity)
             fake.rows.set('current', options.seededIdentity);
+        // and the paths a visitor deleted, which a sharded site's index would
+        // otherwise restore
+        if (options.seededDeleted)
+            fake.rows.set('deleted', options.seededDeleted);
         return fake;
     })();
     global.indexedDB = idb;
@@ -228,6 +232,40 @@ var loadPersist = function (options) {
         stored: local
     };
 };
+/**
+ * Waits for the store's own handshake to land.
+ *
+ * A persist message is answered by a chain of transactions - write the files,
+ * read the tombstone list, write it back - and the page does not expose the
+ * promise. A fixed sleep is a race on a slow runner (Windows was the one that
+ * failed), so the assertions poll for the change they expect instead.
+ */
+var settleUntil = function (check_1) {
+    var args_1 = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args_1[_i - 1] = arguments[_i];
+    }
+    return __awaiter(void 0, __spreadArray([check_1], __read(args_1), false), void 0, function (check, timeout) {
+        var started;
+        if (timeout === void 0) { timeout = 4000; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    started = Date.now();
+                    _a.label = 1;
+                case 1:
+                    if (!(Date.now() - started < timeout)) return [3 /*break*/, 3];
+                    if (check())
+                        return [2 /*return*/];
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 10); })];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+};
 describe('page-side store', function () {
     afterEach(function () {
         jest.useRealTimers();
@@ -440,7 +478,7 @@ describe('page-side store', function () {
                 case 0:
                     _a = loadPersist(), window = _a.window, reply = _a.reply, rows = _a.rows;
                     reply({ type: 'sasjs-persist', files: { '/sasjs/drive/c.txt': 'ccc' } });
-                    return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, 20); })];
+                    return [4 /*yield*/, settleUntil(function () { return rows.get('/sasjs/drive/c.txt') === 'ccc'; })];
                 case 1:
                     _b.sent();
                     expect(rows.get('/sasjs/drive/c.txt')).toBe('ccc');
@@ -448,6 +486,146 @@ describe('page-side store', function () {
             }
         });
     }); });
+    /**
+     * A deletion has to outlive the worker, and the page is the only store that can
+     * keep it.
+     *
+     * The drive in a sharded build is not all in the page either: the index lists
+     * every file the build ships, so a file the visitor deleted comes back on the
+     * next load unless the path is remembered here and handed to the worker at
+     * boot.
+     */
+    it('remembers a deleted path, and forgets it when the path is written again', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, window, reply, rows;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = loadPersist({
+                        seeded: { '/sasjs/drive/a.txt': 'a', '/sasjs/drive/b.txt': 'b' }
+                    }), window = _a.window, reply = _a.reply, rows = _a.rows;
+                    reply({ type: 'sasjs-persist', files: { '/sasjs/drive/a.txt': null } });
+                    return [4 /*yield*/, settleUntil(function () { return rows.has('deleted'); })];
+                case 1:
+                    _b.sent();
+                    expect(rows.get('deleted')).toEqual(['/sasjs/drive/a.txt']);
+                    // the row itself is gone, and the tombstone is what stops the index bringing
+                    // it back
+                    expect(rows.has('/sasjs/drive/a.txt')).toBe(false);
+                    reply({ type: 'sasjs-persist', files: { '/sasjs/drive/a.txt': 'again' } });
+                    // the tombstone is written back after the file, so poll for it rather than
+                    // for the write that precedes it
+                    return [4 /*yield*/, settleUntil(function () { return !rows.has('deleted'); })];
+                case 2:
+                    // the tombstone is written back after the file, so poll for it rather than
+                    // for the write that precedes it
+                    _b.sent();
+                    expect(rows.has('deleted')).toBe(false);
+                    expect(rows.get('/sasjs/drive/a.txt')).toBe('again');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('writes no file when the worker could not read the drive whole', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, page, listeners, reply, answering, pending;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({})
+                    }), page = _a.window, listeners = _a.listeners, reply = _a.reply;
+                    answering = setInterval(function () {
+                        var asked = controller.postMessage.mock.calls;
+                        if (!asked.length)
+                            return;
+                        __spreadArray([], __read(listeners), false).forEach(function (fn) {
+                            return fn({ data: { type: asked[0][0].type + '-ack', booted: true } });
+                        });
+                    }, 5);
+                    return [4 /*yield*/, page.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    clearInterval(answering);
+                    pending = page.SASjsMock.download();
+                    return [4 /*yield*/, Promise.resolve()
+                        // the worker answers with what it has and says why it could not finish, and a
+                        // file built from that would be a capture with every app bundle missing
+                    ];
+                case 2:
+                    _b.sent();
+                    // the worker answers with what it has and says why it could not finish, and a
+                    // file built from that would be a capture with every app bundle missing
+                    reply({
+                        type: 'sasjs-snapshot',
+                        files: { '/sasjs/drive/a.txt': 'a' },
+                        error: 'ensureAll rejected: ENOENT'
+                    });
+                    return [4 /*yield*/, expect(pending).rejects.toThrow(/could not be read whole/)];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('drops the recorded deletions with the rest of the drive', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, window, listeners, rows, pending;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = loadPersist({
+                        seeded: { '/sasjs/drive/a.txt': 'a' },
+                        seededDeleted: ['/sasjs/drive/a.txt']
+                    }), window = _a.window, listeners = _a.listeners, rows = _a.rows;
+                    pending = window.SASjsMock.reset();
+                    return [4 /*yield*/, Promise.resolve()];
+                case 1:
+                    _b.sent();
+                    __spreadArray([], __read(listeners), false).forEach(function (fn) { return fn({ data: { type: 'sasjs-reset-ack' } }); });
+                    return [4 /*yield*/, pending];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, settleUntil(function () { return !rows.has('deleted'); })];
+                case 3:
+                    _b.sent();
+                    expect(rows.has('deleted')).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('tells the worker which paths were deleted, so its index cannot restore them', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, answering;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/b.txt': 'b' },
+                        seededDeleted: ['/sasjs/drive/a.txt']
+                    }), window = _a.window, listeners = _a.listeners;
+                    answering = setInterval(function () {
+                        var asked = controller.postMessage.mock.calls;
+                        if (!asked.length)
+                            return;
+                        var type = asked[0][0].type;
+                        __spreadArray([], __read(listeners), false).forEach(function (fn) {
+                            return fn({ data: { type: type + '-ack', booted: true } });
+                        });
+                    }, 5);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    clearInterval(answering);
+                    expect(controller.postMessage.mock.calls[0][0]).toEqual(expect.objectContaining({
+                        type: 'sasjs-load',
+                        deleted: ['/sasjs/drive/a.txt']
+                    }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('resets the worker and the stored drive together', function () { return __awaiter(void 0, void 0, void 0, function () {
         var _a, window, posted, reply, rows, pending;
         return __generator(this, function (_b) {