@cyklang/cli 0.2.2 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@cyklang/cli",
-   "version": "0.2.2",
+   "version": "0.3.0",
    "description": "cyklang CLI",
    "main": "build/index.js",
    "scripts": {
@@ -17,22 +17,20 @@
    "author": "",
    "license": "ISC",
    "dependencies": {
-      "@cyklang/core": "^0.3.6",
+      "@cyklang/core": "^0.5.0",
       "commander": "^9.4.0",
       "dotenv": "^16.0.1",
       "form-data": "^4.0.0",
       "inquirer": "^8.2.5",
       "loglevel": "^1.8.0",
       "mime-types": "^2.1.35",
-      "pako": "^2.0.4",
-      "xml": "^1.0.1"
+      "pako": "^2.0.4"
    },
    "devDependencies": {
       "@types/inquirer": "^8.2.4",
       "@types/mime-types": "^2.1.1",
       "@types/pako": "^2.0.0",
       "@types/sax": "^1.2.4",
-      "@types/xml": "^1.0.8",
       "nodemon": "^2.0.16",
       "ts-node": "^10.7.0",
       "typescript": "4.5.2"

package/src/AssetCommand.ts

@@ -5,7 +5,8 @@ import { DBClient } from "./DBClient"
 import * as fs from "fs"
 import path from "path"
 import mime from 'mime-types'
-import readline from 'readline'
+import inquirer from 'inquirer'
+// import readline from 'readline'
 import { DBAsset, DBExecuteRequest, ObjectData, parseXML, PrimitiveData } from "@cyklang/core"
 import FormData from 'form-data'
 
@@ -37,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) {
@@ -53,19 +54,33 @@ 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('-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) => {
                 await this.commandUpload(sources, options)
             })
     }
 
+    mimetypeLookup(filename: string): string | false {
+        let result: string | false
+        if (path.extname(filename) === '.cyk') {
+            result = 'application/xml'
+        }
+        else {
+            result = mime.lookup(filename)
+        }
+        return result
+    }
+
     async commandUpload(sources: string[], options: any) {
 
         try {
@@ -79,17 +94,21 @@ class AssetUpload extends Cmd {
             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'
                 const filestat = fs.lstatSync(source)
                 if (filestat.isDirectory() === true) {
-                    await this.uploadDirectory(source, dest)
+                    await this.uploadDirectory(source, dest, options)
                 }
                 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)
                 }
             }
         }
@@ -98,11 +117,27 @@ 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
     //----------------------------------------------------------------------------------------------
 
