@sasjs/cli 6.0.0 → 6.1.0

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

@@ -0,0 +1,405 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+var mockSite_1 = require("../mockSite");
+var appLoc = '/Public/app/test';
+var write = function (file, contents) {
+    fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+    fs_1.default.writeFileSync(file, contents);
+};
+var createProject = function (root) {
+    // sasjsbuild is what `sasjs compile` leaves behind: every service folder
+    // copied in, then the sync folder's contents over the root.
+    var build = path_1.default.join(root, 'sasjsbuild');
+    write(path_1.default.join(build, 'services', 'public', 'getdata.js'), 'const a = 1\n');
+    write(path_1.default.join(build, 'services', 'public', 'viewtables.js'), 'const a = 2\n');
+    write(path_1.default.join(build, 'services', 'admin', 'makedata.js'), 'const a = 3\n');
+    write(path_1.default.join(build, 'mock-storage', 'licence.json'), '{"licenceKey":"invalid"}');
+    // root-level build artefacts must not reach the virtual drive
+    write(path_1.default.join(build, 'server-ci.sas'), '%put build pack;\n');
+    write(path_1.default.join(build, 'server-ci.json'), '{"members":[]}\n');
+    write(path_1.default.join(root, 'client', 'dist', 'index.html'), [
+        '<!doctype html><html><head><title>App</title></head><body>',
+        "<sasjs serverurl=\"https://sas.example.com\" apploc=\"".concat(appLoc, "\" servertype=\"SASJS\" loginmechanism=\"Redirected\"></sasjs>"),
+        '<script src="main.abc123.js" type="module"></script>',
+        '</body></html>'
+    ].join('\n'));
+    write(path_1.default.join(root, 'client', 'dist', 'main.abc123.js'), 'console.log(1)\n');
+};
+describe('browser-hosted build', function () {
+    var root;
+    var out = function () { return path_1.default.join(root, 'sasjsbuild', 'mock'); };
+    var target = function (streamConfig) {
+        if (streamConfig === void 0) { streamConfig = {}; }
+        return ({
+            appLoc: appLoc,
+            streamConfig: __assign({ webSourcePath: './client/dist' }, streamConfig)
+        });
+    };
+    var readSeed = function () {
+        return JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'vfs-seed.json'), 'utf8'));
+    };
+    var readConfig = function () {
+        return JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'mock-config.json'), 'utf8'));
+    };
+    beforeEach(function () {
+        root = fs_1.default.mkdtempSync(path_1.default.join(require('os').tmpdir(), 'sasjs-mock-'));
+        createProject(root);
+        process.projectDir = root;
+        process.sasjsConfig = { syncFolder: 'sasjs' };
+        process.sasjsConstants = {
+            buildDestinationFolder: path_1.default.join(root, 'sasjsbuild')
+        };
+        process.logger = { warn: jest.fn(), info: jest.fn() };
+    });
+    afterEach(function () {
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+    });
+    it('lays the compile output out on the virtual drive', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, seed;
+        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.jsPrograms).toBe(3);
+                    expect(result.driveEntries).toBe(4); // 3 programs + the licence store
+                    seed = readSeed();
+                    expect(seed.files["/sasjs/drive/files".concat(appLoc, "/services/public/getdata.js")]).toBe('const a = 1\n');
+                    expect(seed.files["/sasjs/drive/files".concat(appLoc, "/mock-storage/licence.json")]).toContain('licenceKey');
+                    // the service pack and its manifest stay out of the drive
+                    expect(Object.keys(seed.files).some(function (k) { return k.endsWith('.sas'); })).toBe(false);
+                    expect(Object.keys(seed.files).some(function (k) { return k.endsWith('server-ci.json'); })).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('writes the runtime host and the worker at the site root', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _b, asset;
+        var e_1, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _d.sent();
+                    try {
+                        for (_a = __values([
+                            'md5.js',
+                            'runtime-core.js',
+                            'persist.js',
+                            'intercept.js'
+                        ]), _b = _a.next(); !_b.done; _b = _a.next()) {
+                            asset = _b.value;
+                            expect(fs_1.default.existsSync(path_1.default.join(out(), 'host', asset))).toBe(true);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    // a worker only controls the folder it is served from, so it has to sit at
+                    // the root rather than under host/
+                    expect(fs_1.default.existsSync(path_1.default.join(out(), 'sw.js'))).toBe(true);
+                    expect(fs_1.default.existsSync(path_1.default.join(out(), 'host', 'sw.js'))).toBe(false);
+                    expect(readConfig().appLoc).toBe(appLoc);
+                    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) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    expect(html).toContain('serverurl=""');
+                    expect(html).toContain('loginmechanism="Default"');
+                    expect(html).not.toContain('https://sas.example.com');
+                    expect(html).toContain("register('/sw.js'");
+                    expect(html).toContain('host/persist.js');
+                    expect(html).toContain('main.abc123.js');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('ships a captured drive snapshot when the project has one', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var snapshot, result, shipped;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    snapshot = {
+                        files: (_a = {},
+                            _a["/sasjs/drive/files".concat(appLoc, "/services/public/getdata.js")] = 'const a = 1\n',
+                            _a["/sasjs/drive/files".concat(appLoc, "/data/DC_JSLIB/mpe_config.json")] = '{"rows":[]}',
+                            _a)
+                    };
+                    write(path_1.default.join(root, 'sasjsbuild', 'mock-snapshot.json'), JSON.stringify(snapshot));
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _b.sent();
+                    expect(result.snapshot).toBe(true);
+                    shipped = JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'vfs-snapshot.json'), 'utf8'));
+                    expect(Object.keys(shipped.files).length).toBe(2);
+                    // the runtime prefers a snapshot over the seed, so it must not be mistaken
+                    // for one of the seeded folders
+                    expect(readConfig().snapshot).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('ships no snapshot when the project has none', 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())];
+                case 1:
+                    result = _a.sent();
+                    expect(result.snapshot).toBe(false);
+                    expect(fs_1.default.existsSync(path_1.default.join(out(), 'host', 'vfs-snapshot.json'))).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves non-text files off the drive instead of corrupting them', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var png, result, seed;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    png = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+                    write(path_1.default.join(root, 'sasjsbuild', 'mock-storage', 'fixtures.json'), '{}');
+                    fs_1.default.writeFileSync(path_1.default.join(root, 'sasjsbuild', 'mock-storage', 'logo.png'), png);
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _b.sent();
+                    seed = readSeed();
+                    expect(Object.keys(seed.files).some(function (k) { return k.endsWith('logo.png'); })).toBe(false);
+                    expect(seed.files["/sasjs/drive/files".concat(appLoc, "/mock-storage/fixtures.json")]).toBe('{}');
+                    expect(result.driveEntries).toBe(5); // 3 programs + 2 text files
+                    expect((_a = process.logger) === null || _a === void 0 ? void 0 : _a.warn).toHaveBeenCalledWith(expect.stringContaining('logo.png'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    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');
+                    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');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('refuses to build without a web app', 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({ webSourcePath: './does-not-exist' }))).rejects.toThrow(/Web source folder not found/)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('refuses to build without an appLoc', 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)({ streamConfig: {} })).rejects.toThrow(/No appLoc/)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('replaces an existing output folder rather than merging into it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    write(path_1.default.join(out(), 'stale.txt'), 'old');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    expect(fs_1.default.existsSync(path_1.default.join(out(), 'stale.txt'))).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('warns instead of failing when the index.html is not the expected shape', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    write(path_1.default.join(root, 'client', 'dist', 'index.html'), '<!doctype html><html><body><div id="app"></div></body></html>');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _c.sent();
+                    expect(result.webFileCount).toBeGreaterThan(0);
+                    expect((_a = process.logger) === null || _a === void 0 ? void 0 : _a.warn).toHaveBeenCalledWith(expect.stringContaining('no <sasjs> element found'));
+                    expect((_b = process.logger) === null || _b === void 0 ? void 0 : _b.warn).toHaveBeenCalledWith(expect.stringContaining('no main bundle script tag found'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves a streamed web folder off the drive', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var keys;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    write(path_1.default.join(root, 'sasjsbuild', 'services', 'web', 'index.html'), '<html></html>');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target({ streamWeb: true, streamWebFolder: 'web' }))];
+                case 1:
+                    _a.sent();
+                    keys = Object.keys(readSeed().files);
+                    expect(keys.some(function (k) { return k.startsWith("".concat(appLoc, "/services/web/")); })).toBe(false);
+                    // the same folder is still the site's own content, so it is copied
+                    expect(fs_1.default.existsSync(path_1.default.join(out(), 'index.html'))).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('refuses a mockWebFolder outside the project', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var outside;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    outside = fs_1.default.mkdtempSync(path_1.default.join(require('os').tmpdir(), 'outside-'));
+                    return [4 /*yield*/, expect((0, mockSite_1.buildMockSite)(target({ mockWebFolder: outside }))).rejects.toThrow(/outside the project/)];
+                case 1:
+                    _a.sent();
+                    expect(fs_1.default.existsSync(outside)).toBe(true);
+                    fs_1.default.rmSync(outside, { recursive: true, force: true });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('refuses a mockWebFolder that would delete the project or its inputs', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _b, mockWebFolder, e_2_1;
+        var e_2, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _d.trys.push([0, 5, 6, 7]);
+                    _a = __values([
+                        '.',
+                        './',
+                        '..',
+                        'sasjsbuild',
+                        'client/dist',
+                        'client/dist/mock'
+                    ]), _b = _a.next();
+                    _d.label = 1;
+                case 1:
+                    if (!!_b.done) return [3 /*break*/, 4];
+                    mockWebFolder = _b.value;
+                    return [4 /*yield*/, expect((0, mockSite_1.buildMockSite)(target({ mockWebFolder: mockWebFolder }))).rejects.toThrow(/Refusing to write the mock site/)
+                        // nothing was removed on the way to the refusal
+                    ];
+                case 2:
+                    _d.sent();
+                    // nothing was removed on the way to the refusal
+                    expect(fs_1.default.existsSync(path_1.default.join(root, 'client', 'dist', 'index.html'))).toBe(true);
+                    expect(fs_1.default.existsSync(path_1.default.join(root, 'sasjsbuild', 'services', 'public'))).toBe(true);
+                    _d.label = 3;
+                case 3:
+                    _b = _a.next();
+                    return [3 /*break*/, 1];
+                case 4: return [3 /*break*/, 7];
+                case 5:
+                    e_2_1 = _d.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3 /*break*/, 7];
+                case 6:
+                    try {
+                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                    return [7 /*endfinally*/];
+                case 7:
+                    expect(fs_1.default.existsSync(path_1.default.join(root, 'client', 'dist', 'index.html'))).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

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

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