@cyklang/cli 0.5.0 → 0.5.2

package/build/Cmd.d.ts

@@ -13,4 +13,25 @@ export declare class Cmd extends Command {
      * @param options
      */
     updateAuthAccess(tableName: string, prefix: string, id: string, options: any): Promise<void>;
+    /**
+     * method executeCommand
+     * @param command
+     * @returns
+     */
+    executeCommand(command: string): Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    /**
+     * method runShellCommand
+     * @param command
+     */
+    runShellCommand(command: string, args: string[]): Promise<void>;
+    /**
+     *
+     * @param command
+     * @param args
+     * @returns
+     */
+    spawnCommand(command: string, args: string[]): Promise<void>;
 }

package/build/Cmd.js

@@ -10,6 +10,8 @@ const dotenv_1 = __importDefault(require("dotenv"));
 const loglevel_1 = __importDefault(require("loglevel"));
 const NodeCrypto_1 = require("./NodeCrypto");
 const DBClient_1 = require("./DBClient");
+const child_process_1 = require("child_process");
+const kolorist_1 = require("kolorist");
 const logger = loglevel_1.default.getLogger('Cmd.ts');
 logger.setLevel('debug');
 class Cmd extends commander_1.Command {
@@ -24,7 +26,7 @@ class Cmd extends commander_1.Command {
         const structure = new core_1.Structure();
         if (process.env.DBREMOTE_URL === undefined)
             throw 'DBREMOTE_URL undefined';
-        logger.debug('Cmd.DBREMOTE_URL ' + process.env.DBREMOTE_URL);
+        logger.info('Cyk server: ' + process.env.DBREMOTE_URL);
         const nodeCrypto = new NodeCrypto_1.NodeCrypto();
         this.dbRemote = new core_1.DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto);
         const login = await this.dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD);
@@ -82,5 +84,61 @@ class Cmd extends commander_1.Command {
             throw err;
         }
     }
+    /**
+     * method executeCommand
+     * @param command
+     * @returns
+     */
+    executeCommand(command) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.exec)(command, (error, stdout, stderr) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve({ stdout, stderr });
+            });
+        });
+    }
+    /**
+     * method runShellCommand
+     * @param command
+     */
+    async runShellCommand(command, args) {
+        try {
+            await this.spawnCommand(command, args);
+            // console.log(command)
+            // const result = await this.executeCommand(command);
+            // console.log(result.stdout);
+            // if (result.stderr && result.stderr.trim() !== '')
+            //     console.error(result.stderr);
+        }
+        catch (error) {
+            console.error('Error running "' + command + '":', error);
+            throw error;
+        }
+    }
+    /**
+     *
+     * @param command
+     * @param args
+     * @returns
+     */
+    spawnCommand(command, args) {
+        console.log();
+        console.log([command, ...args, '...'].join(' '));
+        const child_process = (0, child_process_1.spawn)(command, args, { stdio: 'inherit' });
+        return new Promise((resolve, reject) => {
+            child_process.on('close', (code) => {
+                if (code === 0) {
+                    console.log((0, kolorist_1.green)('*') + ' ' + [command, ...args].join(' '));
+                    resolve();
+                }
+                else {
+                    reject(new Error([command, ...args].join(' ') + ' --> Error ' + code));
+                }
+            });
+        });
+    }
 }
 exports.Cmd = Cmd;

package/build/InstallCommand.d.ts

@@ -0,0 +1,15 @@
+import { Cmd } from "./Cmd";
+export declare class InstallCommand extends Cmd {
+    constructor(name: string);
+    install(node_package: string, options: any): Promise<void>;
+    /**
+     * method installNodePackage
+     * @param node_package
+     */
+    installNodePackage(node_package: string): Promise<void>;
+    /**
+     * method lookupInstallScript
+     * @param node_package
+     */
+    lookupInstallScript(node_package: string): Promise<string | undefined>;
+}

package/build/InstallCommand.js

