@cyklang/cli 0.1.0

package/src/RunCommand.ts

@@ -0,0 +1,98 @@
+import { Structure, Script, XmlError, DBRemote, DBManager, ModuleInstruction, parseXML } from "@cyklang/core"
+import * as fs from "fs"
+import { errorconsole, PrintInstructionType } from "./console"
+import loglevel from 'loglevel'
+import { NodeCrypto } from "./NodeCrypto"
+import { Cmd } from "./Cmd"
+loglevel.setLevel('debug')
+const logger = loglevel.getLogger('RunCommand.ts');
+
+export class RunCommand extends Cmd {
+    constructor() {
+        super('run')
+        this.description('run module').version('0.2')
+        .argument('<files...>', 'local module file(s) to run')
+        .action(async(files: any, options: any) => {
+            await this.runFiles(files, options)
+        })
+    }
+    async runFiles(files: string[], options: any) {
+        try {
+            await this.prologue(options)
+            for (let ind=0; ind < files.length; ind++) {
+                const result = await runFile(files[ind])
+                // if (result === false) {
+                //     logger.debug('*********** FAILURE ' + process.argv[ind] + ' ***************')
+                // }
+            }
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+}
+
+
+async function runFile(filename: string): Promise<void> {
+    let result: boolean
+
+    if (filename.indexOf(".") !== -1) {
+        filename = filename.substring(0, filename.indexOf("."))
+    }
+
+    let xmlfilename = filename + ".xml"
+    // let logfilename = filename + ".log"
+    // let outfilename = filename + ".output"
+
+    let xml = fs.readFileSync(xmlfilename)
+    
+    // fs.writeFileSync(logfilename, "")
+
+    try {
+        if (process.env.DBREMOTE_URL === undefined) throw 'DBREMOTE_URL undefined'
+        logger.trace('DBREMOTE_URL '+process.env.DBREMOTE_URL)
+        const structure = new Structure()
+        const nodeCrypto = new NodeCrypto()
+        const dbRemote = new DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto)
+        const login = await dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD)
+        const dbManager = new DBManager(structure.scope, dbRemote)
+        await dbManager.initialize()
+        const tag = parseXML(xmlfilename, xml.toString())
+        const moduleInstruction = new ModuleInstruction(tag, dbManager)
+        await moduleInstruction.parse(structure.scope)
+        await moduleInstruction.execute(structure.scope)
+
+        // structure.scope.addInstructionType(new PrintInstructionType(logfilename))
+        // let script = new Script(structure.scope, xmlfilename, xml.toString())
+        // await script.parseInstructions()
+        // await script.execute()
+    }
+    catch (err) {
+
+        if (err instanceof XmlError) {
+            let xmlError = <XmlError>err
+            errorconsole(xmlError)
+        }
+        console.log(err)
+    }
+
+    // let log = fs.readFileSync(logfilename)
+    // if (fs.existsSync(outfilename) === true ) {
+    //     let out = fs.readFileSync(outfilename)
+
+    //     if (log.toString() === out.toString()) {
+    //         console.log("test " + xmlfilename + " SUCCESS")
+    //         result = true
+    //     }
+    //     else {
+    //         console.log("test " + xmlfilename + " FAILURE")
+    //         result = false
+    //     }
+    // }
+    // else {
+    //     console.log("test " + xmlfilename + " output file not found ")
+    //     result = false
+    // }
+
+    // return result
+}

package/src/TableCommand.ts

@@ -0,0 +1,127 @@
+#!/usr/bin/env ts-node
+import { DBManager } from "@cyklang/core"
+import * as fs from "fs"
+import loglevel from 'loglevel'
+import { Command } from "commander"
+import { spawn } from "child_process"
+import { Cmd } from "./Cmd"
+const logger = loglevel.getLogger("TableCommand.ts")
+logger.setLevel("debug")
+
+export class TableCommand extends Command {
+    constructor(name: string) {
+        super(name)
+        this.description('import/export table rows').version('0.1')
+        this.addCommand(new TableExportCmd())
+    }
+}
+
+class TableExportCmd extends Cmd {
+    constructor() {
+        super('export')
+        this.description('export to CSV file(s)')
+        .argument('<tables...>', 'table(s) to export')
+        .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) => this.commandExport( tables, options))
+    }
+    async commandExport(tables: string[], options: Options) {
+        await this.prologue(options)
+        if (this.dbManager === undefined) throw 'dbManager undefined'
+        await commandImportExport(this.dbManager, 'to', tables, options)
+    }
+}
+
+class TableImportCmd extends Cmd {
+    constructor() {
+        super('import')
+        this.description('import from CSV file(s)')
+        .option('-f --file <file>', 'name of the file to import, defaults to <table_name>.csv')
+        .option('-d --dir <directory>', 'name of the directory where to find files to import')
+        .action(async (tables, options) => this.commandImport(tables, options))
+    }
+    async commandImport(tables: string[], options: Options) {
+        await this.prologue(options)
+        if (this.dbManager === undefined) throw 'dbManager undefined'
+        await commandImportExport(this.dbManager, 'from', tables, options)
+    }
+}
+
+interface Options {
+    env: string | undefined
+    file: string | undefined
+    dir: string | undefined
+}
+
+const commandImportExport = async (dbManager: DBManager, direction: 'from' | 'to', tables: string[], options: Options) => {
+    logger.debug('tables : ', tables, 'options : ', options)
+    try {
+
+        if (options.file === undefined && options.dir === undefined) throw '--file or --dir mandatory'
+        if (options.file !== undefined && options.dir !== undefined) throw '--file and --dir are mutually exclusive'
+        if (tables.length === 0) throw 'at least one table name is mandatory'
+        if (tables.length > 1 && options.dir === undefined) throw 'for multiple tables, --dir is mandatory'
+
+        for (let indi = 0; indi < tables.length; indi++) {
+            const tableName = tables[indi]
+            const dbTable = await dbManager.dbTableExist(tableName)
+            if (dbTable === undefined) {
+                logger.info('table ' + tableName + ' not found')
+                continue
+            }
+            let lcols: string | undefined
+            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 = 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)
+    }
+
+
+}
+

