@sasjs/cli 6.24.2 → 6.26.0

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

@@ -1,4 +1,15 @@
 "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) {
@@ -62,6 +73,15 @@ var __read = (this && this.__read) || function (o, n) {
     }
     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 };
 };
@@ -163,7 +183,7 @@ var loadWorker = function (base) {
     };
     require('../assets/sw.js');
     global.fetch = jest.fn(function (input) { return __awaiter(void 0, void 0, void 0, function () {
-        var target, fixture;
+        var target, fixture, fixture;
         var _a;
         return __generator(this, function (_b) {
             target = typeof input === 'string' ? input : (input && input.url) || String(input);
@@ -175,6 +195,12 @@ var loadWorker = function (base) {
                     })];
             if (target.includes('index.html'))
                 return [2 /*return*/, new Response('<!doctype html><html><head><title>App</title></head><body>home</body></html>', { status: 200, headers: { 'content-type': 'text/html' } })];
+            if (target.includes('identity.json')) {
+                fixture = global.__sasjsIdentity;
+                if (fixture === 'missing')
+                    return [2 /*return*/, new Response('', { status: 404 })];
+                return [2 /*return*/, jsonResponse(fixture || api_1.DEFAULT_IDENTITY)];
+            }
             if (target.includes('sas-transcript')) {
                 fixture = global.__sasTranscript;
                 return [2 /*return*/, fixture ? jsonResponse(fixture) : new Response('', { status: 404 })];
@@ -262,6 +288,8 @@ describe('service worker host', function () {
         delete global.self;
         delete global.importScripts;
         delete global.fetch;
+        delete global.__sasjsIdentity;
+        delete global.__mockHostClients;
     });
     var seeded = function () {
         var _a;
@@ -928,44 +956,40 @@ describe('service worker host', function () {
             });
         }); });
         it('imports the fixture directory, and unpublishes the site itself', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var dispatch, synced, _a, unpublished, _b, other;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var dispatch, synced, _a, siteAppId, unpublished, removed, other;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
                     case 0:
                         dispatch = seeded().dispatch;
                         return [4 /*yield*/, dispatch('/SASjsApi/authConfig/synchroniseWithLDAP', { method: 'POST' })];
                     case 1:
-                        synced = _c.sent();
+                        synced = _b.sent();
                         expect(synced.status).toBe(200);
                         _a = expect;
                         return [4 /*yield*/, synced.json()];
                     case 2:
-                        _a.apply(void 0, [_c.sent()]).toEqual({ userCount: 0, groupCount: 0 });
+                        _a.apply(void 0, [_b.sent()]).toEqual({ userCount: 0, groupCount: 0 });
+                        siteAppId = '6f1c1c1e-6a1e-4c4a-9d1a-1b2c3d4e5f60';
                         return [4 /*yield*/, dispatch('/SASjsApi/drive/deploy', {
                                 method: 'DELETE',
                                 headers: { 'content-type': 'application/json' },
-                                body: JSON.stringify({
-                                    streamServiceName: 'Test',
-                                    appLoc: appLoc
-                                })
+                                body: JSON.stringify({ id: siteAppId })
                             })];
                     case 3:
-                        unpublished = _c.sent();
+                        unpublished = _b.sent();
                         expect(unpublished.status).toBe(200);
-                        _b = expect;
                         return [4 /*yield*/, unpublished.json()];
                     case 4:
-                        _b.apply(void 0, [_c.sent()]).toEqual({ status: 'success' });
+                        removed = _b.sent();
+                        expect(removed.status).toBe('success');
+                        expect(removed.app.id).toBe(siteAppId);
                         return [4 /*yield*/, dispatch('/SASjsApi/drive/deploy', {
                                 method: 'DELETE',
                                 headers: { 'content-type': 'application/json' },
-                                body: JSON.stringify({
-                                    streamServiceName: 'Other',
-                                    appLoc: '/Public/app/other'
-                                })
+                                body: JSON.stringify({ id: '00000000-0000-4000-8000-000000000000' })
                             })];
                     case 5:
-                        other = _c.sent();
+                        other = _b.sent();
                         expect(other.status).toBe(404);
                         return [2 /*return*/];
                 }
@@ -2663,4 +2687,484 @@ describe('service worker host', function () {
             finally { if (e_4) throw e_4.error; }
         }
     });
+    /**
+     * The identity and record corpora, over the worker's HTTP surface.
+     *
+     * The same cases @sasjs/api runs against its own services, and the server runs
+     * against a live sasjs/server. A failure here is this host's transport, the
+     * fixture it booted, or a route it does not answer - never the decisions, which
+     * are the package's.
+     */
+    describe('identity and record conformance', function () {
+        var e_8, _a;
+        /**
+         * Boots the worker from a fixture, the way the page does: the case's own
+         * identity, and `subject: null` for no implicit caller, so a case that
+         * expects the answer an anonymous request gets is not silently answered as
+         * the fixture's administrator.
+         */
+        var boot = function (worker_1, identity_1) {
+            var args_1 = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args_1[_i - 2] = arguments[_i];
+            }
+            return __awaiter(void 0, __spreadArray([worker_1, identity_1], __read(args_1), false), void 0, function (worker, identity, subject) {
+                var pending;
+                if (subject === void 0) { subject = null; }
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            pending = worker.message({
+                                type: 'sasjs-seed',
+                                identity: identity,
+                                subject: subject
+                            }).pending;
+                            return [4 /*yield*/, pending];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        /** The request a case describes, as HTTP: path parameters filled, token sent. */
+        var httpForCase = function (testCase) {
+            var e_9, _a;
+            var _b = __read(testCase.route.split(' '), 2), method = _b[0], routePath = _b[1];
+            var filled = routePath.replace(/\{(\w+)\}/g, function (_match, name) {
+                return encodeURIComponent(String((testCase.request.params || {})[name]));
+            });
+            var query = new URLSearchParams();
+            try {
+                for (var _c = __values(Object.entries(testCase.request.query || {})), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var _e = __read(_d.value, 2), key = _e[0], value = _e[1];
+                    if (value !== undefined)
+                        query.set(key, String(value));
+                }
+            }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
+            var suffix = query.toString() ? "?".concat(query) : '';
+            var headers = {};
+            var init = { method: method, headers: headers };
+            if (testCase.request.token)
+                headers.authorization = 'Bearer ' + testCase.request.token;
+            if (testCase.request.body !== undefined) {
+                init.body = JSON.stringify(testCase.request.body);
+                headers['content-type'] = 'application/json';
+            }
+            return { path: filled + suffix, init: init };
+        };
+        /** The assertions the package's own corpus makes, against an HTTP answer. */
+        var expectAnswer = function (testCase, response) { return __awaiter(void 0, void 0, void 0, function () {
+            var want, contentType, isJson, sent, _a, _b, expected, error, _c, body, _d, required, _e, optional, present_1, allowed_1;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        expect({ case: testCase.id, status: response.status }).toEqual({
+                            case: testCase.id,
+                            status: testCase.expect.status
+                        });
+                        want = testCase.expect;
+                        contentType = response.headers.get('content-type') || '';
+                        isJson = contentType.includes('application/json');
+                        if (!(want.contents !== undefined)) return [3 /*break*/, 5];
+                        if (!(want.encoding === 'text')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, response.text()];
+                    case 1:
+                        _a = _f.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        _b = Uint8Array.bind;
+                        return [4 /*yield*/, response.arrayBuffer()];
+                    case 3:
+                        _a = new (_b.apply(Uint8Array, [void 0, _f.sent()]))();
+                        _f.label = 4;
+                    case 4:
+                        sent = _a;
+                        expected = typeof want.contents === 'string'
+                            ? want.encoding === 'text'
+                                ? want.contents
+                                : new TextEncoder().encode(want.contents)
+                            : want.contents;
+                        expect(sent).toEqual(expected);
+                        return [2 /*return*/];
+                    case 5:
+                        if (!(want.error !== undefined)) return [3 /*break*/, 10];
+                        if (!isJson) return [3 /*break*/, 7];
+                        return [4 /*yield*/, response.json()];
+                    case 6:
+                        _c = (_f.sent()).message;
+                        return [3 /*break*/, 9];
+                    case 7: return [4 /*yield*/, response.text()];
+                    case 8:
+                        _c = _f.sent();
+                        _f.label = 9;
+                    case 9:
+                        error = _c;
+                        expect({ case: testCase.id, error: error }).toEqual({
+                            case: testCase.id,
+                            error: want.error
+                        });
+                        return [2 /*return*/];
+                    case 10:
+                        if (want.body === undefined &&
+                            want.partial === undefined &&
+                            want.keys === undefined &&
+                            want.shape === undefined)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, response.json()];
+                    case 11:
+                        body = _f.sent();
+                        if (want.body !== undefined)
+                            expect(body).toEqual(want.body);
+                        if (want.partial !== undefined)
+                            expect(body).toMatchObject(want.partial);
+                        if (want.keys !== undefined)
+                            expect(Object.keys(body).sort()).toEqual(want.keys.slice().sort());
+                        if (want.shape !== undefined) {
+                            _d = want.shape, required = _d.required, _e = _d.optional, optional = _e === void 0 ? [] : _e;
+                            present_1 = Object.keys(body);
+                            allowed_1 = __spreadArray(__spreadArray([], __read(required), false), __read(optional), false);
+                            expect({
+                                case: testCase.id,
+                                missing: required.filter(function (key) { return !present_1.includes(key); }),
+                                unexpected: present_1.filter(function (key) { return !allowed_1.includes(key); })
+                            }).toEqual({ case: testCase.id, missing: [], unexpected: [] });
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        var _loop_2 = function (testCase) {
+            it("".concat(testCase.id, ": ").concat(testCase.description), function () { return __awaiter(void 0, void 0, void 0, function () {
+                var worker, _a, requestPath, init, _b, _c;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            worker = loadWorker();
+                            return [4 /*yield*/, boot(worker, testCase.identity || api_1.DEFAULT_IDENTITY)];
+                        case 1:
+                            _d.sent();
+                            _a = httpForCase(testCase), requestPath = _a.path, init = _a.init;
+                            _b = expectAnswer;
+                            _c = [testCase];
+                            return [4 /*yield*/, worker.dispatch(requestPath, init)];
+                        case 2: return [4 /*yield*/, _b.apply(void 0, _c.concat([_d.sent()]))];
+                        case 3:
+                            _d.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+        };
+        try {
+            for (var _b = __values(__spreadArray(__spreadArray([], __read(api_1.IDENTITY_CORPUS), false), __read(api_1.RECORD_CORPUS), false)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var testCase = _c.value;
+                _loop_2(testCase);
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        it('answers as the fixture administrator when no subject was chosen', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, response, rules;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        worker = loadWorker();
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/permission')];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        rules = _a.sent();
+                        expect(response.status).toBe(200);
+                        expect(rules.length).toBe(3);
+                        expect(rules.map(function (rule) { return rule.uid; })).toEqual([
+                            'rule-routes',
+                            'rule-execute',
+                            'rule-code'
+                        ]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('signs in as another account, changing the permission answer and the token subject', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, _a, replies, pending, ack, routes, _b, session, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        worker = loadWorker();
+                        _a = worker.message({
+                            type: 'sasjs-as',
+                            username: 'sasjsuser'
+                        }), replies = _a.replies, pending = _a.pending;
+                        return [4 /*yield*/, pending];
+                    case 1:
+                        _d.sent();
+                        ack = replies[0];
+                        expect(ack.username).toBe('sasjsuser');
+                        expect(ack.accessToken).toBeTruthy();
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/info/myAuthorizedRoutes')];
+                    case 2:
+                        routes = _d.sent();
+                        _b = expect;
+                        return [4 /*yield*/, routes.json()];
+                    case 3:
+                        _b.apply(void 0, [(_d.sent()).paths]).toEqual([
+                            '/AppStream',
+                            '/SASjsApi/stp/execute',
+                            '/SASjsApi/drive/file'
+                        ]);
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/session', {
+                                headers: { authorization: 'Bearer ' + ack.accessToken }
+                            })];
+                    case 4:
+                        session = _d.sent();
+                        expect(session.status).toBe(200);
+                        _c = expect;
+                        return [4 /*yield*/, session.json()];
+                    case 5:
+                        _c.apply(void 0, [(_d.sent()).username]).toBe('sasjsuser');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('returns to the administrator with no account named, or with "admin"', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, back, routes, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        worker = loadWorker();
+                        return [4 /*yield*/, worker.message({ type: 'sasjs-as', username: 'sasjsuser' }).pending];
+                    case 1:
+                        _b.sent();
+                        back = worker.message({ type: 'sasjs-as', username: 'admin' });
+                        return [4 /*yield*/, back.pending];
+                    case 2:
+                        _b.sent();
+                        expect(back.replies[0].username).toBe('sasjsadmin');
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/info/myAuthorizedRoutes')
+                            // a route only the administrator's rules reach: the restricted account's
+                            // list is the three entries the corpus pins
+                        ];
+                    case 3:
+                        routes = _b.sent();
+                        // a route only the administrator's rules reach: the restricted account's
+                        // list is the three entries the corpus pins
+                        _a = expect;
+                        return [4 /*yield*/, routes.json()];
+                    case 4:
+                        // a route only the administrator's rules reach: the restricted account's
+                        // list is the three entries the corpus pins
+                        _a.apply(void 0, [(_b.sent()).paths]).toContain('/SASjsApi/code/execute');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('refuses an unknown account by name, naming the accounts the fixture holds', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, _a, replies, pending;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        worker = loadWorker();
+                        _a = worker.message({
+                            type: 'sasjs-as',
+                            username: 'nobody'
+                        }), replies = _a.replies, pending = _a.pending;
+                        return [4 /*yield*/, pending];
+                    case 1:
+                        _b.sent();
+                        expect(replies[0].error).toContain('no account named "nobody"');
+                        expect(replies[0].error).toContain('sasjsadmin');
+                        expect(replies[0].accessToken).toBeUndefined();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('refuses a persisted fixture in a format this build does not read, by name', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, _a, replies, pending;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        worker = loadWorker();
+                        _a = worker.message({
+                            type: 'sasjs-seed',
+                            identity: __assign(__assign({}, api_1.DEFAULT_IDENTITY), { format: 0 }),
+                            subject: null
+                        }), replies = _a.replies, pending = _a.pending;
+                        return [4 /*yield*/, pending];
+                    case 1:
+                        _b.sent();
+                        expect(replies[0].error).toContain('states format 0');
+                        expect(replies[0].error).toContain('Rebuild the site');
+                        // the page drops the stored row ONLY for this kind: a host-side failure
+                        // must not take the visitor's accounts with it
+                        expect(replies[0].errorKind).toBe('identity');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('refuses a shipped fixture it cannot read, naming the file', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, response, body;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ;
+                        global.__sasjsIdentity = __assign(__assign({}, api_1.DEFAULT_IDENTITY), { format: 7 });
+                        worker = loadWorker();
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/permission')];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        body = _a.sent();
+                        expect(response.status).toBe(500);
+                        expect(body.message).toContain('host/identity.json cannot be used');
+                        expect(body.message).toContain('states format 7');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('replies with the error when a reset cannot read the shipped fixture', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, _a, replies, pending;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        // the page waits for this ack: silence is read as success, and a reset is
+                        // the way out of a site whose fixture broke
+                        ;
+                        global.__sasjsIdentity = __assign(__assign({}, api_1.DEFAULT_IDENTITY), { format: 4 });
+                        worker = loadWorker();
+                        // a request first, so the failure is the cached one the site already has
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/permission')];
+                    case 1:
+                        // a request first, so the failure is the cached one the site already has
+                        _b.sent();
+                        _a = worker.message({ type: 'sasjs-reset' }), replies = _a.replies, pending = _a.pending;
+                        return [4 /*yield*/, pending];
+                    case 2:
+                        _b.sent();
+                        expect(replies[0].type).toBe('sasjs-reset-ack');
+                        expect(replies[0].error).toContain('host/identity.json cannot be used');
+                        expect(replies[0].boot).toBeUndefined();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('falls back to the packaged fixture when the site ships no identity file', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, response, rules;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ;
+                        global.__sasjsIdentity = 'missing';
+                        worker = loadWorker();
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/permission')];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        rules = _a.sent();
+                        expect(response.status).toBe(200);
+                        expect(rules.length).toBe(3);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('reports an account created through the routes, so the page can store it', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, sent, response, persisted;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        worker = loadWorker();
+                        sent = [];
+                        global.__mockHostClients = [
+                            { postMessage: function (message) { return sent.push(message); } }
+                        ];
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/user', {
+                                method: 'POST',
+                                headers: { 'content-type': 'application/json' },
+                                body: JSON.stringify({
+                                    username: 'newuser',
+                                    displayName: 'New User',
+                                    password: 'newpass',
+                                    isAdmin: false,
+                                    isActive: true
+                                })
+                            })];
+                    case 1:
+                        response = _a.sent();
+                        expect(response.status).toBe(200);
+                        persisted = sent.find(function (message) { return message.type === 'sasjs-persist' && message.identity; });
+                        expect(persisted.identity.users.map(function (user) { return user.username; })).toContain('newuser');
+                        delete global.__mockHostClients;
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('restores the shipped fixture on reset', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, users, _a, routes, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        worker = loadWorker();
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/user', {
+                                method: 'POST',
+                                headers: { 'content-type': 'application/json' },
+                                body: JSON.stringify({
+                                    username: 'newuser',
+                                    displayName: 'New User',
+                                    password: 'newpass',
+                                    isAdmin: false,
+                                    isActive: true
+                                })
+                            })];
+                    case 1:
+                        _c.sent();
+                        return [4 /*yield*/, worker.message({ type: 'sasjs-as', username: 'sasjsuser' }).pending];
+                    case 2:
+                        _c.sent();
+                        return [4 /*yield*/, worker.message({ type: 'sasjs-reset' }).pending];
+                    case 3:
+                        _c.sent();
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/user')];
+                    case 4:
+                        users = _c.sent();
+                        _a = expect;
+                        return [4 /*yield*/, users.json()];
+                    case 5:
+                        _a.apply(void 0, [(_c.sent()).map(function (user) { return user.username; })]).toEqual([
+                            'sasjsadmin',
+                            'sasjsuser'
+                        ]);
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/info/myAuthorizedRoutes')
+                            // a route only the administrator's rules reach: the restricted account's
+                            // list is the three entries the corpus pins
+                        ];
+                    case 6:
+                        routes = _c.sent();
+                        // a route only the administrator's rules reach: the restricted account's
+                        // list is the three entries the corpus pins
+                        _b = expect;
+                        return [4 /*yield*/, routes.json()];
+                    case 7:
+                        // a route only the administrator's rules reach: the restricted account's
+                        // list is the three entries the corpus pins
+                        _b.apply(void 0, [(_c.sent()).paths]).toContain('/SASjsApi/code/execute');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
 });

package/build/commands/build/internal/spec/appManifest.spec.d.ts

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