@cyklang/cli 0.3.0 → 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 current directory'));
-        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,12 +83,15 @@ class AssetUpload extends Cmd_1.Cmd {
         //----------------------------------------------------------------------------------------------
         this.ignorePatterns = ['.git', 'node_modules'];
         this.description(description)
+            .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) {
@@ -93,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);
@@ -100,6 +153,11 @@ class AssetUpload extends Cmd_1.Cmd {
                 throw 'dbManager undefined';
             if (sources.length === 0)
                 throw 'no source to upload';
+            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);
             let dest = "/";
             if (options.dest !== undefined)
                 dest = options.dest;
@@ -121,7 +179,7 @@ class AssetUpload extends Cmd_1.Cmd {
                 else if (filestat.isFile() === true) {
                     const base = path_1.default.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);
                 }
             }
         }
@@ -169,7 +227,7 @@ class AssetUpload extends Cmd_1.Cmd {
                 uploadConfirmed = true;
         }
         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)
         // rl.question('Do you want to upload this(these) ' + uploadList.length + ' file(s) (Y/N/y/n) ?', async (reply) => {
@@ -269,19 +327,19 @@ class AssetUpload extends Cmd_1.Cmd {
     //----------------------------------------------------------------------------------------------
     // uploadFiles
     //----------------------------------------------------------------------------------------------
-    async uploadFiles(dirName, uploadList, dest) {
+    async uploadFiles(dirName, uploadList, dest, auth) {
         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);
         }
     }
     //----------------------------------------------------------------------------------------------
     // uploadAsset
     //----------------------------------------------------------------------------------------------
-    async uploadAsset(upload, route) {
-        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + this.mimetypeLookup(upload.path));
+    async uploadAsset(upload, route, auth) {
+        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + this.mimetypeLookup(upload.path) + ', auth : ' + auth);
         try {
             let dbAsset = await this.dbManager?.dbAssetExist(route);
             if (dbAsset === undefined) {
@@ -292,6 +350,9 @@ class AssetUpload extends Cmd_1.Cmd {
                 throw 'mimetype false for ' + upload;
             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

@@ -16,23 +16,25 @@ class UserCommand extends commander_1.Command {
     constructor(name) {
         super(name);
         this.description('manage users in cyk_user table').version('0.1');
-        this.addCommand(new UserAddCmd());
+        this.addCommand(new UserAddCmd('add', 'add a new user'));
+        this.addCommand(new UserAddCmd('a', 'add a new user'));
         this.addCommand(new UserUpdateCmd('update', 'update user by id all fields except password'));
         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'));
     }
 }
 exports.UserCommand = UserCommand;
 class UserAddCmd extends Cmd_1.Cmd {
-    constructor() {
-        super('add');
-        this.description('add a new user')
+    constructor(name, description) {
+        super(name);
+        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')
@@ -55,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);
@@ -172,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.0",
+   "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 current directory'))
-        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,26 +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('-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)
             })
     }
 
@@ -81,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 {
@@ -89,6 +142,12 @@ class AssetUpload extends Cmd {
 
             if (sources.length === 0) throw 'no source to upload'
 
+            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)
+
             let dest = "/"
             if (options.dest !== undefined) dest = options.dest
             if (dest.substring(0, 1) !== '/') dest = '/' + dest
@@ -108,7 +167,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)
                 }
             }
         }
@@ -124,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
@@ -168,7 +227,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)
@@ -281,12 +340,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)
         }
     }
 
@@ -294,8 +353,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)
@@ -306,7 +365,9 @@ class AssetUpload extends Cmd {
             if (mimetype === false) throw 'mimetype false for ' + upload
             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

@@ -11,11 +11,13 @@ export class UserCommand extends Command {
     constructor(name: string) {
         super(name)
         this.description('manage users in cyk_user table').version('0.1')
-        this.addCommand(new UserAddCmd())
+        this.addCommand(new UserAddCmd('add', 'add a new user'))
+        this.addCommand(new UserAddCmd('a', 'add a new user'))
         this.addCommand(new UserUpdateCmd('update', 'update user by id all fields except password'))
         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'))
     }
@@ -35,12 +37,12 @@ interface Options {
 }
 
 class UserAddCmd extends Cmd {
-    constructor() {
-        super('add')
-        this.description('add a new user')
+    constructor(name: string, description: string) {
+        super(name)
+        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')
@@ -62,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)
@@ -173,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>