@sasjs/cli 6.19.2 → 6.19.3

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

@@ -89,6 +89,63 @@
 
   const clearAll = () => withStore('readwrite', (store) => store.clear())
 
+  /**
+   * The build this site is, as the page can see it: mock-config.json carries the
+   * stamp the build wrote over its host code and the seed it lays out. Read here
+   * rather than passed down, because the page decides whether to keep a stored
+   * drive before the worker is asked anything.
+   *
+   * The base is the worker's script URL, not the page's: the site can be served
+   * from a folder, and a page reached at `/demo` (no trailing slash) has a
+   * baseURI of `https://host/demo`, which resolves `host/mock-config.json` one
+   * level too high. The worker sits at `<base>/sw.js` and fetches the same file
+   * relative to itself, so its URL is the one definition of the site folder.
+   *
+   * Empty when the config cannot be read, which leaves the drive alone: a page
+   * that cannot tell which build it is has no business dropping one.
+   */
+  const readBuildStamp = async (controller) => {
+    try {
+      const script = controller && controller.scriptURL
+      // no controller URL means no way to name the site folder; keep the drive
+      if (!script) return ''
+      const res = await fetch(new URL('host/mock-config.json', script), {
+        cache: 'no-store'
+      })
+      if (!res.ok) return ''
+      const config = await res.json()
+      return config && typeof config.buildStamp === 'string'
+        ? config.buildStamp
+        : ''
+    } catch (e) {
+      return ''
+    }
+  }
+
+  /** Where the stamp of the build that wrote the stored drive is kept. */
+  const BUILD_STAMP_KEY = 'sasjs-mock-build'
+
+  /**
+   * The stamp recorded for the stored drive, '' when there is none (a drive
+   * from a build before stamps existed) and null when storage cannot be read at
+   * all - which is not the same answer, and must not drop a drive on every load.
+   */
+  const storedBuildStamp = () => {
+    try {
+      return localStorage.getItem(BUILD_STAMP_KEY) || ''
+    } catch (e) {
+      return null
+    }
+  }
+
+  const keepBuildStamp = (stamp) => {
+    try {
+      if (stamp) localStorage.setItem(BUILD_STAMP_KEY, stamp)
+    } catch (e) {
+      /* a browser that refuses storage still runs the site */
+    }
+  }
+
   const waitForController = () =>
     new Promise((resolve) => {
       if (navigator.serviceWorker.controller)
@@ -210,6 +267,32 @@
       console.error('[sasjs-mock] could not read storage: ' + e)
     }
 
+    // A stored drive outlives the build that wrote it, so a returning visitor
+    // would keep running that build's services - including ones the app being
+    // loaded no longer matches. This build stamps the seed it ships, and a drive
+    // whose stamp is absent or different is dropped rather than merged: a
+    // partial drive from two builds is the one thing that cannot be reasoned
+    // about. A site whose config carries no stamp keeps its drives, which is the
+    // behaviour every build before this one had.
+    const stamp = await readBuildStamp(controller)
+    const previous = storedBuildStamp()
+    if (
+      Object.keys(files).length &&
+      stamp &&
+      previous !== null &&
+      previous !== stamp
+    ) {
+      console.info(
+        '[sasjs-mock] the stored drive is from another build - seeding this one'
+      )
+      try {
+        await clearAll()
+      } catch (e) {
+        console.error('[sasjs-mock] could not clear storage: ' + e)
+      }
+      files = {}
+    }
+
     if (Object.keys(files).length) {
       window.__sasjsMockBoot = await askWorker(
         { type: 'sasjs-load', files },
@@ -221,6 +304,8 @@
         'sasjs-seed-ack'
       )
     }
+    if (window.__sasjsMockBoot && !window.__sasjsMockBoot.error)
+      keepBuildStamp(stamp)
     return window.__sasjsMockBoot
   })()
 })()

package/build/commands/build/internal/mockSite/assets/runtime-core.js

