@sasjs/cli 6.17.0 → 6.19.0

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

@@ -114,8 +114,15 @@
     stamp = ''
   }
 
+  // Registered relative to the page, and scoped to the directory it sits in:
+  // the site is served from the origin root on one host and from a folder on
+  // another (a demonstration site beside its own docs), and the worker's scope
+  // has to follow the page rather than assume the root.
   navigator.serviceWorker
-    .register('/sw.js' + stamp, { scope: '/', updateViaCache: 'none' })
+    .register(new URL('sw.js' + stamp, location.href).href, {
+      scope: './',
+      updateViaCache: 'none'
+    })
     .then(function () {
       return navigator.serviceWorker.ready
     })

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

@@ -31,6 +31,31 @@
     if (DEBUG) console.log('[sasjs-mock]', ...args)
   }
 
+  /**
+   * A file's contents, as text or as base64 with a flag.
+   *
+   * An upload is a file, not a string: a PNG, a workbook or an .sas7bdat read
+   * with `text()` arrives as replacement characters, and the drive would store
+   * the damage under a success status. The bytes are decoded as UTF-8 strictly -
+   * if that fails, they are not text by any reading a browser would accept - and
+   * carried as base64, which the worker turns back into the bytes the drive
+   * keeps.
+   */
+  const contentsOf = async (value) => {
+    const bytes = new Uint8Array(await value.arrayBuffer())
+
+    try {
+      return { csv: new TextDecoder('utf-8', { fatal: true }).decode(bytes) }
+    } catch (error) {
+      let binary = ''
+      const chunk = 0x8000
+      for (let i = 0; i < bytes.length; i += chunk)
+        binary += String.fromCharCode.apply(null, bytes.subarray(i, i + chunk))
+
+      return { csv: btoa(binary), binary: true }
+    }
+  }
+
   const readBody = async (body) => {
     const params = {}
     const tables = []
@@ -39,12 +64,16 @@
     if (typeof FormData !== 'undefined' && body instanceof FormData) {
       for (const [key, value] of body.entries()) {
         if (typeof value === 'string') params[key] = value
-        else
+        else {
+          const contents = await contentsOf(value)
+
           tables.push({
             name: key,
             filename: value.name || key + '.csv',
-            csv: await value.text()
+            csv: contents.csv,
+            ...(contents.binary ? { binary: true } : {})
           })
+        }
       }
       return { params, tables }
     }

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

@@ -32,7 +32,7 @@
  * encoding returns a string for either, as node does.
  */
 
-if (typeof importScripts === 'function') importScripts('/host/md5.js')
+if (typeof importScripts === 'function') importScripts('host/md5.js')
 
 // ---------------------------------------------------------------- posix path
 const P = {
@@ -841,8 +841,8 @@ const DRIVE_ROOT = '/sasjs/drive'
 // Rewritten at boot from host/mock-config.json, which the mock build writes.
 let APP_LOC = '/Public/app'
 let DRIVE_APP = `${DRIVE_ROOT}/files${APP_LOC}`
-const SEED_PATH = '/host/vfs-seed.json'
-const SNAPSHOT_PATH = '/host/vfs-snapshot.json'
+let SEED_PATH = 'host/vfs-seed.json'
+const SNAPSHOT_PATH = 'host/vfs-snapshot.json'
 
 /**
  * The drive storage format, stamped into the seed and the snapshot. The markers
@@ -864,13 +864,18 @@ const DRIVE_FORMAT = 1
  */
 const loadMockConfig = async () => {
   try {
-    const res = await fetch('/host/mock-config.json', { cache: 'no-store' })
+    const res = await fetch('host/mock-config.json', { cache: 'no-store' })
     if (!res.ok) return
     const cfg = await res.json()
     if (cfg && typeof cfg.appLoc === 'string' && cfg.appLoc.trim()) {
       APP_LOC = '/' + cfg.appLoc.replace(/^\/+/, '').replace(/\/+$/, '')
       DRIVE_APP = `${DRIVE_ROOT}/files${APP_LOC}`
     }
+    // the build names the seed it wrote; the default above covers a site built
+    // before the config carried it
+    if (cfg && typeof cfg.seedPath === 'string' && cfg.seedPath.trim()) {
+      SEED_PATH = cfg.seedPath
+    }
   } catch (e) {
     /* keep the defaults */
   }
@@ -887,7 +892,7 @@ let weboutSentinels = null
 
 const loadWeboutPrelude = async () => {
   try {
-    const res = await fetch('/host/webout-prelude.json', { cache: 'no-store' })
+    const res = await fetch('host/webout-prelude.json', { cache: 'no-store' })
     if (!res.ok) return
     const cfg = await res.json()
     if (cfg && typeof cfg.template === 'string') {

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

@@ -33,9 +33,9 @@
  * services are the package's; this file supplies the transport, the worker's own
  * activity, and the browser's answers to questions a server asks its process.
  */
-importScripts('/host/runtime-core.js')
-importScripts('/host/api-browser.js')
-importScripts('/host/lint-browser.js')
+importScripts('host/runtime-core.js')
+importScripts('host/api-browser.js')
+importScripts('host/lint-browser.js')
 
 const R = self.SASjsMockRuntime
 
@@ -317,6 +317,21 @@ const tablesOf = (files) => {
 
 const RUNTIME = new BrowserRuntime()
 
+/**
+ * The folder this site is served from.
+ *
+ * Empty at the origin root, `/demo` where a host publishes the demonstration
+ * site beside its own docs. The worker sits at `<base>/sw.js`, so its own
+ * location names the base and the route table can keep matching the paths the
+ * document states.
+ */
+const BASE = (self.location.pathname || '').replace(/\/sw\.js.*$/, '')
+
+const withoutBase = (pathname) =>
+  BASE && pathname.startsWith(BASE)
+    ? pathname.slice(BASE.length) || '/'
+    : pathname
+
 // ------------------------------------------------------------- host reports
 // The Admin routes ask a host what it is doing. A browser has no process, but it
 // does have a page, a heap and this worker's own activity, so the reports are
@@ -448,7 +463,7 @@ const registry = () => {
     registryPromise = (async () => {
       let appLoc
       try {
-        const config = await (await fetch('/host/mock-config.json')).json()
+        const config = await (await fetch('host/mock-config.json')).json()
         appLoc = config && config.appLoc
       } catch (e) {
         appLoc = undefined
@@ -477,7 +492,7 @@ const contentVersion = (text) => {
 
 const homeService = API.createHomeService(async () => {
   try {
-    const response = await fetch('/index.html', { cache: 'no-store' })
+    const response = await fetch('index.html', { cache: 'no-store' })
     if (!response.ok) return undefined
     const html = await response.text()
     return { html, version: contentVersion(html) }
@@ -574,7 +589,15 @@ const readJsonBody = async (request) => {
         name: table.name || `table${index + 1}`,
         filename:
           table.filename || `${table.name || 'table' + (index + 1)}.csv`,
-        contents: table.csv === undefined ? '' : table.csv
+        // A file the bridge could not read as UTF-8 travels as base64 with a
+        // flag: writing its text would replace the bytes and store the damage
+        // under a success status, which is what a binary upload used to do.
+        contents:
+          table.csv === undefined
+            ? ''
+            : table.binary
+              ? toBytes(table.csv)
+              : table.csv
       }))
     }
   }
@@ -852,7 +875,7 @@ const contentsResponse = (answer, path) => {
 }
 
 const routeRequest = async (request, url) => {
-  const path = url.pathname.replace(/\/+$/, '') || '/'
+  const path = withoutBase(url.pathname).replace(/\/+$/, '') || '/'
   const query = {}
   for (const [k, v] of url.searchParams.entries()) query[k] = v
 
@@ -873,13 +896,14 @@ const routeRequest = async (request, url) => {
     // serve nothing at `/AppStream/<name>/` here, and a listing that named it
     // would offer a tile that 404s.
     // `path` has its trailing slashes stripped, and these four answers differ by
-    // exactly that, so they are decided on the request's own pathname.
-    const stream = url.pathname
+    // exactly that, so they are decided on the request's own pathname - minus
+    // the folder the site is served from, which the four patterns do not name.
+    const stream = withoutBase(url.pathname)
 
     if (/^\/AppStream$/i.test(stream))
       return new Response(null, {
         status: 301,
-        headers: { location: '/AppStream/' }
+        headers: { location: `${BASE}/AppStream/` }
       })
 
     if (
@@ -1004,13 +1028,14 @@ const handle = async (request, url) => {
 self.addEventListener('fetch', (event) => {
   const url = new URL(event.request.url)
   if (url.origin !== self.location.origin) return
+  const path = withoutBase(url.pathname)
 
   // The site's own page is answered by the home route, but a navigation must
   // never be at the API's mercy: if that route throws or answers an error, the
   // request falls back to the static host, which holds the same index.html. A
   // broken API route can cost a client its data; it must not cost the app its
   // page.
-  if (url.pathname === '/') {
+  if (path === '/') {
     event.respondWith(
       (async () => {
         try {
@@ -1031,7 +1056,7 @@ self.addEventListener('fetch', (event) => {
   // JSON. `/AppStream` is one of those: the package serves app deployments, but
   // the listing is the server's web route, and an interface that lists apps asks
   // for it on every visit.
-  if (!/^\/(SASjsApi|SASLogon|AppStream)(\/|$)/i.test(url.pathname)) return
+  if (!/^\/(SASjsApi|SASLogon|AppStream)(\/|$)/i.test(path)) return
   event.respondWith(handle(event.request, url))
 })
 

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

@@ -530,6 +530,30 @@ var EXECUTABLE_TYPES = [
     'text/javascript',
     'application/javascript'
 ];
+/**
+ * The folder the site is published under, as a path with no trailing slash.
+ *
+ * Empty for the origin root, which is the ordinary case. A host that serves the
+ * demonstration site beside its documentation (a GitHub Pages site whose root is
+ * the docs) names the folder here, and every path the build emits follows it.
+ */
+var normaliseBasePath = function (value) {
+    if (!value)
+        return '';
+    var base = String(value).trim();
+    if (!base.startsWith('/'))
+        base = '/' + base;
+    base = base.replace(/\/+$/, '');
+    var segments = base.split('/').slice(1);
+    if (!segments.length ||
+        segments.some(function (segment) {
+            return !/^[A-Za-z0-9._~-]+$/.test(segment) ||
+                segment === '.' ||
+                segment === '..';
+        }))
+        throw new Error("mockWebBasePath is not a folder path: ".concat(JSON.stringify(value), ". Use a path such as \"/demo\", or leave it unset for the origin root."));
+    return base;
+};
 /**
  * Tells the interface that this page is answered by the browser host.
  *
@@ -566,12 +590,16 @@ var markBrowserHost = function (html, warnings) {
  * 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 patchIndexHtml = function (html, version, basePath) {
+    if (basePath === void 0) { basePath = ''; }
     var warnings = [];
     var patched = html;
     patched = markBrowserHost(patched, warnings);
     if (/<sasjs[^>]*>/i.test(patched)) {
-        patched = patched.replace(/(<sasjs[^>]*?)\sserverurl="[^"]*"/i, '$1 serverurl=""');
+        // the app talks to the origin root by default; on a site published under a
+        // folder it has to name that folder, or its API calls leave the worker's
+        // scope and meet the static host
+        patched = patched.replace(/(<sasjs[^>]*?)\sserverurl="[^"]*"/i, "$1 serverurl=\"".concat(basePath, "\""));
         patched = patched.replace(/(<sasjs[^>]*?)\sloginmechanism="[^"]*"/i, '$1 loginmechanism="Default"');
     }
     else {
@@ -646,11 +674,11 @@ var patchIndexHtml = function (html, version) {
  */
 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, 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, swPath, snapshotSource, hasSnapshot, indexPath, _d, patched, warnings;
         var e_8, _e;
-        var _f, _g, _h, _j;
-        return __generator(this, function (_k) {
-            switch (_k.label) {
+        var _f, _g, _h, _j, _k, _l;
+        return __generator(this, function (_m) {
+            switch (_m.label) {
                 case 0:
                     projectDir = process.projectDir || process.cwd();
                     appLocRaw = target.appLoc;
@@ -662,23 +690,24 @@ function buildMockSite(target) {
                         path_1.default.join(projectDir, 'sasjsbuild');
                     return [4 /*yield*/, (0, utils_1.folderExists)(buildFolder)];
                 case 1:
-                    if (!(_k.sent())) {
+                    if (!(_m.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;
+                    basePath = normaliseBasePath((_f = target.streamConfig) === null || _f === void 0 ? void 0 : _f.mockWebBasePath);
+                    webSourceRaw = (_g = target.streamConfig) === null || _g === void 0 ? void 0 : _g.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 (!(_k.sent())) {
+                    if (!(_m.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)
+                    outputFolder = ((_h = target.streamConfig) === null || _h === void 0 ? void 0 : _h.mockWebFolder)
                         ? path_1.default.resolve(projectDir, target.streamConfig.mockWebFolder)
                         : path_1.default.join(buildFolder, 'mock');
                     assertSafeOutputFolder(outputFolder, projectDir, buildFolder, webFolder);
@@ -693,21 +722,20 @@ function buildMockSite(target) {
                     jsPrograms = countPrograms(seed, '.js');
                     sasPrograms = countPrograms(seed, '.sas');
                     driveEntries = Object.keys(seed).length;
-                    // A build holding SAS and no JavaScript is a SAS target: its services cannot
-                    // run here, and seeding them would produce a site whose buttons answer 400.
-                    // A build holding NEITHER is a frontend host - the app is the whole thing and
-                    // the worker answers its API - which is what an interface with no services
-                    // compiles to, and the case this site is built for.
+                    // A build whose services are SAS is still a site worth having, and it is built:
+                    // the programs are seeded on the drive, where a visitor can open them in Studio
+                    // and read them - which is how a deployment's own backend code is inspected
+                    // without a SAS licence and without a login. What they cannot do is run here,
+                    // so the build says so rather than letting a Run button be the surprise.
                     if (jsPrograms === 0 && sasPrograms > 0) {
-                        throw new Error("No .js programs in ".concat(buildFolder, "/services, /jobs or /tests, but ").concat(sasPrograms, " SAS program(s). This target builds SAS code, which cannot run in a browser. ") +
-                            'Build a target whose services are JavaScript (typically a mocks project).');
+                        (_j = process.logger) === null || _j === void 0 ? void 0 : _j.warn("".concat(sasPrograms, " SAS program(s) and no JavaScript in ").concat(buildFolder, ": they are placed on the drive to read, and cannot run in a browser."));
                     }
                     // No PROGRAMS is a different thing again: a compile that produced nothing, or
                     // a stale sasjsbuild from an unrelated command - `sasjs doc` leaves a folder
                     // behind that is not a program folder but does reach the drive, so the count
                     // that decides this is of programs, not of files.
                     if (jsPrograms + sasPrograms === 0) {
-                        (_h = process.logger) === null || _h === void 0 ? void 0 : _h.warn("No compiled programs in ".concat(buildFolder, ": this site ships with an empty drive. ") +
+                        (_k = process.logger) === null || _k === void 0 ? void 0 : _k.warn("No compiled programs in ".concat(buildFolder, ": this site ships with an empty drive. ") +
                             'That is expected for an interface with no services; for anything else, check that compile wrote the target.');
                     }
                     // The package supplies the drive rules the worker answers with, so an install
@@ -720,7 +748,7 @@ function buildMockSite(target) {
                             'or check that @sasjs/api still publishes build/browser.js.');
                     }
                     if (skipped.length) {
-                        (_j = process.logger) === null || _j === void 0 ? void 0 : _j.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: ") +
+                        (_l = process.logger) === null || _l === void 0 ? void 0 : _l.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
                                 .slice(0, 3)
                                 .map(function (file) {
@@ -767,7 +795,7 @@ function buildMockSite(target) {
                 case 3:
                     // 2. the linter, bundled from the installed packages so the code routes answer
                     // with the rules this CLI resolved rather than a second implementation
-                    _k.sent();
+                    _m.sent();
                     // 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'));
@@ -803,9 +831,9 @@ 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/api-browser.js')", "importScripts('/host/api-browser.js?v=".concat(hostVersion, "')"))
-                        .replace("importScripts('/host/lint-browser.js')", "importScripts('/host/lint-browser.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, "')"))
+                        .replace("importScripts('host/lint-browser.js')", "importScripts('host/lint-browser.js?v=".concat(hostVersion, "')")));
                     snapshotSource = path_1.default.join(buildFolder, 'mock-snapshot.json');
                     hasSnapshot = fs_1.default.existsSync(snapshotSource);
                     if (hasSnapshot) {
@@ -815,7 +843,7 @@ function buildMockSite(target) {
                     fs_1.default.writeFileSync(path_1.default.join(hostFolder, 'vfs-seed.json'), JSON.stringify({ format: exports.DRIVE_FORMAT, files: seed }));
                     fs_1.default.writeFileSync(path_1.default.join(hostFolder, 'mock-config.json'), JSON.stringify({
                         appLoc: appLoc,
-                        seedPath: '/host/vfs-seed.json',
+                        seedPath: 'host/vfs-seed.json',
                         driveEntries: driveEntries,
                         jsPrograms: jsPrograms,
                         programFolders: PROGRAM_FOLDERS,
@@ -823,7 +851,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), patched = _d.patched, warnings = _d.warnings;
+                    _d = patchIndexHtml(fs_1.default.readFileSync(indexPath, 'utf8'), hostVersion, basePath), 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/boot.spec.js

@@ -125,7 +125,10 @@ var loadBoot = function (specs, options) {
             stored[key] = value;
         }
     };
-    global.location = { reload: function () { return timeline.push('reload'); } };
+    global.location = {
+        href: options.href || 'http://localhost:8123/',
+        reload: function () { return timeline.push('reload'); }
+    };
     jest.spyOn(console, 'error').mockImplementation(function () { });
     require('../assets/boot.js');
     var claim = function () {
@@ -162,7 +165,7 @@ describe('the boot loader', function () {
         delete global.sessionStorage;
         delete global.location;
     });
-    it("registers the worker at the site root, at the build's version", function () { return __awaiter(void 0, void 0, void 0, function () {
+    it("registers the worker beside the page, at the build's version", function () { return __awaiter(void 0, void 0, void 0, function () {
         var registered;
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -170,15 +173,36 @@ describe('the boot loader', function () {
                     registered = loadBoot([]).registered;
                     return [4 /*yield*/, settle()
                         // a cached sw.js would keep a returning visitor on the previous build's
-                        // worker, so the URL carries the host version and the check skips the cache
+                        // worker, so the URL carries the host version and the check skips the cache.
+                        // The scope is the page's own folder: the site is served from the origin
+                        // root on one host and from /demo beside its docs on another.
                     ];
                 case 1:
                     _a.sent();
                     // a cached sw.js would keep a returning visitor on the previous build's
-                    // worker, so the URL carries the host version and the check skips the cache
+                    // worker, so the URL carries the host version and the check skips the cache.
+                    // The scope is the page's own folder: the site is served from the origin
+                    // root on one host and from /demo beside its docs on another.
                     expect(registered).toEqual([
-                        '/sw.js?v=abc123 ' +
-                            JSON.stringify({ scope: '/', updateViaCache: 'none' })
+                        'http://localhost:8123/sw.js?v=abc123 ' +
+                            JSON.stringify({ scope: './', updateViaCache: 'none' })
+                    ]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('registers the worker under the folder the page is served from', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var registered;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    registered = loadBoot([], { href: 'http://localhost:8123/demo/' }).registered;
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _a.sent();
+                    expect(registered).toEqual([
+                        'http://localhost:8123/demo/sw.js?v=abc123 ' +
+                            JSON.stringify({ scope: './', updateViaCache: 'none' })
                     ]);
                     return [2 /*return*/];
             }
@@ -328,7 +352,7 @@ describe('the boot loader', function () {
                     return [4 /*yield*/, settle()];
                 case 1:
                     _a.sent();
-                    expect(registered[0]).toMatch(/^\/sw\.js /);
+                    expect(registered[0]).toMatch(/\/sw\.js \{/);
                     return [2 /*return*/];
             }
         });
@@ -447,7 +471,10 @@ describe('the boot loader', function () {
                     global.navigator = {};
                     global.window = {};
                     global.sessionStorage = { getItem: function () { return null; }, setItem: function () { } };
-                    global.location = { reload: function () { } };
+                    global.location = {
+                        href: 'http://localhost:8123/',
+                        reload: function () { }
+                    };
                     jest.spyOn(console, 'error').mockImplementation(function () { });
                     require('../assets/boot.js');
                     return [4 /*yield*/, settle()];

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

@@ -210,6 +210,32 @@ describe('page-side bridge', function () {
             }
         });
     }); });
+    it('carries a binary file as base64 rather than as damaged text', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var fetchImpl, XHR, bytes, form, xhr, _a, init, payload;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    fetchImpl = jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, jsonResponse('{"status":"success"}')];
+                    }); }); });
+                    XHR = loadBridge(fetchImpl).XHR;
+                    bytes = new Uint8Array([
+                        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a
+                    ]);
+                    form = new FormData();
+                    form.append('file', new Blob([bytes], { type: 'image/png' }), 'logo.png');
+                    xhr = new XHR();
+                    return [4 /*yield*/, run(xhr, 'POST', '/SASjsApi/drive/file', form)];
+                case 1:
+                    _b.sent();
+                    _a = __read(fetchImpl.mock.calls[0], 2), init = _a[1];
+                    payload = JSON.parse(init.body);
+                    expect(payload.tables[0].binary).toBe(true);
+                    expect(payload.tables[0].csv).toBe(btoa('‰PNG\r\n\n'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('parses the response when the app asked for json', function () { return __awaiter(void 0, void 0, void 0, function () {
         var XHR, xhr;
         return __generator(this, function (_a) {

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

@@ -208,9 +208,9 @@ describe('browser-hosted build', function () {
                     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).toMatch(/importScripts\('\/host\/lint-browser\.js\?v=[0-9a-f]{10}'\)/);
+                    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).toMatch(/importScripts\('host\/lint-browser\.js\?v=[0-9a-f]{10}'\)/);
                     expect(sw).not.toContain("importScripts('/host/runtime-core.js')");
                     return [2 /*return*/];
             }
@@ -366,6 +366,35 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
+    it('serves the site under a folder when the target names one', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var html;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target({ mockWebBasePath: '/demo' }))];
+                case 1:
+                    _a.sent();
+                    html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    expect(html).toContain('serverurl="/demo"');
+                    // the loader and the host's files stay relative to the page, so the same
+                    // build works at the origin root and under the folder
+                    expect(html).toContain('<script src="host/boot.js?v=');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('refuses a base path that is not a folder path', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, expect((0, mockSite_1.buildMockSite)(target({ mockWebBasePath: '/demo?x=1' }))).rejects.toThrow(/mockWebBasePath/)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, expect((0, mockSite_1.buildMockSite)(target({ mockWebBasePath: '../escape' }))).rejects.toThrow(/mockWebBasePath/)];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('points the app at itself and installs the boot loader', function () { return __awaiter(void 0, void 0, void 0, function () {
         var html;
         return __generator(this, function (_a) {
@@ -667,25 +696,32 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
-    it('refuses a target whose services are SAS, and keeps the previous site', function () { return __awaiter(void 0, void 0, void 0, function () {
-        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');
+    /**
+     * A SAS backend does not run in a browser, but the programs are still worth
+     * shipping: the drive holds them, so a visitor can open them in Studio and
+     * read what a deployment's services do. The build warns and carries on.
+     */
+    it('builds a target whose services are SAS, and warns they cannot run', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var warn, result, seed;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
                     fs_1.default.rmSync(path_1.default.join(root, 'sasjsbuild', 'services'), {
                         recursive: true,
                         force: true
                     });
                     write(path_1.default.join(root, 'sasjsbuild', 'services', 'public', 'getdata.sas'), '%put sas;\n');
-                    return [4 /*yield*/, expect((0, mockSite_1.buildMockSite)(target())).rejects.toThrow(/No \.js programs/)
-                        // the failure is not allowed to take the last good site with it
-                    ];
-                case 2:
-                    _a.sent();
-                    // the failure is not allowed to take the last good site with it
-                    expect(fs_1.default.readFileSync(path_1.default.join(out(), 'stale.txt'), 'utf8')).toBe('previous');
+                    warn = jest.spyOn((_a = process.logger) !== null && _a !== void 0 ? _a : console, 'warn');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _b.sent();
+                    expect(result.jsPrograms).toBe(0);
+                    expect(result.driveEntries).toBeGreaterThan(0);
+                    expect(warn).toHaveBeenCalledWith(expect.stringContaining('cannot run in a browser'));
+                    seed = readSeed();
+                    expect(Object.keys(seed.files).some(function (key) { return key.endsWith('/getdata.sas'); })).toBe(true);
+                    warn.mockRestore();
                     return [2 /*return*/];
             }
         });

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

@@ -102,12 +102,14 @@ var lintBundle = function () {
     }
     return lintBundlePath;
 };
-var loadWorker = function () {
+var loadWorker = function (base) {
+    if (base === void 0) { base = ''; }
     jest.resetModules();
     var handlers = {};
     var refusingWrites = false;
     var self = {
-        location: { origin: origin },
+        // the worker's own location names the folder the site is served from
+        location: { origin: origin, pathname: "".concat(base, "/sw.js") },
         addEventListener: function (type, fn) {
             handlers[type] = handlers[type] || [];
             handlers[type].push(fn);
@@ -890,6 +892,58 @@ describe('service worker host', function () {
                 }
             });
         }); });
+        it('answers every route under the folder the site is published in', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, info, _a, page, folder, stream, landing, apps, _b;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        worker = loadWorker('/demo');
+                        worker.runtime.load((_c = {},
+                            _c[drivePath('services/public/getdata.js')] = '_webout = "seeded";',
+                            _c));
+                        return [4 /*yield*/, worker.dispatch('/demo/SASjsApi/info')];
+                    case 1:
+                        info = _d.sent();
+                        expect(info.status).toBe(200);
+                        _a = expect;
+                        return [4 /*yield*/, info.json()];
+                    case 2:
+                        _a.apply(void 0, [(_d.sent()).mode]).toBe('desktop');
+                        return [4 /*yield*/, worker.dispatch('/demo/')];
+                    case 3:
+                        page = _d.sent();
+                        expect(page.status).toBe(200);
+                        expect(page.headers.get('content-type')).toContain('text/html');
+                        return [4 /*yield*/, worker.dispatch('/demo')];
+                    case 4:
+                        folder = _d.sent();
+                        expect(folder.status).toBe(200);
+                        expect(folder.headers.get('content-type')).toContain('text/html');
+                        return [4 /*yield*/, worker.dispatch('/demo/AppStream')];
+                    case 5:
+                        stream = _d.sent();
+                        expect(stream.status).toBe(301);
+                        expect(stream.headers.get('location')).toBe('/demo/AppStream/');
+                        return [4 /*yield*/, worker.dispatch('/demo/AppStream/')];
+                    case 6:
+                        landing = _d.sent();
+                        expect(landing.status).toBe(200);
+                        expect(landing.headers.get('content-type')).toContain('text/html');
+                        return [4 /*yield*/, worker.dispatch('/demo/AppStream/apps.json')];
+                    case 7:
+                        apps = _d.sent();
+                        expect(apps.status).toBe(200);
+                        _b = expect;
+                        return [4 /*yield*/, apps.json()];
+                    case 8:
+                        _b.apply(void 0, [_d.sent()]).toEqual({ apps: [] });
+                        // a path outside the folder is not the site's to answer
+                        expect(worker.dispatch('/other/SASjsApi/info')).toBeUndefined();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
         it('serves the build page at the home route, and falls back when it fails', function () { return __awaiter(void 0, void 0, void 0, function () {
             var worker, response, _a, runtime, original, fallback, body;
             return __generator(this, function (_b) {
@@ -1139,6 +1193,46 @@ describe('service worker host', function () {
             });
         }); });
     });
+    it('writes a binary upload as its bytes, not as the text it decodes to', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var dispatch, image, created, read, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    dispatch = seeded().dispatch;
+                    image = new Uint8Array([
+                        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a
+                    ]);
+                    return [4 /*yield*/, dispatch('/SASjsApi/drive/file', {
+                            method: 'POST',
+                            headers: { 'content-type': 'application/json' },
+                            body: JSON.stringify({
+                                params: { filePath: '/Public/logo.png' },
+                                tables: [
+                                    {
+                                        name: 'file',
+                                        filename: 'logo.png',
+                                        csv: btoa(String.fromCharCode.apply(null, Array.from(image))),
+                                        binary: true
+                                    }
+                                ]
+                            })
+                        })];
+                case 1:
+                    created = _c.sent();
+                    expect(created.status).toBe(200);
+                    return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/Public/logo.png'))];
+                case 2:
+                    read = _c.sent();
+                    expect(read.status).toBe(200);
+                    _a = expect;
+                    _b = Uint8Array.bind;
+                    return [4 /*yield*/, read.arrayBuffer()];
+                case 3:
+                    _a.apply(void 0, [new (_b.apply(Uint8Array, [void 0, _c.sent()]))()]).toEqual(image);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('answers 404 for a drive file the drive does not hold', function () { return __awaiter(void 0, void 0, void 0, function () {
         var dispatch, response, _a;
         return __generator(this, function (_b) {

package/package.json

@@ -125,5 +125,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.17.0"
+  "version": "6.19.0"
 }