@intecoag/inteco-cli 1.9.0 → 1.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intecoag/inteco-cli",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "CLI-Tools for Inteco",
   "main": "src/index.js",
   "type": "module",

package/src/index.js

@@ -17,6 +17,7 @@ import showChangelog from './modules/changelog.js';
 import commands from "./ressources/cmds.json" with {type: 'json'};
 import packageJson from "../package.json" with {type: 'json'}
 import extdSearch from './modules/extdSearch.js';
+import t009Search from './modules/t009Search.js';
 import syncConfig from './modules/syncConfig.js';
 import configMutation from './modules/configMutation.js';
 import bundleProduct from './modules/bundleProduct.js';
@@ -89,6 +90,9 @@ switch (cli.input[0]) {
     case "extd_search":
         extdSearch();
         break;
+    case "t009_search":
+        t009Search();
+        break;
     case "sync_config":
         syncConfig();
         break;

package/src/modules/extdSearch.js

@@ -1,200 +1,85 @@
-import { DB } from "../utils/db/DB.js";
-import prompts from "prompts";
-import CliTable3 from "cli-table3";
-import readline from "readline";
-import chalk from "chalk";
-import fuzzysort from "fuzzysort";
+import { DatabaseShellBuilder, TableConfig } from "../utils/shell/DatabaseShellBuilder.js";
 
 // Entry point
 export default async function extdSearch() {
-    const responses = await configureDB();
-
-    if (!responses.dbName) return;
-
-    let currentSearchType = configs[0];
-    let lastQuery = '';
-
-    const baseData = await loadData(responses.dbName, responses.tables);
-    const rl = createReadline();
-
-    console.log(chalk.green("Interactive Search Started."));
-    rl.prompt();
-
-    rl.on('line', async (input) => {
-        const query = input.trim();
-
-        if (handleBuiltInCommands(query, rl)) return;
-
-        const matchedConfig = configs.find(c => query === `:${c.cmd}`);
-        if (matchedConfig) {
-            currentSearchType = matchedConfig;
-        } else {
-            lastQuery = query;
-        }
-
-        const results = await fuzzySearch(baseData, lastQuery, currentSearchType);
-        renderTable(results, currentSearchType);
-        rl.prompt();
-    });
-
-    rl.on('close', () => {
-        console.log(chalk.yellow("Search session ended."));
-        process.exit(0);
-    });
-}
-
-function createReadline() {
-    return readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        prompt: 'Search query (show help with :?)> '
-    });
-}
-
-function handleBuiltInCommands(query, rl) {
-    switch (query) {
-        case ':q':
-            rl.close();
-            return true;
-        case ':?':
-            printHelp();
-            rl.prompt();
-            return true;
-        default:
-            return false;
-    }
-}
-
-function printHelp() {
-    console.log("\n" + chalk.cyan("Available Commands:"));
-    console.log(chalk.yellow(":q") + " - Exit the application");
-    console.log(chalk.yellow(":?") + " - Show this help");
-    configs.forEach(config =>
-        console.log(`${chalk.yellow(`:${config.cmd}`)} - Switch to ${config.name}`)
-    );
-    console.log();
-}
-
-async function configureDB() {
-    console.log();
-    const databaseNames = await DB.getDatabaseNames();
-
-    return await prompts([
-        {
-            type: 'autocomplete',
-            name: 'dbName',
-            message: 'DB-Name?',
-            choices: databaseNames.map(db => ({ title: db.name }))
-        },
-        {
-            type: 'select',
-            name: 'tables',
-            message: 'Search-Type?',
-            choices: [
-                { title: 'EXTD/EXTI', value: 'EXTD/EXTI' },
-                { title: 'EXTI only', value: 'EXTI' },
-                { title: 'EXTD only', value: 'EXTD' }
-            ]
-        }
-    ], {
-        onCancel: () => {
-            console.log("\n" + chalk.red("Cancelled Search!\n"));
-        }
-    });
-}
-
-async function loadData(db, tableChoice) {
-    const extd = await getTableData('extd', db);
-    const exti = await getTableData('exti', db);
-
-    const cleaned = [
-        ...cleanData(extd, 'extd'),
-        ...cleanData(exti, 'exti')
-    ];
-
-    if (tableChoice === 'EXTD') return cleaned.filter(e => e.table === 'extd');
-    if (tableChoice === 'EXTI') return cleaned.filter(e => e.table === 'exti');
-    return cleaned;
-}
-
-function cleanData(entries, tableName) {
-    return entries.map(entry => {
-        const stripped = Object.fromEntries(Object.entries(entry).map(([k, v]) => {
-            return [k.replace(/^ext[di]_/, ''), v];
-        }));
-        return { ...stripped, table: tableName };
-    });
-}
-
-async function getTableData(table, db) {
-    const query = `SELECT * FROM ${table};`;
-    return await DB.executeQueryOnDB(query, db);
-}
-
-async function fuzzySearch(data, query, config) {
-    if (!query) return data.slice(0, 1000);
-    return fuzzysort.go(query, data, {
-        keys: config.searchKeys,
-        limit: 1000,
-        threshold: config.threshold
-    }).map(r => ({ ...r.obj, score: r.score }));
-}
-
-function renderTable(data, config) {
-    const table = new CliTable3({ head: config.tableHeader });
-    data.forEach(row => table.push(config.tableFormatter(row)));
-    console.log(table.toString());
-}
-
-// ---------- Configurations & Helpers ----------
-
-const configs = [
-    {
-        name: "Overview",
-        cmd: "ow",
-        searchKeys: ['mnr', 'name', 'bez_d', 'bez_f', 'bez_i'],
-        threshold: 0.7,
-        tableHeader: ['MNR', 'Table', 'Name', 'Bezeichnung Deutsch', 'Bezeichnung Französisch', 'Bezeichnung Italieniesch'],
-        tableFormatter: p => [p.mnr, p.table, p.name, p.bez_d, p.bez_f, p.bez_i]
-    },
-    {
-        name: "Field-Information",
-        cmd: "fi",
-        searchKeys: [
+    const overviewConfig = new TableConfig()
+        .withName("Overview")
+        .withShortcut(":ow")
+        .withSearchKeys(["mnr", "name", "bez_d", "bez_f", "bez_i"])
+        .withThreshold(0.7)
+        .withHeader(["MNR", "Table", "Name", "Bezeichnung Deutsch", "Bezeichnung Französisch", "Bezeichnung Italienisch"])
+        .withFormatter(p => [p.mnr, p.table, p.name, p.bez_d, p.bez_f, p.bez_i]);
+
+    const fieldInfoConfig = new TableConfig()
+        .withName("Field-Information")
+        .withShortcut(":fi")
+        .withSearchKeys([
             'name', 'bez_d', 'bez_f', 'bez_i',
             'b_dtext_1', 'b_dtext_2', 'b_dtext_3',
             'b_dtext_4', 'b_dtext_5', 'b_dtext_6',
             'b_dtext_7', 'b_dtext_8', 'b_dtext_9'
-        ],
-        threshold: 0.7,
-        tableHeader: ['MNR', 'Table', 'Name', 'Feldtyp', 'Flag', 'Testflag', 'Wert 1', 'Wert 2', 'Wert 3', 'Wert 4', 'Wert 5', 'Wert 6', 'Wert 7', 'Wert 8', 'Wert 9'],
-        tableFormatter: p => [
+        ])
+        .withThreshold(0.7)
+        .withHeader(['MNR', 'Table', 'Name', 'Feldtyp', 'Flag', 'Testflag', 'Wert 1', 'Wert 2', 'Wert 3', 'Wert 4', 'Wert 5', 'Wert 6', 'Wert 7', 'Wert 8', 'Wert 9'])
+        .withFormatter(p => [
             p.mnr, p.table, p.name,
             formatFieldType(p.special),
             formatFlag(p.flag),
-            formatTestFlag(p.testflag),
+            formatTestFlag(p.testflab),
             ...Array.from({ length: 9 }, (_, i) => formatWert(p[`b_value_${i + 1}`], p[`b_dtext_${i + 1}`]))
-        ]
-    },
-    {
-        name: "Disp-Fields",
-        cmd: "df",
-        searchKeys: [
+        ]);
+
+    const dispFieldsConfig = new TableConfig()
+        .withName("Disp-Fields")
+        .withShortcut(":df")
+        .withSearchKeys([
             'mnr', 'name', 'bez_d', 'testfeld',
             'disp_feld_1', 'disp_feld_2', 'disp_feld_3',
             'disp_feld_4', 'disp_feld_5', 'disp_feld_6',
             'disp_feld_7', 'disp_feld_8', 'disp_feld_9'
-        ],
-        threshold: 0.7,
-        tableHeader: ['MNR', 'Table', 'Name', 'Test-Feld', 'Dispmask', 'Dispfeld 1', 'Dispfeld 2', 'Dispfeld 3', 'Dispfeld 4', 'Dispfeld 5', 'Dispfeld 6', 'Dispfeld 7', 'Dispfeld 8', 'Dispfeld 9'],
-        tableFormatter: p => [
+        ])
+        .withThreshold(0.7)
+        .withHeader(['MNR', 'Table', 'Name', 'Test-Feld', 'Dispmask', 'Dispfeld 1', 'Dispfeld 2', 'Dispfeld 3', 'Dispfeld 4', 'Dispfeld 5', 'Dispfeld 6', 'Dispfeld 7', 'Dispfeld 8', 'Dispfeld 9'])
+        .withFormatter(p => [
             p.mnr, p.table, p.name, p.testfeld, p.dispmask,
             p.disp_feld_1, p.disp_feld_2, p.disp_feld_3,
             p.disp_feld_4, p.disp_feld_5, p.disp_feld_6,
             p.disp_feld_7, p.disp_feld_8, p.disp_feld_9
-        ]
-    }
-];
+        ]);
+
+    const builder = new DatabaseShellBuilder();
+    builder
+        .withEditTools(
+            [
+                {
+                    title: 'MNR', column: 'mnr', default: '1'
+                },
+                {
+                    title: 'Name', column: 'name', default: null,
+                },
+                {
+                    title: 'Bezeichnung Deutsch', column: 'bez_d', default: null,
+                },
+                {
+                    title: 'Bezeichnung Französisch', column: 'bez_f', default: null,
+                },
+                {
+                    title: 'Bezeichnung Italienisch', column: 'bez_i', default: null
+                }
+            ],
+            ["name"],
+            ["name"],
+            ["mnr", "bez_d", "bez_f", "bez_i"])
+        .withConfig(overviewConfig)
+        .withConfig(fieldInfoConfig)
+        .withConfig(dispFieldsConfig)
+        .withTables("EXTD/EXTI", ["extd", "exti"])
+        .withTables("EXTD", ["extd"])
+        .withTables("EXTI", ["exti"]);
+
+    const shell = builder.build();
+    await shell.run();
+}
 
 function formatWert(value, bez) {
     return value || bez ? `'${value}'='${bez}'` : '';

package/src/modules/t009Search.js

@@ -0,0 +1,34 @@
+import { DatabaseShellBuilder, TableConfig } from "../utils/shell/DatabaseShellBuilder.js";
+
+export default async function t009Search() {
+
+    const overviewConfig = new TableConfig()
+        .withName("Overview")
+        .withShortcut(":ow")
+        .withSearchKeys(["mnr", "grp_pw", "lnr", "pgm", "flag", "bez", "bez_f", "bez_i"])
+        .withThreshold(0.7)
+        .withHeader(["MNR", "Mitarbeitergruppe", "Zeilennummer", "Programm-Name", "Typ (P=Programm, S=Shell)", "Bezeichnung", "Bezeichnung franz.", "Bezeichnung ital."])
+        .withFormatter(p => [p.mnr, p.grp_pw, p.lnr, p.pgm, p.flag, p.bez, p.bez_f, p.bez_i]);
+
+    const builder = new DatabaseShellBuilder();
+    builder
+        .withEditTools(
+            [
+                { title: 'MNR', column: 'mnr', default: '1' },
+                { title: 'Mitarbeitergruppe', column: 'grp_pw', default: '' },
+                { title: 'Zeilennummer', column: 'lnr', default: null },
+                { title: 'Programm-Name', column: 'pgm', default: null },
+                { title: 'Typ', column: 'flag', default: 'P' },
+                { title: 'Bezeichnung', column: 'bez', default: null },
+                { title: 'Bezeichnung franz.', column: 'bez_f', default: null },
+                { title: 'Bezeichnung ital.', column: 'bez_i', default: null },
+            ],
+            ["mnr", "pgm"],
+            ["mnr", "lnr", "pgm", "bez"],
+            ["grp_pw", "flag", "bez_f", "bez_i"])
+        .withConfig(overviewConfig)
+        .withTables("T009", ["t009"]);
+
+    const shell = builder.build();
+    await shell.run();
+}

package/src/ressources/cmds.json

@@ -29,6 +29,9 @@
     "extd_search": {
         "desc": "Search EXTD/EXTI interactively with full text search"
     },
+    "t009_search": {
+        "desc": "Search t009 interactively with full text search"
+    },
     "set_cli_config": {
         "desc": "Configure the Inteco CLI"
     },

package/src/utils/shell/DatabaseShell.js

@@ -0,0 +1,260 @@
+import chalk from "chalk";
+import { Shell } from "./shell.js";
+import { DB } from "../db/DB.js";
+import fuzzysort from "fuzzysort";
+import CliTable3 from "cli-table3";
+import prompts from "prompts";
+import { TableConfig } from "./DatabaseShellBuilder.js";
+
+export class DatabaseShell {
+
+    constructor() {
+        /**
+         * The currently active tables to load the data from
+         * @type {string[]}
+         * @private
+         */
+        this.currentTables = [];
+
+        /**
+         * The currently active config
+         * @type {TableConfig}
+         */
+        this.currentConfig = null;
+
+        /**
+         * The active database
+         * @type {string}
+         * @private
+         */
+        this.db = null;
+
+        /**
+         * The cached data of the active table
+         * @type {object[]}
+         * @private
+         */
+        this.data = [];
+
+        /**
+         * The tables the user can select to use
+         * @type {object[]}
+         */
+        this.tables = [];
+
+        /**
+         * The underlying shell to handle user input
+         * @type {Shell}
+         */
+        this.shell = null;
+    }
+
+    /**
+     * Configures the database shell and runs the underlying shell
+     */
+    async run() {
+        await this.configure();
+        await this.shell.run();
+    }
+
+    /**
+     * Searches for a string based on the current shell state and prints the results to the console.
+     * @param {string} query The search string
+     */
+    executeSearch(query) {
+        const results = this.fuzzySearch(query);
+        this.renderTable(results);
+    }
+
+    async deleteRow(row) {
+        const table = row.table;
+        const where = Object.entries(row).filter(([k, v]) => k !== "table").map(([k, v]) => `\`${table}_${k}\`='${String(v).replaceAll("'", "\\'")}'`).join(' AND ');
+        const sql = `DELETE FROM \`${table}\` WHERE ${where}`;
+        await DB.executeQueryOnDB(sql, this.db);
+        await this.loadData();
+    }
+
+    async insertRow(row) {
+        const table = row.table;
+        const kvPairs = Object.entries(row).filter(([k, v]) => k !== "table");
+        const sql = `INSERT INTO \`${table}\` (${kvPairs.map(([k, v]) => `\`${table}_${k}\``).join(', ')}) VALUES (${kvPairs.map(([k, v]) => `'${String(v).replaceAll("'", "\\'")}'`)});`;
+        await DB.executeQueryOnDB(sql, this.db);
+        await this.loadData();
+    }
+
+    async updateRow(row, whereRow) {
+        const table = whereRow.table;
+        const set = Object.entries(row).filter(([k, v]) => k !== "table").map(([k, v]) => `\`${table}_${k}\`='${String(v).replaceAll("'", "\\'")}'`).join(', '); 
+        const where = Object.entries(whereRow).filter(([k, v]) => k !== "table").map(([k, v]) => `\`${table}_${k}\`='${String(v).replaceAll("'", "\\'")}'`).join(' AND ');
+        const sql = `UPDATE \`${table}\` SET ${set} WHERE ${where};`;
+        await DB.executeQueryOnDB(sql, this.db);
+        await this.loadData();
+    }
+
+    async editRow(data, columns, requiredFields, optionalFields) {
+        let cancelled = false;
+        const questions = [...requiredFields, ...optionalFields]
+            .filter(f => Object.hasOwn(data, f))
+            .map(f => ({
+                type: 'text',
+                message: columns.find(c => c.column === f).title,
+                name: f,
+                initial: columns.find(c => c.column === f).default ?? data[f]}));
+            
+        const responses = await prompts(questions, { onCancel: () => { cancelled = true; return false; } });
+
+        if(cancelled) return null;
+        
+        const newData = {
+            ...data,
+            ...responses
+        };
+
+
+        return newData;
+    }
+
+    async selectRow(columns, requiredColumns) {
+        let cancelled = false;
+        const questions = requiredColumns.map(f => ({
+                type: 'text',
+                message: columns.find(c => c.column === f).title,
+                name: f,
+                initial: columns.find(c => c.column === f).default
+            }));
+            
+        const responses = await prompts(questions, { onCancel: () => { cancelled = true; return false; } });
+        if(cancelled) return null;
+        const results = this.data.filter(d => Object.entries(responses).every(([k, v]) => d[k] == v));
+        
+        if(results.length == 0) {
+            console.log(chalk.red("No results found."));
+            return null;
+        }
+
+        if(results.length > 1) {
+            console.log(chalk.red("Multiple results found. Please select one from the list..."));
+            const selection = await prompts({
+                type: 'autocomplete',
+                choices: results.map(r => ({
+                    title: Object.entries(r)
+                        .filter(([k, v]) => k === "table" || columns.some(c => c.column === k))
+                        .map(([k, v]) => `${k === "table" ? "Table" : columns.find(c => c.column === k).title}: ${v}`)
+                        .join(", "),
+                    value: r
+                })),
+                message: "Select Row",
+                name: 'result'
+            }, { onCancel: () => { cancelled = true; return false; } });
+
+            if(cancelled) return null;
+
+            return selection.result;
+        }
+
+        return results[0];
+    }
+
+    /**
+     * Loads the rows from the currently active tables into the shell
+     * @private
+     */
+    async loadData() {
+        const data = [];
+
+        for(let i = 0; i < this.currentTables.length; i++) {
+            const tableData = await this.getTableData(this.currentTables[i]);
+            data.push(...this.cleanData(tableData, this.currentTables[i]));
+        }
+
+        this.data = data;
+    }
+
+    /**
+     * Loads all rows from a table of the currently active database
+     * @param {string} table The table name
+     * @returns {Promise<any>}
+     * @private
+     */
+    async getTableData(table) {
+        const query = `SELECT * FROM ${table};`;
+        return await DB.executeQueryOnDB(query, this.db);
+    }
+
+    /**
+     * Removes the table name prefix from the individual rows
+     * @param {object[]} entries The rows of the table
+     * @param {string} tableName The name of the table where the data is from
+     * @returns {object[]}
+     * @private
+     */
+    cleanData(entries, tableName) {
+        return entries.map(entry => {
+            const stripped = Object.fromEntries(
+                Object.entries(entry).map(([k, v]) => [
+                    k.replace(new RegExp(`^${tableName}_`), ''),
+                    v
+                ])
+            );
+
+            return { ...stripped, table: tableName };
+        });
+    }
+
+    /**
+     * Executes a query on the currently loaded table using fuzzysearch
+     * @param {string} query The search query
+     * @returns {object[]}
+     * @private
+     */
+    fuzzySearch(query) {
+        if(!query) return this.data.slice(0, 1000);
+
+        return fuzzysort.go(query, this.data, {
+            keys: this.currentConfig.searchKeys,
+            limit: 1000,
+            threshold: this.currentConfig.threshold
+        }).map(r => ({ ...r.obj, score: r.score }));
+    }
+
+    /**
+     * Renders a table in the console using the currently active config
+     * @param {object[]} tableData The table data to render
+     * @private
+     */
+    renderTable(tableData) {
+        const table = new CliTable3({ head: this.currentConfig.tableHeader });
+        tableData.forEach(row => {
+            table.push(this.currentConfig.tableFormatter(row));
+        });
+        console.log(table.toString());
+    }
+
+    /**
+     * Prompts the user for the database and search type
+     */
+    async configure() {
+        console.log();
+        const databaseNames = await DB.getDatabaseNames();
+
+        const results = await prompts([
+            {
+                type: 'autocomplete',
+                name: 'dbName',
+                message: 'DB-Name?',
+                choices: databaseNames.map(db => ({ title: db.name }))
+            },
+            {
+                type: 'select',
+                name: 'tables',
+                message: 'Search-Type?',
+                choices: this.tables.map(t => ({ title: t.name, value: t.tables }))
+            }
+        ]);
+
+        this.db = results.dbName;
+        this.currentTables = results.tables;
+        
+        await this.loadData();
+    }
+}

