@cyklang/cli 0.1.2 → 0.2.1

package/build/TableCommand.js

@@ -29,6 +29,8 @@ const loglevel_1 = __importDefault(require("loglevel"));
 const commander_1 = require("commander");
 const child_process_1 = require("child_process");
 const Cmd_1 = require("./Cmd");
+const DBClient_1 = require("./DBClient");
+const form_data_1 = __importDefault(require("form-data"));
 const logger = loglevel_1.default.getLogger("TableCommand.ts");
 logger.setLevel("debug");
 class TableCommand extends commander_1.Command {
@@ -36,6 +38,11 @@ class TableCommand extends commander_1.Command {
         super(name);
         this.description('import/export table rows').version('0.1');
         this.addCommand(new TableExportCmd());
+        this.addCommand(new TableImportCmd());
+        this.addCommand(new TableList('list', 'list database tables'));
+        this.addCommand(new TableList('l', '(l)ist database tables'));
+        this.addCommand(new TableQuery('query', 'query select table content'));
+        this.addCommand(new TableQuery('q', 'query select table content'));
     }
 }
 exports.TableCommand = TableCommand;
@@ -52,13 +59,56 @@ class TableExportCmd extends Cmd_1.Cmd {
         await this.prologue(options);
         if (this.dbManager === undefined)
             throw 'dbManager undefined';
-        await commandImportExport(this.dbManager, 'to', tables, options);
+        // await commandImportExport(this.dbManager, 'to', tables, options)
+        try {
+            if (options.file === undefined && options.dir === undefined)
+                throw '--file or --dir mandatory';
+            if (options.file !== undefined && options.dir !== undefined)
+                throw '--file and --dir are mutually exclusive';
+            if (tables.length === 0)
+                throw 'at least one table name is mandatory';
+            if (tables.length > 1 && options.dir === undefined)
+                throw 'for multiple tables, --dir is mandatory';
+            for (let indi = 0; indi < tables.length; indi++) {
+                const tableName = tables[indi];
+                const dbTable = await this.dbManager.dbTableExist(tableName);
+                if (dbTable === undefined) {
+                    logger.info('table ' + tableName + ' not found');
+                    continue;
+                }
+                const filename = buildFilename(dbTable.name, options);
+                await this.copyTo(dbTable, filename);
+            }
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+    async copyTo(dbTable, filename) {
+        if (this.dbRemote === undefined)
+            throw 'dbRemote undefined';
+        try {
+            const writeStream = fs.createWriteStream(filename);
+            const response = await this.dbRemote.apiServer.get('/admin/export/' + dbTable.name, { responseType: 'stream' });
+            const stream = response;
+            stream.on('data', (data) => {
+                logger.debug('**** DATA ****', data.length);
+                const textDecoder = new TextDecoder();
+                const chunk = (textDecoder.decode(data));
+                writeStream.write(chunk);
+            });
+            stream.on('end', () => logger.debug('**** DONE ****'));
+        }
+        catch (err) {
+            logger.error(err);
+        }
     }
 }
 class TableImportCmd extends Cmd_1.Cmd {
     constructor() {
         super('import');
         this.description('import from CSV file(s)')
+            .argument('<tables...>', 'table(s) to import')
             .option('-f --file <file>', 'name of the file to import, defaults to <table_name>.csv')
             .option('-d --dir <directory>', 'name of the directory where to find files to import')
             .action(async (tables, options) => this.commandImport(tables, options));
@@ -67,9 +117,72 @@ class TableImportCmd extends Cmd_1.Cmd {
         await this.prologue(options);
         if (this.dbManager === undefined)
             throw 'dbManager undefined';
-        await commandImportExport(this.dbManager, 'from', tables, options);
+        // await commandImportExport(this.dbManager, 'to', tables, options)
+        try {
+            if (options.file === undefined && options.dir === undefined)
+                throw '--file or --dir mandatory';
+            if (options.file !== undefined && options.dir !== undefined)
+                throw '--file and --dir are mutually exclusive';
+            if (tables.length === 0)
+                throw 'at least one table name is mandatory';
+            if (tables.length > 1 && options.dir === undefined)
+                throw 'for multiple tables, --dir is mandatory';
+            for (let indi = 0; indi < tables.length; indi++) {
+                const tableName = tables[indi];
+                const dbTable = await this.dbManager.dbTableExist(tableName);
+                if (dbTable === undefined) {
+                    logger.info('table ' + tableName + ' not found');
+                    continue;
+                }
+                const filename = buildFilename(dbTable.name, options);
+                this.copyFrom(dbTable, filename);
+            }
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+    async copyFrom(dbTable, filename) {
+        if (this.dbRemote === undefined)
+            throw 'dbRemote undefined';
+        try {
+            const file = fs.createReadStream(filename);
+            const form = new form_data_1.default();
+            form.append('uploadFile', file);
+            const route = '/admin/import/' + dbTable.name;
+            const resp = await this.dbRemote.apiServer.post(route, form);
+            if (resp.status === 200) {
+                logger.debug(filename + ' uploaded');
+            }
+        }
+        catch (err) {
+            logger.error(err);
+        }
     }
 }
+function buildFilename(tableName, options) {
+    let filename;
+    if (options.file !== undefined) {
+        if (fs.existsSync(options.file) && fs.lstatSync(options.file).isDirectory())
+            throw '--file ' + options.file + ' is a directory';
+        filename = options.file;
+    }
+    else if (options.dir === undefined)
+        throw '--file and --dir unspecified';
+    else if (fs.existsSync(options.dir) === false)
+        throw 'directory ' + options.dir + ' does not exist';
+    else if (fs.lstatSync(options.dir).isFile()) {
+        throw ("--dir " + options.dir + " is a file ");
+    }
+    else {
+        let directory = options.dir.trim();
+        if (directory[directory.length - 1] !== '/') {
+            directory += '/';
+        }
+        filename = directory + tableName + '.csv';
+    }
+    return filename;
+}
 const commandImportExport = async (dbManager, direction, tables, options) => {
     logger.debug('tables : ', tables, 'options : ', options);
     try {
@@ -88,53 +201,130 @@ const commandImportExport = async (dbManager, direction, tables, options) => {
                 logger.info('table ' + tableName + ' not found');
                 continue;
             }
-            let lcols;
-            for (let indj = 0; indj < dbTable.columns.length; indj++) {
-                const dbColumn = dbTable.columns[indj];
-                if (lcols === undefined) {
-                    lcols = "(";
+            psqlCmd(dbTable, direction, options);
+        }
+    }
+    catch (err) {
+        logger.error(err);
+    }
+};
+//--------------------------------------------------------------------------------------------------------------------
+// function psqlCmd
+// invoke local install of psql CLI
+//--------------------------------------------------------------------------------------------------------------------
+function psqlCmd(dbTable, direction, options) {
+    let lcols;
+    for (let indj = 0; indj < dbTable.columns.length; indj++) {
+        const dbColumn = dbTable.columns[indj];
+        if (lcols === undefined) {
+            lcols = "(";
+        }
+        else {
+            lcols += ",";
+        }
+        lcols += dbColumn.name;
+    }
+    lcols += ")";
+    let psql_cmd = "psql -c";
+    if (process.env.HEROKU_CLI !== undefined) {
+        psql_cmd = process.env.HEROKU_CLI + ' -c ';
+    }
+    let filename;
+    if (options.file !== undefined) {
+        if (fs.existsSync(options.file) && fs.lstatSync(options.file).isDirectory())
+            throw '--file ' + options.file + ' is a directory';
+        filename = options.file;
+    }
+    else if (options.dir === undefined)
+        throw '--file and --dir unspecified';
+    else if (fs.existsSync(options.dir) === false)
+        throw 'directory ' + options.dir + ' does not exist';
+    else if (fs.lstatSync(options.dir).isFile()) {
+        logger.debug("--dir " + options.dir + " is a file ");
+    }
+    else {
+        let directory = options.dir.trim();
+        if (directory[directory.length - 1] !== '/') {
+            directory += '/';
+        }
+        filename = directory + dbTable.name + '.csv';
+    }
+    let copy_cmd = "\\copy " + dbTable.name + lcols + direction + " '" + filename + "' csv header";
+    const shell_cmd = psql_cmd + '"' + copy_cmd + '"';
+    logger.debug(shell_cmd);
+    const child = (0, child_process_1.spawn)(shell_cmd.trim(), { stdio: 'inherit', shell: true });
+}
+//--------------------------------------------------------------------------------------------------------------------
+// class TableList
+//--------------------------------------------------------------------------------------------------------------------
+class TableList extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .option('-s --sort <columns>', 'sort list by column numbers (begins with 0) separated by comma')
+            .action(async (options) => {
+            await this.commandList(options);
+        });
+    }
+    async commandList(options) {
+        await this.prologue(options);
+        if (this.dbManager === undefined)
+            throw 'dbManager undefined';
+        const dbClient = new DBClient_1.DBClient(this.dbManager);
+        dbClient.selectFromTable('List of Tables', 'cyk_table', { fields: 'table_id,table_name,table_description,table_access', sort: options.sort || '1' });
+    }
+}
+//--------------------------------------------------------------------------------------------------------------------
+// class TableQuery
+//--------------------------------------------------------------------------------------------------------------------
+class TableQuery extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .argument('<table>', 'table to query')
+            .option('--where <clause_where_sql>', 'criteria in SQL syntax')
+            .option('-s --sort <columns>', 'sort by columns positions (begins by 0) separated by comma')
+            .option('-w --width <colwidth>', 'columns widths separated by comma')
+            .action(async (table, options) => {
+            this.commandQuery(table, options);
+        });
+    }
+    async commandQuery(table, options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            const dbTable = await this.dbManager.dbTableExist(table);
+            if (dbTable === undefined)
+                throw 'table ' + table + ' not found';
+            let fields = '';
+            for (let ind = 0; ind < dbTable.columns.length; ind++) {
+                const dbColumn = dbTable.columns[ind];
+                let ok = false;
+                let fieldName = dbColumn.name;
+                if (dbColumn.dbType === 'text' || dbColumn.dbType === 'bytea') {
+                    ok = false;
+                    fieldName = 'length(' + dbColumn.name + ')';
                 }
                 else {
-                    lcols += ",";
+                    ok = true;
                 }
-                lcols += dbColumn.name;
-            }
-            lcols += ")";
-            let psql_cmd = "psql -c";
-            if (process.env.HEROKU_CLI !== undefined) {
-                psql_cmd = process.env.HEROKU_CLI + ' -c ';
-            }
-            let filename;
-            if (options.file !== undefined) {
-                if (fs.existsSync(options.file) && fs.lstatSync(options.file).isDirectory())
-                    throw '--file ' + options.file + ' is a directory';
-                filename = options.file;
-            }
-            else if (options.dir === undefined)
-                throw '--file and --dir unspecified';
-            else if (fs.existsSync(options.dir) === false)
-                throw 'directory ' + options.dir + ' does not exist';
-            else if (fs.lstatSync(options.dir).isFile()) {
-                logger.debug("--dir " + options.dir + " is a file ");
-            }
-            else {
-                let directory = options.dir.trim();
-                if (directory[directory.length - 1] !== '/') {
-                    directory += '/';
+                if (ok === true) {
+                    if (fields !== '')
+                        fields += ',';
+                    fields += fieldName;
                 }
-                filename = directory + tableName + '.csv';
             }
-            let copy_cmd = "\\copy " + tableName + lcols + direction + " '" + filename + "' csv header";
-            const shell_cmd = psql_cmd + '"' + copy_cmd + '"';
-            logger.debug(shell_cmd);
-            const child = (0, child_process_1.spawn)(shell_cmd.trim(), { stdio: 'inherit', shell: true });
-            // exec(shell_cmd.trim(), (error, stdout, stderr) => {
-            //     if (error) throw error
-            //     logger.debug(stdout, stderr)
-            // })
+            logger.debug('commandQuery', table);
+            const dbClient = new DBClient_1.DBClient(this.dbManager);
+            let title = 'Table ' + table;
+            if (options.where !== undefined) {
+                title += ' where ' + options.where;
+            }
+            dbClient.selectFromTable(title, table, { fields: fields, width: options.width, sort: options.sort || '1', where: options.where });
+        }
+        catch (err) {
+            logger.error(err);
         }
     }
-    catch (err) {
-        logger.error(err);
-    }
-};
+}