package/src/TestCommand.ts

@@ -0,0 +1,98 @@
+import { Structure, Script, XmlError, DBRemote, DBManager } from "@cyklang/core"
+import * as fs from "fs"
+import { errorconsole, PrintInstructionType } from "./console"
+import loglevel from 'loglevel'
+import { NodeCrypto } from "./NodeCrypto"
+import { Cmd } from "./Cmd"
+loglevel.setLevel('debug')
+const logger = loglevel.getLogger('TestCommand.ts');
+
+export class TestCommand extends Cmd {
+    constructor() {
+        super('test')
+        this.description('test script').version('0.1')
+        .argument('<files...>', 'local module file(s) to test run')
+        .action(async(files: any, options: any) => {
+            await this.testRun(files, options)
+        })
+    }
+    async testRun(files: string[], options: any) {
+        try {
+            await this.prologue(options)
+            for (let ind=0; ind < files.length; ind++) {
+                const result = await testfile(files[ind])
+                if (result === false) {
+                    logger.debug('*********** FAILURE ' + process.argv[ind] + ' ***************')
+                }
+            }
+        }
+        catch (err) {
+            logger.error(err)
+        }
+
+    }
+}
+
+
+async function testfile(filename: string): Promise<boolean> {
+    let result: boolean
+
+    if (filename.indexOf(".") !== -1) {
+        filename = filename.substring(0, filename.indexOf("."))
+    }
+
+    let xmlfilename = filename + ".xml"
+    let logfilename = filename + ".log"
+    let outfilename = filename + ".output"
+
+    let xml = fs.readFileSync(xmlfilename)
+
+    
+    fs.writeFileSync(logfilename, "")
+    //console.log(xml.toString())
+    try {
+        if (process.env.DBREMOTE_URL === undefined) throw 'DBREMOTE_URL undefined'
+        logger.trace('DBREMOTE_URL '+process.env.DBREMOTE_URL)
+        const structure = new Structure()
+        const nodeCrypto = new NodeCrypto()
+        const dbRemote = new DBRemote(structure.scope, process.env.DBREMOTE_URL, nodeCrypto)
+        const login = await dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD)
+        //const dbRemote = new DBRemote(structure, 'https://cyk-postgres.herokuapp.com')
+        const dbManager = new DBManager(structure.scope, dbRemote)
+        await dbManager.initialize()
+        structure.scope.addInstructionType(new PrintInstructionType(logfilename))
+        let script = new Script(structure.scope, xmlfilename, xml.toString())
+        await script.parseInstructions()
+        await script.execute()
+        // console.log(JSON.stringify(script.block.toString()))
+    }
+    catch (err) {
+
+        if (err instanceof XmlError) {
+            let xmlError = <XmlError>err
+            errorconsole(xmlError)
+        }
+        console.log(err)
+    }
+
+    let log = fs.readFileSync(logfilename)
+    if (fs.existsSync(outfilename) === true ) {
+        let out = fs.readFileSync(outfilename)
+
+        if (log.toString() === out.toString()) {
+            console.log("test " + xmlfilename + " SUCCESS")
+            result = true
+        }
+        else {
+            console.log("test " + xmlfilename + " FAILURE")
+            result = false
+        }
+    }
+    else {
+        console.log("test " + xmlfilename + " output file not found ")
+        result = false
+    }
+
+
+    return result
+}

package/src/UserCommand.ts

