@sasjs/cli 6.30.1 → 6.32.0

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

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

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

@@ -0,0 +1,415 @@
+"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 __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 });
+/**
+ * @jest-environment jsdom
+ * @jest-environment-options {"url": "http://localhost/demo/api-console/"}
+ */
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+/**
+ * The console under a base path.
+ *
+ * `mockWebBasePath` is a supported option (a site published at `/demo`), and the
+ * console works out its root from the worker it registered - `<base>/sw.js` - with
+ * its own URL as the fallback. This file runs the page at `/demo/api-console/`,
+ * where a wrong derivation is silent: the page still renders, and every call goes
+ * to a path the host does not answer.
+ */
+var assets = path_1.default.join(__dirname, '..', 'assets');
+var page = function () { return fs_1.default.readFileSync(path_1.default.join(assets, 'api-index.html'), 'utf8'); };
+var bodyOf = function (html) {
+    return html.slice(html.indexOf('<body>') + 6, html.lastIndexOf('</body>'));
+};
+var jsonResponse = function (body) { return ({
+    ok: true,
+    status: 200,
+    statusText: 'OK',
+    headers: { get: function () { return 'application/json'; } },
+    json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2 /*return*/, body];
+    }); }); },
+    text: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2 /*return*/, JSON.stringify(body)];
+    }); }); }
+}); };
+var operations = [
+    {
+        id: 'GET /SASjsApi/user',
+        method: 'GET',
+        path: '/SASjsApi/user',
+        tag: 'User',
+        summary: 'List all users',
+        params: [],
+        requestBodies: [],
+        responses: [{ status: 200, description: 'Ok' }],
+        implemented: true
+    }
+];
+var settle = function (check) { return __awaiter(void 0, void 0, void 0, function () {
+    var i;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                i = 0;
+                _a.label = 1;
+            case 1:
+                if (!(i < 400)) return [3 /*break*/, 4];
+                if (check())
+                    return [2 /*return*/];
+                return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 5); })];
+            case 2:
+                _a.sent();
+                _a.label = 3;
+            case 3:
+                i++;
+                return [3 /*break*/, 1];
+            case 4: throw new Error('the page did not reach the state the case expected');
+        }
+    });
+}); };
+describe('the API console under a base path', function () {
+    afterEach(function () {
+        delete navigator.serviceWorker;
+    });
+    it('takes the root from the worker that covers it, not from its own folder', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var realCreate, sw, asked;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // the shapes where the two disagree are the only ones that prove the worker
+                    // is read at all: the site's worker at `/demo/sw.js` controlling a console
+                    // two folders down still names `/demo/`, which the folder alone cannot
+                    document.body.innerHTML = bodyOf(page());
+                    document.head.innerHTML =
+                        '<meta name="sasjs-mock-version" content="3.0.0" />';
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            return [2 /*return*/, String(url).includes('operations.json')
+                                    ? jsonResponse(operations)
+                                    : jsonResponse({ format: 1, users: [] })];
+                        });
+                    }); });
+                    realCreate = document.createElement.bind(document);
+                    jest.spyOn(document, 'createElement').mockImplementation(function (tag) {
+                        var node = realCreate(tag);
+                        if (String(tag).toLowerCase() === 'script')
+                            setTimeout(function () { return node.dispatchEvent(new Event('load')); }, 0);
+                        return node;
+                    });
+                    sw = {
+                        controller: { scriptURL: 'http://localhost/demo/sw.js' },
+                        register: jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, ({})];
+                        }); }); }),
+                        addEventListener: jest.fn()
+                    };
+                    Object.defineProperty(navigator, 'serviceWorker', {
+                        value: sw,
+                        configurable: true
+                    });
+                    history.replaceState({}, '', '/demo/tools/api-console/');
+                    jest.resetModules();
+                    require('../assets/api-console.js');
+                    return [4 /*yield*/, settle(function () {
+                            return global.fetch.mock.calls.some(function (call) {
+                                return String(call[0]).includes('identity.json');
+                            });
+                        })];
+                case 1:
+                    _a.sent();
+                    asked = global.fetch.mock.calls.map(function (call) {
+                        return String(call[0]);
+                    });
+                    // the site's root, not the folder two levels up from the page
+                    expect(asked).toContain('/demo/host/identity.json');
+                    expect(asked.some(function (url) { return url.startsWith('/demo/tools/'); })).toBe(false);
+                    history.replaceState({}, '', '/demo/tools/api-console/');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('ignores a worker that belongs to another site', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var realCreate, sw, asked;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // a page can be controlled by some other site's worker; its `sw.js` names a
+                    // root that has nothing to do with this console, so the page's own folder has
+                    // to win
+                    document.body.innerHTML = bodyOf(page());
+                    document.head.innerHTML =
+                        '<meta name="sasjs-mock-version" content="3.0.0" />';
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            return [2 /*return*/, String(url).includes('operations.json')
+                                    ? jsonResponse(operations)
+                                    : jsonResponse({ format: 1, users: [] })];
+                        });
+                    }); });
+                    realCreate = document.createElement.bind(document);
+                    jest.spyOn(document, 'createElement').mockImplementation(function (tag) {
+                        var node = realCreate(tag);
+                        if (String(tag).toLowerCase() === 'script')
+                            setTimeout(function () { return node.dispatchEvent(new Event('load')); }, 0);
+                        return node;
+                    });
+                    sw = {
+                        controller: { scriptURL: 'http://localhost/other/sw.js' },
+                        register: jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, ({})];
+                        }); }); }),
+                        addEventListener: jest.fn()
+                    };
+                    Object.defineProperty(navigator, 'serviceWorker', {
+                        value: sw,
+                        configurable: true
+                    });
+                    history.replaceState({}, '', '/demo/api-console/');
+                    jest.resetModules();
+                    require('../assets/api-console.js');
+                    return [4 /*yield*/, settle(function () {
+                            return global.fetch.mock.calls.some(function (call) {
+                                return String(call[0]).includes('identity.json');
+                            });
+                        })];
+                case 1:
+                    _a.sent();
+                    asked = global.fetch.mock.calls.map(function (call) {
+                        return String(call[0]);
+                    });
+                    expect(asked).toContain('/demo/host/identity.json');
+                    expect(asked.some(function (url) { return url.startsWith('/other/'); })).toBe(false);
+                    history.replaceState({}, '', '/demo/api-console/');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('finds the folder from a URL without its trailing slash', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var realCreate, sw, asked;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // `/demo/api` is the shape a person types, and the page used to read that as
+                    // the origin root: every call went to /SASjsApi/... and the worker to /sw.js
+                    history.replaceState({}, '', '/demo/api-console');
+                    expect(location.pathname).toBe('/demo/api-console');
+                    document.body.innerHTML = bodyOf(page());
+                    document.head.innerHTML =
+                        '<meta name="sasjs-mock-version" content="2.0.0" />';
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            return [2 /*return*/, String(url).includes('operations.json')
+                                    ? jsonResponse(operations)
+                                    : jsonResponse({ format: 1, users: [] })];
+                        });
+                    }); });
+                    realCreate = document.createElement.bind(document);
+                    jest.spyOn(document, 'createElement').mockImplementation(function (tag) {
+                        var node = realCreate(tag);
+                        if (String(tag).toLowerCase() === 'script')
+                            setTimeout(function () { return node.dispatchEvent(new Event('load')); }, 0);
+                        return node;
+                    });
+                    sw = {
+                        controller: {},
+                        register: jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, ({})];
+                        }); }); }),
+                        addEventListener: jest.fn()
+                    };
+                    Object.defineProperty(navigator, 'serviceWorker', {
+                        value: sw,
+                        configurable: true
+                    });
+                    jest.resetModules();
+                    require('../assets/api-console.js');
+                    return [4 /*yield*/, settle(function () { return sw.register.mock.calls.length === 1; })];
+                case 1:
+                    _a.sent();
+                    expect(sw.register.mock.calls[0][0]).toContain('/demo/sw.js?v=2.0.0');
+                    expect(sw.register.mock.calls[0][1]).toEqual(expect.objectContaining({ scope: '/demo/' }));
+                    return [4 /*yield*/, settle(function () { return document.querySelectorAll('#routes .route').length > 0; })];
+                case 2:
+                    _a.sent();
+                    asked = global.fetch.mock.calls.map(function (call) {
+                        return String(call[0]);
+                    });
+                    expect(asked).toContain('/demo/host/identity.json');
+                    history.replaceState({}, '', '/demo/api-console/');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('registers the worker and calls the API under the folder the site lives in', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var calls, realCreate, sw, errors, errorSpy, warnSpy, asked;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    document.body.innerHTML = bodyOf(page());
+                    document.head.innerHTML =
+                        '<meta name="sasjs-mock-version" content="2.0.0" />';
+                    calls = [];
+                    global.fetch = jest.fn(function (url_1) {
+                        var args_1 = [];
+                        for (var _i = 1; _i < arguments.length; _i++) {
+                            args_1[_i - 1] = arguments[_i];
+                        }
+                        return __awaiter(void 0, __spreadArray([url_1], __read(args_1), false), void 0, function (url, init) {
+                            if (init === void 0) { init = {}; }
+                            return __generator(this, function (_a) {
+                                if (String(url).includes('operations.json'))
+                                    return [2 /*return*/, jsonResponse(operations)];
+                                if (String(url).includes('identity.json'))
+                                    return [2 /*return*/, jsonResponse({ format: 1, users: [] })];
+                                calls.push({ url: String(url), init: init });
+                                return [2 /*return*/, jsonResponse([])];
+                            });
+                        });
+                    });
+                    realCreate = document.createElement.bind(document);
+                    jest.spyOn(document, 'createElement').mockImplementation(function (tag) {
+                        var node = realCreate(tag);
+                        if (String(tag).toLowerCase() === 'script')
+                            setTimeout(function () { return node.dispatchEvent(new Event('load')); }, 0);
+                        return node;
+                    });
+                    sw = {
+                        controller: {},
+                        register: jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, ({})];
+                        }); }); }),
+                        addEventListener: jest.fn()
+                    };
+                    Object.defineProperty(navigator, 'serviceWorker', {
+                        value: sw,
+                        configurable: true
+                    });
+                    errors = [];
+                    errorSpy = jest
+                        .spyOn(console, 'error')
+                        .mockImplementation(function () {
+                        var args = [];
+                        for (var _i = 0; _i < arguments.length; _i++) {
+                            args[_i] = arguments[_i];
+                        }
+                        return errors.push(args);
+                    });
+                    warnSpy = jest
+                        .spyOn(console, 'warn')
+                        .mockImplementation(function () {
+                        var args = [];
+                        for (var _i = 0; _i < arguments.length; _i++) {
+                            args[_i] = arguments[_i];
+                        }
+                        return errors.push(args);
+                    });
+                    jest.resetModules();
+                    require('../assets/api-console.js');
+                    return [4 /*yield*/, settle(function () { return sw.register.mock.calls.length === 1; }).catch(function (e) {
+                            throw new Error(e.message +
+                                ' | errors: ' +
+                                JSON.stringify(errors) +
+                                ' | routes: ' +
+                                (document.getElementById('routes') || {}).textContent);
+                        })];
+                case 1:
+                    _a.sent();
+                    errorSpy.mockRestore();
+                    warnSpy.mockRestore();
+                    expect(sw.register.mock.calls[0][0]).toContain('/demo/sw.js?v=2.0.0');
+                    expect(sw.register.mock.calls[0][1]).toEqual(expect.objectContaining({ scope: '/demo/' }));
+                    // the page's data comes from the same folder, not from the origin root
+                    return [4 /*yield*/, settle(function () { return document.querySelectorAll('#routes .route').length > 0; }).catch(function (e) {
+                            throw new Error(e.message +
+                                ' | routes: ' +
+                                JSON.stringify((document.getElementById('routes') || {}).textContent) +
+                                ' | fetched: ' +
+                                JSON.stringify(global.fetch.mock.calls.map(function (c) { return String(c[0]); })) +
+                                ' | errors: ' +
+                                JSON.stringify(errors));
+                        })];
+                case 2:
+                    // the page's data comes from the same folder, not from the origin root
+                    _a.sent();
+                    asked = global.fetch.mock.calls.map(function (call) {
+                        return String(call[0]);
+                    });
+                    // the page's own table is fetched relative to the page, so it follows the
+                    // folder without any substitution; the host files are addressed absolutely
+                    expect(asked).toContain('operations.json');
+                    expect(asked).toContain('/demo/host/identity.json');
+                    __spreadArray([], __read(document.querySelectorAll('#routes .route')), false)[0].click();
+                    document.getElementById('send').click();
+                    return [4 /*yield*/, settle(function () { return calls.length > 0; })];
+                case 3:
+                    _a.sent();
+                    expect(calls[0].url).toBe('/demo/SASjsApi/user');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

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