package/src/utils/shell/DatabaseShellBuilder.js

@@ -0,0 +1,170 @@
+import chalk from "chalk";
+import { Shell } from "./shell.js";
+import { ShellBuilder } from "./ShellBuilder.js"
+import { DatabaseShell } from "./DatabaseShell.js";
+
+export class DatabaseShellBuilder {
+
+    constructor() {
+        /**
+         * The available configs for the shell
+         * @type {TableConfig}
+         * @private
+         */
+        this.configs = [];
+
+        /**
+         * The available tables for the shell
+         * @type {object[]}
+         * @private
+         */
+        this.tables = [];
+
+        this.editTools = null;
+    }
+
+    /**
+     * Adds a table config to the shell
+     * @param {TableConfig} tableConfig The config to add
+     * @returns {DatabaseShellBuilder}
+     */
+    withConfig(tableConfig) {
+        this.configs.push(tableConfig);
+        return this;
+    }
+
+    /**
+     * Adds a source table to the shell
+     * @param {string} name The name displayed in the selection
+     * @param {string[]} tables The names of the tables where to load the data from
+     * @returns {DatabaseShellBuilder}
+     */
+    withTables(name, tables) {
+        this.tables.push({ name: name, tables: tables });
+        return this;
+    }
+
+    /**
+     * Enables edit tools with the specified selectors and values
+     * @param {{title: string, column: string, default: string}[]} columns The colums that are used in the editor
+     * @param {string[]} requiredSelectors The columns that are required to be filled in to select an entry to edit
+     * @param {string[]} requiredValues The columns that are required to be filled to update an entry
+     * @param {string[]} optionalValues The columns that can be optionally updated
+     * @returns {DatabaseShellBuilder}
+     */
+    withEditTools(columns, requiredSelectors, requiredValues, optionalValues) {
+        this.editTools = {
+            columns: columns,
+            requiredSelectors: requiredSelectors,
+            requiredValues: requiredValues,
+            optionalValues: optionalValues
+        };
+
+        return this;
+    }
+
+    /**
+     * Builds the Shell
+     * @returns {DatabaseShell}
+     */
+    build() {
+        const databaseShell = new DatabaseShell();
+
+        const builder = new ShellBuilder();
+        builder.withBuiltInHandler()
+            .withBuiltInCommands()
+            .withCommandHandler((_, input) => { databaseShell.executeSearch(input); return true; })
+            .withCommand(":cfg", "Reconfigure the Database and Search Type", async () => await databaseShell.configure());
+
+        this.configs.forEach(config => {
+            builder.withCommand(config.cmdShortcut, `Switch to ${config.name}`, () => {
+                databaseShell.currentConfig = config;
+                console.log(`Switched to ${chalk.yellow(config.name)}.`);
+            });
+        });
+
+        if(this.editTools !== null) {
+            builder.withCommand(":del", "Delete a row", async (shell, input, args) => {
+                    console.log(chalk.yellow("Select the row to delete: "));
+                    const rowData = await databaseShell.selectRow(this.editTools.columns, this.editTools.requiredSelectors);
+                    if(!rowData) return;
+
+                    await databaseShell.deleteRow(rowData);
+                    console.log(chalk.red("Row deleted"));
+                })
+                .withCommand(":dup", "Duplicate a row", async (shell, input, args) => {
+                    console.log(chalk.yellow("Select the row to duplicate: "));
+                    const rowData = await databaseShell.selectRow(this.editTools.columns, this.editTools.requiredSelectors);
+                    if(!rowData) return;
+
+                    console.log(chalk.yellow("Enter the updated row data: "));
+                    const editedData = await databaseShell.editRow(rowData, this.editTools.columns, this.editTools.requiredValues, this.editTools.optionalValues);
+                    if(!editedData) return;
+
+                    await databaseShell.insertRow(editedData);
+                    console.log(chalk.green("Row duplicated"));
+                })
+                .withCommand(":mod", "Modify an existing row", async (shell, input, args) => {
+                    console.log(chalk.yellow("Select the row to edit: "));
+                    const rowData = await databaseShell.selectRow(this.editTools.columns, this.editTools.requiredSelectors);
+                    if(rowData === null) return;
+
+                    console.log(chalk.yellow("Enter the updated row data: "));
+                    const editedData = await databaseShell.editRow(rowData, this.editTools.columns, this.editTools.requiredValues, this.editTools.optionalValues);
+                    if(!editedData) return;
+
+                    await databaseShell.updateRow(editedData, rowData);
+                    console.log(chalk.yellow("Row updated"));
+                });
+        }
+
+        const shell = builder.build();
+
+        databaseShell.shell = shell;
+        databaseShell.currentConfig = this.configs[0];
+        databaseShell.tables = this.tables;
+
+        return databaseShell;
+    }
+}
+
+export class TableConfig {
+    constructor() {
+        this.name = "";
+        this.cmdShortcut = "";
+        this.searchKeys = [];
+        this.threshold = 0.7;
+        this.tableHeader = [];
+        this.tableFormatter = () => [];
+    }
+
+    withName(name) {
+        this.name = name;
+        return this;
+    }
+
+    withShortcut(shortcut) {
+        this.cmdShortcut = shortcut;
+        return this;
+    }
+
+    withSearchKeys(keys) {
+        this.searchKeys = keys;
+        return this;
+    }
+
+    withThreshold(threshold) {
+        this.threshold = threshold;
+        return this;
+    }
+
+    withHeader(tableHeader) {
+        this.tableHeader = tableHeader;
+        return this;
+    }
+
+    withFormatter(formatter) {
+        this.tableFormatter = formatter;
+        return this;
+    }
+}

