@sasjs/cli 6.11.0 → 6.12.0

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

@@ -100,6 +100,21 @@ exports.WEBOUT_SENTINELS = {
     apiServerUrl: '__SASJS_WEBOUT_APIURL__'
 };
 var ASSETS_FOLDER = path_1.default.join(__dirname, 'assets');
+/**
+ * The browser build of @sasjs/api, from the installed package rather than a copy
+ * in this folder: the worker answers the drive with the same rules sasjs/server
+ * does, so the version that ships is the version the CLI resolves - and a stale
+ * second copy is exactly the drift the package exists to remove.
+ *
+ * The path is walked from `require.resolve` because `exports` in @sasjs/api
+ * exposes only the package root - `require.resolve('@sasjs/api/browser.js')`
+ * fails with ERR_PACKAGE_PATH_NOT_EXPORTED, and no subpath can reach
+ * `build/browser.js`. The walk lands on that file only while `main` stays
+ * `build/cjs/index.js`; a change to `main` or `exports` in the package repoints
+ * it silently, so a missing file is reported by name rather than as a bare
+ * ENOENT three levels up.
+ */
+var API_BROWSER_BUILD = path_1.default.join(path_1.default.dirname(require.resolve('@sasjs/api')), '..', '..', 'build', 'browser.js');
 var toPosix = function (value) { return value.split(path_1.default.sep).join('/'); };
 var listFiles = function (folder, base) {
     var e_1, _a;
@@ -417,6 +432,15 @@ function buildMockSite(target) {
                         throw new Error("No .js programs in ".concat(buildFolder, "/services, /jobs or /tests. This target builds SAS code, which cannot run in a browser. ") +
                             'Build a target whose services are JavaScript (typically a mocks project).');
                     }
+                    // The package supplies the drive rules the worker answers with, so an install
+                    // without its browser build is a build that cannot run. Checked here, with the
+                    // other refusals, so a missing dependency leaves the previous site in place -
+                    // and named, rather than a bare ENOENT from a path three levels up.
+                    if (!fs_1.default.existsSync(API_BROWSER_BUILD)) {
+                        throw new Error("The @sasjs/api browser build is missing: expected it at ".concat(API_BROWSER_BUILD, ". ") +
+                            'Reinstall dependencies (npm ci) so the package that ships the drive rules is present, ' +
+                            'or check that @sasjs/api still publishes build/browser.js.');
+                    }
                     if (skipped.length) {
                         (_h = process.logger) === null || _h === void 0 ? void 0 : _h.warn("Left ".concat(skipped.length, " file(s) off the mock drive, over the ").concat(megabytes(exports.MAX_BINARY_SEED_BYTES), " per-file or ").concat(megabytes(exports.MAX_SEED_BYTES), " total the browser build seeds: ") +
                             "".concat(skipped
@@ -454,6 +478,7 @@ function buildMockSite(target) {
                         }
                         finally { if (e_6) throw e_6.error; }
                     }
+                    fs_1.default.copyFileSync(API_BROWSER_BUILD, path_1.default.join(hostFolder, 'api-browser.js'));
                     // sw.js sits at the site root: a worker can only control the folder it is
                     // served from, and the app has to be controlled from /
                     fs_1.default.copyFileSync(path_1.default.join(ASSETS_FOLDER, 'sw.js'), path_1.default.join(outputFolder, 'sw.js'));
@@ -473,7 +498,13 @@ function buildMockSite(target) {
                         })
                     }));
                     hostVersion = (0, crypto_1.createHash)('md5')
