@sasjs/cli 6.14.0 → 6.15.0

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

@@ -391,6 +391,37 @@ var EXECUTABLE_TYPES = [
     'text/javascript',
     'application/javascript'
 ];
+/**
+ * Tells the interface that this page is answered by the browser host.
+ *
+ * A mock site is the server's own interface running against a service worker,
+ * and nothing in the document said so: the API answers the same routes, the same
+ * mode and the same run times a desktop server does, so an interface could not
+ * tell a visitor what they were looking at. sasjs/server reads the tag and, where
+ * it is absent, knows the server answered the page.
+ *
+ * The insertion is reported when the page has no `<head>`, the way the other two
+ * rewrites report markup they could not find - silently leaving the tag off a
+ * page the browser host cannot mark is what the reader of the absence rule would
+ * misread as "a server answered this". The check for an existing tag is scoped
+ * to the head, because a page may mention the tag in a script or a template
+ * without carrying it, and a document-wide test would then insert nothing.
+ */
+var HOST_TAG = '<meta name="sasjs-host" content="browser" />';
+var HOST_TAG_PATTERN = /<meta\s+name=["']sasjs-host["']/i;
+var markBrowserHost = function (html, warnings) {
+    var head = /<head(\s[^>]*)?>/i.exec(html);
+    if (!head) {
+        warnings.push('no <head> element found - the sasjs-host tag was not added, so the page will read as server-answered');
+        return html;
+    }
+    var start = head.index + head[0].length;
+    var close = html.toLowerCase().indexOf('</head>', start);
+    var inHead = close < 0 ? html.slice(start) : html.slice(start, close);
+    if (HOST_TAG_PATTERN.test(inHead))
+        return html;
+    return html.slice(0, start) + HOST_TAG + html.slice(start);
+};
 /**
  * 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
@@ -399,14 +430,7 @@ var EXECUTABLE_TYPES = [
 var patchIndexHtml = function (html, version) {
     var warnings = [];
     var patched = html;
-    // States where this page's API comes from, for anything in the page that
-    // wants to say so: the server's own interface reads it to describe the host
-    // it is running on, and a browser host is a different thing to explain than a
-    // server process. Absence means the server answered the page.
-    if (!/<meta\s+name=["']sasjs-host["']/i.test(patched))
-        patched = patched.replace(/<head(\s[^>]*)?>/i, function (head) {
-            return "".concat(head, "\n    <meta name=\"sasjs-host\" content=\"browser\" />");
-        });
+    patched = markBrowserHost(patched, warnings);
     if (/<sasjs[^>]*>/i.test(patched)) {
         patched = patched.replace(/(<sasjs[^>]*?)\sserverurl="[^"]*"/i, '$1 serverurl=""');
         patched = patched.replace(/(<sasjs[^>]*?)\sloginmechanism="[^"]*"/i, '$1 loginmechanism="Default"');

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

@@ -368,18 +368,91 @@ describe('browser-hosted build', function () {
         });
     }); });
     it('states in the page that the API is answered here', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var html;
+        var html, tag;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0: 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');
-                    // The interface reads this to tell a browser host from a server: the API
-                    // cannot, because a browser host answers the same routes and the same
-                    // /SASjsApi/info shape. Only the host knows, so the host says.
+                    tag = '<meta name="sasjs-host" content="browser" />';
+                    expect(html).toContain(tag);
+                    expect(html.indexOf(tag)).toBeLessThan(html.indexOf('</head>'));
+                    // once: the tag it inserts is the one the guard then finds
+                    expect(html.split('sasjs-host').length - 1).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves a page that already carries the host tag alone', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var html;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    write(path_1.default.join(root, 'client', 'dist', 'index.html'), [
+                        '<!doctype html><html><head>',
+                        '<meta name="sasjs-host" content="browser">',
+                        '</head><body><script src="main.abc123.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.split('sasjs-host').length - 1).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('inserts the tag when the page only mentions it outside the head', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var html;
+        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>',
+                        '<script src="main.abc123.js"></script>',
+                        '<template><meta name="sasjs-host" content="browser"></template>',
+                        '</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');
+                    // the template's copy is not the page's tag: the head gets its own
+                    expect(html.split('sasjs-host').length - 1).toBe(2);
+                    expect(html.indexOf('content="browser" />')).toBeLessThan(html.indexOf('</head>'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('marks a page whose head is never closed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var html;
+        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><body><script src="main.abc123.js"></script></body></html>');
+                    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).toContain('<meta name="sasjs-host" content="browser" />');
-                    expect(html.indexOf('sasjs-host')).toBeLessThan(html.indexOf('</head>'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('warns when a page has no head to mark', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var html;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    write(path_1.default.join(root, 'client', 'dist', 'index.html'), '<!doctype html><html><body><script src="main.abc123.js"></script></body></html>');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _b.sent();
+                    expect((_a = process.logger) === null || _a === void 0 ? void 0 : _a.warn).toHaveBeenCalledWith(expect.stringContaining('no <head> element found'));
+                    html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    expect(html).not.toContain('sasjs-host');
                     return [2 /*return*/];
             }
         });