@cyklang/cli 0.5.6 → 0.7.0

package/build/TableCommand.d.ts

@@ -1,5 +1,14 @@
 #!/usr/bin/env ts-node
+import { DBManager } from "@cyklang/core";
+import loglevel from 'loglevel';
 import { Command } from "commander";
+export declare const logger: loglevel.Logger;
 export declare class TableCommand extends Command {
     constructor(name: string);
 }
+/**
+ * function dropTable
+ * @param table
+ * @param dbManager
+ */
+export declare function dropTable(table: string, dbManager: DBManager): Promise<void>;

package/build/TableCommand.js

@@ -27,7 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TableCommand = void 0;
+exports.dropTable = exports.TableCommand = exports.logger = void 0;
 const fs = __importStar(require("fs"));
 const loglevel_1 = __importDefault(require("loglevel"));
 const commander_1 = require("commander");
@@ -35,8 +35,9 @@ 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");
+const inquirer_1 = __importDefault(require("inquirer"));
+exports.logger = loglevel_1.default.getLogger("TableCommand.ts");
+exports.logger.setLevel("debug");
 class TableCommand extends commander_1.Command {
     constructor(name) {
         super(name);
@@ -45,8 +46,7 @@ class TableCommand extends commander_1.Command {
         this.addCommand(new TableImportCmd());
         this.addCommand(new TableList('list', 'list database tables'));
         this.addCommand(new TableList('l', '(l)ist database tables'));
-        this.addCommand(new TableData('data', 'table (d)ata'));
-        this.addCommand(new TableData('d', 'table (d)ata'));
+        this.addCommand(new TableDropCommand('drop', 'drop table'));
         this.addCommand(new TableUpdate('update', 'update table properties'));
         this.addCommand(new TableUpdate('u', 'shortcut for (u)pdate table properties'));
     }
@@ -84,7 +84,7 @@ class TableUpdate extends Cmd_1.Cmd {
             await this.updateAuthAccess('cyk_table', 'table', dbTable.id || '', options);
         }
         catch (err) {
-            logger.error(err);
+            exports.logger.error(err);
         }
     }
 }
@@ -115,7 +115,7 @@ class TableExportCmd extends Cmd_1.Cmd {
                 const tableName = tables[indi];
                 const dbTable = await this.dbManager.dbTableExist(tableName);
                 if (dbTable === undefined) {
-                    logger.info('table ' + tableName + ' not found');
+                    exports.logger.info('table ' + tableName + ' not found');
                     continue;
                 }
                 const filename = buildFilename(dbTable.name, options);
@@ -123,7 +123,7 @@ class TableExportCmd extends Cmd_1.Cmd {
             }
         }
         catch (err) {
-            logger.error(err);
+            exports.logger.error(err);
         }
     }
     async copyTo(dbTable, filename) {
@@ -134,15 +134,15 @@ class TableExportCmd extends Cmd_1.Cmd {
             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);
+                exports.logger.debug('**** DATA ****', data.length);
                 const textDecoder = new TextDecoder();
                 const chunk = (textDecoder.decode(data));
                 writeStream.write(chunk);
             });
-            stream.on('end', () => logger.debug('**** DONE ****'));
+            stream.on('end', () => exports.logger.debug('**** DONE ****'));
         }
         catch (err) {
-            logger.error(err);
+            exports.logger.error(err);
         }
     }
 }
@@ -173,7 +173,7 @@ class TableImportCmd extends Cmd_1.Cmd {
                 const tableName = tables[indi];
                 const dbTable = await this.dbManager.dbTableExist(tableName);
                 if (dbTable === undefined) {
-                    logger.info('table ' + tableName + ' not found');
+                    exports.logger.info('table ' + tableName + ' not found');
                     continue;
                 }
                 const filename = buildFilename(dbTable.name, options);
@@ -181,7 +181,7 @@ class TableImportCmd extends Cmd_1.Cmd {
             }
         }
         catch (err) {
-            logger.error(err);
+            exports.logger.error(err);
         }
     }
     async copyFrom(dbTable, filename) {
@@ -194,11 +194,11 @@ class TableImportCmd extends Cmd_1.Cmd {
             const route = '/admin/import/' + dbTable.name;
             const resp = await this.dbRemote.apiServer.post(route, form);
             if (resp.status === 200) {
-                logger.debug(filename + ' uploaded');
+                exports.logger.debug(filename + ' uploaded');
             }
         }
         catch (err) {
-            logger.error(err);
+            exports.logger.error(err);
         }
     }
 }
