@sasjs/cli 6.8.3 → 6.9.0

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

@@ -731,6 +731,15 @@ const FS = {
       else throw e
     }
   },
+  /**
+   * Node's appendFileSync. The webout() block streams its members with it, and
+   * writeFileSync already honours the appending flag, so this is the same write
+   * with that flag set - text stays text and bytes stay bytes, as in node.
+   */
+  appendFileSync(p, data, options) {
+    const { encoding } = writeOptions(options)
+    FS.writeFileSync(p, data, { encoding, flag: 'a' })
+  },
   mkdirSync(p) {
     mkdirp(P.resolve(String(p)))
   },
@@ -858,6 +867,46 @@ const loadMockConfig = async () => {
   }
 }
 
+/**
+ * The webout() block, generated by the mock build from @sasjs/utils with
+ * sentinel values (see WEBOUT_SENTINELS in mockSite.ts). Filled in per run, so
+ * a service that sends data back behaves exactly as it does on a server -
+ * including the content type, which is what the block sets.
+ */
+let weboutPreludeTemplate = ''
+let weboutSentinels = null
+
+const loadWeboutPrelude = async () => {
+  try {
+    const res = await fetch('/host/webout-prelude.json', { cache: 'no-store' })
+    if (!res.ok) return
+    const cfg = await res.json()
+    if (cfg && typeof cfg.template === 'string') {
+      weboutPreludeTemplate = cfg.template
+      weboutSentinels = cfg.sentinels || null
+    }
+  } catch (e) {
+    /* a site built before the block existed keeps the _webout-only path */
+  }
+}
+
+/**
+ * One run's webout() source: each sentinel replaced by this run's value, quoted
+ * exactly as the server's generator quotes it. The sentinel names come from the
+ * build (WEBOUT_SENTINELS), so the two sides cannot disagree about them.
+ */
+const fillWeboutPrelude = (values) => {
+  if (!weboutPreludeTemplate || !weboutSentinels) return ''
+  let text = weboutPreludeTemplate
+  for (const [key, sentinel] of Object.entries(weboutSentinels)) {
+    if (!(key in values)) continue
+    text = text
+      .split('"' + sentinel + '"')
+      .join(JSON.stringify(String(values[key])))
+  }
+  return text
+}
+
 let sessionSeq = 0
 
 const formatArg = (a) => {
@@ -951,6 +1000,18 @@ const runProgram = ({ program, code, params = {}, tables = [] }) => {
   })
   webinStatements.push(`const _WEBIN_FILE_COUNT = ${tables.length};`)
 
+  // The webout() block, filled in for this run. Empty only for a site whose
+  // build predates it, where the _webout-only tail below still works.
+  const weboutPrelude = fillWeboutPrelude({
+    weboutPath,
+    headersPath,
+    program: codePath || program || '',
+    debug: params._debug || '',
+    username: 'DEMO',
+    userId: '0',
+    apiServerUrl: typeof location !== 'undefined' ? location.origin : ''
+  })
+
   const preProgram = `
 let _webout = '';
 const weboutPath = ${JSON.stringify(weboutPath)};
@@ -969,8 +1030,13 @@ const fs = require('fs');
 ${varStatements}
 ${webinStatements.join('\n')}
 ${preProgram}
+${weboutPrelude}
 ${payloadCode || FILES.get(codePath)}
-if (_webout) { fs.writeFile(weboutPath, _webout, function () {}); }
+${
+  weboutPrelude
+    ? '_sasjs_webout.finalise(_webout);'
+    : 'if (_webout) { fs.writeFile(weboutPath, _webout, function () {}); }'
+}
 return _webout;
 `
 