@@ -1100,7 +1100,16 @@ return _webout;
       BUFFERS
     )
   } catch (e) {
-    thrown = e && e.stack ? e.stack : String(e)
+    // The stack alone is not an error message: WebKit's carries frames only, so
+    // a failure there arrives at the app as "anonymous@... > Function:219:1" with
+    // the reason nowhere in it. V8's stack already opens with the message, so it
+    // is prepended only when it is missing rather than repeated.
+    const message = e && e.message ? String(e.message) : ''
+    const stack = e && e.stack ? String(e.stack) : ''
+    thrown =
+      stack && message && stack.indexOf(message) < 0
+        ? message + '\n' + stack
+        : stack || String(e)
     logLines.push(String(thrown))
   }
 
@@ -1415,6 +1424,13 @@ const boot = async () => {
   await loadMockConfig()
   await loadWeboutPrelude()
   const { source, files: seed } = await fetchDrive()
+  // a seed replaces the drive, it does not merge into one: the worker survives
+  // page loads, so it can still hold the drive it was given last time, and any
+  // file only that drive had would otherwise outlive the build that wrote it
+  FILES.clear()
+  SIZES.clear()
+  DIRS.clear()
+  DIRS.add('/')
   mkdirp(DRIVE_APP)
   mkdirp(`${DRIVE_ROOT}/files`)
   for (const [path, contents] of Object.entries(seed)) {

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

@@ -683,7 +683,7 @@ var patchIndexHtml = function (html, version, basePath) {
  */
 function buildMockSite(target) {
     return __awaiter(this, void 0, void 0, function () {
-        var projectDir, appLocRaw, appLoc, buildFolder, basePath, webSourceRaw, webFolder, outputFolder, streamConfig, excluded, _a, seed, skipped, jsPrograms, sasPrograms, driveEntries, webFileCount, hostFolder, _b, _c, asset, hostVersion, swPath, snapshotSource, hasSnapshot, indexPath, _d, patched, warnings;
+        var projectDir, appLocRaw, appLoc, buildFolder, basePath, webSourceRaw, webFolder, outputFolder, streamConfig, excluded, _a, seed, skipped, jsPrograms, sasPrograms, driveEntries, webFileCount, hostFolder, _b, _c, asset, hostVersion, buildStamp, swPath, snapshotSource, hasSnapshot, indexPath, _d, patched, warnings;
         var e_8, _e;
         var _f, _g, _h, _j, _k, _l;
         return __generator(this, function (_m) {
@@ -837,6 +837,12 @@ function buildMockSite(target) {
                         .reduce(function (all, buf) { return Buffer.concat([all, buf]); }, Buffer.alloc(0)))
                         .digest('hex')
                         .slice(0, 10);
+                    buildStamp = (0, crypto_1.createHash)('md5')
+                        .update(JSON.stringify(Object.keys(seed)
+                        .sort()
+                        .map(function (key) { return [key, seed[key]]; })))
+                        .digest('hex')
+                        .slice(0, 10);
                     swPath = path_1.default.join(outputFolder, 'sw.js');
                     fs_1.default.writeFileSync(swPath, fs_1.default
                         .readFileSync(swPath, 'utf8')
@@ -857,6 +863,7 @@ function buildMockSite(target) {
                         jsPrograms: jsPrograms,
                         programFolders: PROGRAM_FOLDERS,
                         snapshot: hasSnapshot,
+                        buildStamp: buildStamp,
                         builtAt: new Date().toISOString()
                     }, null, 2));
                     indexPath = path_1.default.join(outputFolder, 'index.html');

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

@@ -136,6 +136,34 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
+    it('stamps the config with the build, so a page can tell one drive from another', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var first;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    first = readConfig();
+                    expect(first.buildStamp).toMatch(/^[0-9a-f]{10}$/);
+                    // an identical build keeps its stamp: a rebuild that changes nothing must
+                    // not throw a returning visitor's drive away
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 2:
+                    // an identical build keeps its stamp: a rebuild that changes nothing must
+                    // not throw a returning visitor's drive away
+                    _a.sent();
+                    expect(readConfig().buildStamp).toBe(first.buildStamp);
+                    // a changed service changes the stamp, which is what makes the page re-seed
+                    // rather than run the previous build's program
+                    fs_1.default.writeFileSync(path_1.default.join(root, 'sasjsbuild', 'services', 'public', 'getdata.js'), 'const a = 999\n');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 3:
+                    _a.sent();
+                    expect(readConfig().buildStamp).not.toBe(first.buildStamp);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('stamps the seed with the drive format the runtime checks', function () { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {

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

@@ -137,6 +137,10 @@ var loadPersist = function (options) {
     var controller = options.controller === undefined
         ? { postMessage: function (message) { return posted.push(message); } }
         : options.controller;
+    // a real controller names the site folder, which is how the page finds the
+    // config file; every case gets one unless it is testing that it is missing
+    if (controller && !controller.scriptURL)
+        controller.scriptURL = options.scriptURL || 'https://host.test/sw.js';
     var serviceWorker = {
         controller: controller,
         // Never resolves by default: the boot sequence then stops before it touches
@@ -158,6 +162,36 @@ var loadPersist = function (options) {
     var window = {};
     global.window = window;
     global.navigator = { serviceWorker: serviceWorker };
+    // the page reads its build stamp and what the stored drive was written by
+    var local = new Map();
+    if (options.storedStamp !== undefined)
+        local.set('sasjs-mock-build', options.storedStamp);
+    global.localStorage = options.storageUnavailable
+        ? {
+            getItem: function () {
+                throw new Error('storage is denied');
+            },
+            setItem: function () {
+                throw new Error('storage is denied');
+            }
+        }
+        : {
+            getItem: function (key) { return (local.has(key) ? local.get(key) : null); },
+            setItem: function (key, value) { return local.set(key, value); }
+        };
+    global.document = {
+        baseURI: options.baseURI || 'https://host.test/'
+    };
+    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, ({
+                    ok: true,
+                    json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, ({ buildStamp: options.buildStamp || '' })];
+                    }); }); }
+                })];
+        });
+    }); });
     var idb = options.seeded
         ? (function () {
             var fake = createIndexedDB();
@@ -171,7 +205,15 @@ var loadPersist = function (options) {
     global.indexedDB = idb;
     require('../assets/persist.js');
     var reply = function (data) { return __spreadArray([], __read(listeners), false).forEach(function (fn) { return fn({ data: data }); }); };
-    return { window: window, listeners: listeners, removed: removed, posted: posted, reply: reply, rows: idb.rows };
+    return {
+        window: window,
+        listeners: listeners,
+        removed: removed,
+        posted: posted,
+        reply: reply,
+        rows: idb.rows,
+        stored: local
+    };
 };
 describe('page-side store', function () {
     afterEach(function () {
@@ -179,6 +221,9 @@ describe('page-side store', function () {
         delete global.window;
         delete global.navigator;
         delete global.indexedDB;
+        delete global.document;
+        delete global.localStorage;
+        delete global.fetch;
     });
     it('asks the worker for a snapshot and drops the listener when it replies', function () { return __awaiter(void 0, void 0, void 0, function () {
         var _a, window, listeners, removed, reply, before, pending;
@@ -473,4 +518,162 @@ describe('page-side store', function () {
             }
         });
     }); });
+    /**
+     * Answers whatever the page asks, so a boot test can assert on which question
+     * was asked rather than on the reply.
+     */
+    var answerBoot = function (controller, listeners) {
+        var 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' } }); });
+        }, 5);
+        return function () { return clearInterval(answering); };
+    };
+    it("drops a drive written by another build and takes this build's seed", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, stored, rows, stop;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        buildStamp: 'build-b',
+                        storedStamp: 'build-a'
+                    }), window = _a.window, listeners = _a.listeners, stored = _a.stored, rows = _a.rows;
+                    stop = answerBoot(controller, listeners);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    stop();
+                    expect(controller.postMessage).toHaveBeenCalledWith({ type: 'sasjs-seed' });
+                    expect(stored.get('sasjs-mock-build')).toBe('build-b');
+                    // the old drive is gone rather than merged with the new seed
+                    expect(rows.size).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('seeds over a drive from a build before the stamp existed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, stop;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        buildStamp: 'build-b'
+                    }), window = _a.window, listeners = _a.listeners;
+                    stop = answerBoot(controller, listeners);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    stop();
+                    expect(controller.postMessage).toHaveBeenCalledWith({ type: 'sasjs-seed' });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('keeps a drive this build wrote', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, stop;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        buildStamp: 'build-b',
+                        storedStamp: 'build-b'
+                    }), window = _a.window, listeners = _a.listeners;
+                    stop = answerBoot(controller, listeners);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    stop();
+                    expect(controller.postMessage).toHaveBeenCalledWith(expect.objectContaining({ type: 'sasjs-load' }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('keeps the drive when the site publishes no stamp', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, stop;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' }
+                    }), window = _a.window, listeners = _a.listeners;
+                    stop = answerBoot(controller, listeners);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    stop();
+                    expect(controller.postMessage).toHaveBeenCalledWith(expect.objectContaining({ type: 'sasjs-load' }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('keeps the drive when storage is refused, instead of seeding every load', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, stop;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        buildStamp: 'build-b',
+                        storageUnavailable: true
+                    }), window = _a.window, listeners = _a.listeners;
+                    stop = answerBoot(controller, listeners);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    stop();
+                    expect(controller.postMessage).toHaveBeenCalledWith(expect.objectContaining({ type: 'sasjs-load' }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('reads the config from the folder the worker sits in, not the page URL', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, stop, _b, url, init;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        buildStamp: 'build-b',
+                        storedStamp: 'build-a',
+                        scriptURL: 'https://host.test/demo/sw.js',
+                        baseURI: 'https://host.test/demo'
+                    }), window = _a.window, listeners = _a.listeners;
+                    stop = answerBoot(controller, listeners);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _c.sent();
+                    stop();
+                    _b = __read(global.fetch.mock.calls[0], 2), url = _b[0], init = _b[1];
+                    expect(String(url)).toBe('https://host.test/demo/host/mock-config.json');
+                    expect(init).toEqual({ cache: 'no-store' });
+                    // and the stamp it read is acted on
+                    expect(controller.postMessage).toHaveBeenCalledWith({ type: 'sasjs-seed' });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

package/build/commands/build/internal/mockSite/spec/runtime-core.spec.js

@@ -136,6 +136,37 @@ describe('browser runtime', function () {
             }
         });
     }); });
