@sasjs/cli 6.2.1 → 6.2.3

package/build/commands/build/internal/mockSite/assets/persist.js

@@ -176,9 +176,13 @@
         'sasjs-snapshot'
       )
       const files = (snapshot && snapshot.files) || {}
-      const blob = new Blob([JSON.stringify({ files }, null, 2)], {
-        type: 'application/json'
-      })
+      // the format stamp the runtime checks on load: a snapshot that outlived a
+      // marker-format change is refused by name, instead of decoding as text
+      const driveFormat = (self.SASjsMockRuntime || {}).DRIVE_FORMAT
+      const blob = new Blob(
+        [JSON.stringify({ format: driveFormat, files }, null, 2)],
+        { type: 'application/json' }
+      )
       const url = URL.createObjectURL(blob)
       const link = document.createElement('a')
       link.href = url

package/build/commands/build/internal/mockSite/assets/runtime-core.js

@@ -490,7 +490,12 @@ const BUFFERS = {
         )
       if (end < start || end > value.byteLength)
         throw new RangeError('"length" is outside of buffer bounds')
-      return asBuffer(new Uint8Array(value, start, end - start))
+      // node returns a VIEW over the ArrayBuffer for this overload - a service
+      // that patches the bytes through the buffer is patching the ArrayBuffer
+      // it kept - and copies only for a Uint8Array input, which is what
+      // asBytes does below. `decorate` adds the methods to the view in place;
+      // `asBuffer` would copy it and hide the patch.
+      return decorate(new Uint8Array(value, start, end - start))
     }
     const bytes = asBytes(value)
     if (!bytes)
@@ -821,6 +826,19 @@ let DRIVE_APP = `${DRIVE_ROOT}/files${APP_LOC}`
 const SEED_PATH = '/host/vfs-seed.json'
 const SNAPSHOT_PATH = '/host/vfs-snapshot.json'
 
+/**
+ * The drive storage format, stamped into the seed and the snapshot. The markers
+ * themselves (`\u0000base64:` / `\u0000text:`) are written by the build
+ * (DRIVE_BINARY_PREFIX / DRIVE_TEXT_PREFIX in mockSite.ts) and read here, so the
+ * two sides hold the same format independently - and a one-sided edit would
+ * otherwise show up as a byte file reading as text, or a 500 per entry.
+ *
+ * The stamp is what makes that loud instead of silent: a file written by a build
+ * that speaks a different format is refused here, naming both numbers. Bump this
+ * whenever the marker format changes, and the builder's DRIVE_FORMAT with it.
+ */
+const DRIVE_FORMAT = 1
+
 /**
  * Reads the generated mock-config.json (appLoc and provenance). Absent or
  * malformed, the defaults above apply - a demo can then only work when the
@@ -998,10 +1016,19 @@ return _webout;
   const binary = !corrupt && !!fromFile && isBinary(stored)
   const webout = fromFile || (typeof returned === 'string' ? returned : '')
 
+  // The headers file is read as text whatever way it was written, which is what
+  // the server does (`extractHeaders` reads the file, not the write). A service
+  // that writes it as bytes - a Buffer, or any non-UTF-8 encoding - leaves a
+  // byte entry on the drive, so decoding the entry text alone would hand the
+  // worker the `\u0000base64:...` marker and drop every declared header.
+  const storedHeaders = FILES.get(headersPath) || ''
+
   return {
     webout,
     log: logLines.join('\n'),
-    headers: entryText(FILES.get(headersPath) || ''),
+    headers: isBinary(storedHeaders)
+      ? utf8Decoder.decode(entryBytes(storedHeaders))
+      : entryText(storedHeaders),
     // a byte body travels to the host as base64, which is how it is stored
     binary,
     error: thrown
@@ -1115,8 +1142,29 @@ const fetchDrive = async () => {
       if (!res.ok) continue
       const body = await res.json()
       const files = body && body.files ? body.files : body
-      if (files && typeof files === 'object') return { source, files }
+      if (!files || typeof files !== 'object') continue
+
+      // A file that declares a format this runtime does not speak is refused
+      // rather than misread: the markers inside it would decode as text, and the
+      // failure would surface as a corrupt download or a 500 per entry with
+      // nothing naming the cause. A file with no stamp predates the stamp and is
+      // read as the current format.
+      if (body && body.format !== undefined && body.format !== DRIVE_FORMAT)
+        throw new Error(
+          'The drive in ' +
+            url +
+            ' is format ' +
+            JSON.stringify(body.format) +
+            ', and this runtime speaks format ' +
+            DRIVE_FORMAT +
+            '. Rebuild the mock site with the matching @sasjs/cli.'
+        )
+
+      return { source, files }
     } catch (e) {
+      // a format mismatch is not a reason to try the other file: it is the file
+      // the operator meant to ship, and falling through would hide it
+      if (e && /is format /.test(e.message)) throw e
       /* fall through to the next source */
     }
   }
