@sasjs/cli 6.11.0 → 6.12.1

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

@@ -35,7 +35,39 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         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 __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 path_1 = __importDefault(require("path"));
+var api_1 = require("@sasjs/api");
 /**
  * The other half of the parity claim: the service worker is what turns an
  * /SASjsApi/ request into a response, so its framing (webout body, the _debug
@@ -47,6 +79,13 @@ var LOGS_SEPARATOR = 'SASJS_LOGS_SEPARATOR_163ee17b6ff24f028928972d80a26784';
 var drivePath = function (relative) {
     return "/sasjs/drive/files".concat(appLoc, "/").concat(relative);
 };
+/**
+ * The browser build of @sasjs/api that mockSite.ts copies into the site, from the
+ * installed package - the worker under test must be the worker the build ships.
+ */
+var apiBrowserBuild = function () {
+    return path_1.default.join(path_1.default.dirname(require.resolve('@sasjs/api')), '..', '..', 'build', 'browser.js');
+};
 var loadWorker = function () {
     jest.resetModules();
     var handlers = {};
@@ -65,6 +104,8 @@ var loadWorker = function () {
     global.importScripts = function (path) {
         if (path.includes('md5'))
             return;
+        if (path.includes('api-browser'))
+            return require(apiBrowserBuild());
         require('../assets/runtime-core.js');
     };
     require('../assets/sw.js');
@@ -1089,8 +1130,8 @@ describe('service worker host', function () {
                 }
             });
         }); });
-        it('refuses a rename that would produce a blocked extension', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var dispatch, form, toBlocked, fromBlocked;
+        it('refuses a rename into a blocked extension, as the server does', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, form, toBlocked, read;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1108,25 +1149,29 @@ describe('service worker host', function () {
                                     newPath: '/data/x.sh'
                                 })
                             }))
-                            // DELETE and PATCH run the same check on the path they are given, so a file
-                            // renamed into a blocked name could not be removed or replaced afterwards
+                            // The extension rule is the drive's file-path rule, and a rename is a
+                            // file operation: sasjs/api (since 0.2.1, sasjs/api#12) applies the rule
+                            // to a rename whose target is a file, so both hosts refuse the move and
+                            // no entry can be created that the API itself cannot read back. A folder
+                            // is not subject to the file-path schema, so renaming a folder to a
+                            // dotted name stays allowed.
                         ];
                     case 2:
                         toBlocked = _a.sent();
-                        // DELETE and PATCH run the same check on the path they are given, so a file
-                        // renamed into a blocked name could not be removed or replaced afterwards
+                        // The extension rule is the drive's file-path rule, and a rename is a
+                        // file operation: sasjs/api (since 0.2.1, sasjs/api#12) applies the rule
+                        // to a rename whose target is a file, so both hosts refuse the move and
+                        // no entry can be created that the API itself cannot read back. A folder
+                        // is not subject to the file-path schema, so renaming a folder to a
+                        // dotted name stays allowed.
                         expect(toBlocked.status).toBe(400);
-                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/rename', {
-                                method: 'POST',
-                                headers: { 'content-type': 'application/json' },
-                                body: JSON.stringify({
-                                    oldPath: '/data/x.sh',
-                                    newPath: '/data/new.csv'
-                                })
-                            }))];
+                        expect(toBlocked.body).toBe('Invalid file extension');
+                        return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file?_filePath=' +
+                                encodeURIComponent('/data/old.csv')))];
                     case 3:
-                        fromBlocked = _a.sent();
-                        expect(fromBlocked.status).toBe(400);
+                        read = _a.sent();
+                        expect(read.status).toBe(200);
+                        expect(read.body).toBe('r');
                         return [2 /*return*/];
                 }
             });