package/src/utils/shell/Shell.js

@@ -0,0 +1,82 @@
+import chalk from "chalk";
+import prompts from "prompts";
+
+export class Shell {
+
+    constructor() {
+        this.commands = [];
+        this.commandHandlers = [];
+        this.name = "";
+        this.prompt = "";
+        this.autocomplete = [];
+
+        this.exitRequested = false;
+    }
+
+    /**
+     * Starts the shell in a loop and continues until exit() is called.
+     */
+    async run() {
+        this.exitRequested = false;
+
+        console.log(chalk.green(`${this.name} Started.`));
+
+        while (!this.exitRequested) {
+            const response = await prompts({
+                type: "autocomplete",
+                name: "input",
+                message: this.prompt,
+                choices: this.autocomplete.map(ac => ({
+                    title: ac,
+                    value: ac
+                })),
+                limit: 1,
+                suggest: async (input, choices) => {
+                    const text = input ?? "";
+                    const q = text.trim().toLowerCase();
+
+                    const matches = q.length === 0
+                        ? choices
+                        : choices.filter(choice => choice.title.toLowerCase().startsWith(q));
+
+                    return [
+                        {
+                            title: text.length > 0 ? text : " ",
+                            value: text
+                        },
+                        ...matches.filter(choice => choice.value !== text)
+                    ];
+                }
+            });
+
+            const input = (response?.input ?? "").trim();
+
+            if (!await this.handleCommand(input)) {
+                console.log(chalk.red(`Unknown command '${input}'`));
+            }
+        }
+
+        console.log(chalk.yellow(`\n\n${this.name} Ended.`));
+    }
+
+    /**
+     * Requests the shell to exit
+     */
+    exit() {
+        this.exitRequested = true;
+    }
+
+    /**
+     * Executes a single command in the shell
+     * @param {String} input The command to execute
+     * @returns {Promise<boolean>}
+     */
+    async handleCommand(input) {
+        for(let i = 0; i < this.commandHandlers.length; i++) {
+            const handler = this.commandHandlers[i];
+            if(await handler(this, input))
+                return true;
+        }
+        return false;
+    }
+}

