@cyklang/cli 0.3.1 → 0.4.0

package/build/AssetCommand.js

@@ -42,8 +42,9 @@ class AssetCommand extends commander_1.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 sources'));
-        this.addCommand(new AssetUpload('u', '(u)pload assets'));
+        this.addCommand(new AssetU('upload', 'upload asset content from source files to a <destination> path'));
+        this.addCommand(new AssetU('update', 'update properties of asset identified by its <id>'));
+        this.addCommand(new AssetU('u', '(u)pload assets content from sources or (u)pdate asset properties'));
     }
 }
 exports.AssetCommand = AssetCommand;
@@ -51,6 +52,7 @@ class AssetList extends Cmd_1.Cmd {
     constructor(name, description) {
         super(name);
         this.description(description)
+            .option('-d --dest <destination>', 'filter assets whose pathname begins with destination')
             .option('-s --sort <columns>', 'sort list by column numbers (begins by 0) separated by comma')
             .action(async (options) => { await this.commandList(options); });
     }
@@ -60,14 +62,20 @@ 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_auth,asset_access,asset_mimetype,asset_last_update', 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',
+                where: (options.dest ? "asset_route like '" + options.dest + "%'" : undefined)
+            });
         }
         catch (err) {
             logger.error(err);
         }
     }
 }
