@intecoag/inteco-cli 0.5.1

package/src/modules/dumpDB.js

@@ -0,0 +1,216 @@
+import prompts from "prompts"
+import { rmSync } from "fs";
+import ora from "ora";
+import { DB } from "../utils/db/DB.js";
+import { Config } from "../utils/config/config.js";
+import chalk from "chalk";
+import path from "path";
+import { exec, execSync } from "child_process";
+
+
+export async function dumpDB(cli) {
+    console.log()
+
+    const config = await Config.getConfig();
+
+    const databaseNames = await DB.getDatabaseNames();
+
+    let success = true;
+
+    const resultsDB = await prompts([
+        {
+            // DB-Auswahl von DB
+            type: 'autocomplete',
+            name: 'dbName',
+            message: 'DB-Name?',
+            choices: databaseNames.map(name => { return { title: name.name } })
+        },
+        {
+            type: 'toggle',
+            name: 'dataOnly',
+            message: 'Dump data only (no table recreation)?',
+            initial: false,
+            active: 'yes',
+            inactive: 'no'
+        }
+        , {
+            type: 'toggle',
+            name: 'selectIndividualTables',
+            message: 'Select individual tables?',
+            initial: false,
+            active: 'yes',
+            inactive: 'no'
+        }], {
+        onCancel: () => {
+            console.log()
+            console.log(chalk.red("Cancelled Import!"))
+            console.log()
+            success = false
+        }
+    })
+
+    if (success) {
+        let selectedTables = [];
+        if (resultsDB.selectIndividualTables) {
+
+            let tables = await DB.executeQueryOnDB("SHOW TABLES;", resultsDB.dbName);
+            const tableKey = Object.keys(tables[0])[0];
+            tables = tables.map(row => row[tableKey])
+            let continuePrompt = true;
+            while (continuePrompt) {
+                const resultsTable = await prompts([
+                    {
+                        // DB-Auswahl von DB
+                        type: 'autocomplete',
+                        name: 'table',
+                        message: 'Table?',
+                        choices: tables.map(name => { return { title: name } }),
+                        default: ""
+                    }, {
+                        type: 'toggle',
+                        name: 'continue',
+                        message: 'Add another table?',
+                        initial: false,
+                        active: 'yes',
+                        inactive: 'no'
+                    }], {
+                    onCancel: () => {
+                        console.log()
+                        console.log(chalk.red("Cancelled Import!"))
+                        console.log()
+                        success = false
+                    }
+                })
+
+                selectedTables.push(resultsTable.table)
+                continuePrompt = resultsTable.continue
+            }
+
+        }
+
+        const results = await prompts([
+            {
+                // Ordnerauswahl von vorhandenen Ordner in configIndividual
+                type: 'text',
+                name: 'dumpName',
+                message: 'Dump-Name?',
+                initial: 'dump.sql'
+            }
+        ], {
+            onCancel: () => {
+                console.log()
+                console.log(chalk.red("Cancelled Import!"))
+                console.log()
+                success = false
+            }
+        })
+
+        if (success) {
+            console.log()
+            const spinner = ora('Dumping DB').start();
+
+            const dumpCommand = `mysqldump ${resultsDB.dataOnly?'--no-create-info':''} -u${config.dbUser} -p${config.dbPassword} -h${config.dbURL} ${resultsDB.dbName} ${selectedTables.join(" ")} > ${results.dumpName}`;
+
+            exec(dumpCommand, (error, stdout, stderr) => {
+                if (error) {
+                    spinner.fail('Failed to dump DB');
+                    console.error(error);
+                    return;
+                }
+
+                spinner.succeed("Dumped DB to " + results.dumpName);
+                console.log();
+            });
+        }
+    }
+
+
+}
+
+export async function dumpDBMand(cli) {
+    console.log()
+
+    const config = await Config.getConfig();
+
+    const databaseNames = await DB.getDatabaseNames();
+
+    let success = true;
+
+    const results = await prompts([
+        {
+            // DB-Auswahl von DB
+            type: 'autocomplete',
+            name: 'dbName',
+            message: 'DB-Name?',
+            choices: databaseNames.map(name => { return { title: name.name } })
+        },
+        {
+            type: 'number',
+            name: 'mnr',
+            message: 'Mandant?',
+            initial: '1'
+        },
+        {
+            // Ordnerauswahl von vorhandenen Ordner in configIndividual
+            type: 'text',
+            name: 'dumpName',
+            message: 'Dump-Name?',
+            initial: 'dump.sql'
+        }
+    ], {
+        onCancel: () => {
+            console.log()
+            console.log(chalk.red("Cancelled Import!"))
+            console.log()
+            success = false
+        }
+    })
+
+    if (success) {
+        console.log()
+
+        const spinner = ora('Dumping DB').start();
+
+        // Load table names
+        let tables = await DB.executeQueryOnDB("SHOW TABLES;", results.dbName);
+        const tableKey = Object.keys(tables[0])[0];
+        tables = tables.map(row => row[tableKey])
+
+        if (tables == null || tables.length == 0) {
+            spinner.fail("Database has no tables: " + results.dbName)
+        } else {
+            // Remove previous dump
+            rmSync("." + path.sep + results.dumpName, { recursive: true, force: true })
+            for (const table of tables) {
+                // Check if Mand-Column exists
+                const tableSpinner = ora("Dumping data: " + table).start();
+                const tableCol = table + "_mnr"
+                const columnExists = await DB.executeQueryOnDB("SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS WHERE table_schema = '" + results.dbName + "' AND table_name = '" + table + "' AND column_name = '" + tableCol + "';")
+
+                if (columnExists[0]['COUNT(*)'] != 0) {
+                    // Check if Mand-Data is present
+                    const dataExists = await DB.executeQueryOnDB("SELECT COUNT(*) FROM " + table + " WHERE " + tableCol + " = '" + results.mnr + "';", results.dbName);
+
+                    if (dataExists[0]['COUNT(*)'] != 0) {
+                        // Dump table
+                        execSync("mysqldump -u" + config.dbUser + " -p" + config.dbPassword + " -h" + config.dbURL + " --no-create-info --where=\"" + tableCol + " = '" + results.mnr + "'\" " + results.dbName + " " + table + " >> " + results.dumpName);
+
+                        tableSpinner.succeed("Data dumped: " + table);
+                    } else {
+                        tableSpinner.info("No data present, Skipping table: " + table)
+                    }
+                } else {
+                    tableSpinner.info("Column " + tableCol + " not found, Skipping table: " + table)
+                }
+            }
+            // Dump mand-table (special field name)
+            const tableSpinner = ora("Dumping mand (custom logic)")
+            execSync("mysqldump -u" + config.dbUser + " -p" + config.dbPassword + " -h" + config.dbURL + " --no-create-info --where=\"mand_mandant = '" + results.mnr + "'\" " + results.dbName + " mand >> " + results.dumpName);
+            tableSpinner.succeed("Data dumped: mand")
+            spinner.succeed("Dumped DB to " + results.dumpName);
+        }
+
+
+        console.log();
+    }
+}

