@cyklang/cli 0.1.0

package/build/UserCommand.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env ts-node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserCommand = void 0;
+const loglevel_1 = __importDefault(require("loglevel"));
+const commander_1 = require("commander");
+const core_1 = require("@cyklang/core");
+const Cmd_1 = require("./Cmd");
+const DBClient_1 = require("./DBClient");
+const logger = loglevel_1.default.getLogger('UserCommand.ts');
+logger.setLevel('debug');
+class UserCommand extends commander_1.Command {
+    constructor(name) {
+        super(name);
+        this.description('manage users in cyk_user table').version('0.1');
+        this.addCommand(new UserAddCmd());
+        this.addCommand(new UserUpdateCmd('update', 'update user by id all fields except password'));
+        this.addCommand(new UserUpdateCmd('u', 'shortcut for (u)pdate'));
+        this.addCommand(new UserDeleteCmd('delete', 'delete user by id and name. Both options are mandatory to avoid typing error'));
+        this.addCommand(new UserPasswdCmd('passwd', 'change user password'));
+        this.addCommand(new UserListCmd('list', 'list users'));
+        this.addCommand(new UserListCmd('l', 'shortcut for (l)ist'));
+    }
+}
+exports.UserCommand = UserCommand;
+class UserAddCmd extends Cmd_1.Cmd {
+    constructor() {
+        super('add');
+        this.description('add a new user')
+            .requiredOption('-n --name <name>', 'user name')
+            .option('-e --email <email>', 'user email address')
+            .option('-p --passwd <password>', 'initial password')
+            .option('-a --access <acl>', 'access control list')
+            .option('-m --module <module_name>', 'module to launch by default')
+            .option('-d --disable', 'user not abled to connect')
+            .action(async (options) => {
+            const dbUser = new core_1.DBUser();
+            dbUser.name = options.name;
+            dbUser.email = options.email;
+            dbUser.password = options.password;
+            dbUser.access = options.access;
+            dbUser.appli = options.module;
+            dbUser.disable = options.disable || false;
+            await this.commandAdd(dbUser, options);
+        });
+    }
+    async commandAdd(dbUser, options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            const result = await this.dbManager.dbUserInsert(dbUser);
+            logger.debug(result);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
+class UserListCmd extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .option('-s --sort <columns>', 'sort list by column numbers (begins by 0) separated by comma')
+            .action(async (options) => {
+            await this.commandList(options);
+        });
+    }
+    async commandList(options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            const dbClient = new DBClient_1.DBClient(this.dbManager);
+            dbClient.selectFromTable('List of users', 'cyk_user', { fields: 'user_id,user_name,user_email,user_access,user_appli,user_disable', sort: options.sort || '1' });
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
+class UserUpdateCmd extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .requiredOption('-i --id <id>', 'user ID')
+            .option('-n --name <name>', 'user name')
+            .option('-e --email <email>', 'user email address')
+            .option('-a --access <acl>', 'access control list')
+            .option('-m --module <module_name>', 'module to launch by default')
+            .option('-d --disable', 'user not able to connect')
+            .action(async (options) => {
+            const dbUser = new core_1.DBUser();
+            dbUser.id = options.id;
+            dbUser.name = options.name;
+            dbUser.email = options.email;
+            dbUser.access = options.access;
+            dbUser.appli = options.module;
+            dbUser.disable = options.disable;
+            await this.commandUpdate(dbUser, options);
+        });
+    }
+    async commandUpdate(dbUser2, options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            if (dbUser2.id === undefined)
+                throw 'id is missing';
+            const dbUser1 = await this.dbManager.getUser(dbUser2.id);
+            if (dbUser1 === undefined)
+                throw 'user with id ' + dbUser2.id + ' not found';
+            // const dbUser1: DBUser = { id: user.user_id, name: user.user_name, email: user.user_email, password: user.user_password, access: user.user_access, appli: user.user_appli, disable: user.user_disable }
+            if (dbUser2.name !== undefined)
+                dbUser1.name = dbUser2.name;
+            if (dbUser2.email !== undefined)
+                dbUser1.email = dbUser2.email;
+            if (dbUser2.access !== undefined)
+                dbUser1.access = dbUser2.access;
+            if (dbUser2.appli !== undefined)
+                dbUser1.appli = dbUser2.appli;
+            if (dbUser2.disable !== undefined)
+                dbUser1.disable = dbUser2.disable;
+            // logger.debug('dbUser1 before dbUserUpdate : ', dbUser1)
+            await this.dbManager.dbUserUpdate(dbUser1);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
+class UserDeleteCmd extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .requiredOption('-i --id <id>', 'user ID')
+            .requiredOption('-n --name <name>', 'user name')
+            .action(async (options) => {
+            const dbUser = new core_1.DBUser();
+            dbUser.id = options.id;
+            dbUser.name = options.name;
+            await this.commandDelete(dbUser, options);
+        });
+    }
+    async commandDelete(dbUser, options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            if (dbUser.id === undefined || dbUser.name === undefined)
+                throw 'id or name missing';
+            const userExist = await this.dbManager.getUser(dbUser.id);
+            if (userExist === undefined)
+                throw 'user with id ' + dbUser.id + ' not found';
+            if (dbUser.name !== userExist.name)
+                throw 'name ' + dbUser.name + ' different from ' + userExist.name;
+            await this.dbManager.dbUserDelete(dbUser);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
+class UserPasswdCmd extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super('passwd');
+        this.description(description)
+            .requiredOption('-i --id <id>', 'user ID')
+            .requiredOption('-n --name <name>', 'user name')
+            .requiredOption('-p --password <password>', 'new password')
+            .action(async (options) => {
+            const dbUser = new core_1.DBUser();
+            dbUser.id = options.id;
+            dbUser.name = options.name;
+            dbUser.password = options.password;
+            await this.commandPasswd(dbUser, options);
+        });
+    }
+    async commandPasswd(dbUser, options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            // logger.debug(dbUser)
+            if (dbUser.id === undefined || dbUser.name === undefined || dbUser.password === undefined)
+                throw 'id or name or password missing';
+            const userExist = await this.dbManager.getUser(dbUser.id);
+            if (userExist === undefined)
+                throw 'user with id ' + dbUser.id + ' not found';
+            if (dbUser.name !== userExist.name)
+                throw 'name ' + dbUser.name + ' different from ' + userExist.name;
+            await this.dbManager.dbUserPasswd(dbUser.id, dbUser.password);
+            logger.info('password changed for user ' + dbUser.name);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}

package/build/console.d.ts

@@ -0,0 +1,13 @@
+import { XmlError } from '@cyklang/core';
+import { Instruction, InstructionType, Tag } from '@cyklang/core';
+import { Scope } from '@cyklang/core';
+export declare function errorconsole(xmlError: XmlError): void;
+export declare class InputInstructionType extends InstructionType {
+    constructor();
+    parseInstruction(tag: Tag, scope: Scope): Promise<Instruction>;
+}
+export declare class PrintInstructionType extends InstructionType {
+    logfilename: string;
+    constructor(logfilename: string);
+    parseInstruction(tag: Tag, scope: Scope): Promise<Instruction>;
+}

package/build/console.js

@@ -0,0 +1,109 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrintInstructionType = exports.InputInstructionType = exports.errorconsole = void 0;
+const core_1 = require("@cyklang/core");
+const fs = __importStar(require("fs"));
+const core_2 = require("@cyklang/core");
+const core_3 = require("@cyklang/core");
+const loglevel = __importStar(require("loglevel"));
+const logger = loglevel.getLogger('console.ts');
+logger.setLevel('info');
+function errorconsole(xmlError) {
+    if (xmlError.tag !== undefined) {
+        let msg = "\n=============== XmlError at (" + xmlError.tag.filename;
+        if (xmlError.tag.line !== undefined) {
+            msg += ":" + (xmlError.tag.line + 1);
+        }
+        if (xmlError.tag.column !== undefined) {
+            msg += ":" + (xmlError.tag.column + 1);
+        }
+        msg += ") ===============\n";
+        console.log(msg);
+    }
+}
+exports.errorconsole = errorconsole;
+class InputInstructionType extends core_2.InstructionType {
+    constructor() {
+        super("input");
+    }
+    async parseInstruction(tag, scope) {
+        let result = new InputInstruction(tag);
+        return result;
+    }
+}
+exports.InputInstructionType = InputInstructionType;
+class InputInstruction extends core_2.Instruction {
+    constructor(tag) {
+        super(tag);
+    }
+    async execute() {
+        throw new Error("Method not implemented.");
+    }
+    dump() {
+        throw new Error("Method not implemented.");
+    }
+}
+class PrintInstructionType extends core_2.InstructionType {
+    constructor(logfilename) {
+        super("print");
+        this.logfilename = logfilename;
+    }
+    async parseInstruction(tag, scope) {
+        let result = new PrintInstruction(tag, this.logfilename);
+        return result;
+    }
+}
+exports.PrintInstructionType = PrintInstructionType;
+class PrintInstruction extends core_2.Instruction {
+    constructor(tag, logfilename) {
+        super(tag);
+        this.logfilename = logfilename;
+        this.parse(tag);
+    }
+    parse(tag) {
+        this.exprValue = tag.getText();
+    }
+    async execute(scope) {
+        if (this.exprValue !== undefined) {
+            let express = new core_3.Expression(scope);
+            let value;
+            try {
+                value = await express.evaluate(this.exprValue);
+            }
+            catch (err) {
+                console.log(err);
+                throw (new core_1.XmlError("Expression : " + this.exprValue, this.tag));
+            }
+            // logger.debug("print expr " + this.exprValue + " -> " + value?.toString())
+            if (value !== undefined && value !== null) {
+                // console.log("testprint : " + value.toString())
+                fs.appendFileSync(this.logfilename, value.toString() + "\n");
+            }
+            else {
+                console.log(value);
+                //throw (new XmlError("<print> undefined : " + this.exprValue, this.tag))
+            }
+        }
+    }
+    dump() {
+    }
+}

package/build/cykquery.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env ts-node
+export {};

package/build/cykquery.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env ts-node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 cyk_core_1 = require("@cyk-language/cyk-core");
+const fs = __importStar(require("fs"));
+const loglevel_1 = __importDefault(require("loglevel"));
+const path_1 = __importDefault(require("path"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const logger = loglevel_1.default.getLogger("model.ts");
+logger.setLevel("debug");
+dotenv_1.default.config();
+const main = async () => {
+    const structure = new cyk_core_1.Structure();
+    if (process.env.DBREMOTE_URL === undefined)
+        throw 'DBREMOTE_URL undefined';
+    logger.debug('DBREMOTE_URL ' + process.env.DBREMOTE_URL);
+    const dbRemote = new cyk_core_1.DBRemote(structure.scope, process.env.DBREMOTE_URL);
+    const login = await dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD);
+    logger.debug(login);
+    const dbManager = new cyk_core_1.DBManager(structure.scope, dbRemote);
+    await dbManager.initialize();
+    const { command, filepath, basename } = parseCommandLine();
+    const xmlSource = fs.readFileSync(filepath).toString();
+    let tag = parseXmlFile(filepath, basename, xmlSource);
+    if (command === Command.Exec || command === Command.ExecTest) {
+        await executeXml(structure, tag, xmlSource);
+    }
+    if (command === Command.Test || command === Command.ExecTest) {
+        await testQuery(structure, tag.attributes.NAME);
+    }
+};
+main().then(() => logger.debug('finished'));
+var Command;
+(function (Command) {
+    Command["Exec"] = "exec";
+    Command["ExecTest"] = "exectest";
+    Command["Test"] = "test";
+})(Command || (Command = {}));
+function syntax() {
+    console.log(`
+    ----------------------------------------------------------------------------------
+    cykquery executes a <db.query> to the server (DBREMOTE_URL environment variable)
+    syntax :
+    cykquery [ exec | test | exectest ] filename
+    cykquery filename (option exectest by default)
+    ----------------------------------------------------------------------------------
+    `);
+}
+function parseCommandLine() {
+    let command;
+    let filepath;
+    if (process.argv.length < 3 || process.argv.length > 4) {
+        syntax();
+        throw Error('nb of command line arguments : ' + process.argv.length);
+    }
+    if (process.argv.length === 3) {
+        filepath = process.argv[2];
+        command = Command.ExecTest;
+    }
+    else {
+        const option = process.argv[2].toLowerCase();
+        if (option === 'test' || option === 'exec' || option === 'exectest') {
+            command = option;
+        }
+        else {
+            syntax();
+            throw Error('command unknown ' + process.argv[2]);
+        }
+        filepath = process.argv[3];
+    }
+    logger.trace('cykquery filepath : ' + filepath);
+    const basename = path_1.default.basename(filepath);
+    const extname = path_1.default.extname(filepath);
+    logger.trace('basename ' + basename + ', extname ' + extname);
+    if (extname.toLowerCase() !== '.xml') {
+        throw Error('filepath argument ' + filepath + ' should have xml extension');
+    }
+    return { command, filepath, basename };
+}
+function parseXmlFile(filepath, basename, xmlSource) {
+    const tag = (0, cyk_core_1.parseXML)(filepath, xmlSource);
+    if (tag.name !== 'DB.QUERY') {
+        throw Error('tag ' + tag.name + ', should be <db.query>');
+    }
+    const name = tag.attributes.NAME;
+    if (name === undefined) {
+        throw Error('name attribute is missing');
+    }
+    if (basename !== name + '.xml') {
+        throw Error('filename ' + filepath + ' and name ' + name + ' do not correspond');
+    }
+    return tag;
+}
+async function executeXml(structure, tag, xmlSource) {
+    try {
+        logger.debug('executeXml ' + tag.attributes.NAME);
+        // structure.setInstructionType("print", new PrintInstructionType(logfilename))
+        const dbQueryInstructionType = structure.scope.getInstructionType('db.query');
+        if (dbQueryInstructionType === undefined) {
+            throw Error('dbQueryInstructionType not found');
+        }
+        const scopeParse = new cyk_core_1.Scope(structure, structure.scope, undefined);
+        const dbQueryInst = await dbQueryInstructionType.parseInstruction(tag, scopeParse);
+        dbQueryInst.source = xmlSource;
+        const scopeExecute = new cyk_core_1.Scope(structure, structure.scope, undefined);
+        await dbQueryInst.execute(scopeExecute);
+    }
+    catch (err) {
+        logger.error(err);
+    }
+}
+async function testQuery(structure, queryName) {
+    const xmlScript = `
+    <block>
+    <object name='result'/>
+    <db.execute query='${queryName}' result='result' />
+    <print>string(result)</print>
+    </block>
+    `;
+    const script = new cyk_core_1.Script(structure.scope, 'test', xmlScript);
+    await script.parseInstructions();
+    await script.execute();
+}

package/build/cyktable.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env ts-node
+export {};

package/build/cyktable.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env ts-node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 cyk_core_1 = require("@cyk-language/cyk-core");
+const fs = __importStar(require("fs"));
+const loglevel_1 = __importDefault(require("loglevel"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const commander_1 = require("commander");
+const child_process_1 = require("child_process");
+const logger = loglevel_1.default.getLogger("cyktable.ts");
+logger.setLevel("debug");
+const program = new commander_1.Command();
+program.name('cyktable').description('import/export table rows')
+    .version('0.2');
+program.command('export').description('export to CSV file(s)')
+    .argument('<tables...>', 'table(s) to export')
+    .option('-e --env <env>', 'path to the environment variables file')
+    .option('-f --file <file>', 'name of the file to create, defaults to <table_name>.csv')
+    .option('-d --dir <directory>', 'name of the directory where to create exported files')
+    .action(async (tables, options) => commandImportExport('to', tables, options));
+program.command('import').description('export to CSV file(s)')
+    .argument('<tables...>', 'table(s) to export')
+    .option('-e --env <env>', 'path to the environment variables file')
+    .option('-f --file <file>', 'name of the file to create, defaults to <table_name>.csv')
+    .option('-d --dir <directory>', 'name of the directory where to create exported files')
+    .action(async (tables, options) => commandImportExport('from', tables, options));
+const getDBManager = async () => {
+    const structure = new cyk_core_1.Structure();
+    if (process.env.DBREMOTE_URL === undefined)
+        throw 'DBREMOTE_URL undefined';
+    logger.debug('DBREMOTE_URL ' + process.env.DBREMOTE_URL);
+    const dbRemote = new cyk_core_1.DBRemote(structure.scope, process.env.DBREMOTE_URL);
+    const login = await dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD);
+    // logger.debug(login)
+    const dbManager = new cyk_core_1.DBManager(structure.scope, dbRemote);
+    await dbManager.initialize();
+    return dbManager;
+};
+const commandImportExport = async (direction, tables, options) => {
+    logger.debug('tables : ', tables, 'options : ', options);
+    try {
+        const dotenvOutput = dotenv_1.default.config({ path: options.env });
+        if (dotenvOutput.error !== undefined)
+            throw dotenvOutput.error;
+        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';
+        const dbManager = await getDBManager();
+        for (let indi = 0; indi < tables.length; indi++) {
+            const tableName = tables[indi];
+            const dbTable = await dbManager.dbTableExist(tableName);
+            if (dbTable === undefined) {
+                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 = "(";
+                }
+                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 + 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)
+            // })
+        }
+    }
+    catch (err) {
+        logger.error(err);
+    }
+};
+program.parse();

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env ts-node
+export {};

package/build/index.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env ts-node
+"use strict";
+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 ModuleCommand_1 = require("./ModuleCommand");
+const UserCommand_1 = require("./UserCommand");
+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 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 ModuleCommand_1.ModuleCommand('module'));
+program.addCommand(new ModuleCommand_1.ModuleCommand('m'));
+program.addCommand(new UserCommand_1.UserCommand('user'));
+program.addCommand(new UserCommand_1.UserCommand('u'));
+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 TestCommand_1.TestCommand());
+program.addCommand(new RunCommand_1.RunCommand());
+program.parse();

package/build/module.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env ts-node
+export {};