-class AssetUpload extends Cmd_1.Cmd {
+/**
+ * class AssetU
+ */
+class AssetU extends Cmd_1.Cmd {
     constructor(name, description) {
         super(name);
         //----------------------------------------------------------------------------------------------
@@ -75,13 +83,15 @@ class AssetUpload extends Cmd_1.Cmd {
         //----------------------------------------------------------------------------------------------
         this.ignorePatterns = ['.git', 'node_modules'];
         this.description(description)
-            .option('-a --auth <auth_schema>', 'authentication schema : basic | token | any, default is no authentication')
+            .option('-i --id <id>', 'asset id to update properties')
+            .option('--auth <auth_schema>', 'authentication schema : basic | token | cookie | any | none, default is none')
+            .option('--access <access>', 'access rights required')
             .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) => {
-            await this.commandUpload(sources, options);
+            await this.commandU(sources, options);
         });
     }
     mimetypeLookup(filename) {
@@ -94,6 +104,48 @@ class AssetUpload extends Cmd_1.Cmd {
         }
         return result;
     }
+    /**
+     * method commandU
+     * @param sources
+     * @param options
+     */
+    async commandU(sources, options) {
+        if (sources.length > 0) {
+            // upload
+            logger.debug('upload sources :', sources);
+            await this.commandUpload(sources, options);
+        }
+        else {
+            // update
+            logger.debug('update', options);
+            await this.commandUpdate(options);
+        }
+    }
+    /**
+     * method commandUpdate
+     * @param options
+     */
+    async commandUpdate(options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            if (options.id === undefined)
+                throw '<id_or_route> of asset to update is missing';
+            const dbAsset = await this.dbManager.dbAssetExist(options.id);
+            if (dbAsset === undefined)
+                throw 'Asset ' + options.id + ' not found';
+            await this.updateAuthAccess('cyk_asset', 'assert', dbAsset.id || '', options);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+    /**
+     * method commandUpload
+     * @param sources
+     * @param options
+     */
     async commandUpload(sources, options) {
         try {
             await this.prologue(options);
@@ -101,8 +153,8 @@ class AssetUpload extends Cmd_1.Cmd {
                 throw 'dbManager undefined';
             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';
+            if (options.auth && ' basic | token | cookie | any | none'.indexOf(options.auth) === -1) {
+                throw 'valid authentication schemas are : basic | token | cookie | any | none';
             }
             logger.debug('options : ', options);
             logger.debug('auth : ' + options.auth);
@@ -299,6 +351,8 @@ class AssetUpload extends Cmd_1.Cmd {
             dbAsset.mimetype = mimetype;
             dbAsset.route = route;
             dbAsset.auth = auth;
+            if (dbAsset.auth === 'none')
+                dbAsset.auth = undefined;
             // const fstat = fs.statSync(fileName)
             dbAsset.last_update = upload.mtime;
             // const contentBuffer = fs.readFileSync(fileName)

package/build/Cmd.d.ts

@@ -5,4 +5,12 @@ export declare class Cmd extends Command {
     dbRemote: DBRemote | undefined;
     constructor(name: string);
     prologue(options: any): Promise<SigninResponse>;
+    /**
+     * method updateAuthAccess
+     * @param tableName
+     * @param prefix
+     * @param id
+     * @param options
+     */
+    updateAuthAccess(tableName: string, prefix: string, id: string, options: any): Promise<void>;
 }

package/build/Cmd.js

@@ -9,6 +9,7 @@ const commander_1 = require("commander");
 const dotenv_1 = __importDefault(require("dotenv"));
 const loglevel_1 = __importDefault(require("loglevel"));
 const NodeCrypto_1 = require("./NodeCrypto");
+const DBClient_1 = require("./DBClient");
 const logger = loglevel_1.default.getLogger('Cmd.ts');
 logger.setLevel('debug');
 class Cmd extends commander_1.Command {
@@ -32,5 +33,54 @@ class Cmd extends commander_1.Command {
         await this.dbManager.initialize();
         return login;
     }
+    /**
+     * method updateAuthAccess
+     * @param tableName
+     * @param prefix
+     * @param id
+     * @param options
+     */
+    async updateAuthAccess(tableName, prefix, id, options) {
+        try {
+            let dclAuth;
+            if (options.auth) {
+                if (' basic | token | cookie | any | none | null '.indexOf(' ' + options.auth + ' ') === -1) {
+                    throw 'valid authentication schemas are : basic | token | cookie | any | null';
+                }
+                dclAuth = `<string name='${prefix}_auth'>`;
+                if (' none | null '.indexOf(' ' + options.auth + ' ') === -1)
+                    dclAuth += ` "${options.auth}" `;
+                else
+                    dclAuth += ' null ';
+                dclAuth += "</string>";
+            }
+            let dclAccess;
+            if (options.access) {
+                dclAccess = `<string name='${prefix}_access'> `;
+                if (' null | none '.indexOf(' ' + options.access + ' ') === -1)
+                    dclAccess += `"${options.access}"`;
+                else
+                    dclAccess += ' null ';
+                dclAccess += "</string>";
+            }
+            const inst = `
+            <db.update table='${tableName}'>
+                <object>
+                    <number name='${prefix}_id'>${id}</number>
+                    ${dclAuth}
+                    ${dclAccess ? dclAccess : ''}
+                </object>
+            </db.update>
+            `;
+            if (!this.dbManager)
+                throw 'prologue() has not been called before';
+            const dbClient = new DBClient_1.DBClient(this.dbManager);
+            dbClient.execInstructions(inst);
+        }
+        catch (err) {
+            logger.error(err);
+            throw err;
+        }
+    }
 }
 exports.Cmd = Cmd;

package/build/DBClient.d.ts

@@ -2,6 +2,16 @@ import { DBManager } from "@cyklang/core";
 export declare class DBClient {
     dbManager: DBManager;
     constructor(dbManager: DBManager);
+    /**
+     * method execInstructions
+     * @param source
+     */
+    execInstructions(source: string): Promise<void>;
+    /**
+     * method execScript
+     * @param source
+     */
+    execScript(source: string): Promise<void>;
     runQuery(): Promise<void>;
     selectFromTable(title: string, tableName: string, options: {
         fields: string;

package/build/DBClient.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DBClient = void 0;
 const core_1 = require("@cyklang/core");
 const loglevel_1 = __importDefault(require("loglevel"));
+const console_1 = require("./console");
 const logger = loglevel_1.default.getLogger('DBClient.ts');
 logger.setLevel('debug');
 // DBManager wrapper class
@@ -13,6 +14,37 @@ class DBClient {
     constructor(dbManager) {
         this.dbManager = dbManager;
     }
+    /**
+     * method execInstructions
+     * @param source
+     */
+    async execInstructions(source) {
+        const script = `<?xml-model href="https://www.cyklang.net/schema/cyklang.xsd" type="application/xml" schematypens="http://www.w3.org/2001/XMLSchema"?>
+        <module>
+        ` + source + `
+        </module>`;
+        await this.execScript(script);
+    }
+    /**
+     * method execScript
+     * @param source
+     */
+    async execScript(source) {
+        try {
+            const script = new core_1.Script(this.dbManager.scope, '', source);
+            await script.parseInstructions();
+            await script.execute();
+        }
+        catch (err) {
+            console.log(source);
+            console.log();
+            if (err instanceof core_1.XmlError) {
+                let xmlError = err;
+                (0, console_1.errorconsole)(xmlError);
+            }
+            console.log(err);
+        }
+    }
     async runQuery() {
     }
     async selectFromTable(title, tableName, options) {

package/build/ModuleCommand.js

@@ -38,10 +38,10 @@ class ModuleCommand extends commander_1.Command {
         super(name);
         this.description('manage modules');
         // upload
-        this.addCommand(new ModuleUpload('upload', `Upload local module file(s) to the database.
+        this.addCommand(new ModuleU('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'));
+        this.addCommand(new ModuleU('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'));
@@ -64,16 +64,52 @@ function getModuleDBName(filePath) {
         throw 'filename ' + result + ' does not match identifier syntax';
     return result;
 }
-class ModuleUpload extends Cmd_1.Cmd {
+/**
+ * class ModuleU
+ */
+class ModuleU extends Cmd_1.Cmd {
     constructor(name, description) {
         super(name);
         this.description(description)
-            .option('-i --id <id>', 'module ID to upload')
+            .option('--auth <auth_schema>', 'authentication schema : basic | token | cookie | any | none, default is none')
+            .option('--access <access_right>', 'access rights required')
+            .option('-i --id <id>', 'module ID to upload or update')
             .argument('[files...]', 'local module file(s) to upload to the server')
             .action(async (files, options) => {
-            await this.commandUpload(files, options);
+            await this.commandU(files, options);
         });
     }
+    async commandU(files, options) {
+        if (files.length > 0) {
+            await this.commandUpload(files, options);
+        }
+        else {
+            await this.commandUpdate(options);
+        }
+    }
+    /**
+     * method commandUpdate
+     * @param options
+     */
+    async commandUpdate(options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            if (options.id === undefined)
+                throw '<id_or_route> of module to update is missing';
+            const dbModule = await this.dbManager.getModule(options.id);
+            await this.updateAuthAccess('cyk_module', 'module', dbModule.id || '', options);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+    /**
+     * method commandUpload
+     * @param files
+     * @param options
+     */
     async commandUpload(files, options) {
         try {
             await this.prologue(options);

package/build/TableCommand.js

@@ -43,9 +43,47 @@ class TableCommand extends commander_1.Command {
         this.addCommand(new TableList('l', '(l)ist database tables'));
         this.addCommand(new TableData('data', 'table (d)ata'));
         this.addCommand(new TableData('d', 'table (d)ata'));
+        this.addCommand(new TableUpdate('update', 'update table properties'));
+        this.addCommand(new TableUpdate('u', 'shortcut for (u)pdate table properties'));
     }
 }
 exports.TableCommand = TableCommand;
+/**
+ * class TableUpdate
+ */
+class TableUpdate extends Cmd_1.Cmd {
+    /**
+     *
+     * @param name
+     * @param description
+     */
+    constructor(name, description) {
+        super(name);
+        this.description(description)
+            .option('-n --name <table_name>', 'name of the table whose properties are to be changed')
+            .option('--auth <auth_schema>', 'authentication schema : basic | token | cookie | any | none, default is none')
+            .option('--access <access>', 'access rights required')
+            .action(async (options) => {
+            await this.commandUpdate(options);
+        });
+    }
+    async commandUpdate(options) {
+        try {
+            await this.prologue(options);
+            if (this.dbManager === undefined)
+                throw 'dbManager undefined';
+            if (!options.name)
+                throw '<table_name> is missing';
+            const dbTable = await this.dbManager.dbTableExist(options.name);
+            if (!dbTable)
+                throw 'Table ' + options.name + ' not found';
+            await this.updateAuthAccess('cyk_table', 'table', dbTable.id || '', options);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
 class TableExportCmd extends Cmd_1.Cmd {
     constructor() {
         super('export');

package/build/UserCommand.js

@@ -22,6 +22,7 @@ class UserCommand extends commander_1.Command {
         this.addCommand(new UserUpdateCmd('u', 'shortcut for (u)pdate'));
         this.addCommand(new UserDeleteCmd('delete', 'delete user by id and name. Both options are mandatory to avoid typing error'));
         this.addCommand(new UserPasswdCmd('passwd', 'change user password'));
+        this.addCommand(new UserPasswdCmd('p', 'shortcut for (p)asswd'));
         this.addCommand(new UserListCmd('list', 'list users'));
         this.addCommand(new UserListCmd('l', 'shortcut for (l)ist'));
     }
@@ -33,7 +34,7 @@ class UserAddCmd extends Cmd_1.Cmd {
         this.description(description)
             .requiredOption('-n --name <name>', 'user name')
             .option('-e --email <email>', 'user email address')
-            .option('-p --passwd <password>', 'initial password')
+            .option('-p --password <password>', 'initial password')
             .option('-a --access <acl>', 'access control list')
             .option('-m --module <module_name>', 'module to launch by default')
             .option('-d --disable', 'user not abled to connect')
@@ -56,7 +57,11 @@ class UserAddCmd extends Cmd_1.Cmd {
             if (this.dbManager === undefined)
                 throw 'dbManager undefined';
             const result = await this.dbManager.dbUserInsert(dbUser);
-            logger.debug(result);
+            logger.debug('ID', result);
+            if (dbUser.password) {
+                await this.dbManager.dbUserPasswd(result, dbUser.password);
+                logger.info('password changed for user ' + dbUser.name);
+            }
         }
         catch (err) {
             logger.error(err);
@@ -173,7 +178,7 @@ class UserDeleteCmd extends Cmd_1.Cmd {
 }
 class UserPasswdCmd extends Cmd_1.Cmd {
     constructor(name, description) {
-        super('passwd');
+        super(name);
         this.description(description)
             .requiredOption('-i --id <id>', 'user ID')
             .requiredOption('-n --name <name>', 'user name')

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@cyklang/cli",
-   "version": "0.3.1",
+   "version": "0.4.0",
    "description": "cyklang CLI",
    "main": "build/index.js",
    "scripts": {

package/src/AssetCommand.ts

@@ -19,8 +19,9 @@ 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 sources'))
-        this.addCommand(new AssetUpload('u', '(u)pload assets'))
+        this.addCommand(new AssetU('upload', 'upload asset content from source files to a <destination> path'))
+        this.addCommand(new AssetU('update', 'update properties of asset identified by its <id>'))
+        this.addCommand(new AssetU('u', '(u)pload assets content from sources or (u)pdate asset properties'))
     }
 }
 
@@ -28,6 +29,7 @@ class AssetList extends Cmd {
     constructor(name: string, description: string) {
         super(name)
         this.description(description)
+            .option('-d --dest <destination>', 'filter assets whose pathname begins with destination')
             .option('-s --sort <columns>', 'sort list by column numbers (begins by 0) separated by comma')
             .action(async (options: any) => { await this.commandList(options) })
     }
@@ -38,7 +40,11 @@ class AssetList extends Cmd {
 
             const dbClient = new DBClient(this.dbManager)
             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' }
+                {
+                    fields: 'asset_id,asset_route,asset_auth,asset_access,asset_mimetype,asset_last_update', sort: options.sort || '1',
+                    where: (options.dest ? "asset_route like '" + options.dest + "%'" : undefined)
+                }
+
             )
         }
         catch (err) {
@@ -47,27 +53,28 @@ class AssetList extends Cmd {
     }
 }
 
-//----------------------------------------------------------------------------------------------
-// class AssetUpload
-//----------------------------------------------------------------------------------------------
-
 interface FileDescriptor {
     path: string
     mtime: Date
     id?: number
 }
-class AssetUpload extends Cmd {
+/**
+ * class AssetU
+ */
+class AssetU extends Cmd {
 
     constructor(name: string, description: string) {
         super(name)
         this.description(description)
-            .option('-a --auth <auth_schema>', 'authentication schema : basic | token | any, default is no authentication')
+            .option('-i --id <id>', 'asset id to update properties')
+            .option('--auth <auth_schema>', 'authentication schema : basic | token | cookie | any | none, default is none')
+            .option('--access <access>', 'access rights required')
             .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)
+                await this.commandU(sources, options)
             })
     }
 
@@ -82,6 +89,51 @@ class AssetUpload extends Cmd {
         return result
     }
 
+    /**
+     * method commandU
+     * @param sources 
+     * @param options 
+     */
+    async commandU(sources: string[], options: any) {
+        if (sources.length > 0) {
+            // upload
+            logger.debug('upload sources :', sources)
+            await this.commandUpload(sources, options)
+        }
+        else {
+            // update
+            logger.debug('update', options)
+            await this.commandUpdate(options)
+        }
+    }
+
+    /**
+     * method commandUpdate
+     * @param options 
+     */
+    async commandUpdate(options: any) {
+        try {
+            await this.prologue(options)
+            if (this.dbManager === undefined) throw 'dbManager undefined'
+
+            if (options.id === undefined) throw '<id_or_route> of asset to update is missing'
+
+            const dbAsset = await this.dbManager.dbAssetExist(options.id)
+            if (dbAsset === undefined) throw 'Asset ' + options.id + ' not found'
+
+            await this.updateAuthAccess('cyk_asset', 'assert', dbAsset.id || '', options)
+
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+
+    /**
+     * method commandUpload
+     * @param sources 
+     * @param options 
+     */
     async commandUpload(sources: string[], options: any) {
 
         try {
@@ -90,8 +142,8 @@ 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'
+            if (options.auth && ' basic | token | cookie | any | none'.indexOf(options.auth) === -1) {
+                throw 'valid authentication schemas are : basic | token | cookie | any | none'
             }
             logger.debug('options : ', options)
             logger.debug('auth : ' + options.auth)
@@ -131,7 +183,7 @@ class AssetUpload extends Cmd {
     async cleanDestination(dest: string) {
 
         const remoteList = await this.scanAssets()
-        for(let ind = 0; ind < remoteList.length; ind++) {
+        for (let ind = 0; ind < remoteList.length; ind++) {
             const fd = remoteList[ind]
             if (fd.path.startsWith(dest)) {
                 const url = '/api/admin/assets/' + fd.id
@@ -314,7 +366,8 @@ class AssetUpload extends Cmd {
             dbAsset.mimetype = mimetype
             dbAsset.route = route
             dbAsset.auth = auth
-            
+            if (dbAsset.auth === 'none') dbAsset.auth = undefined
+
             // const fstat = fs.statSync(fileName)
             dbAsset.last_update = upload.mtime
 

package/src/Cmd.ts

@@ -3,6 +3,7 @@ import { Command } from "commander";
 import dotenv from 'dotenv'
 import loglevel from 'loglevel'
 import { NodeCrypto } from "./NodeCrypto";
+import { DBClient } from "./DBClient";
 const logger = loglevel.getLogger('Cmd.ts')
 logger.setLevel('debug')
 
@@ -35,4 +36,62 @@ export class Cmd extends Command {
 
 
     }
+
+    /**
+     * method updateAuthAccess
+     * @param tableName 
+     * @param prefix 
+     * @param id 
+     * @param options 
+     */
+    async updateAuthAccess(tableName: string, prefix: string, id: string, options: any) {
+
+        try {
+
+            let dclAuth: string | undefined
+
+            if (options.auth) {
+                if (' basic | token | cookie | any | none | null '.indexOf(' ' + options.auth + ' ') === -1) {
+                    throw 'valid authentication schemas are : basic | token | cookie | any | null'
+                }
+                dclAuth = `<string name='${prefix}_auth'>`
+                if (' none | null '.indexOf(' ' + options.auth + ' ') === -1)
+                    dclAuth += ` "${options.auth}" `
+                else
+                    dclAuth += ' null '
+                dclAuth += "</string>"
+            }
+
+            let dclAccess: string | undefined
+
+            if (options.access) {
+
+                dclAccess = `<string name='${prefix}_access'> `
+                if (' null | none '.indexOf(' ' + options.access + ' ') === -1)
+                    dclAccess += `"${options.access}"`
+                else
+                    dclAccess += ' null '
+                dclAccess += "</string>"
+            }
+
+            const inst = `
+            <db.update table='${tableName}'>
+                <object>
+                    <number name='${prefix}_id'>${id}</number>
+                    ${dclAuth}
+                    ${dclAccess ? dclAccess : ''}
+                </object>
+            </db.update>
+            `
+
+            if (! this.dbManager) throw 'prologue() has not been called before'
+
+            const dbClient = new DBClient(this.dbManager)
+            dbClient.execInstructions(inst)
+        }
+        catch (err) {
+            logger.error(err)
+            throw err
+        }
+    }
 }

package/src/DBClient.ts

@@ -1,5 +1,6 @@
-import { BasicType, DBColumn, DBExecuteRequest, DBManager, DBTable, ObjectData, parseXML, PrimitiveData } from "@cyklang/core";
+import { BasicType, DBColumn, DBExecuteRequest, DBManager, DBTable, ObjectData, parseXML, PrimitiveData, Script, XmlError } from "@cyklang/core";
 import loglevel from "loglevel";
+import { errorconsole } from "./console";
 const logger = loglevel.getLogger('DBClient.ts')
 logger.setLevel('debug')
 // DBManager wrapper class
@@ -10,6 +11,39 @@ export class DBClient {
         this.dbManager = dbManager
     }
 
+    /**
+     * method execInstructions
+     * @param source 
+     */
+    async execInstructions(source: string) {
+        const script = `<?xml-model href="https://www.cyklang.net/schema/cyklang.xsd" type="application/xml" schematypens="http://www.w3.org/2001/XMLSchema"?>
+        <module>
+        ` + source + `
+        </module>`
+        await this.execScript(script)
+    }
+
+    /**
+     * method execScript
+     * @param source 
+     */
+    async execScript(source: string) {
+        try {
+            const script = new Script(this.dbManager.scope, '', source)
+            await script.parseInstructions()
+            await script.execute()
+        }
+        catch (err) {
+            console.log(source)
+            console.log()
+            if (err instanceof XmlError) {
+                let xmlError = <XmlError>err
+                errorconsole(xmlError)
+            }
+            console.log(err)
+        }
+    }
+
     async runQuery() {
 
     }

package/src/ModuleCommand.ts

@@ -14,11 +14,11 @@ export class ModuleCommand extends Command {
         super(name)
         this.description('manage modules')
         // upload
-        this.addCommand(new ModuleUpload('upload', `Upload local module file(s) to the database.
+        this.addCommand(new ModuleU('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'))
+        this.addCommand(new ModuleU('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'))
@@ -45,16 +45,57 @@ interface UploadOptions {
     id: string | undefined
     env: string | undefined
 }
-class ModuleUpload extends Cmd {
+
+/**
+ * class ModuleU
+ */
+class ModuleU extends Cmd {
     constructor(name: string, description: string) {
         super(name)
         this.description(description)
-            .option('-i --id <id>', 'module ID to upload')
+            .option('--auth <auth_schema>', 'authentication schema : basic | token | cookie | any | none, default is none')
+            .option('--access <access_right>', 'access rights required')
+            .option('-i --id <id>', 'module ID to upload or update')
             .argument('[files...]', 'local module file(s) to upload to the server')
             .action(async (files: any, options: any) => {
-                await this.commandUpload(files, options)
+                await this.commandU(files, options)
             })
     }
+
+    async commandU(files: string[], options: any) {
+        if (files.length > 0) {
+            await this.commandUpload(files, options)
+        }
+        else {
+            await this.commandUpdate(options)
+        }
+    }
+
+    /**
+     * method commandUpdate
+     * @param options 
+     */
+    async commandUpdate(options: any) {
+        try {
+            await this.prologue(options)
+            if (this.dbManager === undefined) throw 'dbManager undefined'
+
+            if (options.id === undefined) throw '<id_or_route> of module to update is missing'
+
+            const dbModule = await this.dbManager.getModule(options.id)
+
+            await this.updateAuthAccess('cyk_module', 'module', dbModule.id || '', options)
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+
+    /**
+     * method commandUpload
+     * @param files 
+     * @param options 
+     */
     async commandUpload(files: string[], options: UploadOptions) {
         try {
             await this.prologue(options)

package/src/TableCommand.ts

@@ -22,6 +22,47 @@ export class TableCommand extends Command {
         this.addCommand(new TableList('l', '(l)ist database tables'))
         this.addCommand(new TableData('data', 'table (d)ata'))
         this.addCommand(new TableData('d', 'table (d)ata'))
+        this.addCommand(new TableUpdate('update', 'update table properties'))
+        this.addCommand(new TableUpdate('u', 'shortcut for (u)pdate table properties'))
+    }
+}
+
+/**
+ * class TableUpdate
+ */
+class TableUpdate extends Cmd {
+
+    /**
+     * 
+     * @param name 
+     * @param description 
+     */
+    constructor(name: string, description: string) {
+        super(name)
+        this.description(description)
+        .option('-n --name <table_name>', 'name of the table whose properties are to be changed')
+        .option('--auth <auth_schema>', 'authentication schema : basic | token | cookie | any | none, default is none')
+        .option('--access <access>', 'access rights required')
+        .action(async (options: any) => {
+            await this.commandUpdate(options)
+        })
+    }
+
+    async commandUpdate(options: any) {
+        try {
+            await this.prologue(options)
+            if (this.dbManager === undefined) throw 'dbManager undefined'
+
+            if ( ! options.name ) throw '<table_name> is missing'
+
+            const dbTable = await this.dbManager.dbTableExist(options.name)
+            if ( ! dbTable ) throw 'Table ' + options.name + ' not found'
+
+            await this.updateAuthAccess('cyk_table', 'table', dbTable.id || '', options)
+        }
+        catch (err) {
+            logger.error(err)
+        }
     }
 }
 

package/src/UserCommand.ts

@@ -17,6 +17,7 @@ export class UserCommand extends Command {
         this.addCommand(new UserUpdateCmd('u', 'shortcut for (u)pdate'))
         this.addCommand(new UserDeleteCmd('delete', 'delete user by id and name. Both options are mandatory to avoid typing error'))
         this.addCommand(new UserPasswdCmd('passwd', 'change user password'))
+        this.addCommand(new UserPasswdCmd('p', 'shortcut for (p)asswd'))
         this.addCommand(new UserListCmd('list', 'list users'))
         this.addCommand(new UserListCmd('l', 'shortcut for (l)ist'))
     }
@@ -41,7 +42,7 @@ class UserAddCmd extends Cmd {
         this.description(description)
             .requiredOption('-n --name <name>', 'user name')
             .option('-e --email <email>', 'user email address')
-            .option('-p --passwd <password>', 'initial password')
+            .option('-p --password <password>', 'initial password')
             .option('-a --access <acl>', 'access control list')
             .option('-m --module <module_name>', 'module to launch by default')
             .option('-d --disable', 'user not abled to connect')
@@ -63,7 +64,11 @@ class UserAddCmd extends Cmd {
             await this.prologue(options)
             if (this.dbManager === undefined) throw 'dbManager undefined'
             const result = await this.dbManager.dbUserInsert(dbUser)
-            logger.debug(result)
+            logger.debug('ID', result)
+            if (dbUser.password) {
+                await this.dbManager.dbUserPasswd(result, dbUser.password)
+                logger.info('password changed for user ' + dbUser.name)
+            }
         }
         catch (err) {
             logger.error(err)
@@ -174,7 +179,7 @@ class UserDeleteCmd extends Cmd {
 
 class UserPasswdCmd extends Cmd {
     constructor(name: string, description: string) {
-        super('passwd')
+        super(name)
 
         this.description(description)
             .requiredOption('-i --id <id>', 'user ID')

package/test/t26.output

@@ -3,3 +3,10 @@ date :  <b>Gras</b> <i>Italic </i>
 format 1 : Format sans paramètre
 format 2 : Nom : CYK Final
 format 3 : Nom : { CYK Prénom Philippe }
+{"name":"CYK","surname":"Philippe","adresses":[{"town":"Saint-Denis","department":"Reunion"},{"town":"Paris","department":"Paris"}]}
+var1 = undefined
+var2 = undefined
+var1 == var2
+after set var2 from var1
+var1 == var2
+var1 == var3

package/test/t26.xml

@@ -31,5 +31,42 @@
     </object>
 
     <print>json(person)</print>
+
+    <string name="var1"/>
+    <string name="var2"/>
+    <print>"var1 = " + var1</print>
+    <print>"var2 = " + var2</print>
+
+
+    <if>
+        <condition>var1 == var2</condition>
+        <then>
+            <print>"var1 == var2"</print>
+        </then>
+    </if>
+
+    <set name="var2">var1</set>
+    <print>"after set var2 from var1"</print>
+
+    <if>
+        <condition>var1 == var2</condition>
+        <then>
+            <print>"var1 == var2"</print>
+        </then>
+    </if>
+
+    <string name="var3">var1</string>
+
+    <if>
+        <condition>var1 == var3</condition>
+        <then>
+            <print>"var1 == var3"</print>
+        </then>
+        <else>
+            <print>"var1 !== var3"</print>
+        </else>
+    </if>
+    
+
     
 </module>