@@ -0,0 +1,134 @@
+"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 });
+exports.InstallCommand = void 0;
+const Cmd_1 = require("./Cmd");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const kolorist_1 = require("kolorist");
+const loglevel_1 = __importDefault(require("loglevel"));
+const ModuleCommand_1 = require("./ModuleCommand");
+const logger = loglevel_1.default.getLogger('InstallCommand.ts');
+logger.setLevel('debug');
+class InstallCommand extends Cmd_1.Cmd {
+    constructor(name) {
+        super(name);
+        this.description('npm install and upload xml modules to Cyk server')
+            .argument('<node_package>', 'Node Package installed as dev dependency')
+            .action(async (node_package, options) => {
+            await this.install(node_package, options);
+        });
+    }
+    async install(node_package, options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            /**
+             * install the Node Package
+             */
+            await this.installNodePackage(node_package);
+            const installScript = await this.lookupInstallScript(node_package);
+            if (installScript) {
+                /**
+                 * execute installScript
+                 */
+                const installPath = path.join('node_modules', node_package, 'scripts', installScript);
+                await this.runShellCommand(installPath, []);
+            }
+            else {
+                /**
+                 * default install : upload modules and execute _init.xml
+                 */
+                console.log();
+                console.log('upload modules to server ...');
+                const xmlFolder = path.join('node_modules', node_package, 'xml');
+                if (!fs.existsSync(xmlFolder) || !fs.statSync(xmlFolder).isDirectory()) {
+                    throw 'xml folder not found ( ' + xmlFolder + ' )';
+                }
+                /**
+                 * upload modules to the server
+                 */
+                let initModule;
+                const files = fs.readdirSync(xmlFolder);
+                for (let ind = 0; ind < files.length; ind++) {
+                    const file = files[ind];
+                    await (0, ModuleCommand_1.uploadModule)(path.join(xmlFolder, file), this.dbManager);
+                    if (file.endsWith('_init.xml')) {
+                        initModule = file;
+                    }
+                }
+                console.log((0, kolorist_1.green)('*') + ' upload modules to server');
+                if (initModule) {
+                    const initPath = path.join(xmlFolder, initModule);
+                    await this.runShellCommand('npx', ['cyk', 'run', initPath]);
+                }
+            }
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+    /**
+     * method installNodePackage
+     * @param node_package
+     */
+    async installNodePackage(node_package) {
+        try {
+            await this.runShellCommand('npm', ['install', '--save-dev', node_package]);
+        }
+        catch (error) {
+            console.error('Error installing ' + node_package + ' :', error);
+            throw error;
+        }
+    }
+    /**
+     * method lookupInstallScript
+     * @param node_package
+     */
+    async lookupInstallScript(node_package) {
+        let result;
+        try {
+            const scriptsFolder = path.join('node_modules', node_package, 'scripts');
+            if (fs.existsSync(scriptsFolder) && fs.statSync(scriptsFolder).isDirectory()) {
+                const files = fs.readdirSync(scriptsFolder);
+                for (let ind = 0; ind < files.length; ind++) {
+                    const file = files[ind];
+                    if (file.startsWith('install.')) {
+                        result = file;
+                    }
+                }
+            }
+            return result;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+}
+exports.InstallCommand = InstallCommand;

package/build/ModuleCommand.d.ts

@@ -1,5 +1,12 @@
 #!/usr/bin/env ts-node
+import { DBManager } from "@cyklang/core";
 import { Command } from 'commander';
 export declare class ModuleCommand extends Command {
     constructor(name: string);
 }
+/**
+ *
+ * @param file
+ * @param dbManager
+ */
+export declare function uploadModule(file: string, dbManager: DBManager): Promise<void>;

package/build/ModuleCommand.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.ModuleCommand = void 0;
+exports.uploadModule = exports.ModuleCommand = void 0;
 const core_1 = require("@cyklang/core");
 const fs = __importStar(require("fs"));
 const loglevel_1 = __importDefault(require("loglevel"));
@@ -135,30 +135,7 @@ class ModuleU extends Cmd_1.Cmd {
             else {
                 for (let ind = 0; ind < files.length; ind++) {
                     const file = files[ind];
-                    const dbname = getModuleDBName(file);
-                    const source = fs.readFileSync(file).toString();
-                    const tag = (0, core_1.parseXML)(dbname, source);
-                    const dbModuleExist = await this.dbManager.dbModuleExist(dbname);
-                    if (dbModuleExist === undefined) {
-                        // insert
-                        const dbModule = new core_1.DBModule();
-                        dbModule.source = source;
-                        dbModule.dbname = dbname;
-                        dbModule.access = tag.attributes.ACCESS;
-                        dbModule.description = tag.attributes.DESCRIPTION;
-                        logger.debug('module insert ' + dbname + ' access ' + dbModule.access + ' description ' + dbModule.description);
-                        const id = await this.dbManager.dbModuleInsert(dbModule);
-                        logger.info('module ' + dbname + ' added with ID ' + id);
-                    }
-                    else {
-                        // update
-                        dbModuleExist.source = source;
-                        dbModuleExist.access = tag.attributes.ACCESS;
-                        dbModuleExist.description = tag.attributes.DESCRIPTION;
-                        logger.debug('module update ' + dbname + ' access ' + dbModuleExist.access + ' description ' + dbModuleExist.description);
-                        await this.dbManager.dbModuleUpdate(dbModuleExist);
-                        logger.info('module ' + dbname + ' updated');
-                    }
+                    await uploadModule(file, this.dbManager);
                 }
             }
         }
@@ -167,6 +144,38 @@ class ModuleU extends Cmd_1.Cmd {
         }
     }
 }
+/**
+ *
+ * @param file
+ * @param dbManager
+ */
+async function uploadModule(file, dbManager) {
+    const dbname = getModuleDBName(file);
+    const source = fs.readFileSync(file).toString();
+    const tag = (0, core_1.parseXML)(dbname, source);
+    const dbModuleExist = await dbManager.dbModuleExist(dbname);
+    if (dbModuleExist === undefined) {
+        // insert
+        const dbModule = new core_1.DBModule();
+        dbModule.source = source;
+        dbModule.dbname = dbname;
+        dbModule.access = tag.attributes.ACCESS;
+        dbModule.description = tag.attributes.DESCRIPTION;
+        // logger.debug('module insert ' + dbname + ' access ' + dbModule.access + ' description ' + dbModule.description)
+        const id = await dbManager.dbModuleInsert(dbModule);
+        logger.info('module ' + dbname + ' added with ID ' + id);
+    }
+    else {
+        // update
+        dbModuleExist.source = source;
+        dbModuleExist.access = tag.attributes.ACCESS;
+        dbModuleExist.description = tag.attributes.DESCRIPTION;
+        // logger.debug('module update ' + dbname + ' access ' + dbModuleExist.access + ' description ' + dbModuleExist.description)
+        await dbManager.dbModuleUpdate(dbModuleExist);
+        logger.info('module ' + dbname + ' updated');
+    }
+}
+exports.uploadModule = uploadModule;
 class ModuleDownload extends Cmd_1.Cmd {
     constructor(name, description) {
         super(name);

package/build/OpenCommand.d.ts

@@ -1,5 +1,5 @@
 import { Cmd } from "./Cmd";
 export declare class OpenCommand extends Cmd {
-    constructor();
+    constructor(name: string);
     openBrowser(module: string, options: any): Promise<void>;
 }

package/build/OpenCommand.js

@@ -9,8 +9,8 @@ const loglevel_1 = __importDefault(require("loglevel"));
 const logger = loglevel_1.default.getLogger('OpenCommand.ts');
 logger.setLevel('debug');
 class OpenCommand extends Cmd_1.Cmd {
-    constructor() {
-        super('open');
+    constructor(name) {
+        super(name);
         this.description('open browser').version('0.1')
             .argument('<module>', 'module to execute')
             .action(async (module, options) => {

package/build/RunCommand.d.ts

@@ -1,5 +1,5 @@
 import { Cmd } from "./Cmd";
 export declare class RunCommand extends Cmd {
-    constructor();
+    constructor(name: string);
     runFiles(files: string[], options: any): Promise<void>;
 }

package/build/RunCommand.js

@@ -36,8 +36,8 @@ const Cmd_1 = require("./Cmd");
 loglevel_1.default.setLevel('debug');
 const logger = loglevel_1.default.getLogger('RunCommand.ts');
 class RunCommand extends Cmd_1.Cmd {
-    constructor() {
-        super('run');
+    constructor(name) {
+        super(name);
         this.description('run module').version('0.2')
             .argument('<files...>', 'local module file(s) to run')
             .action(async (files, options) => {

package/build/index.js

@@ -12,7 +12,7 @@ const QueryCommand_1 = require("./QueryCommand");
 const TableCommand_1 = require("./TableCommand");
 const TestCommand_1 = require("./TestCommand");
 const RunCommand_1 = require("./RunCommand");
-const InitCommand_1 = require("./InitCommand");
+const InstallCommand_1 = require("./InstallCommand");
 const AssetCommand_1 = require("./AssetCommand");
 const OpenCommand_1 = require("./OpenCommand");
 const logger = loglevel_1.default.getLogger("index.ts");
@@ -20,7 +20,8 @@ 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 InstallCommand_1.InstallCommand('install'));
+program.addCommand(new InstallCommand_1.InstallCommand('i'));
 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'));
@@ -32,6 +33,8 @@ program.addCommand(new QueryCommand_1.QueryCommand('q'));
 program.addCommand(new TableCommand_1.TableCommand('table'));
 program.addCommand(new TableCommand_1.TableCommand('t'));
 program.addCommand(new TestCommand_1.TestCommand());
-program.addCommand(new RunCommand_1.RunCommand());
-program.addCommand(new OpenCommand_1.OpenCommand());
+program.addCommand(new RunCommand_1.RunCommand('run'));
+program.addCommand(new RunCommand_1.RunCommand('r'));
+program.addCommand(new OpenCommand_1.OpenCommand('open'));
+program.addCommand(new OpenCommand_1.OpenCommand('o'));
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@cyklang/cli",
-   "version": "0.5.0",
+   "version": "0.5.2",
    "description": "cyklang CLI",
    "main": "build/index.js",
    "scripts": {
@@ -22,6 +22,7 @@
       "dotenv": "^16.0.1",
       "form-data": "^4.0.0",
       "inquirer": "^8.2.5",
+      "kolorist": "^1.8.0",
       "loglevel": "^1.8.0",
       "mime-types": "^2.1.35",
       "open": "^9.1.0",

package/src/Cmd.ts

@@ -4,6 +4,9 @@ import dotenv from 'dotenv'
 import loglevel from 'loglevel'
 import { NodeCrypto } from "./NodeCrypto";
 import { DBClient } from "./DBClient";
+import { exec, spawn } from 'child_process';
+import {red, green, bold} from 'kolorist'
+
 const logger = loglevel.getLogger('Cmd.ts')
 logger.setLevel('debug')
 
@@ -23,7 +26,7 @@ export class Cmd extends Command {
 
         const structure = new Structure()
         if (process.env.DBREMOTE_URL === undefined) throw 'DBREMOTE_URL undefined'
-        logger.debug('Cmd.DBREMOTE_URL ' + process.env.DBREMOTE_URL)
+        logger.info('Cyk server: ' + process.env.DBREMOTE_URL)
         const nodeCrypto = new NodeCrypto()
         this.dbRemote = new DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto)
         const login = await this.dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD)
@@ -84,7 +87,7 @@ export class Cmd extends Command {
             </db.update>
             `
 
-            if (! this.dbManager) throw 'prologue() has not been called before'
+            if (!this.dbManager) throw 'prologue() has not been called before'
 
             const dbClient = new DBClient(this.dbManager)
             dbClient.execInstructions(inst)
@@ -94,4 +97,62 @@ export class Cmd extends Command {
             throw err
         }
     }
+
+    /**
+     * method executeCommand
+     * @param command 
+     * @returns 
+     */
+    executeCommand(command: string): Promise<{ stdout: string, stderr: string }> {
+        return new Promise((resolve, reject) => {
+            exec(command, (error, stdout, stderr) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve({ stdout, stderr });
+            });
+        });
+    }
+
+    /**
+     * method runShellCommand
+     * @param command 
+     */
+    async runShellCommand(command: string, args: string[]) {
+        try {
+            await this.spawnCommand(command, args)
+            // console.log(command)
+            // const result = await this.executeCommand(command);
+            // console.log(result.stdout);
+            // if (result.stderr && result.stderr.trim() !== '')
+            //     console.error(result.stderr);
+        } catch (error) {
+            console.error('Error running "' + command + '":', error);
+            throw error
+        }
+    }
+
+    /**
+     * 
+     * @param command 
+     * @param args 
+     * @returns 
+     */
+    spawnCommand(command: string, args: string[]): Promise<void> {
+        console.log()
+        console.log([command, ...args, '...'].join(' '))
+        const child_process = spawn(command, args, { stdio: 'inherit' })
+        return new Promise((resolve, reject) => {
+            child_process.on('close', (code) => {
+                if (code === 0) {
+                    console.log(green('*') + ' ' + [command, ...args].join(' '))
+                    resolve()
+                }
+                else {
+                    reject(new Error([command, ...args].join(' ') + ' --> Error ' + code))
+                }
+            })
+        })
+    }
 }

package/src/InstallCommand.ts

@@ -0,0 +1,113 @@
+import { Cmd } from "./Cmd";
+import * as fs from "fs"
+import * as path from "path"
+import {green, red, bold} from 'kolorist'
+
+import loglevel from 'loglevel'
+import { uploadModule } from "./ModuleCommand";
+const logger = loglevel.getLogger('InstallCommand.ts')
+logger.setLevel('debug')
+
+export class InstallCommand extends Cmd {
+    constructor(name: string) {
+        super(name)
+        this.description('npm install and upload xml modules to Cyk server')
+            .argument('<node_package>', 'Node Package installed as dev dependency')
+            .action(async (node_package: any, options: any) => {
+                await this.install(node_package, options)
+            })
+    }
+
+    async install(node_package: string, options: any) {
+        try {
+            await this.prologue(options)
+            if (this.dbManager === undefined) throw 'dbManager undefined'
+
+            /**
+             * install the Node Package
+             */
+            await this.installNodePackage(node_package)
+
+            const installScript = await this.lookupInstallScript(node_package)
+
+            if (installScript) {
+                /**
+                 * execute installScript
+                 */
+                const installPath = path.join('node_modules',node_package,'scripts',installScript)
+                await this.runShellCommand(installPath, [])
+            }
+            else {
+                /**
+                 * default install : upload modules and execute _init.xml
+                 */
+                console.log()
+                console.log('upload modules to server ...')
+                const xmlFolder = path.join('node_modules', node_package, 'xml')
+                if (!fs.existsSync(xmlFolder) || !fs.statSync(xmlFolder).isDirectory()) {
+                    throw 'xml folder not found ( ' + xmlFolder + ' )'
+                }
+                /**
+                 * upload modules to the server
+                 */
+                let initModule: string | undefined
+                const files = fs.readdirSync(xmlFolder)
+                for (let ind = 0; ind < files.length; ind++) {
+                    const file = files[ind]
+                    await uploadModule(path.join(xmlFolder, file), this.dbManager)
+                    if (file.endsWith('_init.xml')) {
+                        initModule = file
+                    }
+                }
+                console.log(green('*') + ' upload modules to server' )
+                if (initModule) {
+                    const initPath = path.join(xmlFolder, initModule)
+                    await this.runShellCommand('npx', ['cyk', 'run', initPath])
+                }
+            }
+
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+
+    /**
+     * method installNodePackage
+     * @param node_package 
+     */
+    async installNodePackage(node_package: string) {
+
+        try {
+            await this.runShellCommand('npm', ['install', '--save-dev', node_package])
+        } catch (error) {
+            console.error('Error installing ' + node_package + ' :', error);
+            throw error
+        }
+    }
+
+    /**
+     * method lookupInstallScript
+     * @param node_package 
+     */
+    async lookupInstallScript(node_package: string): Promise<string | undefined> {
+        let result: string | undefined
+        try {
+            const scriptsFolder = path.join('node_modules', node_package, 'scripts')
+            if (fs.existsSync(scriptsFolder) && fs.statSync(scriptsFolder).isDirectory()) {
+                const files = fs.readdirSync(scriptsFolder)
+                for (let ind = 0; ind < files.length; ind++) {
+                    const file = files[ind]
+                    if (file.startsWith('install.')) {
+                        result = file
+                    }
+                }
+            }
+            return result
+        }
+        catch (err) {
+            throw err
+        }
+    }
+
+}

package/src/ModuleCommand.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env ts-node
-import { DBModule, parseXML } from "@cyklang/core"
+import { DBManager, DBModule, parseXML } from "@cyklang/core"
 import * as fs from "fs"
 import loglevel from 'loglevel'
 import path from "path"
@@ -115,30 +115,7 @@ class ModuleU extends Cmd {
             else {
                 for (let ind = 0; ind < files.length; ind++) {
                     const file = files[ind]
-                    const dbname = getModuleDBName(file)
-                    const source = fs.readFileSync(file).toString()
-                    const tag = parseXML(dbname, source)
-                    const dbModuleExist = await this.dbManager.dbModuleExist(dbname)
-                    if (dbModuleExist === undefined) {
-                        // insert
-                        const dbModule = new DBModule()
-                        dbModule.source = source
-                        dbModule.dbname = dbname
-                        dbModule.access = tag.attributes.ACCESS
-                        dbModule.description = tag.attributes.DESCRIPTION
-                        logger.debug('module insert ' + dbname + ' access ' + dbModule.access + ' description ' + dbModule.description)
-                        const id = await this.dbManager.dbModuleInsert(dbModule)
-                        logger.info('module ' + dbname + ' added with ID ' + id)
-                    }
-                    else {
-                        // update
-                        dbModuleExist.source = source
-                        dbModuleExist.access = tag.attributes.ACCESS
-                        dbModuleExist.description = tag.attributes.DESCRIPTION
-                        logger.debug('module update ' + dbname + ' access ' + dbModuleExist.access + ' description ' + dbModuleExist.description)
-                        await this.dbManager.dbModuleUpdate(dbModuleExist)
-                        logger.info('module ' + dbname + ' updated')
-                    }
+                    await uploadModule(file, this.dbManager)
                 }
             }
         }
@@ -148,6 +125,38 @@ class ModuleU extends Cmd {
     }
 }
 
+/**
+ * 
+ * @param file 
+ * @param dbManager 
+ */
+export async function uploadModule(file: string, dbManager: DBManager) {
+    const dbname = getModuleDBName(file)
+    const source = fs.readFileSync(file).toString()
+    const tag = parseXML(dbname, source)
+    const dbModuleExist = await dbManager.dbModuleExist(dbname)
+    if (dbModuleExist === undefined) {
+        // insert
+        const dbModule = new DBModule()
+        dbModule.source = source
+        dbModule.dbname = dbname
+        dbModule.access = tag.attributes.ACCESS
+        dbModule.description = tag.attributes.DESCRIPTION
+        // logger.debug('module insert ' + dbname + ' access ' + dbModule.access + ' description ' + dbModule.description)
+        const id = await dbManager.dbModuleInsert(dbModule)
+        logger.info('module ' + dbname + ' added with ID ' + id)
+    }
+    else {
+        // update
+        dbModuleExist.source = source
+        dbModuleExist.access = tag.attributes.ACCESS
+        dbModuleExist.description = tag.attributes.DESCRIPTION
+        // logger.debug('module update ' + dbname + ' access ' + dbModuleExist.access + ' description ' + dbModuleExist.description)
+        await dbManager.dbModuleUpdate(dbModuleExist)
+        logger.info('module ' + dbname + ' updated')
+    }
+}
+
 interface DownloadOptions {
     id: string | undefined
     env: string | undefined

package/src/OpenCommand.ts

@@ -5,8 +5,8 @@ const logger = loglevel.getLogger('OpenCommand.ts')
 logger.setLevel('debug')
 
 export class OpenCommand extends Cmd {
-    constructor() {
-        super('open')
+    constructor(name: string) {
+        super(name)
         this.description('open browser').version('0.1')
             .argument('<module>', 'module to execute')
             .action(async (module: any, options: any) => {

package/src/RunCommand.ts

@@ -8,8 +8,8 @@ loglevel.setLevel('debug')
 const logger = loglevel.getLogger('RunCommand.ts');
 
 export class RunCommand extends Cmd {
-    constructor() {
-        super('run')
+    constructor(name: string) {
+        super(name)
         this.description('run module').version('0.2')
             .argument('<files...>', 'local module file(s) to run')
             .action(async (files: any, options: any) => {

package/src/index.ts

@@ -7,7 +7,7 @@ import { QueryCommand } from './QueryCommand'
 import { TableCommand } from './TableCommand'
 import { TestCommand } from './TestCommand'
 import { RunCommand } from './RunCommand'
-import { InitCommand } from './InitCommand'
+import { InstallCommand } from './InstallCommand'
 import { AssetCommand } from './AssetCommand'
 import { OpenCommand } from './OpenCommand'
 const logger = loglevel.getLogger("index.ts")
@@ -17,7 +17,8 @@ const program = new Command()
 program.name('cyk').description('cyklang CLI')
     .version('0.2')
 
-program.addCommand(new InitCommand('init'))
+program.addCommand(new InstallCommand('install'))
+program.addCommand(new InstallCommand('i'))
 program.addCommand(new AssetCommand('asset', 'manage assets'))
 program.addCommand(new AssetCommand('a', 'manage assets'))
 program.addCommand(new ModuleCommand('module'))
@@ -29,7 +30,9 @@ program.addCommand(new QueryCommand('q'))
 program.addCommand(new TableCommand('table'))
 program.addCommand(new TableCommand('t'))
 program.addCommand(new TestCommand())
-program.addCommand(new RunCommand())
-program.addCommand(new OpenCommand())
+program.addCommand(new RunCommand('run'))
+program.addCommand(new RunCommand('r'))
+program.addCommand(new OpenCommand('open'))
+program.addCommand(new OpenCommand('o'))
 
 program.parse()