package/src/modules/dumpTableToCSV.js

@@ -0,0 +1,154 @@
+import fs from "fs";
+import nReadlines from 'n-readlines';
+import prompts from "prompts";
+import path from "path";
+import ora from "ora";
+import Seven from 'node-7z'
+import sevenBin from '7zip-bin'
+
+
+export default async function dumpTableToCSV() {
+    console.log()
+
+    let success = true;
+
+    const results = await prompts([
+        {
+            // Tabelle die exportiert werden soll
+            type: 'text',
+            name: 'table',
+            message: 'Tabellen-Name?'
+        }
+    ], {
+        onCancel: () => {
+            console.log()
+            console.log(chalk.red("Cancelled Dump!"))
+            console.log()
+            success = false
+        }
+    })
+
+
+    if (success) {
+        console.log()
+
+        // Unpack archives
+        let archives = fs.readdirSync(process.cwd(), { withFileTypes: true }).filter(dirent => dirent.isFile() && (dirent.name.split(".")[dirent.name.split(".").length-1] == "gz") || (dirent.name.split(".")[dirent.name.split(".").length-1] == "7z")).map(dirent => { return dirent.name });
+        for (const archive of archives){
+            await extractDumpsFromArchive(archive)
+        }
+
+        console.log()
+
+        // Read Files and create csv
+        let files = fs.readdirSync(process.cwd(), { withFileTypes: true }).filter(dirent => dirent.isFile() && dirent.name.split(".")[dirent.name.split(".").length-1] == "sql").map(dirent => { return dirent.name });
+
+        await Promise.all(files.map(async (file) => {
+            await createCSVDump(file, results.table)
+        }));
+
+        console.log()
+    }
+}
+
+function getPromiseFromEvent(item, event) {
+    return new Promise((resolve) => {
+      const listener = (data) => {
+        resolve(data);
+      }
+      item.on(event, listener);
+    })
+  }
+
+async function extractDumpsFromArchive(archive){
+    const spinnerZIP = ora('Unpacking Archive: '+archive).start();
+
+    const list = Seven.list(process.cwd() + path.sep + archive, {
+        $bin: sevenBin.path7za
+    })
+
+    const data = await getPromiseFromEvent(list, "data")
+
+    let file = data.file
+
+    if(file.split(".").length == 1){
+        const rename = Seven.rename(process.cwd() + path.sep + archive,[[file, file+".sql"]], {
+            $bin: sevenBin.path7za
+        })
+
+        await getPromiseFromEvent(rename, "end")
+    }  
+
+    const unpack = Seven.extract(process.cwd() + path.sep + archive,"."+path.sep, {
+        $bin: sevenBin.path7za
+    })
+
+    await getPromiseFromEvent(unpack, "end")
+
+    spinnerZIP.succeed("Archive unpacked: "+archive)
+
+}
+
+async function createCSVDump(file, table) {
+    let count = 0;
+    const spinner = ora('Reading file (' + file +"): "+count).start();
+    const readFile = new nReadlines(process.cwd() + path.sep + file);
+
+    let line = "";
+    let data = "";
+    let readHeader = false;
+    let headerData = "";
+
+    while ((line = readFile.next())) {
+        line = line.toString('utf-8').trim()
+
+        if (line.includes("INSERT INTO `" + table + "` VALUES")) {
+            data = data + line;
+        }
+
+        if (line.includes("CREATE TABLE `" + table + "`")) {
+            readHeader = true;
+        }
+
+        if (readHeader) {
+            if (line.includes("PRIMARY KEY")) {
+                readHeader = false;
+            } else {
+                headerData = headerData.concat(line);
+            }
+
+        }
+
+        count++;
+        spinner.text = 'Reading file (' + file +"): "+count
+        spinner.render()
+    }
+    spinner.text = 'Writing file (' + file +")"
+    spinner.render()
+
+    let headers = []
+    let matchHeader = new RegExp(/`(.*?)`/g);
+    var found;
+    while (found = matchHeader.exec(headerData)) {
+        if (found[0] != "`" + table + "`") {
+            headers.push(found[0]);
+        }
+
+    };
+
+    let records = [];
+    var reBrackets = /\((.*?)\)/g;
+    var found;
+    while (found = reBrackets.exec(data)) {
+        records.push(found[1]);
+    };
+
+    let recordsString = records.join("\n").replaceAll(",", ";");
+    let headersString = headers.join(";")
+
+    if (!fs.existsSync(process.cwd() + path.sep + "csv")) {
+        fs.mkdirSync(process.cwd() + path.sep + "csv")
+    }
+    fs.writeFileSync(process.cwd() + path.sep + "csv" + path.sep + file.split(".")[0] + ".csv", headersString + "\n" + recordsString)
+    spinner.succeed("CSV created: "+file.split(".")[0] + ".csv")
+}