package/build/index.js

@@ -13,12 +13,15 @@ const TableCommand_1 = require("./TableCommand");
 const TestCommand_1 = require("./TestCommand");
 const RunCommand_1 = require("./RunCommand");
 const InitCommand_1 = require("./InitCommand");
+const AssetCommand_1 = require("./AssetCommand");
 const logger = loglevel_1.default.getLogger("index.ts");
 logger.setLevel("debug");
 const program = new commander_1.Command();
 program.name('cyk').description('cyklang CLI')
     .version('0.2');
 program.addCommand(new InitCommand_1.InitCommand('init'));
+program.addCommand(new AssetCommand_1.AssetCommand('asset', 'manage assets'));
+program.addCommand(new AssetCommand_1.AssetCommand('a', 'manage assets'));
 program.addCommand(new ModuleCommand_1.ModuleCommand('module'));
 program.addCommand(new ModuleCommand_1.ModuleCommand('m'));
 program.addCommand(new UserCommand_1.UserCommand('user'));

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@cyklang/cli",
-   "version": "0.1.2",
+   "version": "0.2.1",
    "description": "cyklang CLI",
    "main": "build/index.js",
    "scripts": {
@@ -11,20 +11,23 @@
       "npm:upgrade": "npx npm-check-updates -iu",
       "refresh": "rm -rf ./node_modules ./package-lock.json && npm install",
       "dev": "nodemon -e ts --ignore build --exec \"npm run global\" ",
-      "test": "sudo npm i -g && cyk"
+      "test": "cyk test test/t*.xml"
    },
    "keywords": [],
    "author": "",
    "license": "ISC",
    "dependencies": {
-      "@cyklang/core": "^0.3.4",
+      "@cyklang/core": "^0.3.6",
       "commander": "^9.4.0",
       "dotenv": "^16.0.1",
+      "form-data": "^4.0.0",
       "loglevel": "^1.8.0",
+      "mime-types": "^2.1.35",
       "pako": "^2.0.4",
       "xml": "^1.0.1"
    },
    "devDependencies": {
+      "@types/mime-types": "^2.1.1",
       "@types/pako": "^2.0.0",
       "@types/sax": "^1.2.4",
       "@types/xml": "^1.0.8",

package/pgdata/entry.csv

@@ -0,0 +1,22 @@
+entry_id,entry_year,entry_date,entry_jnl,entry_doc,entry_acct,entry_debit,entry_credit,entry_aux,entry_ord,entry_letter,entry_letter_date
+43,2021,2021-01-03,1,16,60221,75.00,,,1,,
+44,2021,2021-01-03,1,16,44566,0.00,,,2,,
+45,2021,2021-01-03,1,16,4011,,75.00,5,3,,
+15,2021,2021-01-01,2,6,4011,1100.00,,12,1,,
+16,2021,2021-01-01,2,6,44566,,100.00,,2,,
+17,2021,2021-01-01,2,6,701,,1000.00,,3,,
+21,2021,2021-01-01,3,10,4011,100.00,,11,1,,
+2,2021,2021-01-01,1,2,44566,10.00,,,2,,
+1,2021,2021-01-01,1,2,601,50.00,,,1,,
+3,2021,2021-01-01,1,2,4011,,60.00,3,3,,
+22,2021,2021-01-01,3,10,512,,100.00,,2,,
+23,2021,2021-01-01,,11,431,500.00,,,1,,
+12,2021,2021-01-02,1,5,6061,50.00,,,1,,
+13,2021,2021-01-02,1,5,44566,0.00,,,2,,
+14,2021,2021-01-02,1,5,4011,,50.00,5,3,,
+40,2021,2021-01-01,,11,512,,500.00,,2,,
+46,2021,2021-01-01,3,17,4011,100.00,,11,1,,
+47,2021,2021-01-01,3,17,512,,100.00,,2,,
+9,2021,2021-01-01,1,4,6061,100.00,,,1,,
+10,2021,2021-01-01,1,4,44566,20.00,,,2,,
+11,2021,2021-01-01,1,4,4011,,120.00,11,3,,

package/pgdata/setting.csv

@@ -0,0 +1,4 @@
+stg_code,stg_num,stg_text,stg_label
+year,2021,,Year
+jnl_id,1,,ID journal de Saisie
+month_begin,,2021-01-01,1er Jour du Mois de Saisie