@sasjs/cli 6.23.0 → 6.24.0

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

@@ -462,7 +462,7 @@ const adminReports = {
         cpuCount: navigator.hardwareConcurrency || 1,
         cpuModel: 'unknown',
         loadAverage: [],
-        runTimes: ['js'],
+        runTimes: ['js', 'sas'],
         sasjsRoot: '/'
       },
       memory: {
@@ -591,11 +591,12 @@ const SERVICES = {
   identity: IDENTITY,
   records: RECORDS,
   runtime: API.createRuntimeService(IDENTITY_STORE, RUNTIME, {
-    // The one run time this host executes. A recorded SAS session is answered
-    // before the runner (see SAS_TRANSCRIPT below), not by claiming a `sas` run
-    // time - a .sas program with no recording must still be refused, and a route
-    // that accepted `sas` would compile SAS source as JavaScript instead.
-    runTimes: ['js']
+    // `js` is executed here; `sas` is offered so a SAS program can be run at all
+    // in the demo, and answered from the recording when one names it. A `.sas`
+    // program with no recording is refused in the runner, deliberately - it must
+    // not be handed to the JavaScript runtime as source, which is what the
+    // resolveProgram guard in BrowserRuntime.run prevents.
+    runTimes: ['js', 'sas']
   }),
   session: API.createSessionService(IDENTITY_STORE, RUNTIME),
   authConfig: API.createAuthConfigService({}),

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

@@ -594,13 +594,55 @@ var markBrowserHost = function (html, warnings) {
         return html;
     return html.slice(0, start) + HOST_TAG + html.slice(start);
 };
+/**
+ * Each app script's URL carries a hash of the script's own contents.
+ *
+ * A static host caches an asset for as long as it says to, and GitHub Pages says
+ * two hours - while the app's bundle name never changes from one build to the
+ * next. So a publish that changes only the app reuses the previous URL, and a
+ * visitor inside that window runs the previous build against the new page: the
+ * screens the new build adds simply never appear, and the ones it removed keep
+ * working. Only the host's own files were versioned before (`?v=` on boot.js and
+ * the worker's imports), and those change with the CLI, not with the app.
+ *
+ * A src that names no file in the output is left alone: a page may load a
+ * script from somewhere this build does not own, and guessing a version for it
+ * would break it.
+ *
+ * The tags in the page are all this covers. A chunk the entry point loads later
+ * - `import('./chunk.js')`, a lazy route - keeps its own URL and is cached for
+ * the same window, because the request for it is made by the bundle's runtime
+ * and never passes through this file. Versioning those would mean rewriting the
+ * chunk map inside the bundle, which is the bundler's business, not the host's;
+ * a page whose chunks matter more than its entry should name them in the page,
+ * where this does reach them.
+ */
+var versionScripts = function (scripts, outputFolder) {
+    return scripts.map(function (script) {
+        var src = script.src;
+        if (!src)
+            return script;
+        var _a = __read(src.split('?'), 2), pathname = _a[0], query = _a[1];
+        var file = path_1.default.join(outputFolder, pathname.replace(/^(\.\/|\/)/, ''));
+        if (!fs_1.default.existsSync(file))
+            return script;
+        var hash = (0, crypto_1.createHash)('md5')
+            .update(fs_1.default.readFileSync(file))
+            .digest('hex')
+            .slice(0, 10);
+        return Object.assign({}, script, {
+            src: "".concat(pathname, "?v=").concat(hash).concat(query ? "&".concat(query) : '')
+        });
+    });
+};
 /**
  * Points the app at its own origin and replaces its script tags with the boot
  * loader. Both changes are reported when the expected markup is absent, rather
  * than producing a site that silently talks to a real server.
  */
-var patchIndexHtml = function (html, version, basePath) {
+var patchIndexHtml = function (html, version, basePath, outputFolder) {
     if (basePath === void 0) { basePath = ''; }
+    if (outputFolder === void 0) { outputFolder = ''; }
     var warnings = [];
     var patched = html;
     patched = markBrowserHost(patched, warnings);
@@ -657,7 +699,10 @@ var patchIndexHtml = function (html, version, basePath) {
         return '';
     });
     if (scripts.length) {
-        var tag = bootTag(scripts, version, basePath);
+        var versioned = outputFolder
+            ? versionScripts(scripts, outputFolder)
+            : scripts;
+        var tag = bootTag(versioned, version, basePath);
         patched = /<\/body>/i.test(patched)
             ? patched.replace(/<\/body>/i, "".concat(tag, "\n</body>"))
             : patched + tag;
@@ -872,7 +917,7 @@ function buildMockSite(target) {
                         builtAt: new Date().toISOString()
                     }, null, 2));
                     indexPath = path_1.default.join(outputFolder, 'index.html');
-                    _d = patchIndexHtml(fs_1.default.readFileSync(indexPath, 'utf8'), hostVersion, basePath), patched = _d.patched, warnings = _d.warnings;
+                    _d = patchIndexHtml(fs_1.default.readFileSync(indexPath, 'utf8'), hostVersion, basePath, outputFolder), patched = _d.patched, warnings = _d.warnings;
                     fs_1.default.writeFileSync(indexPath, patched);
                     warnings.forEach(function (warning) { var _a; return (_a = process.logger) === null || _a === void 0 ? void 0 : _a.warn(warning); });
                     return [2 /*return*/, {

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

@@ -468,7 +468,7 @@ describe('browser-hosted build', function () {
         });
     }); });
     it('points the app at itself and installs the boot loader', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var html;
+        var html, specs;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
@@ -486,7 +486,60 @@ describe('browser-hosted build', function () {
                     // the app's own tags are replayed by the loader, in the order the page has
                     // them, and are gone from the page itself
                     expect(html).not.toContain('<script src="main.abc123.js"');
-                    expect(html).toContain('"src":"main.abc123.js","type":"module"');
+                    specs = JSON.parse(html
+                        .match(/data-scripts='([^']*)'/)[1]
+                        .replace(/&#39;/g, "'")
+                        .replace(/&amp;/g, '&'));
+                    expect(specs).toHaveLength(1);
+                    expect(specs[0].type).toBe('module');
+                    expect(specs[0].src).toMatch(/^main\.abc123\.js\?v=[0-9a-f]{10}$/);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * A publish that changes only the app has to reach a reader whose browser
+     * still holds the previous copy. The host caches an asset for two hours and the
+     * bundle's name never changes, so the URL is what has to change.
+     */
+    it('gives each app script a URL that follows its contents', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var specs, first;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    specs = function () {
+                        var html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                        var tag = html.match(/data-scripts='([^']*)'/);
+                        return JSON.parse(tag[1].replace(/&#39;/g, "'").replace(/&amp;/g, '&'));
+                    };
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    first = specs()[0].src;
+                    expect(first).toMatch(/^main\.abc123\.js\?v=[0-9a-f]{10}$/);
+                    // the same file twice: nothing about the URL changes
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 2:
+                    // the same file twice: nothing about the URL changes
+                    _a.sent();
+                    expect(specs()[0].src).toBe(first);
+                    // a different bundle: a different URL, which is the caching bust
+                    write(path_1.default.join(root, 'client', 'dist', 'main.abc123.js'), 'console.log(2)\n');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 3:
+                    _a.sent();
+                    expect(specs()[0].src).not.toBe(first);
+                    // and a script this build does not own is left exactly as the page asked
+                    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, "\"></sasjs>"),
+                        '<script src="https://cdn.example.com/lib.js"></script>',
+                        '</body></html>'
+                    ].join('\n'));
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 4:
+                    _a.sent();
+                    expect(specs()[0].src).toBe('https://cdn.example.com/lib.js');
                     return [2 /*return*/];
             }
         });

package/package.json

@@ -125,5 +125,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.23.0"
+  "version": "6.24.0"
 }