@sasjs/cli 6.5.0 → 6.7.0

package/build/commands/logcheck/spec/renderLogCheck.spec.js

@@ -0,0 +1,426 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var renderLogCheck_1 = require("../renderLogCheck");
+var types_1 = require("../types");
+var config = types_1.defaultLogCheckConfig;
+var issue = function (overrides) {
+    if (overrides === void 0) { overrides = {}; }
+    return (__assign({ line: 11, endLine: 11, column: 4, endColumn: 20, severity: 'error', message: 'Syntax error, expecting one of the following' }, overrides));
+};
+var log = function (overrides) {
+    if (overrides === void 0) { overrides = {}; }
+    return (__assign({ filePath: '/project/sasjsresults/run.log', displayPath: 'sasjsresults/run.log', issues: [], suppressed: [], counts: { errors: 0, warnings: 0, notes: 0 } }, overrides));
+};
+var summary = function (overrides) {
+    if (overrides === void 0) { overrides = {}; }
+    return (__assign({ logs: [], skipped: [], missing: [], unreadable: [], usedDefaultInput: false, searched: ['sasjsresults'], totals: {
+            errors: 0,
+            warnings: 0,
+            notes: 0,
+            suppressed: 0,
+            logs: 0,
+            skipped: 0
+        } }, overrides));
+};
+var setupLogger = function () {
+    var logger = {
+        log: jest.fn(),
+        table: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+        success: jest.fn()
+    };
+    process.logger = logger;
+    return {
+        logger: logger,
+        output: function () { return logger.log.mock.calls.map(function (call) { return call[0]; }).join('\n'); }
+    };
+};
+describe('renderHuman', function () {
+    afterEach(function () {
+        process.logger = undefined;
+    });
+    it('prints a file table, the issues and the verdict', function () {
+        var output = setupLogger().output;
+        (0, renderLogCheck_1.renderHuman)(summary({
+            logs: [
+                log({
+                    issues: [issue()],
+                    counts: { errors: 1, warnings: 0, notes: 0 }
+                })
+            ],
+            totals: {
+                errors: 1,
+                warnings: 0,
+                notes: 0,
+                suppressed: 0,
+                logs: 1,
+                skipped: 0
+            },
+            failure: '1 error'
+        }), config);
+        var printed = output();
+        expect(printed).toContain('SASjs logcheck');
+        expect(printed).toContain('sasjsresults/run.log');
+        expect(printed).toContain('FAIL');
+        expect(printed).toContain('12:5');
+        expect(printed).toContain('Syntax error, expecting one of the following');
+        expect(printed).toContain('1 error in 1 log');
+        expect(printed).toContain('Logcheck failed: 1 error');
+    });
+    it('says so when the policy is not to fail', function () {
+        var output = setupLogger().output;
+        (0, renderLogCheck_1.renderHuman)(summary({
+            logs: [
+                log({
+                    issues: [issue()],
+                    counts: { errors: 1, warnings: 0, notes: 0 }
+                })
+            ],
+            totals: {
+                errors: 1,
+                warnings: 0,
+                notes: 0,
+                suppressed: 0,
+                logs: 1,
+                skipped: 0
+            }
+        }), __assign(__assign({}, config), { failOn: 'never' }));
+        expect(output()).toContain('Logcheck passed (fail-on: never)');
+    });
+    it('reports the suppressed issues as a count, with the codes', function () {
+        var output = setupLogger().output;
+        (0, renderLogCheck_1.renderHuman)(summary({
+            logs: [
+                log({
+                    issues: [issue()],
+                    suppressed: [issue({ code: '49-169' })],
+                    counts: { errors: 1, warnings: 0, notes: 0 }
+                })
+            ],
+            totals: {
+                errors: 1,
+                warnings: 0,
+                notes: 0,
+                suppressed: 1,
+                logs: 1,
+                skipped: 0
+            }
+        }), __assign(__assign({}, config), { ignoreCodes: ['49-169'] }));
+        expect(output()).toContain('1 issue suppressed by message code (49-169)');
+    });
+    it('names a missing path, and hints when it was the default', function () {
+        var output = setupLogger().output;
+        (0, renderLogCheck_1.renderHuman)(summary({
+            missing: ['sasjsresults'],
+            usedDefaultInput: true,
+            failure: '1 path not found'
+        }), config);
+        var printed = output();
+        expect(printed).toContain('Path not found: sasjsresults');
+        expect(printed).toContain('nothing has run yet, or pass a path');
+        expect(printed).not.toContain('No logs found at the path searched.');
+    });
+    it('reports a folder it could not read, and why', function () {
+        var output = setupLogger().output;
+        (0, renderLogCheck_1.renderHuman)(summary({
+            unreadable: [
+                {
+                    displayPath: 'sasjsresults/locked',
+                    reason: 'could not be listed (EACCES)'
+                }
+            ],
+            failure: '1 folder could not be read'
+        }), config);
+        var printed = output();
+        expect(printed).toContain('Could not read: sasjsresults/locked');
+        expect(printed).toContain('could not be listed (EACCES)');
+        expect(printed).toContain('Logcheck failed: 1 folder could not be read');
+    });
+    it('says when a folder holds nothing to check', function () {
+        var output = setupLogger().output;
+        (0, renderLogCheck_1.renderHuman)(summary(), config);
+        expect(output()).toContain('No logs found at the path searched.');
+    });
+    it('counts the skipped files, and lists them only when asked', function () {
+        var output = setupLogger().output;
+        var withSkips = summary({
+            logs: [log({ counts: { errors: 0, warnings: 0, notes: 0 } })],
+            skipped: [
+                { displayPath: 'sasjsresults/build.log', reason: 'not a SAS log' }
+            ],
+            totals: {
+                errors: 0,
+                warnings: 0,
+                notes: 0,
+                suppressed: 0,
+                logs: 1,
+                skipped: 1
+            }
+        });
+        (0, renderLogCheck_1.renderHuman)(withSkips, config);
+        expect(output()).toContain('1 file skipped');
+        expect(output()).not.toContain('SKIPPED FILE');
+        var verbose = setupLogger();
+        (0, renderLogCheck_1.renderHuman)(withSkips, config, true);
+        expect(verbose.output()).toContain('SKIPPED FILE');
+        expect(verbose.output()).toContain('sasjsresults/build.log');
+    });
+});
+describe('fileFails', function () {
+    it('fails a log carrying an error under the default policy', function () {
+        expect((0, renderLogCheck_1.fileFails)({ errors: 1, warnings: 0, notes: 0 }, config)).toBe(true);
+        expect((0, renderLogCheck_1.fileFails)({ errors: 0, warnings: 4, notes: 4 }, config)).toBe(false);
+    });
+    it('follows the policy for warnings and notes', function () {
+        var warning = { errors: 0, warnings: 1, notes: 0 };
+        var note = { errors: 0, warnings: 0, notes: 1 };
+        expect((0, renderLogCheck_1.fileFails)(warning, __assign(__assign({}, config), { failOn: 'warning' }))).toBe(true);
+        expect((0, renderLogCheck_1.fileFails)(warning, __assign(__assign({}, config), { failOn: 'note' }))).toBe(true);
+        expect((0, renderLogCheck_1.fileFails)(note, __assign(__assign({}, config), { failOn: 'warning' }))).toBe(false);
+        expect((0, renderLogCheck_1.fileFails)(note, __assign(__assign({}, config), { failOn: 'note' }))).toBe(true);
+    });
+    it('fails nothing under the never policy', function () {
+        expect((0, renderLogCheck_1.fileFails)({ errors: 9, warnings: 9, notes: 9 }, __assign(__assign({}, config), { failOn: 'never' }))).toBe(false);
+    });
+    it('does not apply the run-wide warnings budget to one log', function () {
+        expect((0, renderLogCheck_1.fileFails)({ errors: 0, warnings: 3, notes: 0 }, __assign(__assign({}, config), { maxWarnings: 1 }))).toBe(false);
+    });
+});
+describe('columns', function () {
+    it('pads each column to the widest cell and underlines the head', function () {
+        var lines = (0, renderLogCheck_1.columns)([
+            ['a.log', '3'],
+            ['much-longer-name.log', '12']
+        ], ['FILE', 'ERRORS']);
+        expect(lines).toEqual([
+            'FILE                  ERRORS',
+            '--------------------  ------',
+            'a.log                 3',
+            'much-longer-name.log  12'
+        ]);
+    });
+    it('measures colour codes as no width at all', function () {
+        var coloured = '\u001b[31mred\u001b[39m';
+        var lines = (0, renderLogCheck_1.columns)([[coloured]], ['HEADER']);
+        expect(lines[1]).toEqual('------');
+    });
+    it('indents every line it returns', function () {
+        var lines = (0, renderLogCheck_1.columns)([['a']], ['A'], '  ', '    ');
+        expect(lines.every(function (line) { return line.startsWith('    '); })).toBe(true);
+    });
+});
+describe('truncate', function () {
+    it('leaves a short message alone', function () {
+        expect((0, renderLogCheck_1.truncate)('Syntax error')).toEqual('Syntax error');
+    });
+    it('collapses the whitespace SAS wrapped', function () {
+        expect((0, renderLogCheck_1.truncate)('a message\n      wrapped by SAS')).toEqual('a message wrapped by SAS');
+    });
+    it('cuts a long message on a word boundary', function () {
+        var message = 'word '.repeat(40).trim();
+        var cut = (0, renderLogCheck_1.truncate)(message);
+        expect(cut.length).toBeLessThanOrEqual(110);
+        expect(cut.endsWith('...')).toBe(true);
+        expect(cut).not.toContain('  ');
+        expect(message.startsWith(cut.replace('...', '').trim())).toBe(true);
+    });
+});
+describe('severityLabel', function () {
+    it('states the severity in words', function () {
+        expect((0, renderLogCheck_1.severityLabel)('error')).toEqual('error');
+        expect((0, renderLogCheck_1.severityLabel)('warning')).toEqual('warning');
+        expect((0, renderLogCheck_1.severityLabel)('note')).toEqual('note');
+    });
+});
+describe('lineLabel', function () {
+    it('is one-based, and names the range a message was wrapped over', function () {
+        expect((0, renderLogCheck_1.lineLabel)(issue())).toEqual('12:5');
+        expect((0, renderLogCheck_1.lineLabel)(issue({ endLine: 14 }))).toEqual('12-15:5');
+    });
+});
+describe('summarise', function () {
+    it('states what was found and over how many logs', function () {
+        expect((0, renderLogCheck_1.summarise)(summary({
+            totals: {
+                errors: 2,
+                warnings: 1,
+                notes: 0,
+                suppressed: 0,
+                logs: 2,
+                skipped: 0
+            }
+        }), 2)).toEqual('2 errors, 1 warning in 2 logs');
+    });
+    it('says so when there is nothing to report', function () {
+        expect((0, renderLogCheck_1.summarise)(summary({
+            totals: {
+                errors: 0,
+                warnings: 0,
+                notes: 0,
+                suppressed: 0,
+                logs: 1,
+                skipped: 0
+            }
+        }), 1)).toEqual('No issues in 1 log');
+    });
+    it('names the files it read out of the files it saw', function () {
+        expect((0, renderLogCheck_1.summarise)(summary({
+            totals: {
+                errors: 1,
+                warnings: 0,
+                notes: 0,
+                suppressed: 0,
+                logs: 1,
+                skipped: 2
+            }
+        }), 1)).toEqual('1 error in 1 of 3 files');
+    });
+});
+describe('toJson', function () {
+    it('states line and column from one', function () {
+        var json = (0, renderLogCheck_1.toJson)(summary({
+            logs: [
+                log({
+                    issues: [issue({ code: '22-322' })],
+                    counts: { errors: 1, warnings: 0, notes: 0 }
+                })
+            ]
+        }), config);
+        expect(json.logs[0].issues[0]).toEqual({
+            line: 12,
+            endLine: 12,
+            column: 5,
+            endColumn: 21,
+            severity: 'error',
+            code: '22-322',
+            message: 'Syntax error, expecting one of the following'
+        });
+    });
+    it('leaves out a code an issue does not carry', function () {
+        var json = (0, renderLogCheck_1.toJson)(summary({ logs: [log({ issues: [issue()] })] }), config);
+        expect(json.logs[0].issues[0]).not.toHaveProperty('code');
+    });
+    it('lists a folder it could not read', function () {
+        var json = (0, renderLogCheck_1.toJson)(summary({
+            unreadable: [
+                { displayPath: 'logs/locked', reason: 'could not be listed' }
+            ]
+        }), config);
+        expect(json.unreadable).toEqual([
+            { folder: 'logs/locked', reason: 'could not be listed' }
+        ]);
+    });
+    it('carries the counts, the policy and the verdict', function () {
+        var json = (0, renderLogCheck_1.toJson)(summary({
+            logs: [
+                log({
+                    issues: [issue()],
+                    counts: { errors: 1, warnings: 0, notes: 0 },
+                    skippedReason: undefined
+                })
+            ],
+            skipped: [{ displayPath: 'build.log', reason: 'not a SAS log' }],
+            totals: {
+                errors: 1,
+                warnings: 0,
+                notes: 0,
+                suppressed: 0,
+                logs: 1,
+                skipped: 1
+            },
+            failure: '1 error'
+        }), __assign(__assign({}, config), { maxWarnings: 2 }));
+        expect(json.summary).toEqual({
+            logs: 1,
+            skipped: 1,
+            errors: 1,
+            warnings: 0,
+            notes: 0,
+            suppressed: 0,
+            failed: true,
+            failure: '1 error'
+        });
+        expect(json.config.maxWarnings).toEqual(2);
+        expect(json.skipped).toEqual([
+            { file: 'build.log', reason: 'not a SAS log' }
+        ]);
+    });
+});
+describe('toAnnotations', function () {
+    it('writes one workflow command per issue, with one-based positions', function () {
+        var annotations = (0, renderLogCheck_1.toAnnotations)(summary({
+            logs: [
+                log({
+                    issues: [
+                        issue({ code: '22-322' }),
+                        issue({ severity: 'warning', message: 'Symbol not resolved' }),
+                        issue({ severity: 'note', message: 'Division by zero' })
+                    ]
+                })
+            ]
+        }));
+        expect(annotations).toEqual([
+            '::error file=sasjsresults/run.log,line=12,col=5,endLine=12,endColumn=21,title=SAS ERROR 22-322::Syntax error, expecting one of the following',
+            '::warning file=sasjsresults/run.log,line=12,col=5,endLine=12,endColumn=21,title=SAS WARNING::Symbol not resolved',
+            '::notice file=sasjsresults/run.log,line=12,col=5,endLine=12,endColumn=21,title=SAS NOTE::Division by zero'
+        ]);
+    });
+    it('escapes what a workflow command reads as syntax', function () {
+        var annotations = (0, renderLogCheck_1.toAnnotations)(summary({
+            logs: [
+                log({
+                    displayPath: 'logs/with,comma.log',
+                    issues: [issue({ message: '100% wrong\nsecond line' })]
+                })
+            ]
+        }));
+        expect(annotations[0]).toContain('file=logs/with%2Ccomma.log');
+        expect(annotations[0]).toContain('::100%25 wrong%0Asecond line');
+    });
+});
+describe('renderLogCheck', function () {
+    afterEach(function () {
+        jest.restoreAllMocks();
+        process.logger = undefined;
+    });
+    it('writes JSON to stdout, and nothing through the logger', function () {
+        var logger = setupLogger().logger;
+        var write = jest
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(function () { return true; });
+        (0, renderLogCheck_1.renderLogCheck)(summary(), config, { format: 'json' });
+        expect(write).toHaveBeenCalled();
+        expect(JSON.parse(String(write.mock.calls[0][0])).tool).toEqual('sasjs logcheck');
+        expect(logger.log).not.toHaveBeenCalled();
+    });
+    it('writes annotations to stdout, and nothing when there are none', function () {
+        var write = jest
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(function () { return true; });
+        (0, renderLogCheck_1.renderLogCheck)(summary({ logs: [log({ issues: [issue()] })] }), config, {
+            format: 'annotations'
+        });
+        expect(String(write.mock.calls[0][0])).toContain('::error file=');
+        write.mockClear();
+        (0, renderLogCheck_1.renderLogCheck)(summary(), config, { format: 'annotations' });
+        expect(write).not.toHaveBeenCalled();
+    });
+    it('prints the human report by default', function () {
+        var output = setupLogger().output;
+        (0, renderLogCheck_1.renderLogCheck)(summary(), config);
+        expect(output()).toContain('SASjs logcheck');
+    });
+});