package/src/utils/shell/ShellBuilder.js

@@ -0,0 +1,177 @@
+import chalk from "chalk";
+import { Shell } from "./shell.js";
+
+export class ShellBuilder {
+
+    constructor() {
+        this.commands = [];
+        this.commandHandlers = [];
+        this.name = "Interactive Shell";
+        this.prompt = "Interactive Shell (show help with :?)";
+        this.useBuiltInHandler = false;
+    }
+
+    /**
+     * Adds the built-in command handler
+     * @returns {ShellBuilder}
+     */
+    withBuiltInHandler() {
+        this.withCommandHandler(async (shell, input) => {
+            const parts = this.parseArgs(input);
+            if(parts.length == 0) return false;
+
+            const commandName = parts[0];
+            const args = parts.slice(1);
+
+            for(let i = 0; i < shell.commands.length; i++) {
+                const command = shell.commands[i];
+
+                if(command.name == commandName) {
+                    await command.handler(shell, input, ...args);
+                    return true;
+                }
+            }
+
+            return false;
+        });
+
+        this.useBuiltInHandler = true;
+
+        return this;
+    }
+
+    /**
+     * Adds the built-in commands (:q and :?), requires a supported handler to work
+     * @returns {ShellBuilder}
+     */
+    withBuiltInCommands() {
+        this.withCommand(":q", "Exit the shell", shell => {
+                shell.exit();
+            })
+            .withCommand(":?", "Shows this help", shell => {
+                console.log("\n" + chalk.cyan("Available Commands:"));
+                
+                shell.commands.forEach(command => {
+                    console.log(`${chalk.yellow(command.name)} - ${command.helpText}`);
+                });
+            });
+
+        return this;
+    }
+
+    /**
+     * Add a command to be executed by the built in command handler
+     * @param {String} commandName The command name to be entered in the command line
+     * @param {String} helpText The text displayed in the help
+     * @param {(shell: Shell, input: String, ...args: String[]) => void} handler The handler to be executed with the executing shell passed as an arugment
+     * @returns {ShellBuilder}
+     */
+    withCommand(commandName, helpText, handler) {
+        this.commands.push({
+            name: commandName,
+            handler: handler,
+            helpText: helpText
+        });
+        return this;
+    }
+
+    /**
+     * Change the name of the shell
+     * @param {String} name The name of the shell used in some texts
+     * @returns {ShellBuilder}
+     */
+    withName(name) {
+        this.name = name;
+        return this;
+    }
+
+    /**
+     * Change the prompt displayed when entering text
+     * @param {String} prompt The text to be displayed in the prompt
+     * @returns {ShellBuilder}
+     */
+    withPrompt(prompt) {
+        this.prompt = prompt;
+        return this;
+    }
+
+    /**
+     * Add a command handler to be executed if the inputted command doesn't correspond to a built in handler
+     * @param {(shell: Shell, input: String) => boolean} handler The handler to be executed with the inputted text and shell passed as arguments.
+     * Return true to signal that the handler was successful and shouldn't continue with another handler.
+     * 
+     * @returns {ShellBuilder}
+     */
+    withCommandHandler(handler) {
+        this.commandHandlers.push(handler);
+        return this;
+    }
+
+    /**
+     * Creates a usable shell with the built-in and custom functions.
+     * @returns {Shell}
+     */
+    build() {
+        let shell = new Shell();
+        shell.commands = this.commands;
+        shell.name = this.name;
+        shell.prompt = this.prompt;
+        shell.commandHandlers = this.commandHandlers;
+        shell.autocomplete = shell.commands.map(c => c.name);
+
+        return shell;
+    }
+
+    /**
+     * Splits a command into args with support for spaces and and escape sequences
+     * @private
+     * @param {String} input The unformatted command
+     * @returns {String[]}
+     */
+    parseArgs(input) {
+        const result = [];
+        let current = "";
+        let inQuotes = false;
+        let escaping = false;
+
+        for (let i = 0; i < input.length; i++) {
+            const char = input[i];
+
+            if (escaping) {
+                current += char;
+                escaping = false;
+                continue;
+            }
+
+            if (char === "\\") {
+                escaping = true;
+                continue;
+            }
+
+            if (char === '"') {
+                inQuotes = !inQuotes;
+                continue;
+            }
+
+            if (char === " " && !inQuotes) {
+                if (current.length > 0) {
+                result.push(current);
+                current = "";
+                }
+                continue;
+            }
+
+            current += char;
+        }
+
+        if (escaping) {
+            current += "\\";
+        }
+
+        if (current.length > 0) {
+            result.push(current);
+        }
+
+        return result;
+    }
+}