@@ -1175,13 +1220,21 @@ describe('service worker host', function () {
                         child.set('file', new Blob(['b']), 'b.csv');
                         return [4 /*yield*/, answer(dispatch('/SASjsApi/drive/file?_filePath=' +
                                 encodeURIComponent('/data/a.csv/child.csv'), { method: 'POST', body: child }))
-                            // mkdirp would otherwise turn the file into a folder to hold the child
+                            // mkdirp would otherwise turn the file into a folder to hold the child.
+                            // The server loses this at the filesystem (ENOTDIR) and answers a 500, so
+                            // this answers a 500 too: the refusal is the point, the status is the
+                            // server's class, and the message says which path was in the way.
                         ];
                     case 2:
                         under = _b.sent();
-                        // mkdirp would otherwise turn the file into a folder to hold the child
-                        expect(under.status).toBe(400);
-                        expect(under.body).toBe('An ancestor of the path is a file: /data/a.csv');
+                        // mkdirp would otherwise turn the file into a folder to hold the child.
+                        // The server loses this at the filesystem (ENOTDIR) and answers a 500, so
+                        // this answers a 500 too: the refusal is the point, the status is the
+                        // server's class, and the message says which path was in the way.
+                        expect(under.status).toBe(500);
+                        expect(under.body).toEqual({
+                            message: 'ENOTDIR: an ancestor of the path is a file: /data/a.csv'
+                        });
                         return [4 /*yield*/, dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/a.csv'))];
                     case 3:
                         stillAFile = _b.sent();
@@ -1285,4 +1338,171 @@ describe('service worker host', function () {
             });
         }); });
     });