@@ -226,7 +226,7 @@ function buildFilename(tableName, options) {
     return filename;
 }
 const commandImportExport = async (dbManager, direction, tables, options) => {
-    logger.debug('tables : ', tables, 'options : ', options);
+    exports.logger.debug('tables : ', tables, 'options : ', options);
     try {
         if (options.file === undefined && options.dir === undefined)
             throw '--file or --dir mandatory';
@@ -240,14 +240,14 @@ const commandImportExport = async (dbManager, direction, tables, options) => {
             const tableName = tables[indi];
             const dbTable = await dbManager.dbTableExist(tableName);
             if (dbTable === undefined) {
-                logger.info('table ' + tableName + ' not found');
+                exports.logger.info('table ' + tableName + ' not found');
                 continue;
             }
             psqlCmd(dbTable, direction, options);
         }
     }
     catch (err) {
-        logger.error(err);
+        exports.logger.error(err);
     }
 };
 //--------------------------------------------------------------------------------------------------------------------
@@ -282,7 +282,7 @@ function psqlCmd(dbTable, direction, options) {
     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 ");
+        exports.logger.debug("--dir " + options.dir + " is a file ");
     }
     else {
         let directory = options.dir.trim();
@@ -293,7 +293,7 @@ function psqlCmd(dbTable, direction, options) {
     }
     let copy_cmd = "\\copy " + dbTable.name + lcols + direction + " '" + filename + "' csv header";
     const shell_cmd = psql_cmd + '"' + copy_cmd + '"';
-    logger.debug(shell_cmd);
+    exports.logger.debug(shell_cmd);
     const child = (0, child_process_1.spawn)(shell_cmd.trim(), { stdio: 'inherit', shell: true });
 }
 //--------------------------------------------------------------------------------------------------------------------
@@ -316,57 +316,43 @@ class TableList extends Cmd_1.Cmd {
         dbClient.selectFromTable('List of Tables', 'cyk_table', { fields: 'table_id,table_name,table_auth,table_access,table_description', sort: options.sort || '1' });
     }
 }
-//--------------------------------------------------------------------------------------------------------------------
-// class TableData
-//--------------------------------------------------------------------------------------------------------------------
-class TableData extends Cmd_1.Cmd {
+class TableDropCommand extends Cmd_1.Cmd {
     constructor(name, description) {
         super(name);
         this.description(description)
             .argument('<table>', 'table name')
-            .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.commandData(table, options);
+            await this.commandDrop(table, options);
         });
     }