@@ -1180,6 +1246,7 @@ const fetchDrive = async () => {
 
 const boot = async () => {
   await loadMockConfig()
+  await loadWeboutPrelude()
   const { source, files: seed } = await fetchDrive()
   mkdirp(DRIVE_APP)
   mkdirp(`${DRIVE_ROOT}/files`)

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

@@ -10,6 +10,24 @@ export interface MockSiteResult {
     /** True when a captured drive snapshot was shipped with the site. */
     snapshot: boolean;
 }
+/**
+ * The webout() block is the one @sasjs/utils generates for the server, emitted
+ * here with sentinel values and filled in per run by runtime-core.js. That is
+ * what makes a service behave identically as a stored program and in a mock
+ * build: one copy of the block, one set of paths, one envelope.
+ *
+ * The sentinels are quoted in the emitted text (they are JSON string literals),
+ * so the substitution replaces the whole literal and never a fragment.
+ */
+export declare const WEBOUT_SENTINELS: {
+    weboutPath: string;
+    headersPath: string;
+    program: string;
+    debug: string;
+    username: string;
+    userId: string;
+    apiServerUrl: string;
+};
 /**
  * The bounds on what the browser drive seeds. A byte entry is carried as base64
  * in vfs-seed.json and held in the worker's memory, so a large artefact - an

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

@@ -75,12 +75,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DRIVE_FORMAT = exports.MAX_SEED_BYTES = exports.MAX_BINARY_SEED_BYTES = void 0;
+exports.DRIVE_FORMAT = exports.MAX_SEED_BYTES = exports.MAX_BINARY_SEED_BYTES = exports.WEBOUT_SENTINELS = void 0;
 exports.buildMockSite = buildMockSite;
 var crypto_1 = require("crypto");
 var fs_1 = __importDefault(require("fs"));
 var path_1 = __importDefault(require("path"));
 var utils_1 = require("@sasjs/utils");
+/**
+ * The webout() block is the one @sasjs/utils generates for the server, emitted
+ * here with sentinel values and filled in per run by runtime-core.js. That is
+ * what makes a service behave identically as a stored program and in a mock
+ * build: one copy of the block, one set of paths, one envelope.
+ *
+ * The sentinels are quoted in the emitted text (they are JSON string literals),
+ * so the substitution replaces the whole literal and never a fragment.
+ */
+exports.WEBOUT_SENTINELS = {
+    weboutPath: '__SASJS_WEBOUT_PATH__',
+    headersPath: '__SASJS_WEBOUT_HEADERS__',
+    program: '__SASJS_WEBOUT_PROGRAM__',
+    debug: '__SASJS_WEBOUT_DEBUG__',
+    username: '__SASJS_WEBOUT_USERNAME__',
+    userId: '__SASJS_WEBOUT_USERID__',
+    apiServerUrl: '__SASJS_WEBOUT_APIURL__'
+};
 var ASSETS_FOLDER = path_1.default.join(__dirname, 'assets');
 var toPosix = function (value) { return value.split(path_1.default.sep).join('/'); };
 var listFiles = function (folder, base) {
@@ -439,8 +457,23 @@ function buildMockSite(target) {
                     // sw.js sits at the site root: a worker can only control the folder it is
                     // served from, and the app has to be controlled from /
                     fs_1.default.copyFileSync(path_1.default.join(ASSETS_FOLDER, 'sw.js'), path_1.default.join(outputFolder, 'sw.js'));
+                    // 2a. the webout() block, generated once with sentinels that runtime-core.js
+                    // fills in per run. It is the same text the server emits, from @sasjs/utils,
+                    // so a service cannot behave differently in a mock build.
+                    fs_1.default.writeFileSync(path_1.default.join(hostFolder, 'webout-prelude.json'), JSON.stringify({
+                        sentinels: exports.WEBOUT_SENTINELS,
+                        template: (0, utils_1.getWeboutPrelude)({
+                            weboutPath: exports.WEBOUT_SENTINELS.weboutPath,
+                            headersPath: exports.WEBOUT_SENTINELS.headersPath,
+                            program: exports.WEBOUT_SENTINELS.program,
+                            debug: exports.WEBOUT_SENTINELS.debug,
+                            username: exports.WEBOUT_SENTINELS.username,
+                            userId: exports.WEBOUT_SENTINELS.userId,
+                            apiServerUrl: exports.WEBOUT_SENTINELS.apiServerUrl
+                        })
+                    }));
                     hostVersion = (0, crypto_1.createHash)('md5')
-                        .update(['runtime-core.js', 'persist.js', 'intercept.js']
+                        .update(['runtime-core.js', 'persist.js', 'intercept.js', 'webout-prelude.json']
                         .map(function (asset) { return fs_1.default.readFileSync(path_1.default.join(hostFolder, asset)); })
                         .reduce(function (all, buf) { return Buffer.concat([all, buf]); }, Buffer.alloc(0)))
                         .digest('hex')

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

@@ -189,6 +189,40 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
+    it('ships the webout() block with sentinels the runtime fills in', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var prelude, _a, _b, sentinel;
+        var e_2, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _d.sent();
+                    prelude = JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'webout-prelude.json'), 'utf8'));
+                    // The block is the one @sasjs/utils generates for the server. It travels
+                    // with sentinel values because the run's paths and user are not known at
+                    // build time, and the sentinel names travel with it so the two sides cannot
+                    // disagree about them.
+                    expect(prelude.template).toContain('webout(');
+                    expect(prelude.template).toContain('_sasjs_webout.finalise');
+                    expect(prelude.template).toContain('content-type: application/json');
+                    expect(prelude.sentinels.weboutPath).toEqual('__SASJS_WEBOUT_PATH__');
+                    try {
+                        for (_a = __values(Object.values(prelude.sentinels)), _b = _a.next(); !_b.done; _b = _a.next()) {
+                            sentinel = _b.value;
+                            expect(prelude.template).toContain(JSON.stringify(sentinel));
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                    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) {
@@ -293,7 +327,7 @@ describe('browser-hosted build', function () {
     }); });
     it('stops seeding bytes once the drive budget is spent, and names the file', function () { return __awaiter(void 0, void 0, void 0, function () {
         var chunk, _a, _b, name_1, seed, seeded;
-        var e_2, _c;
+        var e_3, _c;
         var _d;
         return __generator(this, function (_e) {
             switch (_e.label) {
@@ -306,12 +340,12 @@ describe('browser-hosted build', function () {
                             fs_1.default.writeFileSync(path_1.default.join(root, 'sasjsbuild', 'mock-storage', name_1), chunk);
                         }
                     }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
                     finally {
                         try {
                             if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                         }
-                        finally { if (e_2) throw e_2.error; }
+                        finally { if (e_3) throw e_3.error; }
                     }
                     return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())
                         // the budget is spent in path order, so the drive is the same on every host:
@@ -465,8 +499,8 @@ describe('browser-hosted build', function () {
         });
     }); });
     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_3_1;
-        var e_3, _c;
+        var _a, _b, mockWebFolder, e_4_1;
+        var e_4, _c;
         return __generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
@@ -497,14 +531,14 @@ describe('browser-hosted build', function () {
                     return [3 /*break*/, 1];
                 case 4: return [3 /*break*/, 7];
                 case 5:
-                    e_3_1 = _d.sent();
-                    e_3 = { error: e_3_1 };
+                    e_4_1 = _d.sent();
+                    e_4 = { error: e_4_1 };
                     return [3 /*break*/, 7];
                 case 6:
                     try {
                         if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                     }
-                    finally { if (e_3) throw e_3.error; }
+                    finally { if (e_4) throw e_4.error; }
                     return [7 /*endfinally*/];
                 case 7:
                     expect(fs_1.default.existsSync(path_1.default.join(root, 'client', 'dist', 'index.html'))).toBe(true);

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

@@ -36,6 +36,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@sasjs/utils");
+var mockSite_1 = require("../mockSite");
 /**
  * The parity claim of a browser-hosted build is that a service runs in the
  * browser exactly as it runs as a stored program. That claim lives in
@@ -59,7 +61,7 @@ var jsonResponse = function (body) { return ({
         return [2 /*return*/, body];
     }); }); }
 }); };
