@factorialco/fcode-cli 1.1.0

package/dist/services/test-runner.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProcessTests = runProcessTests;
+exports.printTestResults = printTestResults;
+const fs = require("fs-extra");
+const path = require("node:path");
+const _ = require("lodash");
+const color_1 = require("@oclif/color");
+const cli_1 = require("../utils/cli");
+const process_runner_1 = require("./process-runner");
+const errors_1 = require("../core/errors");
+const variable_1 = require("../repositories/variable");
+function hooksFileName(programmingLanguage) {
+    return programmingLanguage === 'PYTHON' ? 'testHooks.py' : 'testHooks.js';
+}
+function discoverTests(processSlug, programmingLanguage) {
+    const testsDir = path.join(process.cwd(), 'processes', processSlug, 'tests');
+    if (!fs.existsSync(testsDir))
+        return null;
+    const hooksFile = hooksFileName(programmingLanguage);
+    const entries = fs.readdirSync(testsDir, { withFileTypes: true });
+    const testDirs = entries
+        .filter((e) => e.isDirectory())
+        .map((e) => e.name)
+        .sort();
+    return testDirs
+        .map((name) => {
+        const dir = path.join(testsDir, name);
+        const inputPath = path.join(dir, 'input.json');
+        if (!fs.existsSync(inputPath))
+            return null;
+        const outputCandidate = path.join(dir, 'output.json');
+        const errorCandidate = path.join(dir, 'error.json');
+        const variablesCandidate = path.join(dir, 'variables.test.env');
+        const hooksCandidate = path.join(dir, hooksFile);
+        return {
+            name,
+            inputPath,
+            outputPath: fs.existsSync(outputCandidate) ? outputCandidate : null,
+            errorPath: fs.existsSync(errorCandidate) ? errorCandidate : null,
+            variablesPath: fs.existsSync(variablesCandidate) ? variablesCandidate : null,
+            hooksFilePath: fs.existsSync(hooksCandidate) ? hooksCandidate : null,
+        };
+    })
+        .filter((tc) => tc !== null);
+}
+function getGlobalTestAssets(processSlug, programmingLanguage) {
+    const testsDir = path.join(process.cwd(), 'processes', processSlug, 'tests');
+    const hooksCandidate = path.join(testsDir, hooksFileName(programmingLanguage));
+    const variablesCandidate = path.join(testsDir, 'variables.test.env');
+    return {
+        hooksFilePath: fs.existsSync(hooksCandidate) ? hooksCandidate : null,
+        variablesPath: fs.existsSync(variablesCandidate) ? variablesCandidate : null,
+    };
+}
+async function runProcessTests(fcodeProcess, options = {}) {
+    const { logLevel = 'ERROR', jsonLogs = false } = options;
+    const { slug, script: { programmingLanguage } } = fcodeProcess;
+    const testCases = discoverTests(slug, programmingLanguage);
+    if (!testCases) {
+        return { processSlug: slug, results: [] };
+    }
+    const globalAssets = getGlobalTestAssets(slug, programmingLanguage);
+    const hookOptions = { logLevel, jsonLogs };
+    const variableRepository = new variable_1.default();
+    let baseVariables = await variableRepository.findAllForExecution();
+    if (globalAssets.variablesPath) {
+        baseVariables = (0, process_runner_1.mergeVariables)(baseVariables, (0, process_runner_1.loadVariablesFromFile)(globalAssets.variablesPath));
+    }
+    const results = [];
+    // Run global before hook
+    let globalBeforeFailed = false;
+    if (globalAssets.hooksFilePath) {
+        try {
+            await (0, process_runner_1.runHook)(globalAssets.hooksFilePath, fcodeProcess, baseVariables, { ...hookOptions, hookFunction: 'before' });
+        }
+        catch {
+            globalBeforeFailed = true;
+        }
+    }
+    for (const testCase of testCases) {
+        const start = Date.now();
+        if (globalBeforeFailed) {
+            results.push({ name: testCase.name, passed: false, error: 'Global before hook failed', durationMs: 0 });
+            continue;
+        }
+        // Build per-test variables
+        const testVariables = testCase.variablesPath
+            ? (0, process_runner_1.mergeVariables)(baseVariables, (0, process_runner_1.loadVariablesFromFile)(testCase.variablesPath))
+            : baseVariables;
+        // Misconfiguration guard
+        if (testCase.outputPath && testCase.errorPath) {
+            results.push({ name: testCase.name, passed: false, error: 'Test misconfiguration: output.json and error.json cannot coexist', durationMs: Date.now() - start });
+            continue;
+        }
+        // Parse input
+        let parameters;
+        try {
+            parameters = JSON.parse(fs.readFileSync(testCase.inputPath, 'utf8'));
+        }
+        catch {
+            results.push({ name: testCase.name, passed: false, error: 'Failed to parse input.json', durationMs: Date.now() - start });
+            continue;
+        }
+        // Per-test before hook
+        if (testCase.hooksFilePath) {
+            try {
+                await (0, process_runner_1.runHook)(testCase.hooksFilePath, fcodeProcess, testVariables, { ...hookOptions, hookFunction: 'before' });
+            }
+            catch {
+                results.push({ name: testCase.name, passed: false, error: 'Before hook failed', durationMs: Date.now() - start });
+                continue;
+            }
+        }
+        let passed = true;
+        let errorMsg;
+        if (testCase.errorPath) {
+            // Expected-error test: process must fail
+            let expectedMessage;
+            try {
+                const errorSpec = JSON.parse(fs.readFileSync(testCase.errorPath, 'utf8'));
+                expectedMessage = errorSpec?.message;
+            }
+            catch {
+                results.push({ name: testCase.name, passed: false, error: 'Failed to parse error.json', durationMs: Date.now() - start });
+                if (testCase.hooksFilePath) {
+                    await (0, process_runner_1.runHook)(testCase.hooksFilePath, fcodeProcess, testVariables, { ...hookOptions, hookFunction: 'after' }).catch(() => { });
+                }
+                continue;
+            }
+            try {
+                await (0, process_runner_1.runProcess)({ slug, parameters, variablesOverride: testVariables, logLevel, jsonLogs, suppressElapsedLog: true });
+                passed = false;
+                errorMsg = 'Expected process to fail but it succeeded';
+            }
+            catch (runError) {
+                const actualMessage = runError instanceof errors_1.ErrorExecutingProcess ? runError.message : String(runError);
+                if (expectedMessage && !actualMessage.includes(expectedMessage)) {
+                    passed = false;
+                    errorMsg = `Error message mismatch\n    Expected to contain: ${expectedMessage}\n    Received: ${actualMessage}`;
+                }
+            }
+        }
+        else {
+            // Normal test: process must succeed
+            let actualOutput;
+            try {
+                actualOutput = await (0, process_runner_1.runProcess)({ slug, parameters, variablesOverride: testVariables, logLevel, jsonLogs, suppressElapsedLog: true });
+            }
+            catch (error) {
+                passed = false;
+                errorMsg = `Process execution failed: ${error instanceof Error ? error.message : String(error)}`;
+                if (testCase.hooksFilePath) {
+                    await (0, process_runner_1.runHook)(testCase.hooksFilePath, fcodeProcess, testVariables, { ...hookOptions, hookFunction: 'after' }).catch(() => { });
+                }
+                results.push({ name: testCase.name, passed, error: errorMsg, durationMs: Date.now() - start });
+                continue;
+            }
+            if (testCase.outputPath) {
+                try {
+                    const expected = JSON.parse(fs.readFileSync(testCase.outputPath, 'utf8'));
+                    if (!_.isEqual(actualOutput, expected)) {
+                        passed = false;
+                        errorMsg = `Expected: ${JSON.stringify(expected)}\n    Received: ${JSON.stringify(actualOutput)}`;
+                    }
+                }
+                catch {
+                    passed = false;
+                    errorMsg = 'Failed to parse output.json';
+                }
+            }
+        }
+        results.push({ name: testCase.name, passed, error: errorMsg, durationMs: Date.now() - start });
+        // Per-test after hook
+        if (testCase.hooksFilePath) {
+            await (0, process_runner_1.runHook)(testCase.hooksFilePath, fcodeProcess, testVariables, { ...hookOptions, hookFunction: 'after' }).catch(() => { });
+        }
+    }
+    // Global after hook
+    if (globalAssets.hooksFilePath) {
+        await (0, process_runner_1.runHook)(globalAssets.hooksFilePath, fcodeProcess, baseVariables, { ...hookOptions, hookFunction: 'after' }).catch(() => { });
+    }
+    return { processSlug: slug, results };
+}
+function printTestResults(suiteResults) {
+    const nonEmpty = suiteResults.filter((s) => s.results.length > 0);
+    for (const suite of nonEmpty) {
+        const total = suite.results.length;
+        const passed = suite.results.filter((r) => r.passed).length;
+        cli_1.cli.log(`\nTesting ${color_1.default.bold(suite.processSlug)} (${total} test${total === 1 ? '' : 's'})`);
+        for (const result of suite.results) {
+            if (result.passed) {
+                cli_1.cli.log(`  ${color_1.default.green('✓')} ${result.name} (${result.durationMs}ms)`);
+            }
+            else {
+                cli_1.cli.log(`  ${color_1.default.red('✗')} ${result.name}`);
+                if (result.error) {
+                    for (const line of result.error.split('\n')) {
+                        cli_1.cli.log(`    ${line}`);
+                    }
+                }
+            }
+        }
+        const failed = total - passed;
+        if (failed === 0) {
+            cli_1.cli.log(`\n  ${color_1.default.green(`${passed} passed`)}`);
+        }
+        else {
+            cli_1.cli.log(`\n  ${color_1.default.green(`${passed} passed`)}, ${color_1.default.red(`${failed} failed`)}`);
+        }
+    }
+    if (suiteResults.length === 0)
+        return;
+    const totalTests = suiteResults.reduce((sum, s) => sum + s.results.length, 0);
+    if (totalTests === 0)
+        return;
+    const totalPassed = suiteResults.reduce((sum, s) => sum + s.results.filter((r) => r.passed).length, 0);
+    const totalFailed = totalTests - totalPassed;
+    if (nonEmpty.length > 1) {
+        cli_1.cli.log(`\n${'─'.repeat(48)}`);
+        if (totalFailed === 0) {
+            cli_1.cli.log(`Total: ${totalTests} test${totalTests === 1 ? '' : 's'} — ${color_1.default.green(`${totalPassed} passed`)}`);
+        }
+        else {
+            cli_1.cli.log(`Total: ${totalTests} test${totalTests === 1 ? '' : 's'} — ${color_1.default.green(`${totalPassed} passed`)}, ${color_1.default.red(`${totalFailed} failed`)}`);
+        }
+    }
+}