-    async commandData(table, options) {
+    async commandDrop(table, options) {
         try {
             await this.prologue(options);
-            if (this.dbManager === undefined)
+            if (!this.dbManager)
                 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 {
-                    ok = true;
-                }
-                if (ok === true) {
-                    if (fields !== '')
-                        fields += ',';
-                    fields += fieldName;
-                }
+            if (!dbTable) {
+                console.log('table ' + table + ' does not exist');
+                return;
             }
-            logger.debug('commandQuery', table);
-            const dbClient = new DBClient_1.DBClient(this.dbManager);
-            let title = 'Table ' + table;
-            if (options.where !== undefined) {
-                title += ' where ' + options.where;
+            const reply = await inquirer_1.default.prompt({ type: 'confirm', name: 'confirm', message: 'Drop table ' + table + '?' });
+            if (reply.confirm && this.dbManager) {
+                await dropTable(table, this.dbManager);
             }
-            dbClient.selectFromTable(title, table, { fields: fields, width: options.width, sort: options.sort || '1', where: options.where });
         }
         catch (err) {
-            logger.error(err);
+            exports.logger.error(err);
         }
     }
 }
+/**
+ * function dropTable
+ * @param table
+ * @param dbManager
+ */
+async function dropTable(table, dbManager) {
+    const dbTable = await dbManager.dbTableExist(table);
+    if (dbTable)
+        await dbManager.dbTableDelete(dbTable);
+}
+exports.dropTable = dropTable;

package/build/TableData.d.ts

@@ -0,0 +1,5 @@
+import { Cmd } from "./Cmd";
+export declare class TableDataCommand extends Cmd {
+    constructor(name: string, description: string);
+    commandData(table: string, options: any): Promise<void>;
+}

package/build/TableData.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableDataCommand = void 0;
+const Cmd_1 = require("./Cmd");
+const DBClient_1 = require("./DBClient");
+const TableCommand_1 = require("./TableCommand");
+//--------------------------------------------------------------------------------------------------------------------
+// class TableData
+//--------------------------------------------------------------------------------------------------------------------
+class TableDataCommand extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .argument('<table>', 'table name')
+            .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.commandData(table, options);
+        });
+    }
+    async commandData(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 {
+                    ok = true;
+                }
+                if (ok === true) {
+                    if (fields !== '')
+                        fields += ',';
+                    fields += fieldName;
+                }
+            }
+            TableCommand_1.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) {
+            TableCommand_1.logger.error(err);
+        }
+    }
+}
+exports.TableDataCommand = TableDataCommand;

package/build/TableDataCommand.d.ts

@@ -0,0 +1,5 @@
+import { Cmd } from "./Cmd";
+export declare class TableDataCommand extends Cmd {
+    constructor(name: string, description: string);
+    commandData(table: string, options: any): Promise<void>;
+}

package/build/TableDataCommand.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableDataCommand = void 0;
+const Cmd_1 = require("./Cmd");
+const DBClient_1 = require("./DBClient");
+const TableCommand_1 = require("./TableCommand");
+//--------------------------------------------------------------------------------------------------------------------
+// class TableData
+//--------------------------------------------------------------------------------------------------------------------
+class TableDataCommand extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .argument('<table>', 'table name')
+            .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.commandData(table, options);
+        });
+    }
+    async commandData(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 {
+                    ok = true;
+                }
+                if (ok === true) {
+                    if (fields !== '')
+                        fields += ',';
+                    fields += fieldName;
+                }
+            }
+            TableCommand_1.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) {
+            TableCommand_1.logger.error(err);
+        }
+    }
+}
+exports.TableDataCommand = TableDataCommand;

package/build/index.js

@@ -1,26 +1,148 @@
 #!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const loglevel_1 = __importDefault(require("loglevel"));
 const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const loglevel_1 = __importDefault(require("loglevel"));
+const path_1 = __importDefault(require("path"));
+const AssetCommand_1 = require("./AssetCommand");
+const Cmd_1 = require("./Cmd");
+const InstallCommand_1 = require("./InstallCommand");
 const ModuleCommand_1 = require("./ModuleCommand");
-const UserCommand_1 = require("./UserCommand");
+const OpenCommand_1 = require("./OpenCommand");
 const QueryCommand_1 = require("./QueryCommand");
+const RunCommand_1 = require("./RunCommand");
 const TableCommand_1 = require("./TableCommand");
+const TableDataCommand_1 = require("./TableDataCommand");
 const TestCommand_1 = require("./TestCommand");
-const RunCommand_1 = require("./RunCommand");
-const InstallCommand_1 = require("./InstallCommand");
-const AssetCommand_1 = require("./AssetCommand");
-const OpenCommand_1 = require("./OpenCommand");
 const UninstallCommand_1 = require("./UninstallCommand");
+const UserCommand_1 = require("./UserCommand");
 const logger = loglevel_1.default.getLogger("index.ts");
 logger.setLevel("debug");
