@sasjs/cli 5.1.1 → 6.1.0

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

@@ -0,0 +1,228 @@
+/**
+ * Service-worker host for the browser build.
+ *
+ * Running the backend here (rather than inside the page) means every request is
+ * a real network-layer request: DevTools > Network lists it as "(from
+ * ServiceWorker)", with the request payload and the response body inspectable.
+ *
+ * Storage is owned by the page (host/persist.js) because a service worker can
+ * be terminated between requests, and some browsers do not share IndexedDB
+ * between the page and its worker. The page hands in the drive at boot and
+ * receives the changed files back after every run.
+ *
+ * TRUST MODEL: this is a single-user, no-auth host. It answers every /SASjsApi/
+ * path on the site's origin, runs whatever program the request names, and runs
+ * the code a code/execute request carries - the same contract a SASjs server
+ * offers, minus the server. Nothing here is a boundary: a page at this origin
+ * can already do all of it, because a visitor's own browser is the client. So
+ * a site holding anything private, or one served from a shared origin, belongs
+ * behind a real server rather than a static host.
+ */
+importScripts('/host/runtime-core.js')
+
+const R = self.SASjsMockRuntime
+const LOGS_SEPARATOR = 'SASJS_LOGS_SEPARATOR_163ee17b6ff24f028928972d80a26784'
+
+self.addEventListener('install', () => self.skipWaiting())
+self.addEventListener('activate', (event) =>
+  event.waitUntil(self.clients.claim())
+)
+
+const json = (obj, status) =>
+  new Response(JSON.stringify(obj, null, 2), {
+    status: status || 200,
+    headers: { 'content-type': 'application/json' }
+  })
+
+const text = (body, status) =>
+  new Response(body, {
+    status: status || 200,
+    headers: { 'content-type': 'text/plain' }
+  })
+
+const broadcast = async (message) => {
+  const clients = await self.clients.matchAll({ includeUncontrolled: true })
+  clients.forEach((client) => client.postMessage(message))
+}
+
+const persistChanges = async () => {
+  const files = R.takeDirty()
+  if (Object.keys(files).length)
+    await broadcast({ type: 'sasjs-persist', files })
+}
+
+const readPayload = async (request) => {
+  if (request.method === 'GET' || request.method === 'HEAD')
+    return { params: {}, tables: [] }
+  const type = request.headers.get('content-type') || ''
+  if (!type.includes('application/json')) {
+    try {
+      const form = await request.formData()
+      const params = {}
+      const tables = []
+      for (const [k, v] of form.entries()) {
+        if (typeof v === 'string') params[k] = v
+        else
+          tables.push({
+            name: k,
+            filename: v.name || k + '.csv',
+            csv: await v.text()
+          })
+      }
+      return { params, tables }
+    } catch (e) {
+      return { params: {}, tables: [] }
+    }
+  }
+  const body = await request.json()
+  return { params: body.params || {}, tables: body.tables || [], json: body }
+}
+
+const handle = async (request, url) => {
+  const path = url.pathname.replace(/\/+$/, '')
+  const query = {}
+  for (const [k, v] of url.searchParams.entries()) query[k] = v
+
+  try {
+    await R.ensureReady()
+
+    if (path.endsWith('/SASjsApi/info')) {
+      return json({
+        mode: 'desktop',
+        cors: 'disabled',
+        whiteList: [],
+        protocol: 'browser',
+        runTimes: ['js']
+      })
+    }
+
+    if (path.endsWith('/SASjsApi/drive/folder')) {
+      return json(await R.list(query._folderPath || ''))
+    }
+
+    if (path.endsWith('/SASjsApi/drive/filetree')) {
+      return json(R.tree())
+    }
+
+    if (path.endsWith('/SASjsApi/drive/file') && request.method === 'GET') {
+      return text(R.read(query._filePath || '').contents)
+    }
+
+    if (
+      path.endsWith('/SASjsApi/stp/execute') ||
+      path.endsWith('/SASjsApi/code/execute')
+    ) {
+      const payload = await readPayload(request)
+      const merged = Object.assign({}, query, payload.params)
+      const program = merged._program
+      const code =
+        payload.json && payload.json.code ? payload.json.code : undefined
+      if (!program && !code)
+        return json({ message: '_program is required' }, 400)
+
+      const result = R.run({
+        program,
+        code,
+        params: merged,
+        tables: payload.tables
+      })
+      await persistChanges()
+      if (result.error) {
+        return json(
+          {
+            status: 'failure',
+            message: 'Job execution failed.',
+            error: result.error
+          },
+          500
+        )
+      }
+      const debug = String(merged._debug || '').length > 0
+      return text(
+        debug
+          ? [result.webout, LOGS_SEPARATOR, result.log, LOGS_SEPARATOR].join(
+              '\n'
+            )
+          : result.webout
+      )
+    }
+
+    if (path.includes('/SASjsApi/session')) {
+      return json({ state: 'completed' })
+    }
+
+    return json(
+      { message: 'Not implemented by the browser host: ' + path },
+      404
+    )
+  } catch (e) {
+    const message = (e && e.stack) || String(e)
+    broadcast({ type: 'sasjs-host-error', path, message })
+    return json(
+      { message: (e && e.message) || String(e) },
+      (e && e.status) || 500
+    )
+  }
+}
+
+self.addEventListener('fetch', (event) => {
+  const url = new URL(event.request.url)
+  if (url.origin !== self.location.origin) return
+  if (!url.pathname.includes('/SASjsApi/')) return
+  event.respondWith(handle(event.request, url))
+})
+
+// ------------------------------------------------------------- host messages
+self.addEventListener('message', (event) => {
+  const data = event.data || {}
+  const reply = (message) => event.source && event.source.postMessage(message)
+
+  switch (data.type) {
+    case 'sasjs-load':
+      event.waitUntil(
+        R.load(data.files || {}).then(async () => {
+          await persistChanges()
+          reply({
+            type: 'sasjs-load-ack',
+            boot: R.bootInfo(),
+            stats: R.stats()
+          })
+        })
+      )
+      break
+
+    case 'sasjs-seed':
+      event.waitUntil(
+        R.seed().then(async () => {
+          await persistChanges()
+          reply({
+            type: 'sasjs-seed-ack',
+            boot: R.bootInfo(),
+            stats: R.stats()
+          })
+        })
+      )
+      break
+
+    case 'sasjs-reset':
+      event.waitUntil(
+        R.reset().then(async () => {
+          await persistChanges()
+          reply({ type: 'sasjs-reset-ack', boot: R.bootInfo() })
+        })
+      )
+      break
+
+    case 'sasjs-snapshot':
+      reply({ type: 'sasjs-snapshot', files: R.dumpAll() })
+      break
+
+    case 'sasjs-stats':
+      event.waitUntil(
+        R.ensureReady().then(() =>
+          reply({ type: 'sasjs-stats', boot: R.bootInfo(), stats: R.stats() })
+        )
+      )
+      break
+  }
+})