package/build/commands/logcheck/types.d.ts

@@ -0,0 +1,98 @@
+import { LogIssue } from '@sasjs/utils/logs';
+/**
+ * When a log check fails. `error` is the default: an ERROR is SAS refusing to
+ * do something, and a gate red on day one gets switched off, so the notable
+ * notes legacy code produces in bulk are reported but do not fail the run.
+ */
+export type FailOn = 'error' | 'warning' | 'note' | 'never';
+/** How the result is presented. Only `human` carries colour. */
+export type OutputFormat = 'human' | 'json' | 'annotations';
+/**
+ * The policy for a log check: what fails it, and what is suppressed. The
+ * defaults are set here, a `logCheck` section in `sasjsconfig.json` may
+ * override them, and the flags on the command line override both.
+ */
+export interface LogCheckConfig {
+    /**
+     * Lowest severity that fails the check - see {@link FailOn}.
+     *
+     * `never` does not disable `maxWarnings`: a budget is a specific
+     * instruction and still fails the run when it is exceeded.
+     */
+    failOn: FailOn;
+    /**
+     * Number of warnings tolerated before the check fails, whatever `failOn`
+     * says. Undefined means no budget, which is not the same as zero.
+     */
+    maxWarnings?: number;
+    /**
+     * SAS message codes to suppress, e.g. `49-169` for the note about a
+     * quoted string being truncated. The code is the stable identifier SAS
+     * gives a message, which is what makes it the right thing to key on.
+     */
+    ignoreCodes: string[];
+    /**
+     * Log paths to leave out, as a plain substring (`sasjsresults/legacy`) or a
+     * glob (`**/build*.log`). Matched against the path shown in the report.
+     */
+    ignorePaths: string[];
+    /**
+     * Folder to check when no path is given on the command line. Resolved
+     * against the project folder.
+     */
+    folder?: string;
+}
+export declare const defaultLogCheckConfig: LogCheckConfig;
+/** Counts of the issues a log carries, after suppression. */
+export interface IssueCounts {
+    errors: number;
+    warnings: number;
+    notes: number;
+}
+export declare const emptyCounts: () => IssueCounts;
+/**
+ * One log as the check found it. A log that could not be read, is too large,
+ * or is not a SAS log carries a `skippedReason` and no issues - it is still
+ * part of the report, because a file the user asked about that was quietly
+ * dropped is worse than one reported as skipped.
+ */
+export interface ScannedLog {
+    /** Absolute path, as it was read. */
+    filePath: string;
+    /** Path as shown to the user, relative to the project folder where possible. */
+    displayPath: string;
+    /** Issues that survive the suppression rules. */
+    issues: LogIssue[];
+    /** Issues removed by `ignoreCodes`, reported only as a count. */
+    suppressed: LogIssue[];
+    counts: IssueCounts;
+    /** Set when the file was not checked at all. */
+    skippedReason?: string;
+}
+/** A file the check did not look inside, with the reason it did not. */
+export interface SkippedFile {
+    displayPath: string;
+    reason: string;
+}
+/** Everything one run of the check produced, before any rendering. */
+export interface LogCheckSummary {
+    logs: ScannedLog[];
+    skipped: SkippedFile[];
+    /** Paths the user named that do not exist. */
+    missing: string[];
+    /** Folders the check could not list, so their logs were never looked at. */
+    unreadable: SkippedFile[];
+    /** Whether the paths were defaulted rather than named by the user. */
+    usedDefaultInput: boolean;
+    /** Folders and files that were searched, as shown in the report. */
+    searched: string[];
+    totals: IssueCounts & {
+        suppressed: number;
+        /** Logs actually parsed. */
+        logs: number;
+        /** Files that were passed over, for whatever reason. */
+        skipped: number;
+    };
+    /** Why the check failed, or undefined when it passed. */
+    failure?: string;
+}

package/build/commands/logcheck/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyCounts = exports.defaultLogCheckConfig = void 0;
+exports.defaultLogCheckConfig = {
+    failOn: 'error',
+    ignoreCodes: [],
+    ignorePaths: []
+};
+var emptyCounts = function () { return ({
+    errors: 0,
+    warnings: 0,
+    notes: 0
+}); };
+exports.emptyCounts = emptyCounts;

package/build/commands/testing/spec/testing.spec.js

@@ -116,8 +116,11 @@ describe('sasjs test', function () {
                         return [4 /*yield*/, copyTestFiles(target.name)];
                     case 2:
                         _a.sent();
-                        return [4 /*yield*/, (0, __1.build)(target)];
+                        return [4 /*yield*/, (0, __1.compile)(target)];
                     case 3:
+                        _a.sent();
+                        return [4 /*yield*/, (0, __1.build)(target)];
+                    case 4:
                         _a.sent();
                         process.logger = new utils_1.Logger(utils_1.LogLevel.Off);
                         return [2 /*return*/];
@@ -443,8 +446,11 @@ describe('sasjs test', function () {
                         return [4 /*yield*/, copyTestFiles(target.name)];
                     case 2:
                         _a.sent();
-                        return [4 /*yield*/, (0, __1.build)(target)];
+                        return [4 /*yield*/, (0, __1.compile)(target)];
                     case 3:
+                        _a.sent();
+                        return [4 /*yield*/, (0, __1.build)(target)];
+                    case 4:
                         _a.sent();
                         process.logger = new utils_1.Logger(utils_1.LogLevel.Off);
                         return [2 /*return*/];

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/package.json

@@ -70,10 +70,10 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@sasjs/adapter": "^5.1.1",
+    "@sasjs/adapter": "^5.1.3",
     "@sasjs/core": "^6.1.1",
     "@sasjs/lint": "4.9.0",
-    "@sasjs/utils": "^4.1.2",
+    "@sasjs/utils": "^4.3.2",
     "axios": "1.20.0",
     "chalk": "4.1.2",
     "dotenv": "18.0.8",
@@ -123,5 +123,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.5.0"
+  "version": "6.7.0"
 }