+/**
+ * function getOrchestrator
+ */
+function getOrchestrator() {
+    let result;
+    const cwd = process.cwd();
+    const dockerComposePath = path_1.default.join(cwd, 'docker-compose.yml');
+    const k8sPath = path_1.default.join(cwd, 'k8s');
+    if (fs.existsSync(dockerComposePath) && fs.statSync(dockerComposePath).isFile()) {
+        result = 'docker';
+    }
+    else if (fs.existsSync(k8sPath) && fs.statSync(k8sPath).isDirectory()) {
+        result = 'kubernetes';
+    }
+    return result;
+}
+/**
+ * function startServer
+ */
+async function startServer() {
+    try {
+        const orchestrator = getOrchestrator();
+        if (orchestrator === 'docker') {
+            await (0, Cmd_1.spawnCommand)('docker', ['compose', 'up', '-d']);
+        }
+        if (orchestrator === 'kubernetes') {
+            const portForwardPath = path_1.default.join(process.cwd(), 'k8s', 'port-forward');
+            if (!fs.existsSync(portForwardPath) || !fs.statSync(portForwardPath).isFile())
+                throw portForwardPath + ' file not found';
+            const config = JSON.parse(fs.readFileSync(portForwardPath).toString());
+            if (!config.postgres || !config.nodejs)
+                throw portForwardPath + ' : file format incorrect';
+            (0, Cmd_1.spawnCommand)('kubectl', ['port-forward', 'svc/postgres', config.postgres + ':5432']);
+            logger.info('Postgresql proxy at localhost:' + config.postgres);
+            (0, Cmd_1.spawnCommand)('kubectl', ['port-forward', 'svc/nodejs', config.nodejs + ':3000']);
+            logger.info('Nodejs proxy at localhost:' + config.nodejs);
+        }
+        if (!orchestrator) {
+            logger.error('No cyk server is defined in current folder ' + process.cwd());
+        }
+    }
+    catch (err) {
+        console.error(err);
+    }
+}
+/**
+ * function stopServer
+ */
+async function stopServer() {
+    try {
+        const orchestrator = getOrchestrator();
+        if (orchestrator === 'docker') {
+            await (0, Cmd_1.spawnCommand)('docker', ['compose', 'down']);
+        }
+        if (orchestrator === 'kubernetes') {
+            await (0, Cmd_1.spawnCommand)('kubectl', ['delete', '-f', path_1.default.join(process.cwd(), 'k8s')]);
+            logger.info('Kubernetes deployments and services deleted');
+        }
+        if (!orchestrator) {
+            logger.error('No cyk server is defined in current folder ' + process.cwd());
+        }
+    }
+    catch (err) {
+        console.error(err);
+    }
+}
+/**
+ * class StartCommand
+ */
+class StartCommand extends commander_1.Command {
+    constructor(name) {
+        super(name);
+        this.description('start cyk server defined in current project folder')
+            .action(async (options) => {
+            await startServer();
+        });
+    }
+}
+/**
+ * class StopCommand
+ */
+class StopCommand extends commander_1.Command {
+    constructor(name) {
+        super(name);
+        this.description('stop cyk server defined in current project folder')
+            .action(async (options) => {
+            await stopServer();
+        });
+    }
+}
+/**
+ * Main program
+ */
 const program = new commander_1.Command();
 program.name('cyk').description('cyklang CLI')
-    .version('0.5.6');
+    .version('0.6.0');
+program.addCommand(new StartCommand('start'));
+program.addCommand(new StopCommand('stop'));
 program.addCommand(new InstallCommand_1.InstallCommand('install'));
 program.addCommand(new InstallCommand_1.InstallCommand('i'));
 program.addCommand(new UninstallCommand_1.UninstallCommand('uninstall'));
