@sasjs/cli 6.6.0 → 6.7.0

package/build/commands/logcheck/renderLogCheck.js

@@ -0,0 +1,423 @@
+"use strict";
+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 __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+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.toAnnotations = exports.toReportIssue = exports.toJson = exports.summarise = exports.truncate = exports.severityLabel = exports.lineLabel = exports.columns = exports.issueDetails = exports.fileFails = exports.fileSummary = exports.renderHuman = exports.renderLogCheck = exports.MAX_MESSAGE_WIDTH = void 0;
+var chalk_1 = __importDefault(require("chalk"));
+var types_1 = require("./types");
+/** Longest message shown in the human report before it is cut short. */
+exports.MAX_MESSAGE_WIDTH = 110;
+/** Blank line between two blocks of the human report. */
+var GAP = '';
+/**
+ * Prints the result in the requested format.
+ *
+ * The three formats are three views of one summary, never three scans: the
+ * terminal report, the JSON document and the CI annotations must all be
+ * describing the same parse, or they will disagree about the same log.
+ */
+var renderLogCheck = function (summary, config, options) {
+    if (options === void 0) { options = {}; }
+    var format = options.format || 'human';
+    if (format === 'json') {
+        process.stdout.write("".concat(JSON.stringify((0, exports.toJson)(summary, config), null, 2), "\n"));
+        return;
+    }
+    if (format === 'annotations') {
+        var lines = (0, exports.toAnnotations)(summary);
+        if (lines.length)
+            process.stdout.write("".concat(lines.join('\n'), "\n"));
+        return;
+    }
+    (0, exports.renderHuman)(summary, config, options.verbose || false);
+};
+exports.renderLogCheck = renderLogCheck;
+/**
+ * The human report: what was checked, what was found, and the verdict.
+ *
+ * Colour carries severity and nothing else, so a reader scanning for trouble
+ * has one thing to look at, and the same report pasted into a ticket or
+ * piped into a log file without a terminal is still readable.
+ */
+var renderHuman = function (summary, config, verbose) {
+    var e_1, _a, e_2, _b;
+    var _c;
+    if (verbose === void 0) { verbose = false; }
+    var lines = [];
+    lines.push("".concat(chalk_1.default.bold('SASjs logcheck')).concat(chalk_1.default.dim(summary.searched.length ? "  ".concat(summary.searched.join(', ')) : '')));
+    lines.push(GAP);
+    try {
+        for (var _d = __values(summary.missing), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var missing = _e.value;
+            lines.push(chalk_1.default.red("  Path not found: ".concat(missing)) +
+                (summary.usedDefaultInput
+                    ? chalk_1.default.dim('  - nothing has run yet, or pass a path')
+                    : ''));
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    try {
+        for (var _f = __values(summary.unreadable), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var folder = _g.value;
+            lines.push(chalk_1.default.red("  Could not read: ".concat(folder.displayPath)) +
+                chalk_1.default.dim("  (".concat(folder.reason, ") - its logs were not checked")));
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    var scanned = summary.logs.filter(function (entry) { return !entry.skippedReason; });
+    if (!scanned.length) {
+        if (!summary.missing.length) {
+            lines.push(summary.skipped.length
+                ? chalk_1.default.yellow('  No SAS logs found - every file was skipped.')
+                : chalk_1.default.yellow('  No logs found at the path searched.'));
+        }
+    }
+    else {
+        lines.push.apply(lines, __spreadArray([], __read((0, exports.fileSummary)(scanned, config)), false));
+        lines.push.apply(lines, __spreadArray([], __read(skippedLines(summary, verbose)), false));
+        var details = (0, exports.issueDetails)(scanned);
+        if (details.length)
+            lines.push.apply(lines, __spreadArray([GAP], __read(details), false));
+        lines.push(GAP);
+        lines.push("  ".concat((0, exports.summarise)(summary, scanned.length)));
+        if (summary.totals.suppressed) {
+            lines.push(chalk_1.default.dim("  ".concat(plural(summary.totals.suppressed, 'issue'), " suppressed by message code").concat(config.ignoreCodes.length
+                ? " (".concat(config.ignoreCodes.join(', '), ")")
+                : '')));
+        }
+    }
+    if (summary.failure) {
+        lines.push("".concat(chalk_1.default.red.bold('  Logcheck failed: ')).concat(chalk_1.default.red(summary.failure)) +
+            chalk_1.default.dim("  (fail-on: ".concat(config.failOn, ")")));
+    }
+    else if (scanned.length) {
+        lines.push(chalk_1.default.green("  Logcheck passed (fail-on: ".concat(config.failOn, ")")));
+    }
+    lines.push('');
+    (_c = process.logger) === null || _c === void 0 ? void 0 : _c.log(lines.join('\n'));
+};
+exports.renderHuman = renderHuman;
+/** The one-line-per-file table: what each log carried, and whether it failed. */
+var fileSummary = function (scanned, config) {
+    if (config === void 0) { config = types_1.defaultLogCheckConfig; }
+    var rows = scanned.map(function (entry) { return [
+        entry.displayPath,
+        countCell(entry.counts.errors, chalk_1.default.red),
+        countCell(entry.counts.warnings, chalk_1.default.yellow),
+        countCell(entry.counts.notes, chalk_1.default.cyan),
+        (0, exports.fileFails)(entry.counts, config)
+            ? chalk_1.default.red.bold('FAIL')
+            : chalk_1.default.green('pass')
+    ]; });
+    return (0, exports.columns)(rows, ['FILE', 'ERRORS', 'WARNINGS', 'NOTES', 'STATUS'], '  ');
+};
+exports.fileSummary = fileSummary;
+/**
+ * Whether a single log breaks the policy.
+ *
+ * The warnings budget is deliberately not applied here: it is a budget for the
+ * whole run, so a log carrying three warnings is not the one that broke it.
+ */
+var fileFails = function (counts, config) {
+    if (config.failOn === 'never')
+        return false;
+    if (counts.errors)
+        return true;
+    if (config.failOn === 'warning' || config.failOn === 'note') {
+        if (counts.warnings)
+            return true;
+    }
+    return config.failOn === 'note' && counts.notes > 0;
+};
+exports.fileFails = fileFails;
+/**
+ * The issues themselves, grouped under the log they came from.
+ *
+ * This is the shape a compiler prints and a reader already knows how to scan:
+ * the file once, then `line:column`, the severity, the SAS code where there is
+ * one, and the message.
+ */
+var issueDetails = function (scanned) {
+    var e_3, _a;
+    var blocks = [];
+    try {
+        for (var scanned_1 = __values(scanned), scanned_1_1 = scanned_1.next(); !scanned_1_1.done; scanned_1_1 = scanned_1.next()) {
+            var entry = scanned_1_1.value;
+            if (!entry.issues.length)
+                continue;
+            blocks.push(__spreadArray([
+                chalk_1.default.bold("  ".concat(entry.displayPath))
+            ], __read((0, exports.columns)(entry.issues.map(function (issue) { return [
+                (0, exports.lineLabel)(issue),
+                (0, exports.severityLabel)(issue.severity),
+                issue.code || chalk_1.default.dim('-'),
+                (0, exports.truncate)(issue.message)
+            ]; }), ['LINE:COL', 'SEVERITY', 'CODE', 'MESSAGE'], '  ', '    ')), false));
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (scanned_1_1 && !scanned_1_1.done && (_a = scanned_1.return)) _a.call(scanned_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    // One blank between two logs' issues, none after the last: the caller adds
+    // the gap before the summary line, and two would leave a hole in the report.
+    return blocks.reduce(function (lines, block, index) {
+        return index === blocks.length - 1
+            ? __spreadArray(__spreadArray([], __read(lines), false), __read(block), false) : __spreadArray(__spreadArray(__spreadArray([], __read(lines), false), __read(block), false), [GAP], false);
+    }, []);
+};
+exports.issueDetails = issueDetails;
+var skippedLines = function (summary, verbose) {
+    if (!summary.skipped.length)
+        return [];
+    if (!verbose) {
+        return [
+            GAP,
+            chalk_1.default.dim("  ".concat(plural(summary.skipped.length, 'file'), " skipped (not a SAS log, or excluded) - rerun with --verbose to list them."))
+        ];
+    }
+    return __spreadArray([
+        GAP
+    ], __read((0, exports.columns)(summary.skipped.map(function (entry) { return [
+        chalk_1.default.dim(entry.displayPath),
+        chalk_1.default.dim(entry.reason)
+    ]; }), ['SKIPPED FILE', 'REASON'], '  ', '  ')), false);
+};
+/**
+ * Lays rows out in aligned columns, with the header underlined by dashes.
+ *
+ * Colour codes take no space on screen, so widths are measured on the text
+ * with the codes removed - otherwise every coloured cell is padded by the
+ * length of its own escape sequences and the table drifts.
+ */
+var columns = function (rows, head, gap, indent) {
+    if (gap === void 0) { gap = '  '; }
+    if (indent === void 0) { indent = ''; }
+    var widths = [];
+    var measure = function (row) {
+        return row.forEach(function (cell, index) {
+            widths[index] = Math.max(widths[index] || 0, visibleLength(cell));
+        });
+    };
+    measure(head.map(function (header) { return chalk_1.default.white.bold(header); }));
+    rows.forEach(measure);
+    var render = function (row) {
+        return "".concat(indent).concat(row
+            .map(function (cell, index) {
+            return cell + ' '.repeat(Math.max(0, widths[index] - visibleLength(cell)));
+        })
+            .join(gap)
+            .trimEnd());
+    };
+    return __spreadArray([
+        render(head.map(function (header) { return chalk_1.default.white.bold(header); })),
+        "".concat(indent).concat(widths.map(function (width) { return '-'.repeat(width); }).join(gap))
+    ], __read(rows.map(render)), false);
+};
+exports.columns = columns;
+var visibleLength = function (value) {
+    return value.replace(/\u001b\[[0-9;]*m/g, '').length;
+};
+/** `13:5` for a one-line message, `13-15:5` for one SAS wrapped. */
+var lineLabel = function (issue) {
+    return issue.endLine > issue.line
+        ? "".concat(issue.line + 1, "-").concat(issue.endLine + 1, ":").concat(issue.column + 1)
+        : "".concat(issue.line + 1, ":").concat(issue.column + 1);
+};
+exports.lineLabel = lineLabel;
+var severityLabel = function (severity) {
+    if (severity === 'error')
+        return chalk_1.default.red.bold('error');
+    if (severity === 'warning')
+        return chalk_1.default.yellow.bold('warning');
+    return chalk_1.default.cyan.bold('note');
+};
+exports.severityLabel = severityLabel;
+/** Trims a message to the report width, on a word boundary where there is one. */
+var truncate = function (message) {
+    var flat = message.replace(/\s+/g, ' ').trim();
+    if (flat.length <= exports.MAX_MESSAGE_WIDTH)
+        return flat;
+    var cut = flat.slice(0, exports.MAX_MESSAGE_WIDTH - 3);
+    var boundary = cut.lastIndexOf(' ');
+    return "".concat(boundary > 0 ? cut.slice(0, boundary) : cut, "...");
+};
+exports.truncate = truncate;
+var countCell = function (count, colour) {
+    return count ? colour(String(count)) : chalk_1.default.dim('0');
+};
+/**
+ * The one-line answer: what was found, and over how many logs.
+ *
+ * It names the logs that were checked rather than the files that were not,
+ * because the number a reader compares against is the size of the result they
+ * have just looked at.
+ */
+var summarise = function (summary, scannedCount) {
+    var _a = summary.totals, errors = _a.errors, warnings = _a.warnings, notes = _a.notes, logs = _a.logs, skipped = _a.skipped;
+    var parts = [];
+    if (errors)
+        parts.push(plural(errors, 'error'));
+    if (warnings)
+        parts.push(plural(warnings, 'warning'));
+    if (notes)
+        parts.push(plural(notes, 'note'));
+    var scope = skipped > 0 ? "".concat(logs, " of ").concat(logs + skipped, " files") : plural(logs, 'log');
+    return parts.length
+        ? "".concat(parts.join(', '), " in ").concat(scope)
+        : "No issues in ".concat(scope);
+};
+exports.summarise = summarise;
+/**
+ * The machine report.
+ *
+ * Line and column are one-based here, as an editor and a CI annotation count
+ * them, while the parser works in indexes - the conversion happens once, at
+ * this boundary, so no consumer has to remember which convention it holds.
+ */
+var toJson = function (summary, config) {
+    var _a, _b;
+    return ({
+        tool: 'sasjs logcheck',
+        version: 1,
+        config: {
+            failOn: config.failOn,
+            maxWarnings: (_a = config.maxWarnings) !== null && _a !== void 0 ? _a : null,
+            ignoreCodes: config.ignoreCodes,
+            ignorePaths: config.ignorePaths
+        },
+        summary: {
+            logs: summary.totals.logs,
+            skipped: summary.totals.skipped,
+            errors: summary.totals.errors,
+            warnings: summary.totals.warnings,
+            notes: summary.totals.notes,
+            suppressed: summary.totals.suppressed,
+            failed: !!summary.failure,
+            failure: (_b = summary.failure) !== null && _b !== void 0 ? _b : null
+        },
+        searched: summary.searched,
+        missing: summary.missing,
+        unreadable: summary.unreadable.map(function (folder) { return ({
+            folder: folder.displayPath,
+            reason: folder.reason
+        }); }),
+        logs: summary.logs.map(function (entry) {
+            var _a;
+            return ({
+                file: entry.displayPath,
+                errors: entry.counts.errors,
+                warnings: entry.counts.warnings,
+                notes: entry.counts.notes,
+                suppressed: entry.suppressed.length,
+                skipped: (_a = entry.skippedReason) !== null && _a !== void 0 ? _a : null,
+                issues: entry.issues.map(exports.toReportIssue)
+            });
+        }),
+        skipped: summary.skipped.map(function (entry) { return ({
+            file: entry.displayPath,
+            reason: entry.reason
+        }); })
+    });
+};
+exports.toJson = toJson;
+var toReportIssue = function (issue) { return (__assign(__assign({ line: issue.line + 1, endLine: issue.endLine + 1, column: issue.column + 1, endColumn: issue.endColumn + 1, severity: issue.severity }, (issue.code ? { code: issue.code } : {})), { message: issue.message })); };
+exports.toReportIssue = toReportIssue;
+/**
+ * GitHub Actions annotations, one line per issue.
+ *
+ * The workflow commands escape three characters in the message and five in the
+ * properties; doing it here means SAS's own text arrives intact, commas and
+ * colons included.
+ */
+var toAnnotations = function (summary) {
+    return summary.logs.flatMap(function (entry) {
+        return entry.issues.map(function (issue) {
+            var properties = [
+                "file=".concat(escapeProperty(entry.displayPath)),
+                "line=".concat(issue.line + 1),
+                "col=".concat(issue.column + 1),
+                "endLine=".concat(issue.endLine + 1),
+                "endColumn=".concat(issue.endColumn + 1),
+                "title=".concat(escapeProperty("SAS ".concat(issue.severity.toUpperCase()).concat(issue.code ? " ".concat(issue.code) : '')))
+            ].join(',');
+            return "::".concat(annotationLevel(issue.severity), " ").concat(properties, "::").concat(escapeData(issue.message));
+        });
+    });
+};
+exports.toAnnotations = toAnnotations;
+var annotationLevel = function (severity) {
+    return severity === 'error' ? 'error' : severity === 'warning' ? 'warning' : 'notice';
+};
+var escapeData = function (value) {
+    return value.replace(/%/g, '%25').replace(/\r/g, '%0D').replace(/\n/g, '%0A');
+};
+var escapeProperty = function (value) {
+    return escapeData(value).replace(/:/g, '%3A').replace(/,/g, '%2C');
+};
+var plural = function (count, noun) {
+    return "".concat(count, " ").concat(noun).concat(count === 1 ? '' : 's');
+};

package/build/commands/logcheck/spec/collectLogs.spec.d.ts

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