+    it('replaces the drive when a seed arrives, rather than merging the two', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, info;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    return [4 /*yield*/, seedDrive(runtime, (_a = {}, _a[drivePath('first.txt')] = 'one', _a))
+                        // a worker outlives the page that seeded it, so a later seed - a page that
+                        // found a drive from another build, or a reset - arrives with the previous
+                        // drive still in memory. A file only that drive had must not survive it.
+                    ];
+                case 1:
+                    _b.sent();
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        var _a;
+                        return __generator(this, function (_b) {
+                            return [2 /*return*/, url.includes('mock-config')
+                                    ? jsonResponse({ appLoc: appLoc })
+                                    : jsonResponse({ files: (_a = {}, _a[drivePath('second.txt')] = 'two', _a) })];
+                        });
+                    }); });
+                    return [4 /*yield*/, runtime.seed()];
+                case 2:
+                    info = _b.sent();
+                    expect(info.files).toBe(1);
+                    expect(Object.keys(runtime.dumpAll())).toEqual([drivePath('second.txt')]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('reads a drive file with no format stamp as the current format', function () { return __awaiter(void 0, void 0, void 0, function () {
         var runtime;
         var _a;
@@ -294,6 +325,25 @@ describe('browser runtime', function () {
         expect(result.log).toContain('boom');
         expect(result.webout).toBe('');
     });
+    it('carries the message when the stack does not, as WebKit reports one', function () {
+        var runtime = loadRuntime();
+        // WebKit's Error.stack is frames only - V8's opens with the message - so the
+        // body a service failure returns had the reason nowhere in it there, which is
+        // what a stack of "Function:219:1" in an app's error dialog looks like.
+        var result = runtime.run({
+            code: [
+                'const error = new Error("webout is not defined")',
+                'error.stack = "global code@https://host.test/sw.js:1:1"',
+                'throw error'
+            ].join('\n')
+        });
+        expect(result.error).toBe('webout is not defined\nglobal code@https://host.test/sw.js:1:1');
+    });
+    it('does not repeat a message the stack already carries', function () {
+        var runtime = loadRuntime();
+        var result = runtime.run({ code: 'throw new Error("boom")' });
+        expect(result.error.match(/boom/g)).toHaveLength(1);
+    });
     /**
      * The shims a service reaches for are node's, refusals included: a mock that
      * answered a copy from a missing file with an empty file, or accepted

package/package.json

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