-    async uploadDirectory(source: string, dest: string) {
+    async uploadDirectory(source: string, dest: string, options: any) {
 
         const localList: FileDescriptor[] = []
         let dirName: string
@@ -114,28 +149,38 @@ class AssetUpload extends Cmd {
             dirName = source + '/'
         }
 
-        logger.debug('dirName', dirName)
+        logger.debug('options', options)
 
         this.scanDir(dirName, localList)
 
-        const remoteList: FileDescriptor[] = []
-        await this.scanAssets(remoteList)
+        const remoteList = await this.scanAssets()
 
         const uploadList = this.buildUploadList(dirName, dest, localList, remoteList)
 
         // logger.info(fileNames.join('\n'))
         if (uploadList.length === 0) throw 'None file to upload'
 
-        const rl = readline.createInterface(process.stdin, process.stdout)
-        rl.question('Do you want to upload this(these) ' + uploadList.length + ' file(s) (Y/N/y/n) ?', async (reply) => {
-            rl.close()
-            if (reply !== 'Y' && reply !== 'y') {
-                logger.info('upload cancelled')
-                return
-            }
+        let uploadConfirmed = (options.yes !== undefined)
+
+        if (uploadConfirmed === false) {
+            const reply = await inquirer.prompt({ type: 'confirm', name: 'confirm', message: 'Do you want to upload this(these) ' + uploadList.length + ' file(s) ?' })
+            if (reply.confirm === true) uploadConfirmed = true
+        }
 
+        if (uploadConfirmed === true) {
             await this.uploadFiles(dirName, uploadList, dest)
-        })
+        }
+
+        // const rl = readline.createInterface(process.stdin, process.stdout)
+        // rl.question('Do you want to upload this(these) ' + uploadList.length + ' file(s) (Y/N/y/n) ?', async (reply) => {
+        //     rl.close()
+        //     if (reply !== 'Y' && reply !== 'y') {
+        //         logger.info('upload cancelled')
+        //         return
+        //     }
+
+        //     await this.uploadFiles(dirName, uploadList, dest)
+        // })
     }
 
     //----------------------------------------------------------------------------------------------
@@ -145,32 +190,32 @@ class AssetUpload extends Cmd {
     buildUploadList(dirName: string, dest: string, localList: FileDescriptor[], remoteList: FileDescriptor[]): FileDescriptor[] {
         const result: FileDescriptor[] = []
         const remoteMap = new Map<string, FileDescriptor>()
-        for(let ind = 0; ind < remoteList.length; ind++) {
+        for (let ind = 0; ind < remoteList.length; ind++) {
             const remote = remoteList[ind]
             remoteMap.set(remote.path, remote)
         }
-        for(let ind = 0; ind < localList.length; ind++ ) {
+        for (let ind = 0; ind < localList.length; ind++) {
             const localDesc = localList[ind]
             const route = dest + localDesc.path.substring(dirName.length)
             const remoteDesc = remoteMap.get(route)
 
             if (remoteDesc === undefined || remoteDesc.mtime.getTime() + 1000 < localDesc.mtime.getTime()) {
                 if (remoteDesc === undefined) logger.debug('remoteDesc undefined')
-                else logger.debug('remoteDesc.mtime '+ remoteDesc.mtime.getTime(), 'localDesc.mtime ' + localDesc.mtime.getTime())
+                else logger.debug('remoteDesc.mtime ' + remoteDesc.mtime.getTime(), 'localDesc.mtime ' + localDesc.mtime.getTime())
                 logger.info(localDesc.path)
                 result.push(localDesc)
             }
         }
         return result
     }
-    
-    
+
+
     //----------------------------------------------------------------------------------------------
     // 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'
@@ -181,14 +226,16 @@ class AssetUpload extends Cmd {
         const tag = parseXML('scanAssets', xmlResult)
         const objResult = await this.dbManager.scope.structure.objectDataType.parseData(tag, this.dbManager.scope) as ObjectData
         const rows = (objResult.variables.getData('cyk_asset') as ObjectData).variables
-        for(let ind = 0; ind < rows.list.length; ind++) {
-            const {variable: row} = rows.list[ind]
+        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
     }
 
     //----------------------------------------------------------------------------------------------
@@ -205,12 +252,12 @@ class AssetUpload extends Cmd {
                 this.scanDir(dirName + fileName + '/', result)
             }
             else {
-                if (mime.lookup(fileName) === false) {
+                if (this.mimetypeLookup(fileName) === false) {
                     logger.info(fileName + ' file extension is unknown and will not be uploaded')
                     continue
                 }
                 //const dbAssetExist = this.dbManager?.dbAssetExist()
-                result.push({path: dirName + fileName, mtime: fstat.mtime})
+                result.push({ path: dirName + fileName, mtime: fstat.mtime })
                 // logger.debug(dirName + '/' + fileName)
             }
         }
@@ -248,18 +295,18 @@ class AssetUpload extends Cmd {
     //----------------------------------------------------------------------------------------------
 
     async uploadAsset(upload: FileDescriptor, route: string) {
-        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + mime.lookup(upload.path))
+        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + this.mimetypeLookup(upload.path))
 
         try {
             let dbAsset: DBAsset | undefined = await this.dbManager?.dbAssetExist(route)
             if (dbAsset === undefined) {
                 dbAsset = new DBAsset()
             }
-            const mimetype = mime.lookup(upload.path)
+            const mimetype = this.mimetypeLookup(upload.path)
             if (mimetype === false) throw 'mimetype false for ' + upload
             dbAsset.mimetype = mimetype
             dbAsset.route = route
-
+            
             // const fstat = fs.statSync(fileName)
             dbAsset.last_update = upload.mtime
 
@@ -294,9 +341,9 @@ 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 ) {
+            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,21 +14,25 @@ export class Cmd extends Command {
         super(name);
         this.option('--env <env>', 'path to the environment variables file')
     }
- 
-    async prologue(options: any) {
 
-        const dotenvOutput = dotenv.config({path: options.env})
+    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('DBREMOTE_URL ' + process.env.DBREMOTE_URL)
+        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 }) {
 
@@ -79,6 +83,22 @@ export class DBClient {
             logger.error(err)
         }
     }
+
+    async deleteModule(dbname: string) {
+
+        try {
+            const dbModule = await this.dbManager.dbModuleExist(dbname)
+
+            if (dbModule === undefined) {
+               throw ('Module ' + dbname + ' not found')
+            }
+            await this.dbManager.dbModuleDelete(dbModule)
+        }
+        catch (err) {
+            logger.error(err)
+        }
+
+    }
 }
 
 class List {
@@ -216,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

@@ -25,8 +25,9 @@ Otherwise, a new module is inserted in the database. To rename a module, use opt
         // list
         this.addCommand(new ModuleList('list', 'List modules'))
         this.addCommand(new ModuleList('l', 'shortcut for (l)ist'))
-        // rename
-
+        // rename **TODO**
+        // delete
+        this.addCommand(new ModuleDelete('delete', 'delete module from database'))
     }
 }
 
@@ -36,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
 }
@@ -184,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) {
@@ -197,10 +198,10 @@ class ModuleDelete extends Cmd {
     constructor(name: string, description: string) {
         super(name)
         this.description(description)
-        .argument('[files...]', 'module(s) to delete from the database')
-        .action(async(files: any, options: any) => {
-            await this.commandDelete(files, options)
-        })
+            .argument('[files...]', 'module(s) to delete from the database')
+            .action(async (files: any, options: any) => {
+                await this.commandDelete(files, options)
+            })
     }
     async commandDelete(files: string[], options: any) {
         try {
@@ -208,12 +209,17 @@ class ModuleDelete extends Cmd {
             if (this.dbManager === undefined) throw 'dbManager undefined'
 
             if (files.length === 0) throw 'no module to delete'
-
+            const dbClient = new DBClient(this.dbManager)
+            for (let ind = 0; ind < files.length; ind++) {
+                const dbname = files.at(ind)
+                if (dbname !== undefined)
+                    dbClient.deleteModule(dbname)
+            }
 
         }
-        catch (err){
+        catch (err) {
             logger.error(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)
+        }
+    }
 }