@sasjs/cli 6.8.1 → 6.8.2

package/build/commands/fs/fsCommand.js

@@ -332,17 +332,23 @@ var FSCommand = /** @class */ (function (_super) {
                                 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)
-                                            // after the log file is written: a deploy whose log fails the check is
-                                            // the deploy whose record someone needs to read
+                                            // 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
-                                            return [4 /*yield*/, (0, logcheck_1.checkLog)(log, 'fs deploy')];
+                                            // 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
+                                            // 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*/];
                                     }

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,55 +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();
-                    // A log-check failure is the verdict the caller asked for, not a parse
-                    // error: swallowing it here printed "Logcheck failed" and then exited 0,
-                    // which is the green pipeline the feature exists to prevent.
-                    if ((0, logcheck_1.isLogCheckFailure)(error_1))
-                        throw error_1;
-                    // 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) {
@@ -259,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

@@ -82,6 +82,8 @@ 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();
@@ -194,6 +196,92 @@ describe('executeJobViya', function () {
             }
         });
     }); });
+    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.1"
+  "version": "6.8.2"
 }