@@ -1222,7 +1270,10 @@ const api = {
   run: (payload) => runProgram(payload),
   list: (folder) => listFolder(folder),
   read: (file) => readDriveFile(file),
-  tree: () => buildTree()
+  tree: () => buildTree(),
+  // the format the snapshot download stamps, so persist.js writes the number
+  // this runtime reads rather than a second literal
+  DRIVE_FORMAT
 }
 
 self.SASjsMockRuntime = api

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

@@ -21,6 +21,14 @@ export interface MockSiteResult {
  */
 export declare const MAX_BINARY_SEED_BYTES: number;
 export declare const MAX_SEED_BYTES: number;
+/**
+ * The storage format these markers belong to, stamped into `vfs-seed.json` and
+ * into the snapshot the site downloads. runtime-core.js holds its own copy (it
+ * ships as a plain browser script) and refuses a file whose stamp it does not
+ * speak, so the two cannot drift silently. Bump both numbers together when the
+ * marker format changes.
+ */
+export declare const DRIVE_FORMAT = 1;
 /**
  * Builds a static site that runs the project's JS services (its mocks) in the
  * browser, so a frontend can be tested with no server and no SAS.

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

@@ -75,7 +75,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_SEED_BYTES = exports.MAX_BINARY_SEED_BYTES = void 0;
+exports.DRIVE_FORMAT = exports.MAX_SEED_BYTES = exports.MAX_BINARY_SEED_BYTES = void 0;
 exports.buildMockSite = buildMockSite;
 var crypto_1 = require("crypto");
 var fs_1 = __importDefault(require("fs"));
@@ -162,6 +162,14 @@ exports.MAX_SEED_BYTES = 25 * 1024 * 1024;
  */
 var DRIVE_BINARY_PREFIX = '\u0000base64:';
 var DRIVE_TEXT_PREFIX = '\u0000text:';
+/**
+ * The storage format these markers belong to, stamped into `vfs-seed.json` and
+ * into the snapshot the site downloads. runtime-core.js holds its own copy (it
+ * ships as a plain browser script) and refuses a file whose stamp it does not
+ * speak, so the two cannot drift silently. Bump both numbers together when the
+ * marker format changes.
+ */
+exports.DRIVE_FORMAT = 1;
 /** A byte count in MB, for the message that names a file too large to seed. */
 var megabytes = function (bytes) {
     return "".concat(Math.round((bytes / 1024 / 1024) * 10) / 10, " MB");
@@ -447,7 +455,7 @@ function buildMockSite(target) {
                         fs_1.default.copyFileSync(snapshotSource, path_1.default.join(hostFolder, 'vfs-snapshot.json'));
                     }
                     // 3. the drive, laid out from the compile output
-                    fs_1.default.writeFileSync(path_1.default.join(hostFolder, 'vfs-seed.json'), JSON.stringify({ files: seed }));
+                    fs_1.default.writeFileSync(path_1.default.join(hostFolder, 'vfs-seed.json'), JSON.stringify({ format: exports.DRIVE_FORMAT, files: seed }));
                     fs_1.default.writeFileSync(path_1.default.join(hostFolder, 'mock-config.json'), JSON.stringify({
                         appLoc: appLoc,
                         seedPath: '/host/vfs-seed.json',

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

@@ -136,6 +136,24 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
+    it('stamps the seed with the drive format the runtime checks', 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())
+                    // the runtime ships as a plain browser script and holds its own copy of the
+                    // marker format, so the seed carries the number and a mismatch is refused
+                    // there by name rather than decoded as text
+                ];
+                case 1:
+                    _a.sent();
+                    // the runtime ships as a plain browser script and holds its own copy of the
+                    // marker format, so the seed carries the number and a mismatch is refused
+                    // there by name rather than decoded as text
+                    expect(readSeed().format).toBe(mockSite_1.DRIVE_FORMAT);
+                    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;

package/build/commands/build/internal/mockSite/spec/runtime-core.spec.js

@@ -87,6 +87,47 @@ describe('browser runtime', function () {
         delete global.self;
         delete global.fetch;
     });
+    it('refuses a drive file whose format it does not speak', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            return [2 /*return*/, url.includes('mock-config')
+                                    ? jsonResponse({ appLoc: appLoc })
+                                    : jsonResponse({ format: 999, files: {} })];
+                        });
+                    }); });
+                    return [4 /*yield*/, runtime.seed()];
+                case 1:
+                    result = _a.sent();
+                    expect(result.booted).toBe(false);
+                    expect(result.error).toContain('format 999');
+                    expect(result.error).toContain('speaks format 1');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('reads a drive file with no format stamp as the current format', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    // every snapshot taken before the stamp existed looks like this
+                    return [4 /*yield*/, seedDrive(runtime, (_a = {}, _a[drivePath('a.txt')] = 'a', _a))];
+                case 1:
+                    // every snapshot taken before the stamp existed looks like this
+                    _b.sent();
+                    expect(runtime.stats().files).toBe(1);
+                    expect(runtime.DRIVE_FORMAT).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('exposes request parameters as variables, with JSON escaping', function () {
         var runtime = loadRuntime();
         var result = runtime.run({
@@ -216,6 +257,26 @@ describe('browser runtime', function () {
         });
         expect(result.headers).toBe('content-type: application/json');
     });
+    it('reads headers written as bytes the way the server does', function () {
+        var runtime = loadRuntime();
+        // The server reads the headers FILE, whatever way the service wrote it, so
+        // a byte write must still reach the host as text - handing over the drive's
+        // storage marker instead would drop every declared header and leave the
+        // download with its default type and name.
+        var result = runtime.run({
+            code: [
+                'fs.writeFileSync(_SASJS_WEBOUT_HEADERS, Buffer.from([',
+                "  'Content-type: text/csv',",
+                '  \'Content-Disposition: attachment; filename="report.csv"\'',
+                '].join(String.fromCharCode(10))))',
+                'fs.writeFileSync(weboutPath, Buffer.from([97, 44, 98]))'
+            ].join('\n')
+        });
+        expect(result.error).toBeNull();
+        expect(result.binary).toBe(true);
+        expect(result.headers).toContain('Content-type: text/csv');
+        expect(result.headers).toContain('filename="report.csv"');
+    });
     it('hands a byte body back to the host as base64', function () {
         var runtime = loadRuntime();
         // the shape a service that streams a file uses on the server: write the
@@ -632,6 +693,24 @@ describe('browser runtime', function () {
             ].join('\n')
         }).webout).toBe('504b0304');
     });
+    it('does not copy an ArrayBuffer into a Buffer, and does copy a view', function () {
+        var runtime = loadRuntime();
+        var result = runtime.run({
+            code: [
+                'const ab = new Uint8Array([1, 2, 3, 4]).buffer',
+                'const over = Buffer.from(ab)',
+                'over[0] = 9',
+                'const source = new Uint8Array([1, 2, 3])',
+                'const copy = Buffer.from(source)',
+                'copy[0] = 7',
+                '_webout = [over.length, new Uint8Array(ab)[0], copy[0], source[0]].join("|")'
+            ].join('\n')
+        });
+        expect(result.error).toBeNull();
+        // node returns a view for the ArrayBuffer overload, so the patch is visible
+        // in the ArrayBuffer the service kept, and copies a Uint8Array input
+        expect(result.webout).toBe('4|9|7|1');
+    });
     it('takes the offset and length node takes for an ArrayBuffer, and a length for concat', function () {
         var runtime = loadRuntime();
         var result = runtime.run({

package/package.json

@@ -94,7 +94,7 @@
     "@babel/preset-env": "7.29.7",
     "@babel/preset-typescript": "7.29.7",
     "@nogoo9/gitleaks": "8.30.1-post.2",
-    "@sasjs/lint": "^4.3.1",
+    "@sasjs/lint": "^4.3.2",
     "@types/debug": "4.1.13",
     "@types/find": "0.2.4",
     "@types/jest": "30.0.0",
@@ -124,7 +124,7 @@
     "nanoid": "3.3.18"
   },
   "peerDependencies": {
-    "@sasjs/lint": "^4.3.1"
+    "@sasjs/lint": "^4.3.2"
   },
-  "version": "6.2.1"
+  "version": "6.2.3"
 }