@sasjs/cli 6.30.1 → 6.31.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,303 @@
+"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/"}
+ */
+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 derives everything from its own URL: the API calls come from
+ * `location.pathname` with `/api/` cut off, and the worker is registered beside
+ * the site. Both are right at the origin root by accident there - this file runs
+ * the same page at `/demo/api/`, where the 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('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');
+                    expect(location.pathname).toBe('/demo/api');
+                    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/');
+                    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,92 @@ 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, listed, 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');
+                    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');
+                    listed = /const API_CONSOLE_FILES = (\[[^\]]*\])/.exec(sw);
+                    expect(listed).not.toBeNull();
+                    expect(JSON.parse(listed[1]).sort()).toEqual(shipped);
+                    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 api 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');
+                    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', 'index.html'), 'utf8')).toBe('<p>ours</p>');
+                    expect(fs_1.default.existsSync(path_1.default.join(out(), 'api', 'console.js'))).toBe(false);
+                    expect(process.logger.warn).toHaveBeenCalledWith(expect.stringContaining('api/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'))).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;