@@ -0,0 +1,203 @@
+#!/usr/bin/env ts-node
+import loglevel from 'loglevel'
+import { Command } from 'commander'
+import { DBUser } from '@cyklang/core'
+import { Cmd } from './Cmd'
+import { DBClient } from './DBClient'
+const logger = loglevel.getLogger('UserCommand.ts')
+logger.setLevel('debug')
+
+export class UserCommand extends Command {
+    constructor(name: string) {
+        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'))
+    }
+}
+
+interface Options {
+    id: string | undefined
+    name: string | undefined
+    email: string | undefined
+    access: string | undefined
+    module: string | undefined
+    password: string | undefined
+    disable: boolean | undefined
+    env: string | undefined
+    sort: string | undefined
+}
+
+class UserAddCmd extends 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: Options) => {
+                const dbUser = new 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: DBUser, options: 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 {
+    constructor(name: string, description: string) {
+        super(name)
+        this.description(description)
+            .option('-s --sort <columns>', 'sort list by column numbers (begins by 0) separated by comma')
+            .action(async (options: Options) => {
+                await this.commandList(options)
+            })
+    }
+    async commandList(options: Options) {
+        try {
+            await this.prologue(options)
+            if (this.dbManager === undefined) throw 'dbManager undefined'
+
+            const dbClient = new 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 {
+    constructor(name: string, description: string) {
+        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: Options) => {
+                const dbUser = new 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: DBUser, options: 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 {
+    constructor(name: string, description: string) {
+        super(name)
+        this.description(description)
+            .requiredOption('-i --id <id>', 'user ID')
+            .requiredOption('-n --name <name>', 'user name')
+            .action(async (options: Options) => {
+                const dbUser = new DBUser()
+                dbUser.id = options.id
+                dbUser.name = options.name
+                await this.commandDelete(dbUser, options)
+            })
+    }
+    async commandDelete(dbUser: DBUser, options: 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 {
+    constructor(name: string, description: string) {
+        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: Options) => {
+                const dbUser = new DBUser()
+                dbUser.id = options.id
+                dbUser.name = options.name
+                dbUser.password = options.password
+                await this.commandPasswd(dbUser, options)
+            })
+    }
+    async commandPasswd(dbUser: DBUser, options: 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/src/console.ts

@@ -0,0 +1,97 @@
+import { XmlError } from '@cyklang/core'
+import * as fs from "fs"
+import { Instruction, InstructionType, Tag } from '@cyklang/core'
+import { Data, Scope } from '@cyklang/core'
+import { Expression } from '@cyklang/core'
+import * as loglevel from "loglevel"
+const logger = loglevel.getLogger('console.ts')
+logger.setLevel('info')
+
+export function errorconsole(xmlError: 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)
+    }
+}
+
+export class InputInstructionType extends InstructionType {
+    constructor() {
+        super("input")
+    }
+    async parseInstruction(tag: Tag, scope: Scope): Promise<Instruction> {
+        let result = new InputInstruction(tag)
+
+        return result
+    }
+}
+
+class InputInstruction extends Instruction {
+    constructor(tag: Tag) {
+        super(tag)
+    }
+
+    async execute() {
+        throw new Error("Method not implemented.")
+    }
+    dump(): void {
+        throw new Error("Method not implemented.")
+    }
+
+}
+
+export class PrintInstructionType extends InstructionType {
+    logfilename: string
+    constructor(logfilename: string) {
+        super("print")
+        this.logfilename = logfilename
+    }
+    async parseInstruction(tag: Tag, scope: Scope): Promise<Instruction> {
+        let result = new PrintInstruction(tag, this.logfilename)
+        return result
+    }
+}
+
+class PrintInstruction extends Instruction {
+    exprValue: string | undefined
+    logfilename: string
+    constructor(tag: Tag, logfilename: string) {
+        super(tag)
+        this.logfilename = logfilename
+        this.parse(tag)
+    }
+    parse(tag: Tag): void {
+        this.exprValue = tag.getText()
+    }
+    async execute(scope: Scope) {
+        if (this.exprValue !== undefined) {
+            let express = new Expression(scope)
+            let value: Data | undefined | null
+            try {
+                value = await express.evaluate(this.exprValue)
+            }
+            catch (err) {
+                console.log(err)
+                throw (new 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/src/index.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env ts-node
+import loglevel from 'loglevel'
+import { Command } from 'commander'
+import { ModuleCommand } from "./ModuleCommand"
+import { UserCommand } from './UserCommand'
+import { QueryCommand } from './QueryCommand'
+import { TableCommand } from './TableCommand'
+import { TestCommand } from './TestCommand'
+import { RunCommand } from './RunCommand'
+import { InitCommand } from './InitCommand'
+const logger = loglevel.getLogger("index.ts")
+logger.setLevel("debug")
+
+const program = new Command()
+program.name('cyk').description('cyklang CLI')
+    .version('0.2')
+
+program.addCommand(new InitCommand('init'))
+program.addCommand(new ModuleCommand('module'))
+program.addCommand(new ModuleCommand('m'))
+program.addCommand(new UserCommand('user'))
+program.addCommand(new UserCommand('u'))
+program.addCommand(new QueryCommand('query'))
+program.addCommand(new QueryCommand('q'))
+program.addCommand(new TableCommand('table'))
+program.addCommand(new TableCommand('t'))
+program.addCommand(new TestCommand())
+program.addCommand(new RunCommand())
+
+program.parse()

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./build",
+    "strict": true,
+    "esModuleInterop": true,
+  },
+  "include": [ "src"]
+}
+