-                        .update(['runtime-core.js', 'persist.js', 'intercept.js', 'webout-prelude.json']
+                        .update([
+                        'runtime-core.js',
+                        'persist.js',
+                        'intercept.js',
+                        'api-browser.js',
+                        'webout-prelude.json'
+                    ]
                         .map(function (asset) { return fs_1.default.readFileSync(path_1.default.join(hostFolder, asset)); })
                         .reduce(function (all, buf) { return Buffer.concat([all, buf]); }, Buffer.alloc(0)))
                         .digest('hex')
@@ -481,7 +512,8 @@ function buildMockSite(target) {
                     swPath = path_1.default.join(outputFolder, 'sw.js');
                     fs_1.default.writeFileSync(swPath, fs_1.default
                         .readFileSync(swPath, 'utf8')
-                        .replace("importScripts('/host/runtime-core.js')", "importScripts('/host/runtime-core.js?v=".concat(hostVersion, "')")));
+                        .replace("importScripts('/host/runtime-core.js')", "importScripts('/host/runtime-core.js?v=".concat(hostVersion, "')"))
+                        .replace("importScripts('/host/api-browser.js')", "importScripts('/host/api-browser.js?v=".concat(hostVersion, "')")));
                     snapshotSource = path_1.default.join(buildFolder, 'mock-snapshot.json');
                     hasSnapshot = fs_1.default.existsSync(snapshotSource);
                     if (hasSnapshot) {

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

@@ -167,7 +167,8 @@ describe('browser-hosted build', function () {
                             'md5.js',
                             'runtime-core.js',
                             'persist.js',
-                            'intercept.js'
+                            'intercept.js',
+                            'api-browser.js'
                         ]), _b = _a.next(); !_b.done; _b = _a.next()) {
                             asset = _b.value;
                             expect(fs_1.default.existsSync(path_1.default.join(out(), 'host', asset))).toBe(true);
@@ -189,6 +190,124 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
+    it('ships the @sasjs/api build the CLI resolves, and versions both imports', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var shipped, installed, sw;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())
+                    // the same file the installed package carries: a vendored copy is exactly
+                    // how the worker and the server drift apart
+                ];
+                case 1:
+                    _a.sent();
+                    shipped = fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'api-browser.js'));
+                    installed = fs_1.default.readFileSync(path_1.default.join(path_1.default.dirname(require.resolve('@sasjs/api')), '..', '..', 'build', 'browser.js'));
+                    expect(shipped.equals(installed)).toBe(true);
+                    sw = fs_1.default.readFileSync(path_1.default.join(out(), 'sw.js'), 'utf8');
+                    // both imports carry the host version: a worker caches what it imports, so
+                    // a rebuild that changes either file has to change the URL
+                    expect(sw).toMatch(/importScripts\('\/host\/runtime-core\.js\?v=[0-9a-f]{10}'\)/);
+                    expect(sw).toMatch(/importScripts\('\/host\/api-browser\.js\?v=[0-9a-f]{10}'\)/);
+                    expect(sw).not.toContain("importScripts('/host/runtime-core.js')");
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('names the package when its browser build is missing, and keeps the previous site', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var browserBuild, exists;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    write(path_1.default.join(out(), 'stale.txt'), 'previous');
+                    browserBuild = path_1.default.join(path_1.default.dirname(require.resolve('@sasjs/api')), '..', '..', 'build', 'browser.js');
+                    exists = jest.spyOn(fs_1.default, 'existsSync');
+                    exists.mockImplementation(function (checked) { return String(checked) !== browserBuild; });
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, , 4, 5]);
+                    return [4 /*yield*/, expect((0, mockSite_1.buildMockSite)(target())).rejects.toThrow(/@sasjs\/api browser build is missing/)];
+                case 3:
+                    _a.sent();
+                    return [3 /*break*/, 5];
+                case 4:
+                    exists.mockRestore();
+                    return [7 /*endfinally*/];
+                case 5:
+                    // and the refusal lands before anything is written, so the site that was
+                    // there is still there
+                    expect(fs_1.default.existsSync(path_1.default.join(out(), 'stale.txt'))).toBe(true);
+                    expect(fs_1.default.readFileSync(path_1.default.join(out(), 'stale.txt'), 'utf8')).toBe('previous');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * The worker's scripts share one global scope, so a name declared at the top
+     * level of two of them is a SyntaxError in the browser - and invisible to this
+     * suite, where each file is a module of its own. `importScripts` is the
+     * browser's rule: evaluate the files the build wrote, in one context, once.
+     */
+    it('evaluates the shipped scripts in one global scope, the way a worker does', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var vm, sandbox, context, imported;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    vm = require('vm');
+                    sandbox = {
+                        console: console,
+                        Request: Request,
+                        Response: Response,
+                        Headers: Headers,
+                        URL: URL,
+                        FormData: FormData,
+                        Blob: Blob,
+                        TextEncoder: TextEncoder,
+                        TextDecoder: TextDecoder,
+                        Uint8Array: Uint8Array,
+                        ArrayBuffer: ArrayBuffer,
+                        atob: atob,
+                        btoa: btoa,
+                        setTimeout: setTimeout,
+                        clearTimeout: clearTimeout,
+                        location: { origin: 'https://mock.example.com' },
+                        clients: { claim: function () { }, matchAll: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                return [2 /*return*/, []];
+                            }); }); } },
+                        skipWaiting: function () { },
+                        addEventListener: function () { },
+                        fetch: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, new Response('{}', { headers: { 'content-type': 'application/json' } })];
+                        }); }); }
+                    };
+                    sandbox.self = sandbox;
+                    context = vm.createContext(sandbox);
+                    imported = new Set();
+                    sandbox.importScripts = function (url) {
+                        if (imported.has(url))
+                            return;
+                        imported.add(url);
+                        var file = path_1.default.join(out(), url.replace(/^\//, '').split('?')[0]);
+                        vm.runInContext(fs_1.default.readFileSync(file, 'utf8'), context, {
+                            filename: file
+                        });
+                    };
+                    expect(function () {
+                        return vm.runInContext(fs_1.default.readFileSync(path_1.default.join(out(), 'sw.js'), 'utf8'), context, {
+                            filename: 'sw.js'
+                        });
+                    }).not.toThrow();
+                    // both scripts are loaded, and the drive the API is handed came from the
+                    // runtime rather than a second implementation
+                    expect(Object.keys(sandbox.SASjsMockRuntime)).toContain('driveStore');
+                    expect(typeof sandbox.SASjsApi.createDriveService).toBe('function');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('ships the webout() block with sentinels the runtime fills in', function () { return __awaiter(void 0, void 0, void 0, function () {
         var prelude, _a, _b, sentinel;
         var e_2, _c;