@@ -1042,6 +1042,90 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
+    /**
+     * The API console is generated, not written.
+     *
+     * It is the page that lets a visitor try the API a mock site is a mock of, so
+     * it has to list the operations the package actually answers - and be
+     * generated from the same route table the worker dispatches, or the page and
+     * the host drift.
+     */
+    it('ships an API console built from the route table', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, folder, shipped, sw, operations, createUser, html, version, appHtml, loader;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _a.sent();
+                    expect(result.apiConsole).toBe(true);
+                    folder = path_1.default.join(out(), 'api-console');
+                    shipped = fs_1.default.readdirSync(folder).sort();
+                    // every file the folder holds, and the worker's passthrough list is that same
+                    // list: a second copy in sw.js would let a new file be answered as an API path
+                    expect(shipped).toEqual([
+                        'console.css',
+                        'console.js',
+                        'index.html',
+                        'operations.json'
+                    ]);
+                    sw = fs_1.default.readFileSync(path_1.default.join(out(), 'sw.js'), 'utf8');
+                    expect(sw).not.toContain('API_CONSOLE_FILES');
+                    operations = JSON.parse(fs_1.default.readFileSync(path_1.default.join(folder, 'operations.json'), 'utf8'));
+                    expect(operations.length).toBeGreaterThan(20);
+                    createUser = operations.find(function (operation) { return operation.id === 'POST /SASjsApi/user'; });
+                    expect(createUser).toBeDefined();
+                    expect(createUser.params.map(function (parameter) { return parameter.name; })).toEqual(expect.arrayContaining(['username', 'password']));
+                    expect(createUser.method).toBe('POST');
+                    html = fs_1.default.readFileSync(path_1.default.join(folder, 'index.html'), 'utf8');
+                    expect(html).toContain('<script src="console.js"></script>');
+                    expect(html).not.toMatch(/<script(?![^>]*\ssrc=)[^>]*>[\s\S]*?<\/script>/);
+                    version = /<meta name="sasjs-mock-version" content="([^"]+)" \/>/.exec(html);
+                    expect(version).not.toBeNull();
+                    appHtml = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    loader = /host\/boot\.js\?v=([^"']+)/.exec(appHtml);
+                    expect(loader).not.toBeNull();
+                    expect(version[1]).toBe(loader[1]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves the console out when the site ships its own console folder, and says so', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var own, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    own = path_1.default.join(root, 'client', 'dist', 'api-console');
+                    fs_1.default.mkdirSync(own, { recursive: true });
+                    fs_1.default.writeFileSync(path_1.default.join(own, 'index.html'), '<p>ours</p>');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())
+                        // the project's file is not replaced, and the loss is reported rather than
+                        // silent: the build has no way to know which of the two the site wants
+                    ];
+                case 1:
+                    result = _a.sent();
+                    // the project's file is not replaced, and the loss is reported rather than
+                    // silent: the build has no way to know which of the two the site wants
+                    expect(result.apiConsole).toBe(false);
+                    expect(fs_1.default.readFileSync(path_1.default.join(out(), 'api-console', 'index.html'), 'utf8')).toBe('<p>ours</p>');
+                    expect(fs_1.default.existsSync(path_1.default.join(out(), 'api-console', 'console.js'))).toBe(false);
+                    expect(process.logger.warn).toHaveBeenCalledWith(expect.stringContaining('api-console/index.html'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves the console out when the target asks for the app alone', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target({ mockApi: false }))];
+                case 1:
+                    result = _a.sent();
+                    expect(result.apiConsole).toBe(false);
+                    expect(fs_1.default.existsSync(path_1.default.join(out(), 'api-console'))).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('ships a recorded SAS session when the project has one', function () { return __awaiter(void 0, void 0, void 0, function () {
         var recording, result;
         var _a;

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

@@ -2561,6 +2561,34 @@ describe('service worker host', function () {
             }
         });
     }); });
+    /**
+     * The console's own files are the page, not an API call.
+     *
+     * `/api/...` is the API's short spelling, so the worker answers it - except for
+     * `/api` itself, which a site's own application may answer.
+     */
+    it('leaves /api to the site, and answers the short spelling below it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, response;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    worker = seeded();
+                    // a site's own application can answer /api (the server interface does), so the
+                    // worker hands it on; `/api/<something>` is an API call on the short spelling
+                    expect(worker.dispatch('/api')).toBeUndefined();
+                    expect(worker.dispatch('/api/')).toBeUndefined();
+                    // the console has a folder of its own, which is not an API prefix: the static
+                    // host serves it and the worker never sees it
+                    expect(worker.dispatch('/api-console/console.js')).toBeUndefined();
+                    expect(worker.dispatch('/api-console/operations.json')).toBeUndefined();
+                    return [4 /*yield*/, worker.dispatch('/api/user')];
+                case 1:
+                    response = _a.sent();
+                    expect(response.status).toBe(200);
+                    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/build/commands/version/spec/version.spec.js

@@ -75,6 +75,11 @@ describe('versionMessage', function () {
         writePackage(root, '6.4.7-alpha.1');
         expect((0, version_1.versionMessage)(root)).toEqual("You are using a linked version of SASjs CLI (v6.4.7-alpha.1) running from sources at ".concat(root));
     });
+    it('leaves the placeholder version out of a source checkout', function () {
+        var root = path_1.default.join(tempRoot(), 'cli');
+        writePackage(root, '0.0.0');
+        expect((0, version_1.versionMessage)(root)).toEqual("You are using a linked version of SASjs CLI running from sources at ".concat(root));
+    });
     it('leaves the version out of a source checkout that has none', function () {
         var root = path_1.default.join(tempRoot(), 'cli');
         writePackage(root, undefined);
@@ -92,6 +97,11 @@ describe('versionMessage', function () {
     it('throws when an installed package carries no version', function () {
         var root = packageRoot();
         writePackage(root, undefined);
-        expect(function () { return (0, version_1.versionMessage)(root); }).toThrow(/has no version in its package.json/);
+        expect(function () { return (0, version_1.versionMessage)(root); }).toThrow(/has no version in its package.json\./);
+    });
+    it('names the placeholder when an installed package was never stamped', function () {
+        var root = packageRoot();
+        writePackage(root, '0.0.0');
+        expect(function () { return (0, version_1.versionMessage)(root); }).toThrow(/carries the placeholder version 0\.0\.0, so it was never stamped from a tag/);
     });
 });

package/build/commands/version/version.d.ts

@@ -4,9 +4,11 @@
  * Reads the version from the package.json of the package that is running, so
  * it works for every install shape - global, project-local, `npx`, a temp
  * prefix, or embedded as a dependency. A package root outside a
- * `node_modules` folder is a source checkout (an `npm link`, or a local
- * build), and is reported as such; a source checkout carries no version until
- * semantic-release writes one, so the version is left out when it is absent.
+ * `node_modules` folder is a source checkout (an `npm link`, or a local build),
+ * and is reported as such. Its package.json carries the placeholder version
+ * (`0.0.0`): the version is the git tag, stamped in when the package is
+ * published, so from sources there is nothing to report and the version is left
+ * out.
  *
  * @param packageRoot - the folder holding the package.json of the running CLI.
  */

package/build/commands/version/version.js

@@ -49,9 +49,11 @@ var path_1 = __importDefault(require("path"));
  * Reads the version from the package.json of the package that is running, so
  * it works for every install shape - global, project-local, `npx`, a temp
  * prefix, or embedded as a dependency. A package root outside a
- * `node_modules` folder is a source checkout (an `npm link`, or a local
- * build), and is reported as such; a source checkout carries no version until
- * semantic-release writes one, so the version is left out when it is absent.
+ * `node_modules` folder is a source checkout (an `npm link`, or a local build),
+ * and is reported as such. Its package.json carries the placeholder version
+ * (`0.0.0`): the version is the git tag, stamped in when the package is
+ * published, so from sources there is nothing to report and the version is left
+ * out.
  *
  * @param packageRoot - the folder holding the package.json of the running CLI.
  */
@@ -65,13 +67,21 @@ var versionMessage = function (packageRoot) {
             "Reinstall the CLI - 'npm i -g @sasjs/cli@latest'.");
     }
     var fromSources = !packageRoot.split(path_1.default.sep).includes('node_modules');
+    // the placeholder means "not stamped from a tag" - the same thing as absent
+    var stated = version && !/^0\.0\.0(-|$)/.test(version) ? version : undefined;
     if (fromSources) {
-        return version
-            ? "You are using a linked version of SASjs CLI (v".concat(version, ") running from sources at ").concat(packageRoot)
+        return stated
+            ? "You are using a linked version of SASjs CLI (v".concat(stated, ") running from sources at ").concat(packageRoot)
             : "You are using a linked version of SASjs CLI running from sources at ".concat(packageRoot);
     }
-    if (!version) {
-        throw new Error("The installed CLI at ".concat(packageRoot, " has no version in its package.json. ") +
+    if (!stated) {
+        // two ways to get here, and they mean different things to whoever is reading
+        // it: no version field at all, or the placeholder that was never stamped from
+        // a tag
+        var reason = version
+            ? "carries the placeholder version ".concat(version, ", so it was never stamped from a tag")
+            : 'has no version in its package.json';
+        throw new Error("The installed CLI at ".concat(packageRoot, " ").concat(reason, ". ") +
             "Reinstall it - 'npm i -g @sasjs/cli@latest'.");
     }
     return "You are using SASjs CLI v".concat(version);

package/build/types/mockWebBasePath.d.ts

@@ -20,5 +20,14 @@ declare module '@sasjs/utils/types/config' {
          * slash (`/demo`). Unset means the origin root.
          */
         mockWebBasePath?: string;
+        /**
+         * Whether the mock site carries the API console at `<base>/api-console/`.
+         *
+         * On unless it is set to false: the console is how a demonstration site lets
+         * a visitor try the API it is a mock of, and a page nothing links to costs
+         * the app nothing. A site whose output must be the app and nothing else
+         * turns it off.
+         */
+        mockApi?: boolean;
     }
 }