@cyklang/cli 0.2.3 → 0.3.1

package/src/AssetCommand.ts

@@ -19,7 +19,7 @@ export class AssetCommand extends Command {
         this.description(description)
         this.addCommand(new AssetList('list', 'list assets'))
         this.addCommand(new AssetList('l', '(l)ist assets'))
-        this.addCommand(new AssetUpload('upload', 'upload assets from current directory'))
+        this.addCommand(new AssetUpload('upload', 'upload assets from sources'))
         this.addCommand(new AssetUpload('u', '(u)pload assets'))
     }
 }
@@ -38,7 +38,7 @@ class AssetList extends Cmd {
 
             const dbClient = new DBClient(this.dbManager)
             dbClient.selectFromTable('List of Assets', 'cyk_asset',
-                { fields: 'asset_id,asset_route,asset_last_update,asset_mimetype', sort: options.sort || '1' }
+                { fields: 'asset_id,asset_route,asset_auth,asset_access,asset_mimetype,asset_last_update', sort: options.sort || '1' }
             )
         }
         catch (err) {
@@ -54,13 +54,16 @@ class AssetList extends Cmd {
 interface FileDescriptor {
     path: string
     mtime: Date
+    id?: number
 }
 class AssetUpload extends Cmd {
 
     constructor(name: string, description: string) {
         super(name)
         this.description(description)
-            .option('-d --dest <destination>', 'route of destination')
+            .option('-a --auth <auth_schema>', 'authentication schema : basic | token | any, default is no authentication')
+            .option('-d --dest <destination>', 'destination path, directory name')
+            .option('-c --clean', 'clean destination path before uploading')
             .option('-y --yes', 'upload list is automatically confirmed')
             .argument('[sources...]', 'local files or directories to upload as assets to the server')
             .action(async (sources: any, options: any) => {
@@ -87,11 +90,21 @@ class AssetUpload extends Cmd {
 
             if (sources.length === 0) throw 'no source to upload'
 
+            if ( options.auth && ' basic | token | any '.indexOf(options.auth) === -1 ) {
+                throw 'valid authentication schemas are : basic | token | any'
+            }
+            logger.debug('options : ', options)
+            logger.debug('auth : ' + options.auth)
+
             let dest = "/"
             if (options.dest !== undefined) dest = options.dest
             if (dest.substring(0, 1) !== '/') dest = '/' + dest
             if (dest.substring(dest.length - 1) !== '/') dest = dest + '/'
 
+            if (options.clean) {
+                await this.cleanDestination(dest)
+            }
+
             for (let ind = 0; ind < sources.length; ind++) {
                 const source = sources[ind]
                 if (fs.existsSync(source) === false) throw 'source ' + source + ' does not exist'
@@ -102,7 +115,7 @@ class AssetUpload extends Cmd {
                 else if (filestat.isFile() === true) {
                     const base = path.parse(source).base
                     logger.debug('upload file ' + source + ' to ' + dest + base)
-                    await this.uploadAsset({ path: source, mtime: filestat.mtime }, dest + base)
+                    await this.uploadAsset({ path: source, mtime: filestat.mtime }, dest + base, options.auth)
                 }
             }
         }
@@ -111,6 +124,22 @@ class AssetUpload extends Cmd {
         }
     }
 
+    //----------------------------------------------------------------------------------------------
+    // cleanDestination
+    //----------------------------------------------------------------------------------------------
+
+    async cleanDestination(dest: string) {
+
+        const remoteList = await this.scanAssets()
+        for(let ind = 0; ind < remoteList.length; ind++) {
+            const fd = remoteList[ind]
+            if (fd.path.startsWith(dest)) {
+                const url = '/api/admin/assets/' + fd.id
+                await this.dbRemote?.apiServer.delete(url)
+            }
+        }
+    }
+
     //----------------------------------------------------------------------------------------------
     // uploadDirectory
     //----------------------------------------------------------------------------------------------
@@ -131,8 +160,7 @@ class AssetUpload extends Cmd {
 
         this.scanDir(dirName, localList)
 
-        const remoteList: FileDescriptor[] = []
-        await this.scanAssets(remoteList)
+        const remoteList = await this.scanAssets()
 
         const uploadList = this.buildUploadList(dirName, dest, localList, remoteList)
 
@@ -147,7 +175,7 @@ class AssetUpload extends Cmd {
         }
 
         if (uploadConfirmed === true) {
-            await this.uploadFiles(dirName, uploadList, dest)
+            await this.uploadFiles(dirName, uploadList, dest, options.auth)
         }
 
         // const rl = readline.createInterface(process.stdin, process.stdout)
@@ -193,8 +221,8 @@ class AssetUpload extends Cmd {
     // scanAssets
     //----------------------------------------------------------------------------------------------
 
-    async scanAssets(result: FileDescriptor[]) {
-
+    async scanAssets() {
+        const result: FileDescriptor[] = []
         if (this.dbManager === undefined) throw 'dbManager undefined'
         const dbReq = new DBExecuteRequest()
         dbReq.selectFromTable = 'cyk_asset'
@@ -208,11 +236,13 @@ class AssetUpload extends Cmd {
         for (let ind = 0; ind < rows.list.length; ind++) {
             const { variable: row } = rows.list[ind]
             const record = row.data as ObjectData
+            const asset_id = (record.variables.getData('asset_id') as PrimitiveData).value as number
             const asset_route = (record.variables.getData('asset_route') as PrimitiveData).value as string
-            const asset_last_update = (record.variables.getData('asset_last_update') as PrimitiveData).value as Date
+            const asset_last_update = (record.variables.getData('asset_last_update') as PrimitiveData)?.value as Date
             // logger.debug('asset_route ' + asset_route,'asset_last_update ' + asset_last_update)
-            result.push({ path: asset_route, mtime: asset_last_update })
+            result.push({ path: asset_route, mtime: asset_last_update, id: asset_id })
         }
+        return result
     }
 
     //----------------------------------------------------------------------------------------------
@@ -258,12 +288,12 @@ class AssetUpload extends Cmd {
     // uploadFiles
     //----------------------------------------------------------------------------------------------
 
-    async uploadFiles(dirName: string, uploadList: FileDescriptor[], dest: string) {
+    async uploadFiles(dirName: string, uploadList: FileDescriptor[], dest: string, auth: string | undefined) {
         for (let ind = 0; ind < uploadList.length; ind++) {
             const upload = uploadList[ind]
             const route = dest + upload.path.substring(dirName.length)
             logger.debug('upload ' + upload.path + ' to ' + route)
-            await this.uploadAsset(upload, route)
+            await this.uploadAsset(upload, route, auth)
         }
     }
 
@@ -271,8 +301,8 @@ class AssetUpload extends Cmd {
     // uploadAsset
     //----------------------------------------------------------------------------------------------
 
-    async uploadAsset(upload: FileDescriptor, route: string) {
-        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + this.mimetypeLookup(upload.path))
+    async uploadAsset(upload: FileDescriptor, route: string, auth?: string) {
+        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + this.mimetypeLookup(upload.path) + ', auth : ' + auth)
 
         try {
             let dbAsset: DBAsset | undefined = await this.dbManager?.dbAssetExist(route)
@@ -283,7 +313,8 @@ class AssetUpload extends Cmd {
             if (mimetype === false) throw 'mimetype false for ' + upload
             dbAsset.mimetype = mimetype
             dbAsset.route = route
-
+            dbAsset.auth = auth
+            
             // const fstat = fs.statSync(fileName)
             dbAsset.last_update = upload.mtime
 
@@ -318,7 +349,7 @@ class AssetUpload extends Cmd {
             const form = new FormData()
             form.append('uploadFile', file)
 
-            const route = '/upload/cyk_asset/asset_content?asset_id=' + dbAsset.id
+            const route = '/api/upload/cyk_asset/asset_content?asset_id=' + dbAsset.id
             const resp = await this.dbRemote?.apiServer.post(route, form)
             if (resp.status === 200) {
                 logger.info(fileName + ' uploaded')

package/src/Cmd.ts

@@ -1,4 +1,4 @@
-import { DBManager, DBRemote, Structure } from "@cyklang/core";
+import { DBManager, DBRemote, SigninResponse, Structure } from "@cyklang/core";
 import { Command } from "commander";
 import dotenv from 'dotenv'
 import loglevel from 'loglevel'
@@ -14,27 +14,25 @@ export class Cmd extends Command {
         super(name);
         this.option('--env <env>', 'path to the environment variables file')
     }
- 
-    async prologue(options: any) {
-
-        try {
-            const dotenvOutput = dotenv.config({path: options.env})
-            if (dotenvOutput.error !== undefined) throw dotenvOutput.error
-    
-            const structure = new Structure()
-            if (process.env.DBREMOTE_URL === undefined) throw 'DBREMOTE_URL undefined'
-            logger.debug('Cmd.DBREMOTE_URL ' + 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)
-            // logger.debug(login)
-            
-            this.dbManager = new DBManager(structure.scope, this.dbRemote)
-            await this.dbManager.initialize()
-        }
-        catch (err) {
-            logger.error(err)
-        }
+
+    async prologue(options: any): Promise<SigninResponse> {
+
+        const dotenvOutput = dotenv.config({ path: options.env })
+        if (dotenvOutput.error !== undefined) throw dotenvOutput.error
+
+        const structure = new Structure()
+        if (process.env.DBREMOTE_URL === undefined) throw 'DBREMOTE_URL undefined'
+        logger.debug('Cmd.DBREMOTE_URL ' + 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)
+        // logger.debug(login)
+
+        this.dbManager = new DBManager(structure.scope, this.dbRemote)
+        await this.dbManager.initialize()
+
+        return login
+
 
     }
 }

package/src/DBClient.ts

@@ -10,6 +10,10 @@ export class DBClient {
         this.dbManager = dbManager
     }
 
+    async runQuery() {
+
+    }
+    
     async selectFromTable(title: string, tableName: string, options:
         { fields: string, sort?: string | undefined, where?: string | undefined, width?: string | undefined }) {
 
@@ -232,6 +236,10 @@ class List {
         else {
             result = value.toString()
         }
+
+        // replace \n with a space
+        result = result.replace(/\n/, ' ') 
+
         if (width !== undefined && width !== 0) {
             if (result.length >= width) {
                 result = result.substring(0, width)

package/src/ModuleCommand.ts

@@ -37,7 +37,7 @@ function getModuleDBName(filePath: string): string {
     // result = path.basename(filePath, '.xml')
 
     const result = path.parse(filePath).name
-    const identifierRegex = /^[_a-zA-Z][_a-zA-Z0-9]*$/
+    const identifierRegex = /^[_a-zA-Z][-_a-zA-Z0-9]*$/
     if (result.match(identifierRegex) === null) throw 'filename ' + result + ' does not match identifier syntax'
     return result
 }
@@ -185,7 +185,7 @@ class ModuleList extends Cmd {
 
             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' })
+                { fields: 'module_id,module_dbname,module_auth,module_access,module_description', sort: options.sort || '1' })
 
         }
         catch (err) {

package/src/QueryCommand.ts

@@ -4,59 +4,76 @@ import * as fs from "fs"
 import loglevel from 'loglevel'
 import { Cmd } from './Cmd'
 import { Command } from 'commander'
+import { DBClient } from "./DBClient"
 const logger = loglevel.getLogger("QueryCommand.ts")
 logger.setLevel("debug")
 
 export class QueryCommand extends Command {
     constructor(name: string) {
         super(name)
+        this.description('query management')
+        this.addCommand(new QueryList('list', 'list queries'))
+        this.addCommand(new QueryList('l', 'list queries'))
     }
 }
 
-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')
+//--------------------------------------------------------------------------------------------------------------------
+// class TableList
+//--------------------------------------------------------------------------------------------------------------------
+
+class QueryList extends Cmd {
+    constructor(name: string, description: string) {
+        super(name)
+        this.description(description)
+            .option('-s --sort <columns>', 'sort list by column numbers (begins with 0) separated by comma')
+            .action(async (options: any) => {
+                await this.commandList(options)
+            })
     }
-    if (basename !== name + '.xml') {
-        throw Error('filename ' + filepath + ' and name ' + name + ' do not correspond')
+
+    async commandList(options: any) {
+        await this.prologue(options)
+        if (this.dbManager === undefined) throw 'dbManager undefined'
+
+        const dbClient = new DBClient(this.dbManager)
+        dbClient.selectFromTable('List of Queries', 'cyk_query',
+            { fields: 'query_id,query_name,query_auth,query_access,query_description', sort: options.sort || '1' }
+        )
     }
-    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)
+
+//--------------------------------------------------------------------------------------------------------------------
+// class queryData
+//--------------------------------------------------------------------------------------------------------------------
+
+class queryData extends Cmd {
+
+    constructor(name: string, description: string) {
+        super(name)
+        this.description(description)
+            .argument('<query>', 'query name')
+            .option('--where <clause_where_sql>', 'criteria in SQL syntax')
+            .option('-s --sort <columns>', 'sort by columns positions (begins by 0) separated by comma')
+            .option('-w --width <colwidth>', 'columns widths separated by comma')
+            .action(async (query, options) => {
+                this.commandData(query, options)
+            })
     }
-}
 
-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()
+    async commandData(query: string, options: any) {
+        try {
+            await this.prologue(options)
+            if (this.dbManager === undefined) throw 'dbManager undefined'
+
+            const dbQuery = await this.dbManager.dbQueryExist(query)
+            if (dbQuery === undefined) throw 'query ' + query + ' not found'
+
+            //DBClient
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
 }

package/src/RunCommand.ts

@@ -1,4 +1,4 @@
-import { Structure, Script, XmlError, DBRemote, DBManager, ModuleInstruction, parseXML } from "@cyklang/core"
+import { Structure, Script, XmlError, DBRemote, DBManager, ModuleInstruction, parseXML, MapData } from "@cyklang/core"
 import * as fs from "fs"
 import { errorconsole, PrintInstructionType } from "./console"
 import loglevel from 'loglevel'
@@ -11,15 +11,15 @@ 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)
-        })
+            .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++) {
+            for (let ind = 0; ind < files.length; ind++) {
                 const result = await runFile(files[ind])
                 // if (result === false) {
                 //     logger.debug('*********** FAILURE ' + process.argv[ind] + ' ***************')
@@ -40,32 +40,46 @@ async function runFile(filename: string): Promise<void> {
         filename = filename.substring(0, filename.indexOf("."))
     }
 
+    // skip filename with double underscore
+    if (filename.indexOf("__") !== -1) return
+
     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)
+        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()
+        const user_lang = login.content.user_lang
+        if (user_lang && user_lang.trim() !== '') {
+
+            const langfilename = filename + "__" + user_lang + ".xml"
+
+            if (fs.existsSync(langfilename)) {
+                const langXml = fs.readFileSync(langfilename)
+                const tag = parseXML(xmlfilename, langXml.toString())
+                const modLang = new ModuleInstruction(tag, dbManager)
+                await modLang.parse(structure.scope)
+                await modLang.execute(structure.scope)
+
+                const langMap = modLang.objectData?.variables.getData(user_lang)
+
+                if (langMap !== null && langMap !== undefined) {
+                    structure.mapLang = langMap as MapData
+                }
+            }
+        }
+
+        let script = new Script(structure.scope, xmlfilename, xml.toString())
+        await script.parseInstructions()
+        await script.execute()
     }
     catch (err) {
 
@@ -75,24 +89,4 @@ async function runFile(filename: string): Promise<void> {
         }
         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

@@ -20,8 +20,8 @@ export class TableCommand extends Command {
         this.addCommand(new TableImportCmd())
         this.addCommand(new TableList('list', 'list database tables'))
         this.addCommand(new TableList('l', '(l)ist database tables'))
-        this.addCommand(new TableQuery('query', 'query select table content'))
-        this.addCommand(new TableQuery('q', 'query select table content'))
+        this.addCommand(new TableData('data', 'table (d)ata'))
+        this.addCommand(new TableData('d', 'table (d)ata'))
     }
 }
 
@@ -273,30 +273,30 @@ class TableList extends Cmd {
 
         const dbClient = new DBClient(this.dbManager)
         dbClient.selectFromTable('List of Tables', 'cyk_table',
-            { fields: 'table_id,table_name,table_description,table_access', sort: options.sort || '1' }
+            { fields: 'table_id,table_name,table_auth,table_access,table_description', sort: options.sort || '1' }
         )
     }
 }
 
 //--------------------------------------------------------------------------------------------------------------------
-// class TableQuery
+// class TableData
 //--------------------------------------------------------------------------------------------------------------------
 
-class TableQuery extends Cmd {
+class TableData extends Cmd {
 
     constructor(name: string, description: string) {
         super(name)
         this.description(description)
-            .argument('<table>', 'table to query')
+            .argument('<table>', 'table name')
             .option('--where <clause_where_sql>', 'criteria in SQL syntax')
             .option('-s --sort <columns>', 'sort by columns positions (begins by 0) separated by comma')
             .option('-w --width <colwidth>', 'columns widths separated by comma')
             .action(async (table, options) => {
-                this.commandQuery(table, options)
+                this.commandData(table, options)
             })
     }
 
-    async commandQuery(table: string, options: any) {
+    async commandData(table: string, options: any) {
         try {
             await this.prologue(options)
             if (this.dbManager === undefined) throw 'dbManager undefined'

package/src/TestCommand.ts

@@ -1,4 +1,4 @@
-import { Structure, Script, XmlError, DBRemote, DBManager } from "@cyklang/core"
+import { Structure, Script, XmlError, DBRemote, DBManager, MapData, ModuleInstruction, parseXML } from "@cyklang/core"
 import * as fs from "fs"
 import { errorconsole, PrintInstructionType } from "./console"
 import loglevel from 'loglevel'
@@ -18,7 +18,7 @@ export class TestCommand extends Cmd {
     }
     async testRun(files: string[], options: any) {
         try {
-            await this.prologue(options)
+            const signinResponse = await this.prologue(options)
             for (let ind=0; ind < files.length; ind++) {
                 const result = await testfile(files[ind])
                 if (result === false) {
@@ -41,6 +41,9 @@ async function testfile(filename: string): Promise<boolean> {
         filename = filename.substring(0, filename.indexOf("."))
     }
 
+    // skip filename with double underscore
+    if (filename.indexOf("__") !== -1) return true
+
     let xmlfilename = filename + ".xml"
     let logfilename = filename + ".log"
     let outfilename = filename + ".output"
@@ -62,6 +65,28 @@ async function testfile(filename: string): Promise<boolean> {
         await dbManager.initialize()
         structure.scope.addInstructionType(new PrintInstructionType(logfilename))
         let script = new Script(structure.scope, xmlfilename, xml.toString())
+        const user_lang = login.content.user_lang
+        if (user_lang && user_lang.trim() !== '') {
+            
+            const langfilename = filename + "__" + user_lang + ".xml"
+
+            if (fs.existsSync(langfilename)) {
+                const langXml = fs.readFileSync(langfilename)
+                const tag = parseXML(xmlfilename, langXml.toString())
+                const modLang = new ModuleInstruction(tag, dbManager)
+                await modLang.parse(structure.scope)
+                await modLang.execute(structure.scope)
+
+                const langMap = modLang.objectData?.variables.getData(user_lang)
+
+                if (langMap !== null && langMap !== undefined) {
+                    structure.mapLang = langMap as MapData
+
+                    outfilename = filename + "__" + user_lang + ".output"
+                }
+            }
+        }
+
         await script.parseInstructions()
         await script.execute()
         // console.log(JSON.stringify(script.block.toString()))