package/build/commands/build/internal/mockSite/mockSite.d.ts

@@ -0,0 +1,27 @@
+import { Target } from '@sasjs/utils';
+export interface MockSiteResult {
+    outputFolder: string;
+    appLoc: string;
+    /** Drive entries written into the seed (programs plus any other content). */
+    driveEntries: number;
+    /** Executable .js programs found under services, jobs or tests. */
+    jsPrograms: number;
+    webFileCount: number;
+    /** True when a captured drive snapshot was shipped with the site. */
+    snapshot: boolean;
+}
+/**
+ * Builds a static site that runs the project's JS services (its mocks) in the
+ * browser, so a frontend can be tested with no server and no SAS.
+ *
+ * The output is an ordinary folder of static files: serve it over http(s) and
+ * the app behaves as though it were talking to a single-user SASjs server. The
+ * work happens in a service worker, so every request is still a real request -
+ * visible in DevTools > Network, marked "(from ServiceWorker)" - and the drive
+ * it writes to is persisted in IndexedDB, so refreshes keep their state.
+ *
+ * Everything comes from the target: appLoc, streamConfig.mockWebFolder for the
+ * output, streamConfig.webSourcePath for the built app, and the compile output
+ * for the drive.
+ */
+export declare function buildMockSite(target: Target): Promise<MockSiteResult>;

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