package/src/modules/extdSearch.js

@@ -0,0 +1,226 @@
+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";
+
+// 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: ['name', 'bez_d', 'bez_f', 'bez_i'],
+        threshold: 0.7,
+        tableHeader: ['Table', 'Name', 'Bezeichnung Deutsch', 'Bezeichnung Französisch', 'Bezeichnung Italieniesch'],
+        tableFormatter: p => [p.table, p.name, p.bez_d, p.bez_f, p.bez_i]
+    },
+    {
+        name: "Field-Information",
+        cmd: "fi",
+        searchKeys: [
+            '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: ['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 => [
+            p.table, p.name,
+            formatFieldType(p.special),
+            formatFlag(p.flag),
+            formatTestFlag(p.testflag),
+            ...Array.from({ length: 9 }, (_, i) => formatWert(p[`b_value_${i + 1}`], p[`b_dtext_${i + 1}`]))
+        ]
+    },
+    {
+        name: "Disp-Fields",
+        cmd: "df",
+        searchKeys: [
+            '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: ['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 => [
+            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
+        ]
+    }
+];
+
+function formatWert(value, bez) {
+    return value || bez ? `'${value}'='${bez}'` : '';
+}
+
+function formatFieldType(type) {
+    return {
+        '0': 'Custom',
+        '1': 'Checkbox',
+        '2': 'Radiobutton',
+        '4': 'Text'
+    }[type] || '';
+}
+
+function formatFlag(flag) {
+    return {
+        '0': 'Optional',
+        '1': 'Zwingend',
+        '2': 'Aus',
+        '3': 'Dialog aus'
+    }[flag] || '';
+}
+
+function formatTestFlag(flag) {
+    return {
+        '0': 'Zwingend',
+        '1': 'Null/Space erlaubt'
+    }[flag] || '';
+}

package/src/modules/graphqlSchemaExport.js

@@ -0,0 +1,61 @@
+import prompts from "prompts";
+import chalk from "chalk";
+import graphql from "graphql"
+import { writeFileSync, readFileSync, readdirSync, writeFile, unlinkSync, mkdirSync, renameSync, rmSync } from "fs";
+
+export default async function qraphqlSchemaExport(){
+    console.log()
+    
+    let success = true;
+    
+    const responses = await prompts([{
+        type: 'text',
+        name: 'url',
+        message: 'URL?',
+        initial: "http://localhost:8080/graphql"
+    },
+    {
+        type: 'text',
+        name: 'token',
+        message: 'AUTH-Token?'
+    },
+    {
+        type: 'text',
+        name: 'file',
+        message: 'File-Name?',
+        initial: 'schema.graphqls'
+    }], {
+        onCancel: () => {
+            console.log()
+            console.log(chalk.red("Cancelled GraphQL-Schema-Export!"))
+            console.log()
+            success = false
+        }
+    })
+
+    if(success){
+        console.log()
+
+        try{
+            const {data, errors} = await fetch(responses.url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Accept": "application/json",
+                    "Authorization": "Bearer "+responses.token
+                },
+                body: JSON.stringify({query: graphql.getIntrospectionQuery()})
+            }).then(res => res.json())
+
+            const schema = graphql.buildClientSchema(data)
+            
+
+            writeFileSync(responses.file, graphql.printSchema(schema))
+            console.log(chalk.green("Schema loaded: "+responses.file))
+            console.log();
+        }catch(e){
+            console.log(chalk.red("Error loading schema: "+e))
+            console.log();
+        }
+    }
+}