package/dist/utils/canonical-hash.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Serializes a value with object keys sorted and no insignificant whitespace, so
+ * that two values that differ only in formatting (indentation, key order, trailing
+ * newline) produce an identical string. Used to hash metadata files independently
+ * of how they happen to be formatted on disk.
+ */
+export declare function canonicalStringify(value: unknown): string;
+/** MD5 of the canonical serialization of `value` (see {@link canonicalStringify}). */
+export declare function canonicalJsonHash(value: unknown): string;

package/dist/utils/canonical-hash.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalStringify = canonicalStringify;
+exports.canonicalJsonHash = canonicalJsonHash;
+const crypto = require("node:crypto");
+/**
+ * Serializes a value with object keys sorted and no insignificant whitespace, so
+ * that two values that differ only in formatting (indentation, key order, trailing
+ * newline) produce an identical string. Used to hash metadata files independently
+ * of how they happen to be formatted on disk.
+ */
+function canonicalStringify(value) {
+    if (value === null || value === undefined) {
+        return 'null';
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => canonicalStringify(item)).join(',')}]`;
+    }
+    if (typeof value === 'object') {
+        const entries = Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonicalStringify(value[key])}`);
+        return `{${entries.join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+/** MD5 of the canonical serialization of `value` (see {@link canonicalStringify}). */
+function canonicalJsonHash(value) {
+    return crypto.createHash('md5').update(canonicalStringify(value)).digest('hex');
+}

package/dist/utils/cli/index.d.ts

@@ -0,0 +1,14 @@
+import * as Table from './styled/table';
+import { CLIError } from '../../core/errors';
+export declare const cli: {
+    action: import("@oclif/core/lib/ux/action/simple").default | import("@oclif/core/lib/ux/action/spinner").default;
+    confirm(message: string): Promise<boolean>;
+    readonly table: typeof import("./styled/table").table;
+    error(format: string | CLIError, ...args: string[]): void;
+    info(format: string, ...args: string[]): void;
+    log(format?: string, ...args: string[]): void;
+    password(message: string): Promise<string>;
+    prompt(message: string): Promise<string>;
+};
+export default cli;
+export { Table };

package/dist/utils/cli/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = exports.cli = void 0;
+const Table = require("./styled/table");
+exports.Table = Table;
+const util = require("util");
+const prompts_1 = require("@inquirer/prompts");
+const core_1 = require("@oclif/core");
+const color_1 = require("@oclif/color");
+const errors_1 = require("../../core/errors");
+exports.cli = {
+    action: core_1.ux.action,
+    confirm(message) {
+        return (0, prompts_1.confirm)({ message });
+    },
+    get table() {
+        if (process.env.SILENT_MODE === 'true') {
+            return () => { };
+        }
+        return require('./styled/table').table;
+    },
+    error(format, ...args) {
+        if (format instanceof errors_1.CLIError) {
+            const message = format.message +
+                (format.suggestions && format.suggestions.length > 0
+                    ? ` Try this: ${format.suggestions.map((suggestion) => `'${suggestion}'`).join('\n')} \n`
+                    : '');
+            this.info(color_1.default.red(`✖ `) + message);
+        }
+        else {
+            this.info(color_1.default.red(`✖ `) + format, ...args);
+        }
+    },
+    info(format, ...args) {
+        if (process.env.SILENT_MODE === 'true') {
+            return;
+        }
+        process.stdout.write(util.format(format, ...args) + '\n');
+    },
+    log(format, ...args) {
+        this.info(format || '', ...args);
+    },
+    password(message) {
+        return (0, prompts_1.password)({ message });
+    },
+    prompt(message) {
+        return (0, prompts_1.input)({ message });
+    },
+};
+exports.default = exports.cli;

package/dist/utils/cli/screen.d.ts

@@ -0,0 +1,2 @@
+export declare let stdtermwidth: number;
+export declare let errtermwidth: number;

package/dist/utils/cli/screen.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errtermwidth = exports.stdtermwidth = void 0;
+function termwidth(stream) {
+    if (!stream.isTTY) {
+        return 80;
+    }
+    const width = stream.getWindowSize()[0];
+    if (width < 1) {
+        return 80;
+    }
+    if (width < 40) {
+        return 40;
+    }
+    return width;
+}
+const columns = global.columns;
+exports.stdtermwidth = columns || termwidth(process.stdout);
+exports.errtermwidth = columns || termwidth(process.stderr);
+process.stdout.on('resize', () => {
+    exports.stdtermwidth = columns || termwidth(process.stdout);
+});
+process.stderr.on('resize', () => {
+    exports.errtermwidth = columns || termwidth(process.stderr);
+});

package/dist/utils/cli/styled/table.d.ts

@@ -0,0 +1,23 @@
+export declare function table<T extends Record<string, unknown>>(data: T[], columns: table.Columns<T>, options?: table.Options): void;
+export declare namespace table {
+    interface Column<T extends Record<string, unknown>> {
+        header: string;
+        extended: boolean;
+        minWidth: number;
+        get(row: T): any;
+    }
+    type Columns<T extends Record<string, unknown>> = {
+        [key: string]: Partial<Column<T>>;
+    };
+    interface Options {
+        [key: string]: any;
+        sort?: string;
+        filter?: string;
+        columns?: string;
+        extended?: boolean;
+        'no-truncate'?: boolean;
+        output?: string;
+        'no-header'?: boolean;
+        printLine?(s: any): any;
+    }
+}

package/dist/utils/cli/styled/table.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.table = table;
+const chalk = require("chalk");
+const _ = require("lodash");
+const util_1 = require("util");
+const screen_1 = require("../screen");
+const sw = require('string-width');
+const { orderBy } = require('natural-orderby');
+class Table {
+    constructor(data, columns, options = {}) {
+        this.data = data;
+        // assign columns
+        this.columns = Object.keys(columns).map((key) => {
+            const col = columns[key];
+            const extended = col.extended || false;
+            const get = col.get || ((row) => row[key]);
+            const header = typeof col.header === 'string' ? col.header : _.capitalize(key.replace(/_/g, ' '));
+            const minWidth = Math.max(col.minWidth || 0, sw(header) + 1);
+            return {
+                extended,
+                get,
+                header,
+                key,
+                minWidth,
+            };
+        });
+        // assign options
+        const { columns: cols, filter, csv, output, extended, sort, title, printLine } = options;
+        this.options = {
+            columns: cols,
+            output: csv ? 'csv' : output,
+            extended,
+            filter,
+            'no-header': options['no-header'] || false,
+            'no-truncate': options['no-truncate'] || false,
+            printLine: printLine || ((s) => process.stdout.write(s + '\n')),
+            rowStart: ' ',
+            sort,
+            title,
+        };
+    }
+    display() {
+        // build table rows from input array data
+        let rows = this.data.map((d) => {
+            const row = {};
+            for (const col of this.columns) {
+                let val = col.get(d);
+                if (typeof val !== 'string')
+                    val = (0, util_1.inspect)(val, { breakLength: Number.POSITIVE_INFINITY });
+                row[col.key] = val;
+            }
+            return row;
+        });
+        // filter rows
+        if (this.options.filter) {
+            /* eslint-disable-next-line prefer-const */
+            let [header, regex] = this.options.filter.split('=');
+            const isNot = header[0] === '-';
+            if (isNot)
+                header = header.slice(1);
+            const col = this.findColumnFromHeader(header);
+            if (!col || !regex)
+                throw new Error('Filter flag has an invalid value');
+            rows = rows.filter((d) => {
+                const re = new RegExp(regex);
+                const val = d[col.key];
+                const match = val.match(re);
+                return isNot ? !match : match;
+            });
+        }
+        // sort rows
+        if (this.options.sort) {
+            const sorters = this.options.sort.split(',');
+            const sortHeaders = sorters.map((k) => (k[0] === '-' ? k.slice(1) : k));
+            const sortKeys = this.filterColumnsFromHeaders(sortHeaders).map((c) => {
+                return (v) => v[c.key];
+            });
+            const sortKeysOrder = sorters.map((k) => (k[0] === '-' ? 'desc' : 'asc'));
+            rows = orderBy(rows, sortKeys, sortKeysOrder);
+        }
+        // and filter columns
+        if (this.options.columns) {
+            const filters = this.options.columns.split(',');
+            this.columns = this.filterColumnsFromHeaders(filters);
+        }
+        else if (!this.options.extended) {
+            // show extented columns/properties
+            this.columns = this.columns.filter((c) => !c.extended);
+        }
+        this.data = rows;
+        switch (this.options.output) {
+            case 'csv':
+                this.outputCSV();
+                break;
+            case 'json':
+                this.outputJSON();
+                break;
+            default:
+                this.outputTable();
+        }
+    }
+    findColumnFromHeader(header) {
+        return this.columns.find((c) => c.header.toLowerCase() === header.toLowerCase());
+    }
+    filterColumnsFromHeaders(filters) {
+        // unique
+        filters = [...new Set(filters)];
+        const cols = [];
+        for (const f of filters) {
+            const c = this.columns.find((c) => c.header.toLowerCase() === f.toLowerCase());
+            if (c)
+                cols.push(c);
+        }
+        return cols;
+    }
+    getCSVRow(d) {
+        const values = this.columns.map((col) => d[col.key] || '');
+        const lineToBeEscaped = values.find((e) => e.includes('"') || e.includes('\n') || e.includes('\r\n') || e.includes('\r') || e.includes(','));
+        return values.map((e) => (lineToBeEscaped ? `"${e.replace('"', '""')}"` : e));
+    }
+    resolveColumnsToObjectArray() {
+        // tslint:disable-next-line:no-this-assignment
+        const { data, columns } = this;
+        return data.map((d) => {
+            // eslint-disable-next-line unicorn/prefer-object-from-entries
+            return columns.reduce((obj, col) => {
+                return {
+                    ...obj,
+                    [col.key]: d[col.key] || '',
+                };
+            }, {});
+        });
+    }
+    outputJSON() {
+        this.options.printLine(JSON.stringify(this.resolveColumnsToObjectArray(), undefined, 2));
+    }
+    outputCSV() {
+        // tslint:disable-next-line:no-this-assignment
+        const { data, columns, options } = this;
+        if (!options['no-header']) {
+            options.printLine(columns.map((c) => c.header).join(','));
+        }
+        for (const d of data) {
+            const row = this.getCSVRow(d);
+            options.printLine(row.join(','));
+        }
+    }
+    outputTable() {
+        // tslint:disable-next-line:no-this-assignment
+        const { data, columns, options } = this;
+        // column truncation
+        //
+        // find max width for each column
+        for (const col of columns) {
+            // convert multi-line cell to single longest line
+            // for width calculations
+            const widthData = data.map((row) => {
+                const d = row[col.key];
+                const manyLines = d.split('\n');
+                if (manyLines.length > 1) {
+                    return '*'.repeat(Math.max(...manyLines.map((r) => sw(r))));
+                }
+                return d;
+            });
+            const widths = ['.'.padEnd(col.minWidth - 1), col.header, ...widthData.map((row) => row)].map((r) => sw(r));
+            col.maxWidth = Math.max(...widths) + 1;
+            col.width = col.maxWidth;
+        }
+        // terminal width
+        const maxWidth = screen_1.stdtermwidth - 2;
+        // truncation logic
+        const shouldShorten = () => {
+            // don't shorten if full mode
+            if (options['no-truncate'] || (!process.stdout.isTTY && !process.env.CLI_UX_SKIP_TTY_CHECK))
+                return;
+            // don't shorten if there is enough screen width
+            const dataMaxWidth = _.sumBy(columns, (c) => c.width);
+            const overWidth = dataMaxWidth - maxWidth;
+            if (overWidth <= 0)
+                return;
+            // not enough room, short all columns to minWidth
+            for (const col of columns) {
+                col.width = col.minWidth;
+            }
+            // if sum(minWidth's) is greater than term width
+            // nothing can be done so
+            // display all as minWidth
+            const dataMinWidth = _.sumBy(columns, (c) => c.minWidth);
+            if (dataMinWidth >= maxWidth)
+                return;
+            // some wiggle room left, add it back to "needy" columns
+            let wiggleRoom = maxWidth - dataMinWidth;
+            const needyCols = columns.map((c) => ({ key: c.key, needs: c.maxWidth - c.width })).sort((a, b) => a.needs - b.needs);
+            for (const { key, needs } of needyCols) {
+                if (!needs)
+                    continue;
+                const col = columns.find((c) => key === c.key);
+                if (!col)
+                    continue;
+                if (wiggleRoom > needs) {
+                    col.width = col.width + needs;
+                    wiggleRoom -= needs;
+                }
+                else if (wiggleRoom) {
+                    col.width = col.width + wiggleRoom;
+                    wiggleRoom = 0;
+                }
+            }
+        };
+        shouldShorten();
+        // print table title
+        if (options.title) {
+            options.printLine(options.title);
+            // print title divider
+            options.printLine(''.padEnd(columns.reduce((sum, col) => sum + col.width, 1), '='));
+            options.rowStart = '| ';
+        }
+        // print headers
+        if (!options['no-header']) {
+            let headers = options.rowStart;
+            for (const col of columns) {
+                const header = col.header;
+                headers += header.padEnd(col.width);
+            }
+            options.printLine(chalk.bold(headers));
+            // print header dividers
+            let dividers = options.rowStart;
+            for (const col of columns) {
+                const divider = ''.padEnd(col.width - 1, '─') + ' ';
+                dividers += divider.padEnd(col.width);
+            }
+            options.printLine(chalk.bold(dividers));
+        }
+        // print rows
+        for (const row of data) {
+            // find max number of lines
+            // for all cells in a row
+            // with multi-line strings
+            let numOfLines = 1;
+            for (const col of columns) {
+                const d = row[col.key];
+                const lines = d.split('\n').length;
+                if (lines > numOfLines)
+                    numOfLines = lines;
+            }
+            // eslint-disable-next-line unicorn/no-new-array
+            const linesIndexess = [...new Array(numOfLines).keys()];
+            // print row
+            // including multi-lines
+            for (const i of linesIndexess) {
+                let l = options.rowStart;
+                for (const col of columns) {
+                    const width = col.width;
+                    let d = row[col.key];
+                    d = d.split('\n')[i] || '';
+                    const visualWidth = sw(d);
+                    const colorWidth = d.length - visualWidth;
+                    let cell = d.padEnd(width + colorWidth);
+                    if (cell.length - colorWidth > width || visualWidth === width) {
+                        cell = cell.slice(0, width - 2) + '… ';
+                    }
+                    l += cell;
+                }
+                options.printLine(l);
+            }
+        }
+    }
+}
+function table(data, columns, options = {}) {
+    new Table(data, columns, options).display();
+}

package/dist/utils/colorize-resource.d.ts

@@ -0,0 +1 @@
+export declare function colorizeByStatus(text: string | unknown, status: string): string | unknown;

package/dist/utils/colorize-resource.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorizeByStatus = colorizeByStatus;
+const color_1 = require("@oclif/color");
+function colorizeByStatus(text, status) {
+    return status.includes('removed') || status.includes('sensitivity-changed') ? color_1.default.red(text) : text;
+}

package/dist/utils/env-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function escapeEnvValue(value: string): string;
+export declare function unescapeEnvValue(value: string): string;