-var seedDrive = function (runtime, files) { return __awaiter(void 0, void 0, void 0, function () {
+var seedDrive = function (runtime, files, prelude) { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
@@ -70,6 +72,12 @@ var seedDrive = function (runtime, files) { return __awaiter(void 0, void 0, voi
                             return [2 /*return*/, jsonResponse({ appLoc: appLoc })];
                         if (url.includes('vfs-seed'))
                             return [2 /*return*/, jsonResponse({ files: files })];
+                        if (url.includes('webout-prelude'))
+                            return [2 /*return*/, prelude
+                                    ? jsonResponse(prelude)
+                                    : { ok: false, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                            return [2 /*return*/, ({})];
+                                        }); }); } }];
                         return [2 /*return*/, { ok: false, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
                                     return [2 /*return*/, ({})];
                                 }); }); } }];
@@ -128,6 +136,65 @@ describe('browser runtime', function () {
             }
         });
     }); });
+    it('sends data back the way the server does, through webout()', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, result, parsed;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    // A mock build ships the same block the server generates, with sentinel
+                    // values runtime-core fills per run. Without it a service written with
+                    // webout() fails in a mock build with "webout is not defined", which is the
+                    // gap this closes.
+                    return [4 /*yield*/, seedDrive(runtime, {}, {
+                            sentinels: mockSite_1.WEBOUT_SENTINELS,
+                            template: (0, utils_1.getWeboutPrelude)({
+                                weboutPath: mockSite_1.WEBOUT_SENTINELS.weboutPath,
+                                headersPath: mockSite_1.WEBOUT_SENTINELS.headersPath,
+                                program: mockSite_1.WEBOUT_SENTINELS.program,
+                                debug: mockSite_1.WEBOUT_SENTINELS.debug,
+                                username: mockSite_1.WEBOUT_SENTINELS.username,
+                                userId: mockSite_1.WEBOUT_SENTINELS.userId,
+                                apiServerUrl: mockSite_1.WEBOUT_SENTINELS.apiServerUrl
+                            })
+                        })];
+                case 1:
+                    // A mock build ships the same block the server generates, with sentinel
+                    // values runtime-core fills per run. Without it a service written with
+                    // webout() fails in a mock build with "webout is not defined", which is the
+                    // gap this closes.
+                    _a.sent();
+                    result = runtime.run({
+                        code: "\nwebout('OPEN')\nwebout('OBJ', 'users', [{ name: 'ann' }, { name: 'bob' }])\nwebout('CLOSE')"
+                    });
+                    expect(result.error).toBeNull();
+                    parsed = JSON.parse(result.webout);
+                    expect(parsed.users).toEqual([{ name: 'ann' }, { name: 'bob' }]);
+                    expect(parsed.SYSDATE).toMatch(/^\d{2}[A-Z]{3}\d{4}$/);
+                    expect(parsed.MF_GETUSER).toEqual('DEMO');
+                    expect(parsed.SYSPROCESSNAME).toEqual('Browser');
+                    expect(parsed.SYSSCPL).toEqual('browser');
+                    // The content type is the point: the block sets it, so the worker hands the
+                    // app JSON rather than a string. The mock seeds the file empty (the server
+                    // seeds text/html), so the block's record is the only one here.
+                    expect(result.headers).toContain('content-type: application/json');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves the headers alone for a service that only assigns _webout', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, result;
+        return __generator(this, function (_a) {
+            runtime = loadRuntime();
+            result = runtime.run({ code: "_webout = '<h1>raw</h1>'" });
+            expect(result.error).toBeNull();
+            expect(result.webout).toEqual('<h1>raw</h1>');
+            // Unchanged behaviour: a raw assignment declares no type here, and the
+            // worker's binary fallback depends on this file staying empty.
+            expect(result.headers).toEqual('');
+            return [2 /*return*/];
+        });
+    }); });
     it('exposes request parameters as variables, with JSON escaping', function () {
         var runtime = loadRuntime();
         var result = runtime.run({

package/build/commands/flow/flowCommand.js

@@ -67,8 +67,17 @@ var FlowSubCommand;
 })(FlowSubCommand || (FlowSubCommand = {}));
 var syntax = 'flow <subCommand> [options]';
 var usage = 'sasjs flow <execute> --source <flowPath> [options]';
-var description = 'Performs operations on flows of jobs.\n' +
-    'Exits non-zero when a flow does not complete: 6 when a job did not succeed, 2 when the flow could not be executed at all.';
+// the codes are read from the enum rather than written out, so a member
+// inserted ahead of them cannot make this text describe numbers the command no
+// longer returns. A function rather than a constant: `types/command/index.ts`
+// re-exports `parse` before `ReturnCode`, and `parse` loads every command, so
+// reading the enum while this module initialises finds it undefined.
+var commandDescription = function () {
+    return 'Performs operations on flows of jobs.\n' +
+        "Exits ".concat(command_1.ReturnCode.FlowError, " when a flow finishes with a job that did not ") +
+        "succeed, and ".concat(command_1.ReturnCode.InternalError, " when the flow could not be executed ") +
+        'at all.';
+};
 var examples = [
     {
         command: 'sasjs flow execute --source /local/flow.json --logFolder /local/log/folder --csvFile /local/some.csv --target myTarget --streamLog',
@@ -114,7 +123,7 @@ var FlowCommand = /** @class */ (function (_super) {
         return _super.call(this, args, {
             parseOptions: parseOptions,
             usage: usage,
-            description: description,
+            description: commandDescription(),
             examples: examples,
             syntax: syntax
         }) || this;

package/build/commands/shared/fetchLogFileContent.js

@@ -62,6 +62,31 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchLogFileContent = void 0;
+/**
+ * Parses a log response into the text of the log, or into the paged shape Viya
+ * returns.
+ *
+ * Viya answers a log request with `{ items: [{ line }] }` and pages it with
+ * `start` and `limit`. A server that answers with the log itself has no chunks
+ * to parse, and the body must not be fed to `JSON.parse` blindly: a log whose
+ * first character happens to be a digit parses as a number, and reading `.items`
+ * off it throws.
+ *
+ * The adapter hands back `JSON.stringify(result)` whatever the server sent, so
+ * the log arrives here quoted and escaped - parsing once gives the text back.
+ */
+var parseLogChunk = function (body) {
+    var parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch (_) {
+        return { text: body !== null && body !== void 0 ? body : '' };
+    }
+    if (parsed && Array.isArray(parsed.items))
+        return parsed;
+    return { text: typeof parsed === 'string' ? parsed : (body !== null && body !== void 0 ? body : '') };
+};
 /**
  * Fetches content of the log file
  * @param {object} sasjs - configuration object of SAS adapter.
@@ -71,27 +96,32 @@ exports.fetchLogFileContent = void 0;
  * @returns an object containing log lines in 'items' array.
  */
 var fetchLogFileContent = function (sasjs, accessToken, logUrl, logCount) { return __awaiter(void 0, void 0, void 0, function () {
-    var logJson, loglimit, start, logChunkJson, _a, _b;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
+    var logJson, loglimit, start, body, parsed, logChunkJson;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
             case 0:
                 logJson = { items: [] };
                 loglimit = logCount < 10000 ? logCount : 10000;
                 start = 0;
-                _c.label = 1;
-            case 1:
-                _b = (_a = JSON).parse;
-                return [4 /*yield*/, sasjs.fetchLogFileContent("".concat(logUrl, "?start=").concat(start, "&limit=").concat(loglimit), accessToken)];
+                _a.label = 1;
+            case 1: return [4 /*yield*/, sasjs.fetchLogFileContent("".concat(logUrl, "?start=").concat(start, "&limit=").concat(loglimit), accessToken)];
             case 2:
-                logChunkJson = _b.apply(_a, [(_c.sent())]);
+                body = (_a.sent());
+                parsed = parseLogChunk(body);
+                // Not Viya's paged shape, so the body is the log: SASjs Server answers with
+                // the log itself, and the `start`/`limit` parameters mean nothing to it.
+                // Asking again would return the same text, so this is the whole answer.
+                if ('text' in parsed)
+                    return [2 /*return*/, { items: [{ line: parsed.text }] }];
+                logChunkJson = parsed;
                 if (logChunkJson.items.length === 0)
                     return [3 /*break*/, 4];
                 logJson.items = __spreadArray(__spreadArray([], __read(logJson.items), false), __read(logChunkJson.items), false);
                 start += loglimit;
-                _c.label = 3;
+                _a.label = 3;
             case 3:
                 if (start < logCount) return [3 /*break*/, 1];
-                _c.label = 4;
+                _a.label = 4;
             case 4: return [2 /*return*/, logJson];
         }
     });

package/build/commands/shared/spec/fetchLogFileContent.spec.d.ts

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

package/build/commands/shared/spec/fetchLogFileContent.spec.js

@@ -0,0 +1,134 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fetchLogFileContent_1 = require("../fetchLogFileContent");
+/**
+ * Two servers answer a log request, in two shapes: Viya with a paged JSON chunk
+ * (`{ items: [{ line }] }`), SASjs Server with the log itself. The fetcher has to
+ * read both, and the case that broke was the second - a log starting with a digit
+ * parsed as a number, so `items` was undefined.
+ */
+var makeSasjs = function (responses) {
+    var fetchMock = jest.fn();
+    responses.forEach(function (response) { return fetchMock.mockResolvedValueOnce(response); });
+    return {
+        sasjs: { fetchLogFileContent: fetchMock },
+        fetchMock: fetchMock
+    };
+};
+describe('fetchLogFileContent', function () {
+    it('pages the JSON chunks Viya returns', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, sasjs, fetchMock, log;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = makeSasjs([
+                        JSON.stringify({ items: [{ line: 'NOTE: one' }, { line: 'NOTE: two' }] })
+                    ]), sasjs = _a.sasjs, fetchMock = _a.fetchMock;
+                    return [4 /*yield*/, (0, fetchLogFileContent_1.fetchLogFileContent)(sasjs, 'token', 'https://viya.example/compute/jobs/1/log', 2)];
+                case 1:
+                    log = _b.sent();
+                    expect(log.items).toEqual([{ line: 'NOTE: one' }, { line: 'NOTE: two' }]);
+                    expect(fetchMock).toHaveBeenCalledTimes(1);
+                    expect(fetchMock).toHaveBeenCalledWith('https://viya.example/compute/jobs/1/log?start=0&limit=2', 'token');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('stops when Viya answers with no further lines', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, sasjs, fetchMock, log;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = makeSasjs([JSON.stringify({ items: [] })]), sasjs = _a.sasjs, fetchMock = _a.fetchMock;
+                    return [4 /*yield*/, (0, fetchLogFileContent_1.fetchLogFileContent)(sasjs, 'token', 'log', 50000)];
+                case 1:
+                    log = _b.sent();
+                    expect(log.items).toEqual([]);
+                    expect(fetchMock).toHaveBeenCalledTimes(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('takes the whole body when it is not a JSON chunk', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var body, _a, sasjs, fetchMock, log;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    body = '1  The SAS System\nNOTE: hello\nERROR: something wrong\n';
+                    _a = makeSasjs([body]), sasjs = _a.sasjs, fetchMock = _a.fetchMock;
+                    return [4 /*yield*/, (0, fetchLogFileContent_1.fetchLogFileContent)(sasjs, 'token', 'https://sas.4gl.io/SASjsApi/session/1/log', 4)];
+                case 1:
+                    log = _b.sent();
+                    expect(log.items).toEqual([{ line: body }]);
+                    // and it is not asked again: the text is the whole log, not a page of it
+                    expect(fetchMock).toHaveBeenCalledTimes(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('unwraps a log the adapter has stringified', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var text, sasjs, log;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    text = '1  The SAS System\nERROR: 22-322: Syntax error\n';
+                    sasjs = makeSasjs([JSON.stringify(text)]).sasjs;
+                    return [4 /*yield*/, (0, fetchLogFileContent_1.fetchLogFileContent)(sasjs, 'token', 'log', 2)];
+                case 1:
+                    log = _a.sent();
+                    expect(log.items).toEqual([{ line: text }]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('treats an empty body as an empty log', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var sasjs, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    sasjs = makeSasjs(['']).sasjs;
+                    _a = expect;
+                    return [4 /*yield*/, (0, fetchLogFileContent_1.fetchLogFileContent)(sasjs, 'token', 'log', 0)];
+                case 1:
+                    _a.apply(void 0, [(_b.sent()).items]).toEqual([{ line: '' }]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/package.json

@@ -73,7 +73,7 @@
     "@sasjs/adapter": "^5.1.3",
     "@sasjs/core": "^6.1.1",
     "@sasjs/lint": "4.9.0",
-    "@sasjs/utils": "^4.3.2",
+    "@sasjs/utils": "^4.4.0",
     "axios": "1.20.0",
     "chalk": "4.1.2",
     "dotenv": "18.0.8",
@@ -123,5 +123,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.8.3"
+  "version": "6.9.0"
 }