@sasjs/cli 6.8.0 → 6.8.2

package/build/commands/fs/fsCommand.d.ts

@@ -7,6 +7,6 @@ export declare class FSCommand extends TargetCommand {
     getOutputPath(): Promise<string>;
     execute(): Promise<ReturnCode>;
     compile(): Promise<ReturnCode>;
-    deploy(): Promise<ReturnCode.Success | ReturnCode.InternalError>;
-    sync(): Promise<ReturnCode.Success | ReturnCode.InternalError>;
+    deploy(): Promise<ReturnCode.Success | ReturnCode.InternalError | ReturnCode.LogCheckError>;
+    sync(): Promise<ReturnCode.Success | ReturnCode.InternalError | ReturnCode.LogCheckError>;
 }

package/build/commands/fs/fsCommand.js

@@ -113,6 +113,7 @@ var utils_2 = require("@sasjs/utils");
 // bundle that imported anything from the barrel (sasjs/utils#275, #283).
 var fs_1 = require("@sasjs/utils/fs");
 var executeCode_1 = require("./internal/executeCode");
+var logcheck_1 = require("../../utils/logcheck");
 var FsSubCommand;
 (function (FsSubCommand) {
     FsSubCommand["Compile"] = "compile";
@@ -123,7 +124,12 @@ var syntax = 'fs <subCommand> [options]';
 var usage = 'Usage: sasjs fs <subCommand> [options]';
 var description = 'Handles operations around file system synchronisation';
 var parseOptions = {
-    output: { type: 'string', alias: 'o' }
+    output: { type: 'string', alias: 'o' },
+    logcheck: {
+        type: 'boolean',
+        default: undefined,
+        description: 'Check the SAS log this command received, and fail when logCheck in sasjsconfig.json says so. --no-logcheck switches both the report and the verdict off.'
+    }
 };
 var compileCommandSyntax = 'fs <subCommand> <local> [options]';
 var compileCommandUsage = 'sasjs fs compile <localFolder> [options]';
@@ -243,6 +249,7 @@ var FSCommand = /** @class */ (function (_super) {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        (0, logcheck_1.setLogCheckMode)((0, logcheck_1.logCheckModeOf)(this.parsed.logcheck));
                         if (!(this.parsed.subCommand === FsSubCommand.Compile)) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.compile()];
                     case 1: return [2 /*return*/, _a.sent()];
@@ -324,8 +331,24 @@ var FSCommand = /** @class */ (function (_super) {
                                 var log = _b.log;
                                 return __generator(this, function (_c) {
                                     switch (_c.label) {
-                                        case 0: return [4 /*yield*/, (0, utils_1.saveLog)(log, path_1.default.join(outputFolder, 'deploy.log'), '', false)];
+                                        case 0: return [4 /*yield*/, (0, utils_1.saveLog)(log, path_1.default.join(outputFolder, 'deploy.log'), '', false)
+                                            // After the log file is written: a deploy whose log fails the check is
+                                            // the deploy whose record someone needs to read. Fatal, because a
+                                            // deploy that aborted still has to fail the build - reporting it and
+                                            // then printing "successfully deployed" is the bug in sasjs/cli#1535.
+                                        ];
                                         case 1:
+                                            _c.sent();
+                                            // After the log file is written: a deploy whose log fails the check is
+                                            // the deploy whose record someone needs to read. Fatal, because a
+                                            // deploy that aborted still has to fail the build - reporting it and
+                                            // then printing "successfully deployed" is the bug in sasjs/cli#1535.
+                                            return [4 /*yield*/, (0, logcheck_1.checkLog)(log, 'fs deploy', { fatal: true })];
+                                        case 2:
+                                            // After the log file is written: a deploy whose log fails the check is
+                                            // the deploy whose record someone needs to read. Fatal, because a
+                                            // deploy that aborted still has to fail the build - reporting it and
+                                            // then printing "successfully deployed" is the bug in sasjs/cli#1535.
                                             _c.sent();
                                             return [2 /*return*/];
                                     }
@@ -337,6 +360,10 @@ var FSCommand = /** @class */ (function (_super) {
                         return [2 /*return*/, command_1.ReturnCode.Success];
                     case 7:
                         error_1 = _f.sent();
+                        // the verdict the caller asked for, not an internal failure: it carries
+                        // its own exit code and has already printed the report
+                        if ((0, logcheck_1.isLogCheckFailure)(error_1))
+                            return [2 /*return*/, command_1.ReturnCode.LogCheckError];
                         logPath = path_1.default.join(outputFolder, 'error.log');
                         return [4 /*yield*/, createErrorLogFile(error_1, logPath)];
                     case 8:
@@ -386,7 +413,7 @@ var FSCommand = /** @class */ (function (_super) {
                                         outputFolder = _v.sent();
                                         _v.label = 2;
                                     case 2:
-                                        _v.trys.push([2, 15, , 17]);
+                                        _v.trys.push([2, 17, , 19]);
                                         (_h = process.logger) === null || _h === void 0 ? void 0 : _h.info('generating program to get remote hash');
                                         return [4 /*yield*/, (0, fs_1.generateProgramToGetRemoteHash)(obj.remote)];
                                     case 3:
@@ -400,15 +427,18 @@ var FSCommand = /** @class */ (function (_super) {
                                         log = (_v.sent()).log;
                                         return [4 /*yield*/, (0, utils_1.saveLog)(log, path_1.default.join(outputFolder, 'getRemoteHash.log'), '', false)];
                                     case 6:
+                                        _v.sent();
+                                        return [4 /*yield*/, (0, logcheck_1.checkLog)(log, 'fs sync')];
+                                    case 7:
                                         _v.sent();
                                         (_k = process.logger) === null || _k === void 0 ? void 0 : _k.info('extracting hashes from log');
                                         remoteHashes = (0, fs_1.extractHashArray)(log);
                                         return [4 /*yield*/, createHashFile(JSON.stringify(remoteHashes, null, 2), path_1.default.join(outputFolder, 'hashesBeforeSync.json'))];
-                                    case 7:
+                                    case 8:
                                         _v.sent();
                                         (_l = process.logger) === null || _l === void 0 ? void 0 : _l.info('creating the hash of local folder');
                                         return [4 /*yield*/, (0, fs_1.getHash)((0, utils_2.getAbsolutePath)(obj.local, process.projectDir))];
-                                    case 8:
+                                    case 9:
                                         localHash = _v.sent();
                                         remoteHashMap_1 = remoteHashes.reduce(function (map, item) {
                                             var from = obj.remote.replace(/\//g, path_1.default.sep);
@@ -424,25 +454,28 @@ var FSCommand = /** @class */ (function (_super) {
                                         (_o = process.logger) === null || _o === void 0 ? void 0 : _o.info('Extract differences from local and remote hash');
                                         hashedDiff = (0, fs_1.compareHashes)(localHash, remoteHashMap_1);
                                         return [4 /*yield*/, createHashFile(JSON.stringify(hashedDiff, null, 2), path_1.default.join(outputFolder, 'hashesDiff.json'))];
-                                    case 9:
+                                    case 10:
                                         _v.sent();
                                         (_p = process.logger) === null || _p === void 0 ? void 0 : _p.info('generating program to sync differences');
                                         return [4 /*yield*/, (0, fs_1.generateProgramToSyncHashDiff)(hashedDiff, obj.remote)];
-                                    case 10:
+                                    case 11:
                                         syncProgram = _v.sent();
                                         return [4 /*yield*/, createProgramFile(syncProgram, path_1.default.join(outputFolder, 'syncProgram.sas'))];
-                                    case 11:
+                                    case 12:
                                         _v.sent();
                                         (_q = process.logger) === null || _q === void 0 ? void 0 : _q.info('executing program to sync differences');
                                         return [4 /*yield*/, (0, executeCode_1.executeCode)(target, syncProgram)];
-                                    case 12:
+                                    case 13:
                                         syncLog = (_v.sent()).log;
                                         return [4 /*yield*/, (0, utils_1.saveLog)(syncLog, path_1.default.join(outputFolder, 'sync.log'), '', false)];
-                                    case 13:
+                                    case 14:
+                                        _v.sent();
+                                        return [4 /*yield*/, (0, logcheck_1.checkLog)(syncLog, 'fs sync')];
+                                    case 15:
                                         _v.sent();
                                         syncedHash = (0, fs_1.extractHashArray)(syncLog);
                                         return [4 /*yield*/, createHashFile(JSON.stringify(syncedHash, null, 2), path_1.default.join(outputFolder, 'hashesAfterSync.json'))];
-                                    case 14:
+                                    case 16:
                                         _v.sent();
                                         syncedHashMap = syncedHash.reduce(function (map, item) {
                                             var from = obj.remote.replace(/\//g, path_1.default.sep);
@@ -472,16 +505,18 @@ var FSCommand = /** @class */ (function (_super) {
                                                 (_a = process.logger) === null || _a === void 0 ? void 0 : _a.log("* ".concat(item));
                                             });
                                         }
-                                        return [3 /*break*/, 17];
-                                    case 15:
+                                        return [3 /*break*/, 19];
+                                    case 17:
                                         error_2 = _v.sent();
+                                        if ((0, logcheck_1.isLogCheckFailure)(error_2))
+                                            return [2 /*return*/, { value: command_1.ReturnCode.LogCheckError }];
                                         logPath = path_1.default.join(outputFolder, 'error.log');
                                         return [4 /*yield*/, createErrorLogFile(error_2, logPath)];
-                                    case 16:
+                                    case 18:
                                         _v.sent();
                                         (_t = process.logger) === null || _t === void 0 ? void 0 : _t.error("An error has occurred. For more info see ".concat(logPath));
                                         return [2 /*return*/, { value: command_1.ReturnCode.InternalError }];
-                                    case 17: return [2 /*return*/];
+                                    case 19: return [2 /*return*/];
                                 }
                             });
                         };

package/build/commands/fs/internal/executeCode.d.ts

@@ -1,4 +1,10 @@
 import { Target } from '@sasjs/utils';
+/**
+ * Runs generated SAS and returns the log it came back with.
+ *
+ * The caller saves that log and then checks it - not here, because a check that
+ * throws before the log file is written is a failed run nobody can read.
+ */
 export declare const executeCode: (target: Target, code: string) => Promise<{
     log: any;
 }>;

package/build/commands/fs/internal/executeCode.js

@@ -39,6 +39,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeCode = void 0;
 var utils_1 = require("@sasjs/utils");
 var utils_2 = require("../../../utils/");
+/**
+ * Runs generated SAS and returns the log it came back with.
+ *
+ * The caller saves that log and then checks it - not here, because a check that
+ * throws before the log file is written is a failed run nobody can read.
+ */
 var executeCode = function (target, code) { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
         switch (_a.label) {

package/build/commands/fs/spec/fsCommand.spec.js

@@ -103,6 +103,8 @@ var FileModule = __importStar(require("@sasjs/utils/file"));
 var configUtils = __importStar(require("../../../utils/config"));
 var setConstantsUtils = __importStar(require("../../../utils/setConstants"));
 var executeCodeModule = __importStar(require("../internal/executeCode"));
+var logcheckModule = __importStar(require("../../../utils/logcheck"));
+var logcheck_1 = require("../../../utils/logcheck");
 var defaultArgs = ['node', 'sasjs', 'fs'];
 var target = new utils_1.Target({
     name: 'test',
@@ -227,6 +229,28 @@ describe('FSCommand', function () {
                 }
             });
         }); });
+        it('should return the logcheck code when the deploy log fails the check', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var returnCode;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest
+                            .spyOn(logcheckModule, 'checkLog')
+                            .mockImplementation(function () {
+                            return Promise.reject(new logcheck_1.LogCheckFailure('2 errors'));
+                        });
+                        return [4 /*yield*/, executeCommandWrapper([
+                                'deploy',
+                                'localFolder',
+                                'remoteFolder'
+                            ])];
+                    case 1:
+                        returnCode = _a.sent();
+                        expect(returnCode).toEqual(command_1.ReturnCode.LogCheckError);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
     describe('sync', function () {
         beforeEach(function () {
@@ -335,6 +359,102 @@ describe('FSCommand', function () {
                 }
             });
         }); });
+        it('should return the logcheck code when the sync log fails the check', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var returnCode;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest
+                            .spyOn(logcheckModule, 'checkLog')
+                            .mockImplementation(function () {
+                            return Promise.reject(new logcheck_1.LogCheckFailure('1 error'));
+                        });
+                        jest.spyOn(FSModule, 'extractHashArray').mockImplementationOnce(function () { return []; });
+                        return [4 /*yield*/, executeCommandWrapper([
+                                'sync',
+                                '-l',
+                                'localFolder',
+                                '-r',
+                                'remoteFolder'
+                            ])];
+                    case 1:
+                        returnCode = _a.sent();
+                        expect(returnCode).toEqual(command_1.ReturnCode.LogCheckError);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe('log check mode', function () {
+        beforeEach(function () {
+            process.logger = new utils_1.Logger(utils_1.LogLevel.Off);
+            jest.spyOn(process.logger, 'info');
+            setupMocks();
+            jest
+                .spyOn(FSModule, 'generateCompileProgram')
+                .mockImplementation(function () { return Promise.resolve(''); });
+            jest
+                .spyOn(FileModule, 'createFile')
+                .mockImplementation(function () { return Promise.resolve(); });
+            jest
+                .spyOn(executeCodeModule, 'executeCode')
+                .mockImplementation(function () { return Promise.resolve({ log: '' }); });
+            jest
+                .spyOn(logcheckModule, 'checkLog')
+                .mockImplementation(function () { return Promise.resolve(); });
+        });
+        it('should switch the log check on for --logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var spy;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        spy = jest.spyOn(logcheckModule, 'setLogCheckMode');
+                        return [4 /*yield*/, executeCommandWrapper([
+                                'deploy',
+                                'localFolder',
+                                'remoteFolder',
+                                '--logcheck'
+                            ])];
+                    case 1:
+                        _a.sent();
+                        expect(spy).toHaveBeenCalledWith('on');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should switch the log check off for --no-logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var spy;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        spy = jest.spyOn(logcheckModule, 'setLogCheckMode');
+                        return [4 /*yield*/, executeCommandWrapper([
+                                'deploy',
+                                'localFolder',
+                                'remoteFolder',
+                                '--no-logcheck'
+                            ])];
+                    case 1:
+                        _a.sent();
+                        expect(spy).toHaveBeenCalledWith('off');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should leave the log check on auto when no flag is given', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var spy;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        spy = jest.spyOn(logcheckModule, 'setLogCheckMode');
+                        return [4 /*yield*/, executeCommandWrapper(['deploy', 'localFolder', 'remoteFolder'])];
+                    case 1:
+                        _a.sent();
+                        expect(spy).toHaveBeenCalledWith('auto');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
     });
     describe('invalid subCommand', function () {
         it('should return ReturnCode.InvalidCommand when subCommand is unknown', function () { return __awaiter(void 0, void 0, void 0, function () {

package/build/commands/job/internal/execute/viya.js

@@ -68,7 +68,7 @@ var utils_4 = require("../utils");
  */
 function executeJobViya(sasjs, authConfig, jobPath, target, waitForJob, output, logFile, statusFile, ignoreWarnings, source, streamLog) {
     return __awaiter(this, void 0, void 0, function () {
-        var pollOptions, result, startTime, contextName, macroVars, submittedJob, endTime, outputJson, currentDirPath, outputPath, folderPath, parentFolderPath, logObj, logUrl, logCount, logData, error_1;
+        var pollOptions, result, startTime, contextName, macroVars, submittedJob, endTime, wantsVerdict, outputJson, currentDirPath, outputPath, folderPath, parentFolderPath, error_1, logObj, logUrl, logCount, logData, error_2;
         var _this = this;
         var _a, _b;
         return __generator(this, function (_c) {
@@ -176,15 +176,18 @@ function executeJobViya(sasjs, authConfig, jobPath, target, waitForJob, output,
                     _c.sent();
                     _c.label = 8;
                 case 8:
-                    if (!(submittedJob && submittedJob.links)) return [3 /*break*/, 22];
+                    if (!(submittedJob && submittedJob.links)) return [3 /*break*/, 28];
                     if (!result)
                         result = true;
-                    if (!(output || logFile)) return [3 /*break*/, 21];
-                    _c.label = 9;
+                    return [4 /*yield*/, (0, logcheck_1.logCheckWantsVerdict)()];
                 case 9:
-                    _c.trys.push([9, 20, , 21]);
+                    wantsVerdict = _c.sent();
+                    if (!output) return [3 /*break*/, 18];
+                    _c.label = 10;
+                case 10:
+                    _c.trys.push([10, 17, , 18]);
                     outputJson = JSON.stringify(submittedJob, null, 2);
-                    if (!(typeof output === 'string')) return [3 /*break*/, 14];
+                    if (!(typeof output === 'string')) return [3 /*break*/, 15];
                     currentDirPath = path_1.default.isAbsolute(output)
                         ? ''
                         : process.projectDir;
@@ -195,50 +198,71 @@ function executeJobViya(sasjs, authConfig, jobPath, target, waitForJob, output,
                     folderPath.pop();
                     parentFolderPath = folderPath.join(path_1.default.sep);
                     return [4 /*yield*/, (0, utils_2.folderExists)(parentFolderPath)];
-                case 10:
-                    if (!!(_c.sent())) return [3 /*break*/, 12];
-                    return [4 /*yield*/, (0, utils_2.createFolder)(parentFolderPath)];
                 case 11:
+                    if (!!(_c.sent())) return [3 /*break*/, 13];
+                    return [4 /*yield*/, (0, utils_2.createFolder)(parentFolderPath)];
+                case 12:
                     _c.sent();
-                    _c.label = 12;
-                case 12: return [4 /*yield*/, (0, utils_2.createFile)(outputPath, outputJson)];
-                case 13:
+                    _c.label = 13;
+                case 13: return [4 /*yield*/, (0, utils_2.createFile)(outputPath, outputJson)];
+                case 14:
                     _c.sent();
                     (0, displayResult_1.displaySuccess)("Output saved to: ".concat(outputPath));
-                    return [3 /*break*/, 15];
-                case 14:
+                    return [3 /*break*/, 16];
+                case 15:
                     if (output) {
                         // log job object to the console
                         ;
                         (process.logger || console).log(outputJson);
                     }
-                    _c.label = 15;
-                case 15:
-                    if (!(logFile && !pollOptions.streamLog)) return [3 /*break*/, 19];
+                    _c.label = 16;
+                case 16:
+                    result = submittedJob;
+                    return [3 /*break*/, 18];
+                case 17:
+                    error_1 = _c.sent();
+                    // handle use case when submitted job can't be parsed
+                    result = false;
+                    (0, displayResult_1.displayError)(null, 'An error has occurred when parsing an output of the job.');
+                    return [3 /*break*/, 18];
+                case 18:
+                    if (!(!pollOptions.streamLog && (Boolean(logFile) || wantsVerdict))) return [3 /*break*/, 27];
                     logObj = submittedJob.links.find(function (link) { return link.rel === 'log' && link.method === 'GET'; });
-                    if (!logObj) return [3 /*break*/, 19];
+                    if (!logObj) return [3 /*break*/, 26];
+                    _c.label = 19;
+                case 19:
+                    _c.trys.push([19, 24, , 25]);
                     logUrl = target.serverUrl + logObj.href;
                     logCount = submittedJob.logStatistics.lineCount;
                     return [4 /*yield*/, (0, fetchLogFileContent_1.fetchLogFileContent)(sasjs, authConfig.access_token, logUrl, logCount)];
-                case 16:
+                case 20:
                     logData = _c.sent();
+                    if (!logFile) return [3 /*break*/, 22];
                     return [4 /*yield*/, (0, utils_4.saveLog)(logData, logFile, jobPath)];
-                case 17:
+                case 21:
                     _c.sent();
-                    return [4 /*yield*/, (0, logcheck_1.checkLog)(typeof logData === 'string' ? logData : (0, utils_1.parseLogLines)(logData), jobPath)];
-                case 18:
+                    _c.label = 22;
+                case 22: return [4 /*yield*/, (0, logcheck_1.checkLog)(typeof logData === 'string' ? logData : (0, utils_1.parseLogLines)(logData), jobPath)];
+                case 23:
                     _c.sent();
-                    _c.label = 19;
-                case 19:
-                    result = submittedJob;
-                    return [3 /*break*/, 21];
-                case 20:
-                    error_1 = _c.sent();
-                    // handle use case when submitted job can't be parsed
+                    return [3 /*break*/, 25];
+                case 24:
+                    error_2 = _c.sent();
+                    // the verdict the caller asked for, not a failed fetch
+                    if ((0, logcheck_1.isLogCheckFailure)(error_2))
+                        throw error_2;
                     result = false;
-                    (0, displayResult_1.displayError)(null, 'An error has occurred when parsing an output of the job.');
-                    return [3 /*break*/, 21];
-                case 21:
+                    (0, displayResult_1.displayError)(null, 'An error has occurred when retrieving the job log.');
+                    return [3 /*break*/, 25];
+                case 25: return [3 /*break*/, 27];
+                case 26:
+                    // A log was asked for and the job carries none. Staying quiet here is
+                    // the same "flag that does nothing" this block exists to remove: it
+                    // reaches the end with the job's own status and exits 0.
+                    result = false;
+                    (0, displayResult_1.displayError)(null, 'An error has occurred: the job returned no log to check or save.');
+                    _c.label = 27;
+                case 27:
                     // wait for job state and return status(0,1,2) based on it
                     if (waitForJob && submittedJob.state) {
                         switch (submittedJob.state) {
@@ -254,13 +278,13 @@ function executeJobViya(sasjs, authConfig, jobPath, target, waitForJob, output,
                                 break;
                         }
                     }
-                    return [3 /*break*/, 23];
-                case 22:
+                    return [3 /*break*/, 29];
+                case 28:
                     if (result) {
                         (0, utils_3.terminateProcess)(command_1.ReturnCode.InternalError);
                     }
-                    _c.label = 23;
-                case 23:
+                    _c.label = 29;
+                case 29:
                     (_b = process.logger) === null || _b === void 0 ? void 0 : _b.info("This job was executed in ".concat((endTime - startTime) / 1000, " seconds"));
                     return [2 /*return*/, result];
             }

package/build/commands/job/spec/execute.spec.js

@@ -79,6 +79,11 @@ var path_1 = __importDefault(require("path"));
 var utils_2 = require("../../../utils");
 var utilsModule = __importStar(require("../../../utils/utils"));
 var configUtils = __importStar(require("../../../utils/config"));
+var logcheckModule = __importStar(require("../../../utils/logcheck"));
+var fetchLogFileContentModule = __importStar(require("../../shared/fetchLogFileContent"));
+var logcheck_1 = require("../../../utils/logcheck");
+var jobUtils = __importStar(require("../internal/utils"));
+var displayResultModule = __importStar(require("../../../utils/displayResult"));
 var execute_1 = require("../internal/execute");
 var mocks_1 = require("./mocks");
 var sasjs = new node_1.default();
@@ -165,6 +170,118 @@ describe('executeJobViya', function () {
             }
         });
     }); });
+    it('propagates a log-check failure instead of reporting a parse error', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var failure;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // a job whose log fails the check used to print the verdict and then exit 0,
+                    // because this function's catch-all treated the failure as a bad output
+                    jest.spyOn(sasjs, 'startComputeJob').mockResolvedValue({
+                        job: {
+                            state: 'completed',
+                            links: [{ rel: 'log', method: 'GET', href: '/log' }],
+                            logStatistics: { lineCount: 5 }
+                        }
+                    });
+                    jest
+                        .spyOn(fetchLogFileContentModule, 'fetchLogFileContent')
+                        .mockResolvedValue('ERROR: deliberate');
+                    failure = new logcheck_1.LogCheckFailure('SAS log check failed for test/job');
+                    jest.spyOn(logcheckModule, 'checkLog').mockRejectedValue(failure);
+                    return [4 /*yield*/, expect((0, execute_1.executeJobViya)(sasjs, mocks_1.mockAuthConfig, 'test/job', target, true, false, testLogsPath, undefined, false, undefined, false)).rejects.toBe(failure)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('fetches the log under --logcheck even when no log file was named', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var saveSpy, fetchSpy, failure;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // otherwise the flag prints nothing and exits 0, which reads as a clean log
+                    jest.spyOn(logcheckModule, 'logCheckWantsVerdict').mockResolvedValue(true);
+                    saveSpy = jest.spyOn(jobUtils, 'saveLog').mockResolvedValue(undefined);
+                    jest.spyOn(sasjs, 'startComputeJob').mockResolvedValue({
+                        job: {
+                            state: 'completed',
+                            links: [{ rel: 'log', method: 'GET', href: '/log' }],
+                            logStatistics: { lineCount: 5 }
+                        }
+                    });
+                    fetchSpy = jest
+                        .spyOn(fetchLogFileContentModule, 'fetchLogFileContent')
+                        .mockResolvedValue('ERROR: deliberate');
+                    failure = new logcheck_1.LogCheckFailure('SAS log check failed for test/job');
+                    jest.spyOn(logcheckModule, 'checkLog').mockRejectedValue(failure);
+                    return [4 /*yield*/, expect((0, execute_1.executeJobViya)(sasjs, mocks_1.mockAuthConfig, 'test/job', target, true, false, undefined, undefined, false, undefined, false)).rejects.toBe(failure)];
+                case 1:
+                    _a.sent();
+                    expect(fetchSpy).toHaveBeenCalled();
+                    // the log was fetched for the verdict, not asked for: writing it would
+                    // leave a file in the project directory that nobody requested
+                    expect(saveSpy).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('names the log fetch, not the job output, when the log cannot be retrieved', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var checkSpy, displaySpy, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jest.spyOn(logcheckModule, 'logCheckWantsVerdict').mockResolvedValue(true);
+                    jest.spyOn(sasjs, 'startComputeJob').mockResolvedValue({
+                        job: {
+                            state: 'completed',
+                            links: [{ rel: 'log', method: 'GET', href: '/log' }],
+                            logStatistics: { lineCount: 5 }
+                        }
+                    });
+                    jest
+                        .spyOn(fetchLogFileContentModule, 'fetchLogFileContent')
+                        .mockRejectedValue(new Error('502 Bad Gateway'));
+                    checkSpy = jest.spyOn(logcheckModule, 'checkLog');
+                    displaySpy = jest.spyOn(displayResultModule, 'displayError');
+                    return [4 /*yield*/, (0, execute_1.executeJobViya)(sasjs, mocks_1.mockAuthConfig, 'test/job', target, false, false, undefined, undefined, false, undefined, false)];
+                case 1:
+                    result = _a.sent();
+                    expect(result).toBe(false);
+                    expect(checkSpy).not.toHaveBeenCalled();
+                    expect(displaySpy).toHaveBeenCalledWith(null, 'An error has occurred when retrieving the job log.');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('fails a verdict asked for from a job that carries no log link', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var fetchSpy, checkSpy, displaySpy, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jest.spyOn(logcheckModule, 'logCheckWantsVerdict').mockResolvedValue(true);
+                    jest.spyOn(sasjs, 'startComputeJob').mockResolvedValue({
+                        job: {
+                            state: 'completed',
+                            links: [],
+                            logStatistics: { lineCount: 0 }
+                        }
+                    });
+                    fetchSpy = jest.spyOn(fetchLogFileContentModule, 'fetchLogFileContent');
+                    checkSpy = jest.spyOn(logcheckModule, 'checkLog');
+                    displaySpy = jest.spyOn(displayResultModule, 'displayError');
+                    return [4 /*yield*/, (0, execute_1.executeJobViya)(sasjs, mocks_1.mockAuthConfig, 'test/job', target, false, false, undefined, undefined, false, undefined, false)];
+                case 1:
+                    result = _a.sent();
+                    expect(result).toBe(false);
+                    expect(fetchSpy).not.toHaveBeenCalled();
+                    expect(checkSpy).not.toHaveBeenCalled();
+                    expect(displaySpy).toHaveBeenCalledWith(null, 'An error has occurred: the job returned no log to check or save.');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });
 describe('executeJobSasjs', function () {
     beforeEach(function () { return __awaiter(void 0, void 0, void 0, function () {

package/build/utils/logcheck.d.ts

@@ -32,6 +32,15 @@ export declare class LogCheckFailure extends Error {
     readonly logCheckFailure = true;
     constructor(message: string);
 }
+/**
+ * Whether a log reaching this command has to be fetched at all.
+ *
+ * Reporting is free once a command owns a log, but a command that never
+ * receives one - a Viya job run without `--log` - has to ask for it. It asks
+ * when the verdict counts: `--logcheck`, or `logCheck.autoCheck` in the project
+ * config. A check nobody asked for is not worth an extra request.
+ */
+export declare const logCheckWantsVerdict: () => Promise<boolean>;
 export declare const isLogCheckFailure: (error: unknown) => error is LogCheckFailure;
 /**
  * Reports the issues in a log a command just received, and throws when the
@@ -41,4 +50,6 @@ export declare const isLogCheckFailure: (error: unknown) => error is LogCheckFai
  * have their own success output, and a check that announces itself on every
  * green run is noise that gets switched off.
  */
-export declare const checkLog: (logText: string | undefined | null, label: string) => Promise<void>;
+export declare const checkLog: (logText: string | undefined | null, label: string, options?: {
+    fatal?: boolean;
+}) => Promise<void>;

package/build/utils/logcheck.js

@@ -90,7 +90,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkLog = exports.isLogCheckFailure = exports.LogCheckFailure = exports.logCheckModeOf = exports.getLogCheckMode = exports.setLogCheckMode = void 0;
+exports.checkLog = exports.isLogCheckFailure = exports.logCheckWantsVerdict = exports.LogCheckFailure = exports.logCheckModeOf = exports.getLogCheckMode = exports.setLogCheckMode = void 0;
 var logs_1 = require("@sasjs/utils/logs");
 var chalk_1 = __importDefault(require("chalk"));
 var collectLogs_1 = require("../commands/logcheck/collectLogs");
@@ -135,6 +135,36 @@ var LogCheckFailure = /** @class */ (function (_super) {
     return LogCheckFailure;
 }(Error));
 exports.LogCheckFailure = LogCheckFailure;
+/**
+ * Whether a log reaching this command has to be fetched at all.
+ *
+ * Reporting is free once a command owns a log, but a command that never
+ * receives one - a Viya job run without `--log` - has to ask for it. It asks
+ * when the verdict counts: `--logcheck`, or `logCheck.autoCheck` in the project
+ * config. A check nobody asked for is not worth an extra request.
+ */
+var logCheckWantsVerdict = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                if (mode === 'off')
+                    return [2 /*return*/, false];
+                if (mode === 'on')
+                    return [2 /*return*/, true];
+                _b.label = 1;
+            case 1:
+                _b.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, (0, logCheckConfig_1.readLogCheckConfig)()];
+            case 2: return [2 /*return*/, (_b.sent()).autoCheck === true];
+            case 3:
+                _a = _b.sent();
+                return [2 /*return*/, false];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+exports.logCheckWantsVerdict = logCheckWantsVerdict;
 var isLogCheckFailure = function (error) {
     return (error === null || error === void 0 ? void 0 : error.logCheckFailure) === true;
 };
@@ -147,43 +177,50 @@ exports.isLogCheckFailure = isLogCheckFailure;
  * have their own success output, and a check that announces itself on every
  * green run is noise that gets switched off.
  */
-var checkLog = function (logText, label) { return __awaiter(void 0, void 0, void 0, function () {
-    var config, error_1, _a, issues, suppressed, counts, failing, totals, failure;
-    var _b;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
-            case 0:
-                if (mode === 'off' || !logText)
+var checkLog = function (logText_1, label_1) {
+    var args_1 = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args_1[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, __spreadArray([logText_1, label_1], __read(args_1), false), void 0, function (logText, label, options) {
+        var config, error_1, _a, issues, suppressed, counts, failing, totals, failure;
+        var _b;
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (mode === 'off' || !logText)
+                        return [2 /*return*/];
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, (0, logCheckConfig_1.readLogCheckConfig)()];
+                case 2:
+                    config = _c.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_1 = _c.sent();
+                    // An automatic check must never break the command it is riding on: a
+                    // config it cannot read is worth a warning, not a failed run.
+                    (_b = process.logger) === null || _b === void 0 ? void 0 : _b.warn("Skipping the SAS log check: ".concat(error_1.message));
                     return [2 /*return*/];
-                _c.label = 1;
-            case 1:
-                _c.trys.push([1, 3, , 4]);
-                return [4 /*yield*/, (0, logCheckConfig_1.readLogCheckConfig)()];
-            case 2:
-                config = _c.sent();
-                return [3 /*break*/, 4];
-            case 3:
-                error_1 = _c.sent();
-                // An automatic check must never break the command it is riding on: a
-                // config it cannot read is worth a warning, not a failed run.
-                (_b = process.logger) === null || _b === void 0 ? void 0 : _b.warn("Skipping the SAS log check: ".concat(error_1.message));
-                return [2 /*return*/];
-            case 4:
-                _a = (0, collectLogs_1.partitionIssues)((0, logs_1.parseLog)(logText), config.ignoreCodes), issues = _a.issues, suppressed = _a.suppressed;
-                if (!issues.length)
+                case 4:
+                    _a = (0, collectLogs_1.partitionIssues)((0, logs_1.parseLog)(logText), config.ignoreCodes), issues = _a.issues, suppressed = _a.suppressed;
+                    if (!issues.length)
+                        return [2 /*return*/];
+                    counts = (0, collectLogs_1.countIssues)(issues);
+                    failing = options.fatal === true || mode === 'on' || config.autoCheck === true;
+                    totals = __assign(__assign({}, counts), { suppressed: suppressed.length, logs: 1, skipped: 0 });
+                    failure = failing ? (0, processLogCheck_1.describeFailure)(totals, config) : undefined;
+                    renderInline(label, issues, counts, suppressed.length, config, failure);
+                    if (failure) {
+                        throw new LogCheckFailure("SAS log check failed for ".concat(label, ": ").concat(failure));
+                    }
                     return [2 /*return*/];
-                counts = (0, collectLogs_1.countIssues)(issues);
-                failing = mode === 'on' || config.autoCheck === true;
-                totals = __assign(__assign({}, counts), { suppressed: suppressed.length, logs: 1, skipped: 0 });
-                failure = failing ? (0, processLogCheck_1.describeFailure)(totals, config) : undefined;
-                renderInline(label, issues, counts, suppressed.length, config, failure);
-                if (failure) {
-                    throw new LogCheckFailure("SAS log check failed for ".concat(label, ": ").concat(failure));
-                }
-                return [2 /*return*/];
-        }
+            }
+        });
     });
-}); };
+};
 exports.checkLog = checkLog;
 /**
  * The inline report: the heading, the issues, and the verdict when there is

package/build/utils/spec/logcheck.spec.js

@@ -208,6 +208,19 @@ describe('checkLog', function () {
             }
         });
     }); });
+    it('fails a command that cannot succeed on a bad log, whatever the config says', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, withProject()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, expect((0, logcheck_1.checkLog)(logWithError, 'fs deploy', { fatal: true })).rejects.toBeInstanceOf(logcheck_1.LogCheckFailure)];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('does not fail on a note under the default policy', function () { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -269,6 +282,99 @@ describe('checkLog', function () {
         });
     }); });
 });
+describe('logCheckWantsVerdict', function () {
+    var originalProjectDir = process.projectDir;
+    var withProject = function (logCheck) { return __awaiter(void 0, void 0, void 0, function () {
+        var folder;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, tempFolder()];
+                case 1:
+                    folder = _a.sent();
+                    process.projectDir = folder;
+                    if (!(logCheck !== undefined)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, fs_1.promises.writeFile(path_1.default.join(folder, 'sasjsconfig.json'), JSON.stringify({ logCheck: logCheck }))];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); };
+    afterEach(function () {
+        process.projectDir = originalProjectDir;
+        (0, logcheck_1.setLogCheckMode)('auto');
+    });
+    it('is true under --logcheck and false under --no-logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, withProject()];
+                case 1:
+                    _c.sent();
+                    (0, logcheck_1.setLogCheckMode)('on');
+                    _a = expect;
+                    return [4 /*yield*/, (0, logcheck_1.logCheckWantsVerdict)()];
+                case 2:
+                    _a.apply(void 0, [_c.sent()]).toBe(true);
+                    (0, logcheck_1.setLogCheckMode)('off');
+                    _b = expect;
+                    return [4 /*yield*/, (0, logcheck_1.logCheckWantsVerdict)()];
+                case 3:
+                    _b.apply(void 0, [_c.sent()]).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('follows autoCheck when the mode is auto', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, withProject({ autoCheck: true })];
+                case 1:
+                    _d.sent();
+                    _a = expect;
+                    return [4 /*yield*/, (0, logcheck_1.logCheckWantsVerdict)()];
+                case 2:
+                    _a.apply(void 0, [_d.sent()]).toBe(true);
+                    return [4 /*yield*/, withProject()];
+                case 3:
+                    _d.sent();
+                    _b = expect;
+                    return [4 /*yield*/, (0, logcheck_1.logCheckWantsVerdict)()];
+                case 4:
+                    _b.apply(void 0, [_d.sent()]).toBe(false);
+                    return [4 /*yield*/, withProject({ autoCheck: false })];
+                case 5:
+                    _d.sent();
+                    _c = expect;
+                    return [4 /*yield*/, (0, logcheck_1.logCheckWantsVerdict)()];
+                case 6:
+                    _c.apply(void 0, [_d.sent()]).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('asks for no log when the config cannot be read', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var folder, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, tempFolder()];
+                case 1:
+                    folder = _b.sent();
+                    process.projectDir = folder;
+                    return [4 /*yield*/, fs_1.promises.writeFile(path_1.default.join(folder, 'sasjsconfig.json'), '{ "logCheck": ')];
+                case 2:
+                    _b.sent();
+                    _a = expect;
+                    return [4 /*yield*/, (0, logcheck_1.logCheckWantsVerdict)()];
+                case 3:
+                    _a.apply(void 0, [_b.sent()]).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
 describe('isLogCheckFailure', function () {
     it('recognises only its own error', function () {
         expect((0, logcheck_1.isLogCheckFailure)(new logcheck_1.LogCheckFailure('x'))).toBe(true);

package/package.json

@@ -123,5 +123,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.8.0"
+  "version": "6.8.2"
 }