+    describe('conformance corpus', function () {
+        var e_1, _a;
+        /**
+         * The corpus is what "the same API" means: the cases @sasjs/api runs against
+         * its own services, and against a live sasjs/server, run here against this
+         * worker's HTTP surface. A case that answers differently is this host
+         * drifting from the server - the failure mode the hand-written drive routes
+         * used to have - and it is a test rather than a review.
+         */
+        var httpFor = function (testCase) {
+            var e_2, _a;
+            var _b;
+            var _c = __read(testCase.route.split(' '), 2), method = _c[0], routePath = _c[1];
+            var query = new URLSearchParams();
+            try {
+                for (var _d = __values(Object.entries(testCase.request.query || {})), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var _f = __read(_e.value, 2), key = _f[0], value = _f[1];
+                    if (value !== undefined)
+                        query.set(key, String(value));
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            var suffix = query.toString() ? "?".concat(query) : '';
+            var init = { method: method };
+            var file = testCase.request.file;
+            if (file) {
+                var form = new FormData();
+                // the Blob types want a view over an ArrayBuffer; a Uint8Array from the
+                // corpus is typed over ArrayBufferLike, which a Blob does not accept
+                var bytes = typeof file.contents === 'string'
+                    ? new TextEncoder().encode(file.contents)
+                    : new Uint8Array(file.contents);
+                form.set('file', new Blob([bytes]), file.name);
+                var formPath = (_b = testCase.request.body) === null || _b === void 0 ? void 0 : _b.filePath;
+                if (formPath !== undefined)
+                    form.set('filePath', String(formPath));
+                init.body = form;
+            }
+            else if (testCase.request.body) {
+                init.body = JSON.stringify(testCase.request.body);
+                init.headers = { 'content-type': 'application/json' };
+            }
+            return { path: routePath + suffix, init: init };
+        };
+        /**
+         * The case's own files, at the paths the drive stores them under. `load`
+         * restores the seed snapshot, which is a map of strings - a byte entry is a
+         * snapshot of an upload, so it goes in through the store the way an upload
+         * does.
+         */
+        var seedDrive = function (runtime, testCase) { return __awaiter(void 0, void 0, void 0, function () {
+            var text, _a, _b, _c, file, contents, _d, _e, _f, file, contents, e_3_1;
+            var e_4, _g, e_3, _h;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        text = {};
+                        try {
+                            for (_a = __values(Object.entries(testCase.seed || {})), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                _c = __read(_b.value, 2), file = _c[0], contents = _c[1];
+                                if (typeof contents === 'string')
+                                    text["/sasjs/drive/files".concat(file)] = contents;
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                        return [4 /*yield*/, runtime.load(text)];
+                    case 1:
+                        _j.sent();
+                        _j.label = 2;
+                    case 2:
+                        _j.trys.push([2, 7, 8, 9]);
+                        _d = __values(Object.entries(testCase.seed || {})), _e = _d.next();
+                        _j.label = 3;
+                    case 3:
+                        if (!!_e.done) return [3 /*break*/, 6];
+                        _f = __read(_e.value, 2), file = _f[0], contents = _f[1];
+                        if (!(typeof contents !== 'string')) return [3 /*break*/, 5];
+                        return [4 /*yield*/, runtime.driveStore.write(file, contents)];
+                    case 4:
+                        _j.sent();
+                        _j.label = 5;
+                    case 5:
+                        _e = _d.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_3_1 = _j.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_e && !_e.done && (_h = _d.return)) _h.call(_d);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        }); };
+        var _loop_1 = function (testCase) {
+            it(testCase.id, function () { return __awaiter(void 0, void 0, void 0, function () {
+                var worker, _a, requestPath, init, response, _b, want, _c, _d, _e;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
+                        case 0:
+                            worker = loadWorker();
+                            return [4 /*yield*/, seedDrive(worker.runtime, testCase)];
+                        case 1:
+                            _f.sent();
+                            _a = httpFor(testCase), requestPath = _a.path, init = _a.init;
+                            return [4 /*yield*/, worker.dispatch(requestPath, init)];
+                        case 2:
+                            response = _f.sent();
+                            expect(response.status).toBe(testCase.expect.status);
+                            if (!(testCase.expect.error !== undefined)) return [3 /*break*/, 4];
+                            _b = expect;
+                            return [4 /*yield*/, response.text()];
+                        case 3:
+                            _b.apply(void 0, [_f.sent()]).toBe(testCase.expect.error);
+                            _f.label = 4;
+                        case 4:
+                            want = testCase.expect.contents;
+                            if (!(typeof want === 'string')) return [3 /*break*/, 6];
+                            _c = expect;
+                            return [4 /*yield*/, response.text()];
+                        case 5:
+                            _c.apply(void 0, [_f.sent()]).toBe(want);
+                            return [3 /*break*/, 8];
+                        case 6:
+                            if (!(want !== undefined)) return [3 /*break*/, 8];
+                            _d = expect;
+                            _e = Uint8Array.bind;
+                            return [4 /*yield*/, response.arrayBuffer()];
+                        case 7:
+                            _d.apply(void 0, [new (_e.apply(Uint8Array, [void 0, _f.sent()]))()]).toEqual(want);
+                            _f.label = 8;
+                        case 8: return [2 /*return*/];
+                    }
+                });
+            }); });
+        };
+        try {
+            for (var DRIVE_CORPUS_1 = __values(api_1.DRIVE_CORPUS), DRIVE_CORPUS_1_1 = DRIVE_CORPUS_1.next(); !DRIVE_CORPUS_1_1.done; DRIVE_CORPUS_1_1 = DRIVE_CORPUS_1.next()) {
+                var testCase = DRIVE_CORPUS_1_1.value;
+                _loop_1(testCase);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (DRIVE_CORPUS_1_1 && !DRIVE_CORPUS_1_1.done && (_a = DRIVE_CORPUS_1.return)) _a.call(DRIVE_CORPUS_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
 });

package/package.json

@@ -2,7 +2,7 @@
   "name": "@sasjs/cli",
   "description": "Command line interface for SASjs",
   "engines": {
-    "node": ">=22"
+    "node": "^22.14.0 || >=24.10.0"
   },
   "main": "index.js",
   "files": [
@@ -71,6 +71,7 @@
   },
   "dependencies": {
     "@sasjs/adapter": "^5.1.3",
+    "@sasjs/api": "0.2.1",
     "@sasjs/core": "^6.1.1",
     "@sasjs/lint": "5.0.0",
     "@sasjs/utils": "^4.7.0",
@@ -123,5 +124,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.11.0"
+  "version": "6.12.1"
 }