@@ -34,6 +156,8 @@ program.addCommand(new QueryCommand_1.QueryCommand('query'));
 program.addCommand(new QueryCommand_1.QueryCommand('q'));
 program.addCommand(new TableCommand_1.TableCommand('table'));
 program.addCommand(new TableCommand_1.TableCommand('t'));
+program.addCommand(new TableDataCommand_1.TableDataCommand('data', 'show table data'));
+program.addCommand(new TableDataCommand_1.TableDataCommand('d', 'show table data'));
 program.addCommand(new TestCommand_1.TestCommand());
 program.addCommand(new RunCommand_1.RunCommand('run'));
 program.addCommand(new RunCommand_1.RunCommand('r'));

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@cyklang/cli",
-   "version": "0.5.6",
+   "version": "0.7.0",
    "description": "cyklang CLI",
    "main": "build/index.js",
    "scripts": {
@@ -17,7 +17,7 @@
    "author": "",
    "license": "ISC",
    "dependencies": {
-      "@cyklang/core": "^0.5.3",
+      "@cyklang/core": "^0.5.4",
       "commander": "^9.4.0",
       "dotenv": "^16.0.1",
       "form-data": "^4.0.0",

package/src/TableCommand.ts

@@ -8,8 +8,10 @@ import { Cmd } from "./Cmd"
 import { DBClient } from "./DBClient"
 import { Stream } from "form-data"
 import FormData from 'form-data'
+import inquirer from 'inquirer'
+import { TableDataCommand } from "./TableDataCommand"
 
-const logger = loglevel.getLogger("TableCommand.ts")
+export const logger = loglevel.getLogger("TableCommand.ts")
 logger.setLevel("debug")
 
 export class TableCommand extends Command {
@@ -20,8 +22,7 @@ export class TableCommand extends Command {
         this.addCommand(new TableImportCmd())
         this.addCommand(new TableList('list', 'list database tables'))
         this.addCommand(new TableList('l', '(l)ist database tables'))
-        this.addCommand(new TableData('data', 'table (d)ata'))
-        this.addCommand(new TableData('d', 'table (d)ata'))
+        this.addCommand(new TableDropCommand('drop', 'drop table'))
         this.addCommand(new TableUpdate('update', 'update table properties'))
         this.addCommand(new TableUpdate('u', 'shortcut for (u)pdate table properties'))
     }
@@ -40,12 +41,12 @@ class TableUpdate extends Cmd {
     constructor(name: string, description: string) {
         super(name)
         this.description(description)
-        .option('-n --name <table_name>', 'name of the table whose properties are to be changed')
-        .option('--auth <auth_schema>', 'authentication schema : basic | token | cookie | any | none, default is none')
-        .option('--access <access>', 'access rights required')
-        .action(async (options: any) => {
-            await this.commandUpdate(options)
-        })
+            .option('-n --name <table_name>', 'name of the table whose properties are to be changed')
+            .option('--auth <auth_schema>', 'authentication schema : basic | token | cookie | any | none, default is none')
+            .option('--access <access>', 'access rights required')
+            .action(async (options: any) => {
+                await this.commandUpdate(options)
+            })
     }
 
     async commandUpdate(options: any) {
@@ -53,10 +54,10 @@ class TableUpdate extends Cmd {
             await this.prologue(options)
             if (this.dbManager === undefined) throw 'dbManager undefined'
 
-            if ( ! options.name ) throw '<table_name> is missing'
+            if (!options.name) throw '<table_name> is missing'
 
             const dbTable = await this.dbManager.dbTableExist(options.name)
-            if ( ! dbTable ) throw 'Table ' + options.name + ' not found'
+            if (!dbTable) throw 'Table ' + options.name + ' not found'
 
             await this.updateAuthAccess('cyk_table', 'table', dbTable.id || '', options)
         }
@@ -319,63 +320,46 @@ class TableList extends Cmd {
     }
 }
 
-//--------------------------------------------------------------------------------------------------------------------
-// class TableData
-//--------------------------------------------------------------------------------------------------------------------
-
-class TableData extends Cmd {
-
+class TableDropCommand extends Cmd {
     constructor(name: string, description: string) {
         super(name)
         this.description(description)
             .argument('<table>', 'table name')
-            .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.commandData(table, options)
+                await this.commandDrop(table, options)
             })
     }
 
-    async commandData(table: string, options: any) {
+    async commandDrop(table: string, options: any) {
         try {
             await this.prologue(options)
-            if (this.dbManager === undefined) throw 'dbManager undefined'
-
+            if (!this.dbManager) 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 {
-                    ok = true
-                }
-                if (ok === true) {
-                    if (fields !== '') fields += ','
-                    fields += fieldName
-                }
+            if (!dbTable) {
+                console.log('table ' + table + ' does not exist')
+                return
             }
-
-            logger.debug('commandQuery', table)
-            const dbClient = new DBClient(this.dbManager)
-            let title = 'Table ' + table
-            if (options.where !== undefined) {
-                title += ' where ' + options.where
+            const reply = await inquirer.prompt({ type: 'confirm', name: 'confirm', message: 'Drop table ' + table + '?' })
+            if (reply.confirm && this.dbManager) {
+                await dropTable(table, this.dbManager)
             }
-            dbClient.selectFromTable(title, table,
-                { fields: fields, width: options.width, sort: options.sort || '1', where: options.where })
         }
-        catch (err) {
+        catch(err) {
             logger.error(err)
         }
     }
 }
 
+/**
+ * function dropTable
+ * @param table 
+ * @param dbManager 
+ */
+export async function dropTable(table: string, dbManager: DBManager) {
+    const dbTable = await dbManager.dbTableExist(table)
+    if (dbTable)
+        await dbManager.dbTableDelete(dbTable)
+}
+
+

package/src/TableDataCommand.ts

@@ -0,0 +1,62 @@
+import { Cmd } from "./Cmd";
+import { DBClient } from "./DBClient";
+import { logger } from "./TableCommand";
+
+//--------------------------------------------------------------------------------------------------------------------
+// class TableData
+//--------------------------------------------------------------------------------------------------------------------
+export class TableDataCommand extends Cmd {
+
+    constructor(name: string, description: string) {
+        super(name);
+        this.description(description)
+            .argument('<table>', 'table name')
+            .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.commandData(table, options);
+            });
+    }
+
+    async commandData(table: string, options: any) {
+        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 {
+                    ok = true;
+                }
+                if (ok === true) {
+                    if (fields !== '') fields += ',';
+                    fields += fieldName;
+                }
+            }
+
+            logger.debug('commandQuery', table);
+            const dbClient = new 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);
+        }
+    }
+}

package/src/index.ts

@@ -1,23 +1,129 @@
 #!/usr/bin/env node
-import loglevel from 'loglevel'
 import { Command } from 'commander'
+import * as fs from 'fs'
+import loglevel from 'loglevel'
+import path from 'path'
+import { AssetCommand } from './AssetCommand'
+import { Cmd, spawnCommand } from './Cmd'
+import { InstallCommand } from './InstallCommand'
 import { ModuleCommand } from "./ModuleCommand"
-import { UserCommand } from './UserCommand'
+import { OpenCommand } from './OpenCommand'
 import { QueryCommand } from './QueryCommand'
+import { RunCommand } from './RunCommand'
 import { TableCommand } from './TableCommand'
+import { TableDataCommand } from './TableDataCommand'
 import { TestCommand } from './TestCommand'
-import { RunCommand } from './RunCommand'
-import { InstallCommand } from './InstallCommand'
-import { AssetCommand } from './AssetCommand'
-import { OpenCommand } from './OpenCommand'
 import { UninstallCommand } from './UninstallCommand'
+import { UserCommand } from './UserCommand'
+
 const logger = loglevel.getLogger("index.ts")
 logger.setLevel("debug")
 
+type Orchestrator = 'kubernetes' | 'docker' | undefined
+
+/**
+ * function getOrchestrator
+ */
+function getOrchestrator(): Orchestrator {
+    let result: Orchestrator
+    const cwd = process.cwd()
+    const dockerComposePath = path.join(cwd, 'docker-compose.yml')
+    const k8sPath = path.join(cwd, 'k8s')
+    if (fs.existsSync(dockerComposePath) && fs.statSync(dockerComposePath).isFile()) {
+        result = 'docker'
+    }
+    else if (fs.existsSync(k8sPath) && fs.statSync(k8sPath).isDirectory()) {
+        result = 'kubernetes'
+    }
+    return result
+}
+
+/**
+ * function startServer
+ */
+async function startServer() {
+    try {
+        const orchestrator = getOrchestrator()
+        if (orchestrator === 'docker') {
+            await spawnCommand('docker', ['compose', 'up', '-d'])
+        }
+        if (orchestrator === 'kubernetes') {
+            const portForwardPath = path.join(process.cwd(), 'k8s', 'port-forward')
+            if (!fs.existsSync(portForwardPath) || !fs.statSync(portForwardPath).isFile())
+                throw portForwardPath + ' file not found'
+            const config = JSON.parse(fs.readFileSync(portForwardPath).toString())
+            if (! config.postgres || ! config.nodejs) 
+                throw portForwardPath + ' : file format incorrect'
+            spawnCommand('kubectl', ['port-forward', 'svc/postgres', config.postgres + ':5432'])
+            logger.info('Postgresql proxy at localhost:' + config.postgres)
+            spawnCommand('kubectl', ['port-forward', 'svc/nodejs', config.nodejs + ':3000'])
+            logger.info('Nodejs proxy at localhost:' + config.nodejs)
+        }
+        if (!orchestrator) {
+            logger.error('No cyk server is defined in current folder ' + process.cwd())
+        }
+    }
+    catch (err) {
+        console.error(err)
+    }
+}
+
+/**
+ * function stopServer
+ */
+async function stopServer() {
+    try {
+        const orchestrator = getOrchestrator()
+        if (orchestrator === 'docker') {
+            await spawnCommand('docker', ['compose', 'down'])
+        }
+        if (orchestrator === 'kubernetes') {
+            await spawnCommand('kubectl', ['delete', '-f', path.join(process.cwd(), 'k8s')])
+            logger.info('Kubernetes deployments and services deleted')
+        }
+        if (!orchestrator) {
+            logger.error('No cyk server is defined in current folder ' + process.cwd())
+        }
+    }
+    catch (err) {
+        console.error(err)
+    }
+}
+
+/**
+ * class StartCommand
+ */
+class StartCommand extends Command {
+    constructor(name: string) {
+        super(name)
+        this.description('start cyk server defined in current project folder')
+            .action(async (options: any) => {
+                await startServer()
+            })
+    }
+}
+
+/**
+ * class StopCommand
+ */
+class StopCommand extends Command {
+    constructor(name: string) {
+        super(name)
+        this.description('stop cyk server defined in current project folder')
+            .action(async (options: any) => {
+                await stopServer()
+            })
+    }
+}
+
+/**
+ * Main program
+ */
 const program = new Command()
 program.name('cyk').description('cyklang CLI')
-    .version('0.5.6')
-
+    .version('0.6.0')
+program.addCommand(new StartCommand('start'))
+program.addCommand(new StopCommand('stop'))
 program.addCommand(new InstallCommand('install'))
 program.addCommand(new InstallCommand('i'))
 program.addCommand(new UninstallCommand('uninstall'))
@@ -31,6 +137,8 @@ program.addCommand(new QueryCommand('query'))
 program.addCommand(new QueryCommand('q'))
 program.addCommand(new TableCommand('table'))
 program.addCommand(new TableCommand('t'))
+program.addCommand(new TableDataCommand('data', 'show table data'))
+program.addCommand(new TableDataCommand('d', 'show table data'))
 program.addCommand(new TestCommand())
 program.addCommand(new RunCommand('run'))
 program.addCommand(new RunCommand('r'))