@cyklang/cli 0.3.1 → 0.5.0

package/build/TableCommand.js

@@ -2,7 +2,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -43,9 +47,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/TestCommand.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

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/build/console.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/build/index.js

@@ -14,6 +14,7 @@ const TestCommand_1 = require("./TestCommand");
 const RunCommand_1 = require("./RunCommand");
 const InitCommand_1 = require("./InitCommand");
 const AssetCommand_1 = require("./AssetCommand");
+const OpenCommand_1 = require("./OpenCommand");
 const logger = loglevel_1.default.getLogger("index.ts");
 logger.setLevel("debug");
 const program = new commander_1.Command();
@@ -32,4 +33,5 @@ program.addCommand(new TableCommand_1.TableCommand('table'));
 program.addCommand(new TableCommand_1.TableCommand('t'));
 program.addCommand(new TestCommand_1.TestCommand());
 program.addCommand(new RunCommand_1.RunCommand());
+program.addCommand(new OpenCommand_1.OpenCommand());
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@cyklang/cli",
-   "version": "0.3.1",
+   "version": "0.5.0",
    "description": "cyklang CLI",
    "main": "build/index.js",
    "scripts": {
@@ -17,13 +17,14 @@
    "author": "",
    "license": "ISC",
    "dependencies": {
-      "@cyklang/core": "^0.5.0",
+      "@cyklang/core": "^0.5.2",
       "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",
+      "open": "^9.1.0",
       "pako": "^2.0.4"
    },
    "devDependencies": {
@@ -32,8 +33,8 @@
       "@types/pako": "^2.0.0",
       "@types/sax": "^1.2.4",
       "nodemon": "^2.0.16",
-      "ts-node": "^10.7.0",
-      "typescript": "4.5.2"
+      "ts-node": "^10.9.1",
+      "typescript": "^5.2.2"
    },
    "bin": {
       "cyk": "build/index.js"

package/src/AssetCommand.ts

@@ -7,27 +7,144 @@ import path from "path"
 import mime from 'mime-types'
 import inquirer from 'inquirer'
 // import readline from 'readline'
-import { DBAsset, DBExecuteRequest, ObjectData, parseXML, PrimitiveData } from "@cyklang/core"
+import { DBAsset, DBExecuteRequest, DBManager, ObjectData, parseXML, PrimitiveData } from "@cyklang/core"
 import FormData from 'form-data'
 
 const logger = getLogger('AssetCommand.ts')
 logger.setLevel('debug')
 
+
+//----------------------------------------------------------------------------------------------
+// scanAssets
+//----------------------------------------------------------------------------------------------
+
+const scanAssets = async (dbManager: DBManager | undefined, dest?: string): Promise<FileDescriptor[]> => {
+
+    const result: FileDescriptor[] = []
+    if (dbManager === undefined) throw 'dbManager undefined'
+    const dbReq = new DBExecuteRequest()
+    dbReq.selectFromTable = 'cyk_asset'
+    const pFields = dbReq.parameters.addVariable('fields', dbManager.scope.structure.stringDataType)
+    pFields.data = new PrimitiveData(dbManager.scope.structure.stringDataType, "asset_id,asset_route,asset_last_update,asset_mimetype")
+    const xmlResult = await dbManager.dbExecute(dbReq)
+    if (xmlResult === undefined || xmlResult === null) throw 'xmlResult null or undefined'
+    const tag = parseXML('scanAssets', xmlResult)
+    const objResult = await dbManager.scope.structure.objectDataType.parseData(tag, dbManager.scope) as ObjectData
+    const rows = (objResult.variables.getData('cyk_asset') as ObjectData).variables
+    for (let ind = 0; ind < rows.list.length; ind++) {
+        const { variable: row } = rows.list[ind]
+        const record = row.data as ObjectData
+        const asset_id = (record.variables.getData('asset_id') as PrimitiveData).value as number
+        const asset_route = (record.variables.getData('asset_route') as PrimitiveData).value as string
+        const asset_last_update = (record.variables.getData('asset_last_update') as PrimitiveData)?.value as Date
+        // logger.debug('asset_route ' + asset_route,'asset_last_update ' + asset_last_update)
+
+        if (!dest || asset_route.startsWith(dest))
+            result.push({ path: asset_route, mtime: asset_last_update, id: asset_id })
+    }
+    return result
+}
+
 export class AssetCommand extends Command {
     constructor(name: string, description: string) {
         super(name)
         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'))
+        this.addCommand(new AssetDelete('delete', 'delete an asset'))
+    }
+}
+
+/**
+ * class AssetDelete
+ */
+class AssetDelete extends Cmd {
+    constructor(name: string, description: string) {
+        super(name)
+        this.description(description)
+            .option('-i --id <id_pathname>', 'asset id or pathname to delete')
+            .option('-d --dest <destination>', 'delete all assets whose pathname begins with dest')
+            .action(async (options: any) => {
+                if (options.id)
+                    await this.commandDeleteOne(options)
+                else if (options.dest) {
+                    await this.commandDeletePathname(options)
+                }
+                else {
+                    logger.error('one of --id or --dest options is required')
+                }
+            })
+    }
+
+    /**
+     * 
+     * @param options 
+     */
+    async commandDeleteOne(options: any) {
+        try {
+            await this.prologue(options)
+            if (this.dbManager === undefined) throw 'dbManager undefined'
+
+            if (options.id === undefined) throw '<id_or_pathname> of asset to delete is missing'
+
+            if (!options.id.startsWith('/')) throw '-i --id only pathname is supported at the moment'
+
+            const dbAsset = await this.dbManager.dbAssetExist(options.id)
+            if (dbAsset === undefined) throw 'Asset ' + options.id + ' not found'
+
+            await this.dbManager.dbAssetDelete(dbAsset)
+
+            logger.info('asset ' + dbAsset.id + ' ' + dbAsset.route + ' deleted')
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+
+    /**
+     * 
+     * @param options 
+     */
+    async commandDeletePathname(options: any) {
+
+        try {
+            await this.prologue(options)
+            if (! this.dbManager) throw 'dbManager undefined'
+            const dbClient = new DBClient(this.dbManager)
+            const list = await dbClient.selectFromTable('Assets to delete', '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)
+                }
+
+            );
+            const reply = await inquirer.prompt({type: 'confirm', name: 'confirm', message: 'Do you want to delete these ' + list.length +  ' file(s)'})
+            if (reply.confirm) {
+                for(let ind = 0; ind < list.length; ind++) {
+                    const asset = list[ind]
+                    logger.info('delete ' + asset.asset_route)
+                    const url = '/api/admin/assets/' + asset.asset_id
+                    await this.dbRemote?.apiServer.delete(url)
+                }
+            }
+
+        }
+        catch (err) {
+            logger.error(err)
+        }
+
     }
+
 }
 
 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 +155,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 +168,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 or pathname whose properties are updated')
+            .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 +204,53 @@ 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_pathname> of asset to update is missing'
+
+            if (!options.id.startsWith('/')) throw '-i --id only pathname is supported at the moment'
+
+            const dbAsset = await this.dbManager.dbAssetExist(options.id)
+            if (dbAsset === undefined) throw 'Asset ' + options.id + ' not found'
+
+            await this.updateAuthAccess('cyk_asset', 'asset', dbAsset.id || '', options)
+
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+
+    /**
+     * method commandUpload
+     * @param sources 
+     * @param options 
+     */
     async commandUpload(sources: string[], options: any) {
 
         try {
@@ -90,11 +259,11 @@ 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)
+            // logger.debug('options : ', options)
+            // logger.debug('auth : ' + options.auth)
 
             let dest = "/"
             if (options.dest !== undefined) dest = options.dest
@@ -130,8 +299,8 @@ class AssetUpload extends Cmd {
 
     async cleanDestination(dest: string) {
 
-        const remoteList = await this.scanAssets()
-        for(let ind = 0; ind < remoteList.length; ind++) {
+        const remoteList = await scanAssets(this.dbManager)
+        for (let ind = 0; ind < remoteList.length; ind++) {
             const fd = remoteList[ind]
             if (fd.path.startsWith(dest)) {
                 const url = '/api/admin/assets/' + fd.id
@@ -156,11 +325,11 @@ class AssetUpload extends Cmd {
             dirName = source + '/'
         }
 
-        logger.debug('options', options)
+        // logger.debug('options', options)
 
         this.scanDir(dirName, localList)
 
-        const remoteList = await this.scanAssets()
+        const remoteList = await scanAssets(this.dbManager)
 
         const uploadList = this.buildUploadList(dirName, dest, localList, remoteList)
 
@@ -216,35 +385,6 @@ class AssetUpload extends Cmd {
         return result
     }
 
-
-    //----------------------------------------------------------------------------------------------
-    // scanAssets
-    //----------------------------------------------------------------------------------------------
-
-    async scanAssets() {
-        const result: FileDescriptor[] = []
-        if (this.dbManager === undefined) throw 'dbManager undefined'
-        const dbReq = new DBExecuteRequest()
-        dbReq.selectFromTable = 'cyk_asset'
-        const pFields = dbReq.parameters.addVariable('fields', this.dbManager.scope.structure.stringDataType)
-        pFields.data = new PrimitiveData(this.dbManager.scope.structure.stringDataType, "asset_id,asset_route,asset_last_update,asset_mimetype")
-        const xmlResult = await this.dbManager.dbExecute(dbReq)
-        if (xmlResult === undefined || xmlResult === null) throw 'xmlResult null or undefined'
-        const tag = parseXML('scanAssets', xmlResult)
-        const objResult = await this.dbManager.scope.structure.objectDataType.parseData(tag, this.dbManager.scope) as ObjectData
-        const rows = (objResult.variables.getData('cyk_asset') as ObjectData).variables
-        for (let ind = 0; ind < rows.list.length; ind++) {
-            const { variable: row } = rows.list[ind]
-            const record = row.data as ObjectData
-            const asset_id = (record.variables.getData('asset_id') as PrimitiveData).value as number
-            const asset_route = (record.variables.getData('asset_route') as PrimitiveData).value as string
-            const asset_last_update = (record.variables.getData('asset_last_update') as PrimitiveData)?.value as Date
-            // logger.debug('asset_route ' + asset_route,'asset_last_update ' + asset_last_update)
-            result.push({ path: asset_route, mtime: asset_last_update, id: asset_id })
-        }
-        return result
-    }
-
     //----------------------------------------------------------------------------------------------
     // scanDir
     //----------------------------------------------------------------------------------------------
@@ -302,7 +442,7 @@ class AssetUpload extends Cmd {
     //----------------------------------------------------------------------------------------------
 
     async uploadAsset(upload: FileDescriptor, route: string, auth?: string) {
-        logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + this.mimetypeLookup(upload.path) + ', auth : ' + auth)
+        // 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)
@@ -314,7 +454,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
+        }
+    }
 }