@sasjs/cli 6.6.0 → 6.8.0

package/build/commands/request/requestCommand.js

@@ -58,6 +58,7 @@ var targetCommand_1 = require("../../types/command/targetCommand");
 var utils_2 = require("../../utils");
 var request_1 = require("./request");
 var getLogFilePath_1 = require("../../utils/getLogFilePath");
+var logcheck_1 = require("../../utils/logcheck");
 var syntax = 'request <sasProgramPath> [options]';
 var usage = 'sasjs request <sasProgramPath> --data <path-to-datafile> --config <path-to-configfile> --target <target-name> --output <path-to-outputfile> --log <path-to-logfile>';
 var description = "Lets the user run a SAS job against a specified target.\n" +
@@ -104,6 +105,11 @@ var RequestCommand = /** @class */ (function (_super) {
                     type: 'string',
                     alias: 'o',
                     description: 'path where output of the finished job execution will be saved.'
+                },
+                logcheck: {
+                    type: 'boolean',
+                    default: undefined,
+                    description: 'Check the SAS log this request received, and fail when logCheck in sasjsconfig.json says so. --no-logcheck switches both the report and the verdict off.'
                 }
             },
             syntax: syntax,
@@ -117,7 +123,9 @@ var RequestCommand = /** @class */ (function (_super) {
             var _a, target, isLocal, jobPath, log, output, authConfig, _b, e_1, _c, sasProgramPath, data, config;
             return __generator(this, function (_d) {
                 switch (_d.label) {
-                    case 0: return [4 /*yield*/, this.getTargetInfo()];
+                    case 0:
+                        (0, logcheck_1.setLogCheckMode)((0, logcheck_1.logCheckModeOf)(this.parsed.logcheck));
+                        return [4 /*yield*/, this.getTargetInfo()];
                     case 1:
                         _a = _d.sent(), target = _a.target, isLocal = _a.isLocal;
                         jobPath = (0, utils_2.prefixAppLoc)(target.appLoc, process.currentDir);
@@ -152,6 +160,8 @@ var RequestCommand = /** @class */ (function (_super) {
                                 return command_1.ReturnCode.Success;
                             })
                                 .catch(function (err) {
+                                if ((0, logcheck_1.isLogCheckFailure)(err))
+                                    return command_1.ReturnCode.LogCheckError;
                                 (0, utils_2.displayError)(err, 'An error has occurred when running your SAS job.');
                                 return command_1.ReturnCode.InternalError;
                             })];

package/build/commands/request/spec/requestCommand.spec.js

@@ -100,6 +100,7 @@ var utils_1 = require("@sasjs/utils");
 var configUtils = __importStar(require("../../../utils/config"));
 var setConstantsUtils = __importStar(require("../../../utils/setConstants"));
 var command_1 = require("../../../types/command");
+var logcheck_1 = require("../../../utils/logcheck");
 var defaultArgs = ['node', 'sasjs'];
 var target = new utils_1.Target({
     name: 'test',
@@ -116,6 +117,45 @@ describe('RequestCommand', function () {
     beforeEach(function () {
         setupMocks();
     });
+    afterEach(function () { return (0, logcheck_1.setLogCheckMode)('auto'); });
+    it('should return the logcheck code when the log check failed the request', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var command, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    jest
+                        .spyOn(requestModule, 'runSasJob')
+                        .mockImplementation(function () { return Promise.reject(new logcheck_1.LogCheckFailure('1 error')); });
+                    command = new requestCommand_1.RequestCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [
+                        'request',
+                        sasProgramPath
+                    ], false));
+                    _a = expect;
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toEqual(command_1.ReturnCode.LogCheckError);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should switch the log check off for --no-logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var command;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    command = new requestCommand_1.RequestCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [
+                        'request',
+                        sasProgramPath,
+                        '--no-logcheck'
+                    ], false));
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.sent();
+                    expect((0, logcheck_1.getLogCheckMode)()).toEqual('off');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should parse sasjs request command', function () { return __awaiter(void 0, void 0, void 0, function () {
         var args, command, targetInfo;
         return __generator(this, function (_a) {

package/build/commands/run/run.d.ts

@@ -6,6 +6,4 @@ import { Target } from '@sasjs/utils';
  * @param {boolean} compile - compiles sas file present at 'filePath' before running code.
  * @param {string} logFile - (Optional) Path to log file.
  */
-export declare function runSasCode(target: Target, filePath: string, compile?: boolean, logFile?: string, source?: string): Promise<{
-    log: any;
-}>;
+export declare function runSasCode(target: Target, filePath: string, compile?: boolean, logFile?: string, source?: string): Promise<any>;

package/build/commands/run/run.js

@@ -74,6 +74,7 @@ var utils_2 = require("../../utils/");
 var axios_1 = __importDefault(require("axios"));
 var saveLog_1 = require("../../utils/saveLog");
 var parseSourceFile_1 = require("../../utils/parseSourceFile");
+var logcheck_1 = require("../../utils/logcheck");
 /**
  * Runs SAS code from a given file on the specified target.
  * @param {Target} target - the target to run the SAS code on.
@@ -83,7 +84,7 @@ var parseSourceFile_1 = require("../../utils/parseSourceFile");
  */
 function runSasCode(target_1, filePath_1) {
     return __awaiter(this, arguments, void 0, function (target, filePath, compile, logFile, source) {
-        var isTempFile, sasFilePath, sasFileContent, linesToExecute, macroVars, macroVarStatements, _a;
+        var isTempFile, sasFilePath, sasFileContent, linesToExecute, macroVars, macroVarStatements, result, _a;
         var _b;
         var _c;
         if (compile === void 0) { compile = false; }
@@ -137,12 +138,26 @@ function runSasCode(target_1, filePath_1) {
                     }
                     return [3 /*break*/, 17];
                 case 11: return [4 /*yield*/, executeOnSasViya(filePath, target, linesToExecute, logFile)];
-                case 12: return [2 /*return*/, _d.sent()];
+                case 12:
+                    result = _d.sent();
+                    return [3 /*break*/, 17];
                 case 13: return [4 /*yield*/, executeOnSas9(target, linesToExecute, logFile)];
-                case 14: return [2 /*return*/, _d.sent()];
+                case 14:
+                    result = _d.sent();
+                    return [3 /*break*/, 17];
                 case 15: return [4 /*yield*/, executeOnSasJS(filePath, target, linesToExecute, logFile)];
-                case 16: return [2 /*return*/, _d.sent()];
-                case 17: return [2 /*return*/];
+                case 16:
+                    result = _d.sent();
+                    _d.label = 17;
+                case 17: 
+                // Only a run that claims to have worked is worth checking: an executor that
+                // threw has already written the log it failed on, truncated at the failure.
+                return [4 /*yield*/, (0, logcheck_1.checkLog)(result === null || result === void 0 ? void 0 : result.log, path_1.default.basename(filePath))];
+                case 18:
+                    // Only a run that claims to have worked is worth checking: an executor that
+                    // threw has already written the log it failed on, truncated at the failure.
+                    _d.sent();
+                    return [2 /*return*/, result];
             }
         });
     });

package/build/commands/run/runCommand.js

@@ -55,6 +55,7 @@ exports.RunCommand = void 0;
 var command_1 = require("../../types/command");
 var targetCommand_1 = require("../../types/command/targetCommand");
 var utils_1 = require("../../utils");
+var logcheck_1 = require("../../utils/logcheck");
 var run_1 = require("./run");
 var syntax = 'run <sasFilePath> [options]';
 var usage = 'sasjs run <sasFilePath> --target <target-name>';
@@ -103,6 +104,11 @@ var RunCommand = /** @class */ (function (_super) {
                     type: 'string',
                     alias: 's',
                     description: 'Path to an input JSON containing job variables.'
+                },
+                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.'
                 }
             },
             syntax: syntax,
@@ -120,11 +126,14 @@ var RunCommand = /** @class */ (function (_super) {
                     case 1:
                         target = (_b.sent()).target;
                         _a = this.parsed, sasFilePath = _a.sasFilePath, compile = _a.compile, log = _a.log, source = _a.source;
+                        (0, logcheck_1.setLogCheckMode)((0, logcheck_1.logCheckModeOf)(this.parsed.logcheck));
                         return [4 /*yield*/, (0, run_1.runSasCode)(target, sasFilePath, compile, log, source)
                                 .then(function () {
                                 return command_1.ReturnCode.Success;
                             })
                                 .catch(function (err) {
+                                if ((0, logcheck_1.isLogCheckFailure)(err))
+                                    return command_1.ReturnCode.LogCheckError;
                                 (0, utils_1.displayError)(err, 'An error has occurred when running your SAS code.');
                                 return command_1.ReturnCode.InternalError;
                             })];

package/build/commands/run/spec/runCommand.spec.js

@@ -100,6 +100,7 @@ var utils_1 = require("@sasjs/utils");
 var configUtils = __importStar(require("../../../utils/config"));
 var setConstantsUtils = __importStar(require("../../../utils/setConstants"));
 var command_1 = require("../../../types/command");
+var logcheck_1 = require("../../../utils/logcheck");
 var defaultArgs = ['node', 'sasjs', 'run'];
 var target = new utils_1.Target({
     name: 'test',
@@ -114,6 +115,55 @@ describe('RunCommand', function () {
     beforeEach(function () {
         setupMocks();
     });
+    afterEach(function () { return (0, logcheck_1.setLogCheckMode)('auto'); });
+    it('should return the logcheck code when the log check failed the run', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var command, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    jest
+                        .spyOn(runModule, 'runSasCode')
+                        .mockImplementation(function () { return Promise.reject(new logcheck_1.LogCheckFailure('2 errors')); });
+                    command = new runCommand_1.RunCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [sasFilePath], false));
+                    _a = expect;
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toEqual(command_1.ReturnCode.LogCheckError);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should switch the log check off for --no-logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var command;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    command = new runCommand_1.RunCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [
+                        sasFilePath,
+                        '--no-logcheck'
+                    ], false));
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.sent();
+                    expect((0, logcheck_1.getLogCheckMode)()).toEqual('off');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should switch the log check on for --logcheck', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var command;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    command = new runCommand_1.RunCommand(__spreadArray(__spreadArray([], __read(defaultArgs), false), [sasFilePath, '--logcheck'], false));
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    _a.sent();
+                    expect((0, logcheck_1.getLogCheckMode)()).toEqual('on');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('should parse sasjs run command', function () { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {

package/build/types/command/commandAliases.js

@@ -11,6 +11,7 @@ exports.aliasMap = new Map([
     ['deploy', ['d']],
     ['doc', ['docs']],
     ['help', ['h']],
+    ['logcheck', ['lc']],
     ['request', ['rq']],
     ['run', ['r']],
     ['test', ['t']],

package/build/types/command/commandFactory.js

@@ -24,6 +24,7 @@ var requestCommand_1 = require("../../commands/request/requestCommand");
 var helpCommand_1 = require("../../commands/help/helpCommand");
 var jobCommand_1 = require("../../commands/job/jobCommand");
 var lintCommand_1 = require("../../commands/lint/lintCommand");
+var logcheckCommand_1 = require("../../commands/logcheck/logcheckCommand");
 var flowCommand_1 = require("../../commands/flow/flowCommand");
 var fsCommand_1 = require("../../commands/fs/fsCommand");
 var snippetsCommand_1 = require("../../commands/snippets/snippetsCommand");
@@ -49,6 +50,7 @@ exports.commandFactory = new Map([
     ['init', function (args) { return new initCommand_1.InitCommand(args); }],
     ['job', function (args) { return new jobCommand_1.JobCommand(args); }],
     ['lint', function (args) { return new lintCommand_1.LintCommand(args); }],
+    ['logcheck', function (args) { return new logcheckCommand_1.LogCheckCommand(args); }],
     ['flow', function (args) { return new flowCommand_1.FlowCommand(args); }],
     ['request', function (args) { return new requestCommand_1.RequestCommand(args); }],
     ['run', function (args) { return new runCommand_1.RunCommand(args); }],

package/build/types/command/returnCode.d.ts

@@ -3,5 +3,6 @@ export declare enum ReturnCode {
     InvalidCommand = 1,
     InternalError = 2,
     LintError = 3,
-    AlreadyInitialised = 4
+    AlreadyInitialised = 4,
+    LogCheckError = 5
 }

package/build/types/command/returnCode.js

@@ -11,4 +11,8 @@ var ReturnCode;
     // InvalidCommand, which also covers unparseable arguments, so a script can
     // tell a refusal from a bad invocation.
     ReturnCode[ReturnCode["AlreadyInitialised"] = 4] = "AlreadyInitialised";
+    // `logcheck` found issues at or above the configured failure policy. Kept
+    // apart from LintError so a pipeline can tell a code-quality failure from a
+    // run that SAS complained about.
+    ReturnCode[ReturnCode["LogCheckError"] = 5] = "LogCheckError";
 })(ReturnCode || (exports.ReturnCode = ReturnCode = {}));

package/build/utils/index.d.ts

@@ -3,6 +3,7 @@ export * from './config';
 export * from './displayResult';
 export * from './file';
 export * from './loadEnvVariables';
+export * from './logcheck';
 export * from './saveLog';
 export * from './setConstants';
 export * from './setProjectDir';

package/build/utils/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./config"), exports);
 __exportStar(require("./displayResult"), exports);
 __exportStar(require("./file"), exports);
 __exportStar(require("./loadEnvVariables"), exports);
+__exportStar(require("./logcheck"), exports);
 __exportStar(require("./saveLog"), exports);
 __exportStar(require("./setConstants"), exports);
 __exportStar(require("./setProjectDir"), exports);

package/build/utils/logcheck.d.ts

@@ -0,0 +1,44 @@
+/**
+ * How the log a command just received is treated.
+ *
+ * `auto` decides from `logCheck.autoCheck` in the project config, which is off
+ * by default; `on` and `off` are the `--logcheck` / `--no-logcheck` flags. The
+ * distinction matters because the two halves of the behaviour are separate:
+ * reporting what SAS printed is always worth doing, while changing the exit
+ * code of a command whose status a pipeline already trusts is not something to
+ * do behind a project's back.
+ */
+export type LogCheckMode = 'auto' | 'on' | 'off';
+export declare const setLogCheckMode: (value: LogCheckMode) => void;
+export declare const getLogCheckMode: () => LogCheckMode;
+/** Reads a tri-state yargs boolean: absent is `undefined`, not `false`. */
+export declare const logCheckModeOf: (flag: unknown) => LogCheckMode;
+/**
+ * A run whose log broke the policy, once `autoCheck` or `--logcheck` asked for
+ * the verdict to count.
+ *
+ * It is an error rather than a return value because it is raised several
+ * frames below the command, from whichever executor received the log, and the
+ * command is the only place that can turn it into an exit code.
+ */
+export declare class LogCheckFailure extends Error {
+    /**
+     * Marker rather than `instanceof`: the CLI is compiled to a target where a
+     * subclass of a built-in loses its prototype chain, so `instanceof` answers
+     * false in the built artefact while answering true under the test transform.
+     * The flag is read by {@link isLogCheckFailure} and cannot be faked by an
+     * unrelated error.
+     */
+    readonly logCheckFailure = true;
+    constructor(message: string);
+}
+export declare const isLogCheckFailure: (error: unknown) => error is LogCheckFailure;
+/**
+ * Reports the issues in a log a command just received, and throws when the
+ * policy says the run should fail.
+ *
+ * Nothing is printed for a clean log: the commands this runs inside already
+ * 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>;

package/build/utils/logcheck.js

@@ -0,0 +1,224 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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;
+var logs_1 = require("@sasjs/utils/logs");
+var chalk_1 = __importDefault(require("chalk"));
+var collectLogs_1 = require("../commands/logcheck/collectLogs");
+var logCheckConfig_1 = require("../commands/logcheck/logCheckConfig");
+var processLogCheck_1 = require("../commands/logcheck/processLogCheck");
+var renderLogCheck_1 = require("../commands/logcheck/renderLogCheck");
+var mode = 'auto';
+var setLogCheckMode = function (value) {
+    mode = value;
+};
+exports.setLogCheckMode = setLogCheckMode;
+var getLogCheckMode = function () { return mode; };
+exports.getLogCheckMode = getLogCheckMode;
+/** Reads a tri-state yargs boolean: absent is `undefined`, not `false`. */
+var logCheckModeOf = function (flag) {
+    return flag === true ? 'on' : flag === false ? 'off' : 'auto';
+};
+exports.logCheckModeOf = logCheckModeOf;
+/**
+ * A run whose log broke the policy, once `autoCheck` or `--logcheck` asked for
+ * the verdict to count.
+ *
+ * It is an error rather than a return value because it is raised several
+ * frames below the command, from whichever executor received the log, and the
+ * command is the only place that can turn it into an exit code.
+ */
+var LogCheckFailure = /** @class */ (function (_super) {
+    __extends(LogCheckFailure, _super);
+    function LogCheckFailure(message) {
+        var _this = _super.call(this, message) || this;
+        /**
+         * Marker rather than `instanceof`: the CLI is compiled to a target where a
+         * subclass of a built-in loses its prototype chain, so `instanceof` answers
+         * false in the built artefact while answering true under the test transform.
+         * The flag is read by {@link isLogCheckFailure} and cannot be faked by an
+         * unrelated error.
+         */
+        _this.logCheckFailure = true;
+        _this.name = 'LogCheckFailure';
+        return _this;
+    }
+    return LogCheckFailure;
+}(Error));
+exports.LogCheckFailure = LogCheckFailure;
+var isLogCheckFailure = function (error) {
+    return (error === null || error === void 0 ? void 0 : error.logCheckFailure) === true;
+};
+exports.isLogCheckFailure = isLogCheckFailure;
+/**
+ * Reports the issues in a log a command just received, and throws when the
+ * policy says the run should fail.
+ *
+ * Nothing is printed for a clean log: the commands this runs inside already
+ * 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)
+                    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)
+                    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
+ * one. Deliberately narrower than the `logcheck` report - there is one log
+ * here and its name is already on screen, so there is no file table.
+ */
+var renderInline = function (label, issues, counts, suppressedCount, config, failure) {
+    var _a;
+    var lines = [
+        "".concat(chalk_1.default.bold('SAS log check'), " ").concat(chalk_1.default.dim(label), " - ").concat(describe(counts))
+    ];
+    lines.push.apply(lines, __spreadArray([], __read((0, renderLogCheck_1.columns)(issues.map(function (issue) { return [
+        (0, renderLogCheck_1.lineLabel)(issue),
+        (0, renderLogCheck_1.severityLabel)(issue.severity),
+        issue.code || chalk_1.default.dim('-'),
+        (0, renderLogCheck_1.truncate)(issue.message)
+    ]; }), ['LINE:COL', 'SEVERITY', 'CODE', 'MESSAGE'], '  ', '  ')), false));
+    if (suppressedCount) {
+        lines.push(chalk_1.default.dim("  ".concat(suppressedCount, " issue").concat(suppressedCount === 1 ? '' : 's', " suppressed by message code").concat(config.ignoreCodes.length ? " (".concat(config.ignoreCodes.join(', '), ")") : '')));
+    }
+    if (failure) {
+        lines.push("".concat(chalk_1.default.red.bold('  Logcheck failed: ')).concat(chalk_1.default.red(failure)));
+    }
+    (_a = process.logger) === null || _a === void 0 ? void 0 : _a.log(lines.join('\n'));
+};
+var describe = function (counts) {
+    var parts = [];
+    if (counts.errors)
+        parts.push(plural(counts.errors, 'error'));
+    if (counts.warnings)
+        parts.push(plural(counts.warnings, 'warning'));
+    if (counts.notes)
+        parts.push(plural(counts.notes, 'note'));
+    return parts.join(', ');
+};
+var plural = function (count, noun) {
+    return "".concat(count, " ").concat(noun).concat(count === 1 ? '' : 's');
+};

package/build/utils/spec/logcheck.spec.d.ts

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