@cyklang/cli 0.1.0

package/src/DBClient.ts

@@ -0,0 +1,220 @@
+import { BasicType, DBColumn, DBExecuteRequest, DBManager, DBTable, ObjectData, parseXML, PrimitiveData } from "@cyklang/core";
+import loglevel from "loglevel";
+const logger = loglevel.getLogger('DBClient.ts')
+logger.setLevel('debug')
+// DBManager wrapper class
+
+export class DBClient {
+    dbManager: DBManager
+    constructor(dbManager: DBManager) {
+        this.dbManager = dbManager
+    }
+
+    async selectFromTable(title: string, tableName: string, options:
+        { fields: string, sort?: string | undefined, where?: string | undefined }) {
+
+        try {
+
+            const objectDataType = this.dbManager.scope.structure.objectDataType;
+            const stringDataType = this.dbManager.scope.structure.stringDataType
+            const request = new DBExecuteRequest()
+            request.selectFromTable = tableName
+
+            request.parameters.addVariable('fields', stringDataType).data = new PrimitiveData(stringDataType, options.fields)
+            request.parameters.addVariable('where', stringDataType).data = new PrimitiveData(stringDataType, options.where)
+            if (options.sort !== undefined) {
+                const colnames = options.fields.split(',')
+                const sortcols = options.sort.split(',')
+                let order_by = ''
+                for (let ind = 0; ind < sortcols.length; ind++ ) {
+                    const coli = sortcols[ind]
+                    const colname = colnames[Number(coli)]
+                    if (order_by !== '') order_by += ','
+                    order_by += colname
+                }
+                logger.debug('order_by '+order_by)
+                request.parameters.addVariable('order_by', stringDataType).data = new PrimitiveData(stringDataType, order_by)
+            }
+
+            // if (options !== undefined) {
+            //     Object.entries(options).forEach(([key, value]) => {
+            //         const data = new PrimitiveData(stringDataType, value)
+            //         request.parameters.addVariable(key, stringDataType).data = data
+            //     })
+            // }
+    
+            const xmlResult = await this.dbManager.dbExecute(request)
+            if (xmlResult === undefined) throw 'xmlResult undefined'
+            const tagXmlResult = parseXML('xmlResult', xmlResult)
+    
+            const objXmlResult = (await objectDataType.parseData(tagXmlResult, this.dbManager.scope)) as ObjectData
+            const objectMeta = (objXmlResult.variables.getData('meta')) as ObjectData
+            if (objectMeta === undefined) throw 'objectMeta not found'
+            const xmlMeta = objectMeta.variables.getString(tableName)
+            if (xmlMeta === undefined) throw 'meta does not have ' + tableName + ' description'
+    
+            const tagDBTable = parseXML('dbTable', xmlMeta)
+            const dbTable = new DBTable(tagDBTable)
+    
+            const fields = options.fields.split(',')
+            const list = new List()
+    
+            for (let ind = 0; ind < fields.length; ind++) {
+                const field = fields[ind]
+                const dbColumn = dbTable.columns.filter((dbColumn) => dbColumn.name === field)[0]
+                if (dbColumn === undefined) throw 'field ' + field + ' not found'
+                list.addDBColumn(dbColumn)
+            }
+    
+            const objDataset = objXmlResult.variables.getData(tableName) as ObjectData
+            for (let ind = 0; ind < objDataset.variables.length(); ind++) {
+                const record = (objDataset.variables.at(ind)?.data as ObjectData)
+                list.addObjectData(record)
+            }
+            logger.info(list.renderList(title))
+            
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+}
+
+class List {
+    columns: Column[] = []
+    rows: Row[] = []
+    lines: string[] = []
+    currentLine: string = ''
+
+    addDBColumn(dbColumn: DBColumn) {
+        const col = new Column(dbColumn.name)
+        col.label = dbColumn.label || dbColumn.name
+        col.dbColumn = dbColumn
+        this.columns.push(col)
+    }
+
+    addObjectData(objectData: ObjectData) {
+        const cells: BasicType[] = []
+        this.columns.forEach((column) => {
+            let cell: BasicType = undefined
+            const data = objectData.variables.getData(column.name)
+            if (data !== undefined && data !== null) {
+                cell = (data as PrimitiveData).value
+            }
+            cells.push(cell)
+        })
+        this.rows.push(new Row(cells))
+    }
+
+    renderList(title: string): string {
+        // calculate column.width
+        let total_width = 0
+        for (let indi = 0; indi < this.columns.length; indi++) {
+            const column = this.columns[indi]
+            column.width = column.label.length
+            this.rows.forEach((row) => {
+                const cell = row.cells[indi]
+                const renderedCell = this.renderCell(cell)
+                if (renderedCell.length > column.width) {
+                    column.width = renderedCell.length
+                }
+            })
+            if (total_width > 0) total_width += 3
+            total_width += column.width
+        }
+
+        // title
+        this.lines.push(this.renderCell(title, total_width, 'center'))
+
+        // header
+        this.lines.push(this.renderHeaderRow())
+        this.lines.push(this.renderSeparator())
+
+        // rows
+        for (let indj = 0; indj < this.rows.length; indj++ ) {
+            const row = this.rows[indj]
+            this.lines.push(this.renderRow(row))
+        }
+        return this.lines.join('\n')
+    }
+
+    renderHeaderRow(): string {
+        let result = ''
+        for (let indi = 0; indi < this.columns.length; indi++ ) {
+            const column = this.columns[indi]
+            if (result !== '') result += ' | '
+            result += this.renderCell(column.label, column.width, 'center')
+        }
+        return result
+    }
+
+    renderRow(row: Row): string {
+        let result = ''
+        for (let indi = 0; indi < this.columns.length; indi++ ) {
+            const column = this.columns[indi]
+            let justify: 'left' | 'right' | 'center' | undefined = 'left'
+            if (column.dbColumn?.dataTypeName === 'number' || column?.type === 'number') {
+                justify = 'right'
+            }
+            if (result !== '') result += ' | '
+            result += this.renderCell(row.cells[indi], column.width, justify)
+        }
+        return result
+    }
+
+    renderSeparator(): string {
+        let result = ''
+        for ( let indi = 0; indi < this.columns.length; indi++ ) {
+            const column = this.columns[indi]
+            if (result !== '') result += '-+-'
+            result += '-'.repeat(column.width)
+        }
+        return result
+    }
+
+    renderCell(value: BasicType, width?: number | undefined, justify?: 'left' | 'right' | 'center' | undefined): string {
+        let result: string
+        if (value === undefined) {
+            result = ''
+        }
+        else if (value === null) {
+            result = 'null'
+        }
+        else {
+            result = value.toString()
+        }
+        if (width !== undefined && result.length < width) {
+            if (justify === undefined || justify === 'left') {
+                result += ' '.repeat(width - result.length)
+            }
+            else if (justify === 'right') {
+                result = ' '.repeat(width - result.length) + result
+            }
+            else {
+                // justify === center
+                const before = Math.floor((width - result.length) / 2)
+                result = ' '.repeat(before) + result + ' '.repeat(width - result.length - before)
+            }
+        }
+        return result
+    }
+}
+
+class Column {
+    name: string;
+    label: string = '';
+    dbColumn: DBColumn | undefined;
+    type?: string | undefined;
+    computed?: string | undefined;
+    width: number = 0
+    constructor(name: string) {
+        this.name = name
+    }
+}
+
+class Row {
+    cells: BasicType[]
+    constructor(cells: BasicType[]) {
+        this.cells = cells
+    }
+}

package/src/InitCommand.ts

@@ -0,0 +1,107 @@
+import { Command } from "commander";
+import * as fs from 'fs'
+import { getLogger } from "loglevel";
+const logger = getLogger('InitCommand.ts')
+
+logger.setLevel('debug')
+
+export class InitCommand extends Command {
+    constructor(name: string) {
+        super(name)
+        this.description('initialize a folder with files necessary for a cyklang project')
+            .action(async (options: any) => {
+                await this.commandInit(options)
+            })
+    }
+    async commandInit(options: any) {
+        try {
+            await this.writeEnvFile()
+            await this.writeDockerComposeFile()
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+
+    // developer.mozilla.org Math.random()
+    // On renvoie un entier aléatoire entre une valeur min (incluse)
+    // et une valeur max (exclue).
+    // Attention : si on utilisait Math.round(), on aurait une distribution
+    // non uniforme !
+    
+    getRandomInt(min: number, max: number) {
+        min = Math.ceil(min);
+        max = Math.floor(max);
+        return Math.floor(Math.random() * (max - min)) + min;
+    }
+
+    generateToken(): string {
+        let result = ''
+        for (let ind = 0; ind < 32; ind++ ) {
+            result += this.getRandomInt(0,15).toString(16)
+        }
+        return result
+    }
+
+    async writeEnvFile() {
+        const envFilename = '.env'
+        if (fs.existsSync(envFilename) === true) {
+            logger.info(envFilename + ' file already exists. Remove it before launching init command')
+            return
+        }
+        Math.random()
+        const content = `# PostgreSql connection
+# used by psql command line utility
+PGHOST="localhost"
+PGPORT="4321"
+PGUSER="postgres"
+PGPASSWORD="postgres"
+
+# at postgresql database initialization
+
+# POSTGRES_USER="postgres"
+POSTGRES_PASSWORD="postgres"
+
+# admin user
+# created at database initialization
+ADMIN_NAME=cyk
+ADMIN_PASSWORD=cyk
+ADMIN_EMAIL=my-email@my-domain
+
+# JWT token generation
+# e.g. https://www.allkeysgenerator.com
+# 128 bits Hex 
+
+SECRET_TOKEN="${this.generateToken()}"
+SECRET_RTOKEN="${this.generateToken()}"
+
+# Login Page Config
+LOGIN_IMAGE="https://media.smartbox.com/pim/1000001967971201770883.jpg?thumbor=800x0/filters:quality(90)"
+LOGIN_TITLE="CYK Framework"
+LOGIN_SUBTITLE="Une application pilote du framework CYK"
+LOGIN_APPLI="accounting"
+
+# credential used by cyk CLI
+
+USER_NAME=cyk
+USER_PASSWORD=cyk
+CYK_PORT="3000"
+DBREMOTE_URL="http://localhost:3000"        
+`
+        fs.writeFileSync(envFilename, content)
+        logger.debug('created ' + envFilename)
+    }
+
+    async writeDockerComposeFile() {
+        const dockerComposeFilename = 'docker-compose.yml'
+        if (fs.existsSync(dockerComposeFilename) === true) {
+            logger.info(dockerComposeFilename + ' already exists. Remove it before launching init command')
+            return
+        }
+
+        const modelFilename = __dirname + '/../' + dockerComposeFilename
+        const content = fs.readFileSync(modelFilename)
+        fs.writeFileSync(dockerComposeFilename, content)
+        logger.debug('created ' + dockerComposeFilename)
+    }
+}

package/src/ModuleCommand.ts

@@ -0,0 +1,192 @@
+#!/usr/bin/env ts-node
+import { DBModule, parseXML } from "@cyklang/core"
+import * as fs from "fs"
+import loglevel from 'loglevel'
+import path from "path"
+import { Command } from 'commander'
+import { Cmd } from "./Cmd"
+import { DBClient } from "./DBClient"
+const logger = loglevel.getLogger("ModuleCommand.ts")
+logger.setLevel("debug")
+
+export class ModuleCommand extends Command {
+    constructor(name: string) {
+        super(name)
+        this.description('manage modules')
+        // upload
+        this.addCommand(new ModuleUpload('upload', `Upload local module file(s) to the database.
+Module name is the base name of the file. If a module with the same name already exists, it will be updated.
+Otherwise, a new module is inserted in the database. To rename a module, use option --id to indicate the module you want to rename`)
+        )
+        this.addCommand(new ModuleUpload('u', 'shortcut for (u)pload'))
+        // download
+        this.addCommand(new ModuleDownload('download', 'download module files to the current directory'))
+        this.addCommand(new ModuleDownload('d', 'shortcut for (d)ownload'))
+        // list
+        this.addCommand(new ModuleList('list', 'List modules'))
+        this.addCommand(new ModuleList('l', 'shortcut for (l)ist'))
+        // rename
+
+    }
+}
+
+function getModuleDBName(filePath: string): string {
+    let result
+    if (filePath.endsWith('.xml') === false) throw filePath + ' does not have .xml extension'
+    result = path.basename(filePath, '.xml')
+    const identifierRegex = /^[_a-zA-Z][_a-zA-Z0-9]*$/
+    if (result.match(identifierRegex) === null) throw 'filename ' + result + ' does not match identifier syntax'
+    return result
+}
+interface UploadOptions {
+    id: string | undefined
+    env: string | undefined
+}
+class ModuleUpload extends Cmd {
+    constructor(name: string, description: string) {
+        super(name)
+        this.description(description)
+            .option('-i --id <id>', 'module ID to download')
+            .argument('[files...]', 'local module file(s) to upload to the server')
+            .action(async (files: any, options: any) => {
+                await this.commandUpload(files, options)
+            })
+    }
+    async commandUpload(files: string[], options: UploadOptions) {
+        try {
+            await this.prologue(options)
+            if (this.dbManager === undefined) throw 'dbManager undefined'
+
+            if (files.length === 0) throw 'file(s) argument is missing'
+            if (options.id !== undefined) {
+                if (files.length > 1) throw 'with --id option you can only specify 1 local file'
+                const dbModule = await this.dbManager.getModule(options.id)
+                dbModule.source = fs.readFileSync(files[0]).toString()
+                dbModule.dbname = getModuleDBName(files[0])
+                const tag = parseXML(dbModule.dbname, dbModule.source)
+                dbModule.access = tag.attributes.ACCESS
+                dbModule.description = tag.attributes.DESCRIPTION
+                await this.dbManager.dbModuleUpdate(dbModule)
+            }
+            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.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')
+                    }
+                }
+            }
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+}
+
+interface DownloadOptions {
+    id: string | undefined
+    env: string | undefined
+    all: string | undefined
+}
+class ModuleDownload extends Cmd {
+    constructor(name: string, description: string) {
+        super(name)
+        this.description(description)
+            .option('-i --id <id>', 'module ID')
+            .option('-a --all', 'download all the modules')
+            .argument('[files...]', 'module(s) name(s) are derived as the basename(s) of the file(s) path')
+            .action(async (files: string[], options: DownloadOptions) => {
+                await this.commandDownload(files, options)
+            })
+    }
+    async commandDownload(files: string[], options: DownloadOptions) {
+        try {
+            await this.prologue(options)
+            if (this.dbManager === undefined) throw 'dbManager undefined'
+
+            if (options.id !== undefined) {
+                const dbModule = await this.dbManager.getModule(options.id)
+                await this.downloadModule(dbModule.dbname || '', dbModule)
+            }
+            else if (options.all !== undefined) {
+                const modules = await this.dbManager.getModules(undefined)
+                for (let ind = 0; ind < modules.length; ind++) {
+                    const dbModule = modules[ind]
+                    await this.downloadModule(dbModule.dbname || '', dbModule)
+                }
+            }
+            else {
+                for (let ind = 0; ind < files.length; ind++) {
+                    await this.downloadModule(getModuleDBName(files[ind]))
+                }
+            }
+
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+
+    async downloadModule(dbname: string, dbModule?: DBModule) {
+        logger.debug('downloadModule ' + dbname)
+        if (dbModule === undefined) {
+            dbModule = await this.dbManager?.dbModuleExist(dbname)
+            if (dbModule === undefined) throw 'module not found : ' + dbname
+        }
+        const filePath = dbname + '.xml'
+        if (fs.existsSync(filePath) === true) {
+            logger.info('file ' + filePath + ' already exists and will not be overwritten ')
+        }
+        else {
+            fs.writeFileSync(filePath, dbModule.source || '')
+            logger.info('module ' + dbname + ' has been downloaded and file ' + filePath + ' has been created')
+        }
+    }
+}
+
+class ModuleList 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: any) => {
+                await this.commandList(options)
+            })
+    }
+
+    async commandList(options: any) {
+        try {
+            await this.prologue(options)
+            if (this.dbManager === undefined) throw 'dbManager undefined'
+
+            const dbClient = new DBClient(this.dbManager)
+            dbClient.selectFromTable('List of Modules', 'cyk_module',
+                { fields: 'module_id,module_dbname,module_access,module_description', sort: options.sort || '1' })
+
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+}
+

package/src/NodeCrypto.ts

@@ -0,0 +1,60 @@
+import { createCipheriv, createDecipheriv, randomBytes } from 'crypto'
+import { getLogger } from 'loglevel'
+import { CryptoEngine } from '@cyklang/core'
+import { cipherKey } from '@cyklang/core'
+import pako from 'pako'
+import { TextDecoder } from 'util'
+const logger = getLogger('NodeCrypto.ts')
+logger.setLevel('debug')
+
+const algorithm = 'aes-128-cbc'
+const iv_length = 16
+
+export class NodeCrypto implements CryptoEngine {
+
+    // last_iv: Buffer | undefined
+
+    async encrypt(plain: string): Promise<string> {
+
+        const deflatedData = pako.deflate(plain)
+        // logger.debug('deflatedData : ', deflatedData[0], deflatedData[1])
+        const iv: Buffer = randomBytes(iv_length)
+        // this.last_iv = iv
+
+        // logger.debug("encrypt iv " + iv.toString('hex'))
+
+        const cipher = createCipheriv(algorithm, cipherKey, iv)
+        let result = cipher.update(deflatedData, undefined, "hex")
+        result += cipher.final("hex")
+        result += iv.toString('hex')
+
+        return result
+    }
+
+    async decrypt(encoded: string): Promise<string> {
+
+        const iv_hex = encoded.substring(encoded.length - 2 * iv_length)
+        const encryptedData = encoded.substring(0, encoded.length - 2 * iv_length)
+
+        // logger.debug("decrypt iv " + iv_hex)
+        const iv = Buffer.from(iv_hex, 'hex')
+
+        // if (this.last_iv === undefined) throw 'last_iv undefined'
+        // if (Buffer.compare(iv, this.last_iv) !== 0) throw 'iv and last_iv are different'
+
+        const decipher = createDecipheriv(algorithm, cipherKey, iv)
+        let deflatedData1 = decipher.update(encryptedData, 'hex')
+        
+        const deflatedData2 = decipher.final()
+        const deflatedData = Buffer.concat([deflatedData1, deflatedData2])
+
+        let inflatedData = deflatedData
+        if (deflatedData[0] === 0x78 && deflatedData[1] === 0x9c) {
+            inflatedData = Buffer.from(pako.inflate(deflatedData))
+        }
+
+        const result = (new TextDecoder()).decode(inflatedData)
+        return result
+    }
+}
+

package/src/QueryCommand.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env ts-node
+import { Script, Structure, DBRemote, DBManager, DBQueryInstruction, parseXML, Tag, Scope } from "@cyklang/core"
+import * as fs from "fs"
+import loglevel from 'loglevel'
+import { Cmd } from './Cmd'
+import { Command } from 'commander'
+const logger = loglevel.getLogger("QueryCommand.ts")
+logger.setLevel("debug")
+
+export class QueryCommand extends Command {
+    constructor(name: string) {
+        super(name)
+    }
+}
+
+function parseXmlFile(filepath: string, basename: string, xmlSource: string): Tag {
+    const tag = 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: Structure, tag: Tag, xmlSource: string) {
+    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 Scope(structure, structure.scope, undefined)
+        const dbQueryInst = <DBQueryInstruction>await dbQueryInstructionType.parseInstruction(tag, scopeParse)
+        dbQueryInst.source = xmlSource
+        const scopeExecute = new Scope(structure, structure.scope, undefined)
+        await dbQueryInst.execute(scopeExecute)
+    }
+    catch (err) {
+        logger.error(err)
+    }
+}
+
+async function testQuery(structure: Structure, queryName: string) {
+    const xmlScript = `
+    <block>
+    <object name='result'/>
+    <db.execute query='${queryName}' result='result' />
+    <print>string(result)</print>
+    </block>
+    `
+    const script = new Script(structure.scope, 'test', xmlScript)
+    await script.parseInstructions()
+    await script.execute()
+}