@cyklang/cli 0.2.3 → 0.3.0

package/build/AssetCommand.js

@@ -60,7 +60,7 @@ class AssetList extends Cmd_1.Cmd {
             if (this.dbManager === undefined)
                 throw 'dbManager undefined';
             const dbClient = new DBClient_1.DBClient(this.dbManager);
-            dbClient.selectFromTable('List of Assets', 'cyk_asset', { fields: 'asset_id,asset_route,asset_last_update,asset_mimetype', sort: options.sort || '1' });
+            dbClient.selectFromTable('List of Assets', 'cyk_asset', { fields: 'asset_id,asset_route,asset_auth,asset_access,asset_mimetype,asset_last_update', sort: options.sort || '1' });
         }
         catch (err) {
             logger.error(err);
@@ -75,7 +75,8 @@ class AssetUpload extends Cmd_1.Cmd {
         //----------------------------------------------------------------------------------------------
         this.ignorePatterns = ['.git', 'node_modules'];
         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, options) => {
@@ -106,6 +107,9 @@ class AssetUpload extends Cmd_1.Cmd {
                 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)
@@ -126,6 +130,19 @@ class AssetUpload extends Cmd_1.Cmd {
         }
     }
     //----------------------------------------------------------------------------------------------
+    // cleanDestination
+    //----------------------------------------------------------------------------------------------
+    async cleanDestination(dest) {
+        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, dest, options) {
@@ -140,8 +157,7 @@ class AssetUpload extends Cmd_1.Cmd {
         }
         logger.debug('options', options);
         this.scanDir(dirName, localList);
-        const remoteList = [];
-        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)
@@ -193,7 +209,8 @@ class AssetUpload extends Cmd_1.Cmd {
     //----------------------------------------------------------------------------------------------
     // scanAssets
     //----------------------------------------------------------------------------------------------
-    async scanAssets(result) {
+    async scanAssets() {
+        const result = [];
         if (this.dbManager === undefined)
             throw 'dbManager undefined';
         const dbReq = new core_1.DBExecuteRequest();
@@ -209,11 +226,13 @@ class AssetUpload extends Cmd_1.Cmd {
         for (let ind = 0; ind < rows.list.length; ind++) {
             const { variable: row } = rows.list[ind];
             const record = row.data;
+            const asset_id = record.variables.getData('asset_id').value;
             const asset_route = record.variables.getData('asset_route').value;
-            const asset_last_update = record.variables.getData('asset_last_update').value;
+            const asset_last_update = record.variables.getData('asset_last_update')?.value;
             // 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;
     }
     //----------------------------------------------------------------------------------------------
     // scanDir
@@ -301,7 +320,7 @@ class AssetUpload extends Cmd_1.Cmd {
             const file = fs.createReadStream(fileName);
             const form = new form_data_1.default();
             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/build/Cmd.d.ts

@@ -1,8 +1,8 @@
-import { DBManager, DBRemote } from "@cyklang/core";
+import { DBManager, DBRemote, SigninResponse } from "@cyklang/core";
 import { Command } from "commander";
 export declare class Cmd extends Command {
     dbManager: DBManager | undefined;
     dbRemote: DBRemote | undefined;
     constructor(name: string);
-    prologue(options: any): Promise<void>;
+    prologue(options: any): Promise<SigninResponse>;
 }

package/build/Cmd.js

@@ -17,24 +17,20 @@ class Cmd extends commander_1.Command {
         this.option('--env <env>', 'path to the environment variables file');
     }
     async prologue(options) {
-        try {
-            const dotenvOutput = dotenv_1.default.config({ path: options.env });
-            if (dotenvOutput.error !== undefined)
-                throw dotenvOutput.error;
-            const structure = new core_1.Structure();
-            if (process.env.DBREMOTE_URL === undefined)
-                throw 'DBREMOTE_URL undefined';
-            logger.debug('Cmd.DBREMOTE_URL ' + process.env.DBREMOTE_URL);
-            const nodeCrypto = new NodeCrypto_1.NodeCrypto();
-            this.dbRemote = new core_1.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 core_1.DBManager(structure.scope, this.dbRemote);
-            await this.dbManager.initialize();
-        }
-        catch (err) {
-            logger.error(err);
-        }
+        const dotenvOutput = dotenv_1.default.config({ path: options.env });
+        if (dotenvOutput.error !== undefined)
+            throw dotenvOutput.error;
+        const structure = new core_1.Structure();
+        if (process.env.DBREMOTE_URL === undefined)
+            throw 'DBREMOTE_URL undefined';
+        logger.debug('Cmd.DBREMOTE_URL ' + process.env.DBREMOTE_URL);
+        const nodeCrypto = new NodeCrypto_1.NodeCrypto();
+        this.dbRemote = new core_1.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 core_1.DBManager(structure.scope, this.dbRemote);
+        await this.dbManager.initialize();
+        return login;
     }
 }
 exports.Cmd = Cmd;

package/build/DBClient.d.ts

@@ -2,6 +2,7 @@ import { DBManager } from "@cyklang/core";
 export declare class DBClient {
     dbManager: DBManager;
     constructor(dbManager: DBManager);
+    runQuery(): Promise<void>;
     selectFromTable(title: string, tableName: string, options: {
         fields: string;
         sort?: string | undefined;

package/build/DBClient.js

@@ -13,6 +13,8 @@ class DBClient {
     constructor(dbManager) {
         this.dbManager = dbManager;
     }
+    async runQuery() {
+    }
     async selectFromTable(title, tableName, options) {
         try {
             const objectDataType = this.dbManager.scope.structure.objectDataType;
@@ -215,6 +217,8 @@ 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/build/ModuleCommand.js

@@ -59,7 +59,7 @@ function getModuleDBName(filePath) {
     // if (filePath.endsWith('.xml') === false) throw filePath + ' does not have .xml extension'
     // result = path.basename(filePath, '.xml')
     const result = path_1.default.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;
@@ -196,7 +196,7 @@ class ModuleList extends Cmd_1.Cmd {
             if (this.dbManager === undefined)
                 throw 'dbManager undefined';
             const dbClient = new DBClient_1.DBClient(this.dbManager);
-            dbClient.selectFromTable('List of Modules', 'cyk_module', { fields: 'module_id,module_dbname,module_access,module_description', sort: options.sort || '1' });
+            dbClient.selectFromTable('List of Modules', 'cyk_module', { fields: 'module_id,module_dbname,module_auth,module_access,module_description', sort: options.sort || '1' });
         }
         catch (err) {
             logger.error(err);

package/build/QueryCommand.js

@@ -5,58 +5,68 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryCommand = void 0;
-const core_1 = require("@cyklang/core");
 const loglevel_1 = __importDefault(require("loglevel"));
+const Cmd_1 = require("./Cmd");
 const commander_1 = require("commander");
+const DBClient_1 = require("./DBClient");
 const logger = loglevel_1.default.getLogger("QueryCommand.ts");
 logger.setLevel("debug");
 class QueryCommand extends commander_1.Command {
     constructor(name) {
         super(name);
+        this.description('query management');
+        this.addCommand(new QueryList('list', 'list queries'));
+        this.addCommand(new QueryList('l', 'list queries'));
     }
 }
 exports.QueryCommand = QueryCommand;
-function parseXmlFile(filepath, basename, xmlSource) {
-    const tag = (0, core_1.parseXML)(filepath, xmlSource);
-    if (tag.name !== 'DB.QUERY') {
-        throw Error('tag ' + tag.name + ', should be <db.query>');
-    }
-    const name = tag.attributes.NAME;
-    if (name === undefined) {
-        throw Error('name attribute is missing');
+//--------------------------------------------------------------------------------------------------------------------
+// class TableList
+//--------------------------------------------------------------------------------------------------------------------
+class QueryList extends Cmd_1.Cmd {
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .option('-s --sort <columns>', 'sort list by column numbers (begins with 0) separated by comma')
+            .action(async (options) => {
+            await this.commandList(options);
+        });
     }
-    if (basename !== name + '.xml') {
-        throw Error('filename ' + filepath + ' and name ' + name + ' do not correspond');
+    async commandList(options) {
+        await this.prologue(options);
+        if (this.dbManager === undefined)
+            throw 'dbManager undefined';
+        const dbClient = new DBClient_1.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, tag, xmlSource) {
-    try {
-        logger.debug('executeXml ' + tag.attributes.NAME);
-        // structure.setInstructionType("print", new PrintInstructionType(logfilename))
-        const dbQueryInstructionType = structure.scope.getInstructionType('db.query');
-        if (dbQueryInstructionType === undefined) {
-            throw Error('dbQueryInstructionType not found');
-        }
-        const scopeParse = new core_1.Scope(structure, structure.scope, undefined);
-        const dbQueryInst = await dbQueryInstructionType.parseInstruction(tag, scopeParse);
-        dbQueryInst.source = xmlSource;
-        const scopeExecute = new core_1.Scope(structure, structure.scope, undefined);
-        await dbQueryInst.execute(scopeExecute);
+//--------------------------------------------------------------------------------------------------------------------
+// class queryData
+//--------------------------------------------------------------------------------------------------------------------
+class queryData extends Cmd_1.Cmd {
+    constructor(name, description) {
+        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);
+        });
     }
-    catch (err) {
-        logger.error(err);
+    async commandData(query, options) {
+        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);
+        }
     }
 }
-async function testQuery(structure, queryName) {
-    const xmlScript = `
-    <block>
-    <object name='result'/>
-    <db.execute query='${queryName}' result='result' />
-    <print>string(result)</print>
-    </block>
-    `;
-    const script = new core_1.Script(structure.scope, 'test', xmlScript);
-    await script.parseInstructions();
-    await script.execute();
-}

package/build/RunCommand.js

@@ -61,11 +61,11 @@ async function runFile(filename) {
     if (filename.indexOf(".") !== -1) {
         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';
@@ -76,14 +76,24 @@ async function runFile(filename) {
         const login = await dbRemote.signin(process.env.USER_NAME, undefined, process.env.USER_PASSWORD);
         const dbManager = new core_1.DBManager(structure.scope, dbRemote);
         await dbManager.initialize();
-        const tag = (0, core_1.parseXML)(xmlfilename, xml.toString());
-        const moduleInstruction = new core_1.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 = (0, core_1.parseXML)(xmlfilename, langXml.toString());
+                const modLang = new core_1.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;
+                }
+            }
+        }
+        let script = new core_1.Script(structure.scope, xmlfilename, xml.toString());
+        await script.parseInstructions();
+        await script.execute();
     }
     catch (err) {
         if (err instanceof core_1.XmlError) {
@@ -92,21 +102,4 @@ async function runFile(filename) {
         }
         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/build/TableCommand.js

@@ -41,8 +41,8 @@ class TableCommand extends commander_1.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'));
     }
 }
 exports.TableCommand = TableCommand;
@@ -271,25 +271,25 @@ class TableList extends Cmd_1.Cmd {
         if (this.dbManager === undefined)
             throw 'dbManager undefined';
         const dbClient = new DBClient_1.DBClient(this.dbManager);
-        dbClient.selectFromTable('List of Tables', 'cyk_table', { fields: 'table_id,table_name,table_description,table_access', sort: options.sort || '1' });
+        dbClient.selectFromTable('List of Tables', 'cyk_table', { fields: 'table_id,table_name,table_auth,table_access,table_description', sort: options.sort || '1' });
     }
 }
 //--------------------------------------------------------------------------------------------------------------------
-// class TableQuery
+// class TableData
 //--------------------------------------------------------------------------------------------------------------------
-class TableQuery extends Cmd_1.Cmd {
+class TableData extends Cmd_1.Cmd {
     constructor(name, description) {
         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, options) {
+    async commandData(table, options) {
         try {
             await this.prologue(options);
             if (this.dbManager === undefined)

package/build/TestCommand.js

@@ -42,7 +42,7 @@ class TestCommand extends Cmd_1.Cmd {
     }
     async testRun(files, options) {
         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) {
@@ -61,6 +61,9 @@ async function testfile(filename) {
     if (filename.indexOf(".") !== -1) {
         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";
@@ -80,6 +83,22 @@ async function testfile(filename) {
         await dbManager.initialize();
         structure.scope.addInstructionType(new console_1.PrintInstructionType(logfilename));
         let script = new core_1.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 = (0, core_1.parseXML)(xmlfilename, langXml.toString());
+                const modLang = new core_1.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;
+                    outfilename = filename + "__" + user_lang + ".output";
+                }
+            }
+        }
         await script.parseInstructions();
         await script.execute();
         // console.log(JSON.stringify(script.block.toString()))

package/build/UserCommand.js

@@ -36,6 +36,7 @@ class UserAddCmd extends Cmd_1.Cmd {
             .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')
+            .option('-l --lang <language>', 'user language')
             .action(async (options) => {
             const dbUser = new core_1.DBUser();
             dbUser.name = options.name;
@@ -44,6 +45,7 @@ class UserAddCmd extends Cmd_1.Cmd {
             dbUser.access = options.access;
             dbUser.appli = options.module;
             dbUser.disable = options.disable || false;
+            dbUser.lang = options.lang;
             await this.commandAdd(dbUser, options);
         });
     }
@@ -75,7 +77,7 @@ class UserListCmd extends Cmd_1.Cmd {
             if (this.dbManager === undefined)
                 throw 'dbManager undefined';
             const dbClient = new DBClient_1.DBClient(this.dbManager);
-            dbClient.selectFromTable('List of users', 'cyk_user', { fields: 'user_id,user_name,user_email,user_access,user_appli,user_disable', sort: options.sort || '1' });
+            dbClient.selectFromTable('List of users', 'cyk_user', { fields: 'user_id,user_name,user_email,user_access,user_appli,user_lang,user_disable', sort: options.sort || '1' });
         }
         catch (err) {
             logger.error(err);
@@ -91,6 +93,7 @@ class UserUpdateCmd extends Cmd_1.Cmd {
             .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('-l --lang <language>', 'user language')
             .option('-d --disable', 'user not able to connect')
             .action(async (options) => {
             const dbUser = new core_1.DBUser();
@@ -99,6 +102,7 @@ class UserUpdateCmd extends Cmd_1.Cmd {
             dbUser.email = options.email;
             dbUser.access = options.access;
             dbUser.appli = options.module;
+            dbUser.lang = options.lang;
             dbUser.disable = options.disable;
             await this.commandUpdate(dbUser, options);
         });
@@ -122,6 +126,8 @@ class UserUpdateCmd extends Cmd_1.Cmd {
                 dbUser1.access = dbUser2.access;
             if (dbUser2.appli !== undefined)
                 dbUser1.appli = dbUser2.appli;
+            if (dbUser2.lang !== undefined)
+                dbUser1.lang = dbUser2.lang;
             if (dbUser2.disable !== undefined)
                 dbUser1.disable = dbUser2.disable;
             // logger.debug('dbUser1 before dbUserUpdate : ', dbUser1)

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@cyklang/cli",
-   "version": "0.2.3",
+   "version": "0.3.0",
    "description": "cyklang CLI",
    "main": "build/index.js",
    "scripts": {
@@ -17,22 +17,20 @@
    "author": "",
    "license": "ISC",
    "dependencies": {
-      "@cyklang/core": "^0.4.2",
+      "@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"