@@ -0,0 +1,408 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMockSite = buildMockSite;
+var crypto_1 = require("crypto");
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+var utils_1 = require("@sasjs/utils");
+var ASSETS_FOLDER = path_1.default.join(__dirname, 'assets');
+var toPosix = function (value) { return value.split(path_1.default.sep).join('/'); };
+var listFiles = function (folder, base) {
+    var e_1, _a;
+    if (base === void 0) { base = folder; }
+    var entries = fs_1.default.readdirSync(folder, { withFileTypes: true });
+    var files = [];
+    try {
+        for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {
+            var entry = entries_1_1.value;
+            var absolute = path_1.default.join(folder, entry.name);
+            if (entry.isDirectory())
+                files.push.apply(files, __spreadArray([], __read(listFiles(absolute, base)), false));
+            else if (entry.isFile())
+                files.push(toPosix(path_1.default.relative(base, absolute)));
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return files;
+};
+var copyFolder = function (from, to) {
+    var e_2, _a;
+    fs_1.default.mkdirSync(to, { recursive: true });
+    try {
+        for (var _b = __values(fs_1.default.readdirSync(from, { withFileTypes: true })), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var entry = _c.value;
+            var source = path_1.default.join(from, entry.name);
+            var target = path_1.default.join(to, entry.name);
+            if (entry.isDirectory())
+                copyFolder(source, target);
+            else
+                fs_1.default.copyFileSync(source, target);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+};
+/**
+ * The drive seed comes from the COMPILE OUTPUT, not the sources: `sasjs
+ * compile` copies every service folder into sasjsbuild/services and then
+ * copies the sync folder's contents over the build folder root, so sasjsbuild
+ * already holds exactly what a SASjs server would receive on its drive.
+ *
+ * Root-level files are skipped on purpose - those are the service pack (.sas),
+ * its manifest (.json), the compile tree and the zip, none of which belong on
+ * the drive.
+ */
+var PROGRAM_FOLDERS = ['services', 'jobs', 'tests'];
+/**
+ * A drive file is a string in the browser runtime, so a file that does not
+ * survive a UTF-8 round trip (an image, an archive, a compiled artefact) cannot
+ * be carried onto it. Returning null for those keeps the site honest: the app
+ * sees a missing file rather than mojibake it would happily write back.
+ */
+var readTextFile = function (absolute) {
+    var buffer = fs_1.default.readFileSync(absolute);
+    var text = buffer.toString('utf8');
+    return Buffer.from(text, 'utf8').equals(buffer) ? text : null;
+};
+var seedFromBuild = function (buildFolder, appLoc, exclude, excludeFolders) {
+    var e_3, _a, e_4, _b;
+    if (exclude === void 0) { exclude = []; }
+    if (excludeFolders === void 0) { excludeFolders = []; }
+    var files = {};
+    var skipped = [];
+    var driveBase = "/sasjs/drive/files".concat(appLoc);
+    // Every folder of the build goes on the drive, so a sync folder's content (a
+    // licence store, for instance) survives as well as the program folders.
+    var directories = fs_1.default
+        .readdirSync(buildFolder, { withFileTypes: true })
+        .filter(function (entry) { return entry.isDirectory(); });
+    try {
+        for (var directories_1 = __values(directories), directories_1_1 = directories_1.next(); !directories_1_1.done; directories_1_1 = directories_1.next()) {
+            var entry = directories_1_1.value;
+            var folder = path_1.default.join(buildFolder, entry.name);
+            if (excludeFolders.includes(path_1.default.resolve(folder)))
+                continue;
+            var _loop_1 = function (relative) {
+                var key = "".concat(driveBase, "/").concat(entry.name, "/").concat(relative);
+                if (exclude.some(function (prefix) { return key.startsWith(prefix); }))
+                    return "continue";
+                var contents = readTextFile(path_1.default.join(folder, relative));
+                if (contents === null)
+                    skipped.push(key);
+                else
+                    files[key] = contents;
+            };
+            try {
+                for (var _c = (e_4 = void 0, __values(listFiles(folder))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var relative = _d.value;
+                    _loop_1(relative);
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (directories_1_1 && !directories_1_1.done && (_a = directories_1.return)) _a.call(directories_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return { files: files, skipped: skipped };
+};
+/**
+ * `mockWebFolder` decides a folder that is deleted before it is written, so it
+ * has to name a folder of its own. Anything that would delete the project, the
+ * build output the drive is seeded from, or the web app it is copied from is
+ * refused before a single file is touched.
+ */
+var assertSafeOutputFolder = function (outputFolder, projectDir, buildFolder, webFolder) {
+    var isSameOrChild = function (parent, child) {
+        var relative = path_1.default.relative(parent, child);
+        return (relative === '' ||
+            (relative !== '..' &&
+                !relative.startsWith('..' + path_1.default.sep) &&
+                !path_1.default.isAbsolute(relative)));
+    };
+    var refusal = function (why) {
+        return new Error("Refusing to write the mock site to ".concat(outputFolder, ": ").concat(why, ". ") +
+            'Set streamConfig.mockWebFolder to a folder of its own, for example "sasjsbuild/mock".');
+    };
+    if (isSameOrChild(outputFolder, projectDir))
+        throw refusal('that folder is the project folder or contains it');
+    if (isSameOrChild(outputFolder, buildFolder))
+        throw refusal('that folder holds the build output the drive is seeded from');
+    if (isSameOrChild(outputFolder, webFolder))
+        throw refusal('that folder holds the web app the site is copied from');
+    if (isSameOrChild(webFolder, outputFolder))
+        throw refusal('that folder is inside the web app the site is copied from, so copying it would copy itself');
+    if (!isSameOrChild(projectDir, outputFolder) &&
+        !isSameOrChild(buildFolder, outputFolder))
+        throw refusal('that folder is outside the project');
+};
+var countJsPrograms = function (files) {
+    return Object.keys(files).filter(function (key) {
+        var inProgramFolder = PROGRAM_FOLDERS.some(function (folder) {
+            return key.includes("/".concat(folder, "/"));
+        });
+        return inProgramFolder && key.toLowerCase().endsWith('.js');
+    }).length;
+};
+var loaderScript = function (mainScript, version) { return "<script>\n    // Boot order: register the service worker that hosts the mock backend, wait\n    // until it controls this page, hand it the persisted drive, install the XHR\n    // bridge, then start the app.\n    (function () {\n      function load(src, next, isModule) {\n        var s = document.createElement('script')\n        if (isModule) s.type = 'module'\n        s.src = src\n        s.onload = next\n        s.onerror = function () { console.error('[mock] failed to load ' + src); next() }\n        document.body.appendChild(s)\n      }\n      function start() {\n        load('host/persist.js?v=".concat(version, "', function () {\n          Promise.resolve(window.__sasjsMockReady).then(function (boot) {\n            if (boot && boot.error) console.error('[mock] boot: ' + boot.error)\n            load('host/intercept.js?v=").concat(version, "', function () {\n              load('").concat(mainScript, "', function () {}, true)\n            })\n          })\n        })\n      }\n      if (!('serviceWorker' in navigator)) {\n        console.error('[mock] service workers are unavailable - the mock backend cannot run')\n        start()\n        return\n      }\n      navigator.serviceWorker\n        .register('/sw.js', { scope: '/' })\n        .then(function () { return navigator.serviceWorker.ready })\n        .then(function () {\n          if (navigator.serviceWorker.controller) return\n          return new Promise(function (resolve) {\n            var timer = setTimeout(resolve, 4000)\n            navigator.serviceWorker.addEventListener('controllerchange', function () {\n              clearTimeout(timer)\n              resolve()\n            })\n          })\n        })\n        .then(function () {\n          if (navigator.serviceWorker.controller) return start()\n          if (!sessionStorage.getItem('mock-sw-reloaded')) {\n            sessionStorage.setItem('mock-sw-reloaded', '1')\n            location.reload()\n            return\n          }\n          console.error('[mock] no service worker controller - requests will fail')\n          start()\n        })\n        .catch(function (err) {\n          console.error('[mock] service worker registration failed: ' + err)\n          start()\n        })\n    })()\n  </script>"); };
+/**
+ * Points the app at its own origin and replaces its bundle tag 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) {
+    var warnings = [];
+    var patched = html;
+    if (/<sasjs[^>]*>/i.test(patched)) {
+        patched = patched.replace(/(<sasjs[^>]*?)\sserverurl="[^"]*"/i, '$1 serverurl=""');
+        patched = patched.replace(/(<sasjs[^>]*?)\sloginmechanism="[^"]*"/i, '$1 loginmechanism="Default"');
+    }
+    else {
+        warnings.push('no <sasjs> element found - check the adapter configuration manually');
+    }
+    var mainMatch = patched.match(/<script[^>]*src="([^"]*main[^"]*\.js)"[^>]*><\/script>/i);
+    if (mainMatch) {
+        patched = patched.replace(mainMatch[0], loaderScript(mainMatch[1], version));
+    }
+    else {
+        warnings.push('no main bundle script tag found - the mock loader was not installed');
+    }
+    return { patched: patched, warnings: warnings };
+};
+/**
+ * Builds a static site that runs the project's JS services (its mocks) in the
+ * browser, so a frontend can be tested with no server and no SAS.
+ *
+ * The output is an ordinary folder of static files: serve it over http(s) and
+ * the app behaves as though it were talking to a single-user SASjs server. The
+ * work happens in a service worker, so every request is still a real request -
+ * visible in DevTools > Network, marked "(from ServiceWorker)" - and the drive
+ * it writes to is persisted in IndexedDB, so refreshes keep their state.
+ *
+ * Everything comes from the target: appLoc, streamConfig.mockWebFolder for the
+ * output, streamConfig.webSourcePath for the built app, and the compile output
+ * for the drive.
+ */
+function buildMockSite(target) {
+    return __awaiter(this, void 0, void 0, function () {
+        var projectDir, appLocRaw, appLoc, buildFolder, webSourceRaw, webFolder, outputFolder, streamConfig, excluded, _a, seed, skipped, jsPrograms, driveEntries, webFileCount, hostFolder, _b, _c, asset, hostVersion, swPath, snapshotSource, hasSnapshot, indexPath, _d, patched, warnings;
+        var e_5, _e;
+        var _f, _g, _h;
+        return __generator(this, function (_j) {
+            switch (_j.label) {
+                case 0:
+                    projectDir = process.projectDir || process.cwd();
+                    appLocRaw = target.appLoc;
+                    if (!appLocRaw) {
+                        throw new Error('No appLoc. Set appLoc on the target - it has to match the appLoc the app is built with.');
+                    }
+                    appLoc = '/' + appLocRaw.replace(/^\/+/, '').replace(/\/+$/, '');
+                    buildFolder = process.sasjsConstants.buildDestinationFolder ||
+                        path_1.default.join(projectDir, 'sasjsbuild');
+                    return [4 /*yield*/, (0, utils_1.folderExists)(buildFolder)];
+                case 1:
+                    if (!(_j.sent())) {
+                        throw new Error("Build folder not found: ".concat(buildFolder, ". Run `sasjs compile` first."));
+                    }
+                    webSourceRaw = (_f = target.streamConfig) === null || _f === void 0 ? void 0 : _f.webSourcePath;
+                    if (!webSourceRaw) {
+                        throw new Error('No built web app. Set streamConfig.webSourcePath on the target (for example ./client/dist), and build the frontend first.');
+                    }
+                    webFolder = path_1.default.resolve(projectDir, webSourceRaw);
+                    return [4 /*yield*/, (0, utils_1.folderExists)(webFolder)];
+                case 2:
+                    if (!(_j.sent())) {
+                        throw new Error("Web source folder not found: ".concat(webFolder, ". Check streamConfig.webSourcePath - build the frontend first."));
+                    }
+                    if (!fs_1.default.existsSync(path_1.default.join(webFolder, 'index.html'))) {
+                        throw new Error("".concat(webFolder, " does not contain an index.html - is streamConfig.webSourcePath pointing at the built app?"));
+                    }
+                    outputFolder = ((_g = target.streamConfig) === null || _g === void 0 ? void 0 : _g.mockWebFolder)
+                        ? path_1.default.resolve(projectDir, target.streamConfig.mockWebFolder)
+                        : path_1.default.join(buildFolder, 'mock');
+                    assertSafeOutputFolder(outputFolder, projectDir, buildFolder, webFolder);
+                    streamConfig = target.streamConfig;
+                    excluded = [];
+                    // streamWebFolder is defaulted by the config validator, so a streamed app
+                    // always names its folder.
+                    if ((streamConfig === null || streamConfig === void 0 ? void 0 : streamConfig.streamWeb) && streamConfig.streamWebFolder) {
+                        excluded.push("/sasjs/drive/files".concat(appLoc, "/services/").concat(streamConfig.streamWebFolder, "/"));
+                    }
+                    _a = seedFromBuild(buildFolder, appLoc, excluded, [outputFolder]), seed = _a.files, skipped = _a.skipped;
+                    jsPrograms = countJsPrograms(seed);
+                    driveEntries = Object.keys(seed).length;
+                    if (jsPrograms === 0) {
+                        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).');
+                    }
+                    if (skipped.length) {
+                        (_h = process.logger) === null || _h === void 0 ? void 0 : _h.warn("Left ".concat(skipped.length, " non-text file(s) off the mock drive, which holds text files only: ") +
+                            "".concat(skipped.slice(0, 3).join(', ')).concat(skipped.length > 3 ? ', ...' : ''));
+                    }
+                    // Only now is the previous site expendable.
+                    fs_1.default.rmSync(outputFolder, { recursive: true, force: true });
+                    fs_1.default.mkdirSync(outputFolder, { recursive: true });
+                    // 1. the app
+                    copyFolder(webFolder, outputFolder);
+                    webFileCount = listFiles(outputFolder).length;
+                    hostFolder = path_1.default.join(outputFolder, 'host');
+                    fs_1.default.mkdirSync(hostFolder, { recursive: true });
+                    try {
+                        for (_b = __values([
+                            'md5.js',
+                            'runtime-core.js',
+                            'persist.js',
+                            'intercept.js'
+                        ]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                            asset = _c.value;
+                            fs_1.default.copyFileSync(path_1.default.join(ASSETS_FOLDER, asset), path_1.default.join(hostFolder, asset));
+                        }
+                    }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (_c && !_c.done && (_e = _b.return)) _e.call(_b);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                    }
+                    // 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'));
+                    hostVersion = (0, crypto_1.createHash)('md5')
+                        .update(['runtime-core.js', 'persist.js', 'intercept.js']
+                        .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')
+                        .slice(0, 10);
+                    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, "')")));
+                    snapshotSource = path_1.default.join(buildFolder, 'mock-snapshot.json');
+                    hasSnapshot = fs_1.default.existsSync(snapshotSource);
+                    if (hasSnapshot) {
+                        fs_1.default.copyFileSync(snapshotSource, path_1.default.join(hostFolder, 'vfs-snapshot.json'));
+                    }
+                    // 3. the drive, laid out from the compile output
+                    fs_1.default.writeFileSync(path_1.default.join(hostFolder, 'vfs-seed.json'), JSON.stringify({ files: seed }));
+                    fs_1.default.writeFileSync(path_1.default.join(hostFolder, 'mock-config.json'), JSON.stringify({
+                        appLoc: appLoc,
+                        seedPath: '/host/vfs-seed.json',
+                        driveEntries: driveEntries,
+                        jsPrograms: jsPrograms,
+                        programFolders: PROGRAM_FOLDERS,
+                        snapshot: hasSnapshot,
+                        builtAt: new Date().toISOString()
+                    }, null, 2));
+                    indexPath = path_1.default.join(outputFolder, 'index.html');
+                    _d = patchIndexHtml(fs_1.default.readFileSync(indexPath, 'utf8'), hostVersion), 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*/, {
+                            outputFolder: outputFolder,
+                            appLoc: appLoc,
+                            driveEntries: driveEntries,
+                            jsPrograms: jsPrograms,
+                            webFileCount: webFileCount,
+                            snapshot: hasSnapshot
+                        }];
+            }
+        });
+    });
+}

package/build/commands/build/internal/mockSite/spec/intercept.spec.d.ts

@@ -0,0 +1 @@
+export {};