@cyklang/cli 0.5.3 → 0.5.5

package/build/AssetCommand.d.ts

@@ -1,4 +1,28 @@
 import { Command } from "commander";
+import { DBManager, DBRemote } from "@cyklang/core";
 export declare class AssetCommand extends Command {
     constructor(name: string, description: string);
 }
+export interface FileDescriptor {
+    path: string;
+    mtime: Date;
+    id?: number;
+}
+/**
+ * function uploadDirectory
+ * @param source
+ * @param dest
+ * @param options {yes: no confirmation, auth: basic/token/cookie/undefined}
+ * @param dbManager
+ * @param dbRemote
+ */
+export declare function uploadDirectory(source: string, dest: string, options: any, dbManager: DBManager | undefined, dbRemote: DBRemote | undefined): Promise<void>;
+/**
+ * function uploadAsset
+ * @param upload
+ * @param route
+ * @param dbManager
+ * @param dbRemote
+ * @param auth
+ */
+export declare function uploadAsset(upload: FileDescriptor, route: string, dbManager: DBManager | undefined, dbRemote: DBRemote | undefined, auth?: string): Promise<void>;

package/build/AssetCommand.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssetCommand = void 0;
+exports.uploadAsset = exports.uploadDirectory = exports.AssetCommand = void 0;
 const commander_1 = require("commander");
 const loglevel_1 = require("loglevel");
 const Cmd_1 = require("./Cmd");
@@ -184,10 +184,6 @@ class AssetList extends Cmd_1.Cmd {
 class AssetU extends Cmd_1.Cmd {
     constructor(name, description) {
         super(name);
-        //----------------------------------------------------------------------------------------------
-        // file2exclude
-        //----------------------------------------------------------------------------------------------
-        this.ignorePatterns = ['.git', 'node_modules'];
         this.description(description)
             .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')
@@ -200,16 +196,6 @@ class AssetU extends Cmd_1.Cmd {
             await this.commandU(sources, options);
         });
     }
-    mimetypeLookup(filename) {
-        let result;
-        if (path_1.default.extname(filename) === '.cyk') {
-            result = 'application/xml';
-        }
-        else {
-            result = mime_types_1.default.lookup(filename);
-        }
-        return result;
-    }
     /**
      * method commandU
      * @param sources
@@ -274,7 +260,7 @@ class AssetU extends Cmd_1.Cmd {
             if (dest.substring(dest.length - 1) !== '/')
                 dest = dest + '/';
             if (options.clean) {
-                await this.cleanDestination(dest);
+                await cleanDestination(dest, this.dbManager, this.dbRemote);
             }
             for (let ind = 0; ind < sources.length; ind++) {
                 const source = sources[ind];
@@ -282,12 +268,12 @@ class AssetU extends Cmd_1.Cmd {
                     throw 'source ' + source + ' does not exist';
                 const filestat = fs.lstatSync(source);
                 if (filestat.isDirectory() === true) {
-                    await this.uploadDirectory(source, dest, options);
+                    await uploadDirectory(source, dest, options, this.dbManager, this.dbRemote);
                 }
                 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, options.auth);
+                    await uploadAsset({ path: source, mtime: filestat.mtime }, dest + base, this.dbManager, this.dbRemote, options.auth);
                 }
             }
         }
@@ -295,180 +281,223 @@ class AssetU extends Cmd_1.Cmd {
             logger.error(err);
         }
     }
-    //----------------------------------------------------------------------------------------------
-    // cleanDestination
-    //----------------------------------------------------------------------------------------------
-    async cleanDestination(dest) {
-        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;
-                await this.dbRemote?.apiServer.delete(url);
-            }
+}
+/**
+ * function cleanDestination
+ * @param dest
+ * @param dbManager
+ * @param dbRemote
+ */
+async function cleanDestination(dest, dbManager, dbRemote) {
+    const remoteList = await scanAssets(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;
+            await dbRemote?.apiServer.delete(url);
         }
     }
-    //----------------------------------------------------------------------------------------------
-    // uploadDirectory
-    //----------------------------------------------------------------------------------------------
-    async uploadDirectory(source, dest, options) {
-        const localList = [];
-        let dirName;
-        if (source.substring(source.length - 1) === '/') {
-            // trailing directory separator
-            dirName = source;
-        }
-        else {
-            dirName = source + '/';
-        }
-        // logger.debug('options', options)
-        this.scanDir(dirName, localList);
-        const remoteList = await scanAssets(this.dbManager);
-        const uploadList = this.buildUploadList(dirName, dest, localList, remoteList);
-        // logger.info(fileNames.join('\n'))
-        if (uploadList.length === 0)
-            throw 'None file to upload';
-        let uploadConfirmed = (options.yes !== undefined);
-        if (uploadConfirmed === false) {
-            const reply = await inquirer_1.default.prompt({ type: 'confirm', name: 'confirm', message: 'Do you want to upload this(these) ' + uploadList.length + ' file(s) ?' });
-            if (reply.confirm === true)
-                uploadConfirmed = true;
-        }
-        if (uploadConfirmed === true) {
-            await this.uploadFiles(dirName, uploadList, dest, 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) => {
-        //     rl.close()
-        //     if (reply !== 'Y' && reply !== 'y') {
-        //         logger.info('upload cancelled')
-        //         return
-        //     }
-        //     await this.uploadFiles(dirName, uploadList, dest)
-        // })
+}
+/**
+ * function uploadDirectory
+ * @param source
+ * @param dest
+ * @param options {yes: no confirmation, auth: basic/token/cookie/undefined}
+ * @param dbManager
+ * @param dbRemote
+ */
+async function uploadDirectory(source, dest, options, dbManager, dbRemote) {
+    const localList = [];
+    let dirName;
+    if (source.substring(source.length - 1) === '/') {
+        // trailing directory separator
+        dirName = source;
     }
-    //----------------------------------------------------------------------------------------------
-    // buildUploadList
-    //----------------------------------------------------------------------------------------------
-    buildUploadList(dirName, dest, localList, remoteList) {
-        const result = [];
-        const remoteMap = new Map();
-        for (let ind = 0; ind < remoteList.length; ind++) {
-            const remote = remoteList[ind];
-            remoteMap.set(remote.path, remote);
-        }
-        for (let ind = 0; ind < localList.length; ind++) {
-            const localDesc = localList[ind];
-            const route = dest + localDesc.path.substring(dirName.length);
-            const remoteDesc = remoteMap.get(route);
-            if (remoteDesc === undefined || remoteDesc.mtime.getTime() + 1000 < localDesc.mtime.getTime()) {
-                if (remoteDesc === undefined)
-                    logger.debug('remoteDesc undefined');
-                else
-                    logger.debug('remoteDesc.mtime ' + remoteDesc.mtime.getTime(), 'localDesc.mtime ' + localDesc.mtime.getTime());
-                logger.info(localDesc.path);
-                result.push(localDesc);
-            }
+    else {
+        dirName = source + '/';
+    }
+    // logger.debug('options', options)
+    scanDir(dirName, localList);
+    const remoteList = await scanAssets(dbManager);
+    const uploadList = buildUploadList(dirName, dest, localList, remoteList);
+    // logger.info(fileNames.join('\n'))
+    if (uploadList.length === 0)
+        throw 'None file to upload';
+    let uploadConfirmed = (options.yes !== undefined);
+    if (uploadConfirmed === false) {
+        const reply = await inquirer_1.default.prompt({ type: 'confirm', name: 'confirm', message: 'Do you want to upload this(these) ' + uploadList.length + ' file(s) ?' });
+        if (reply.confirm === true)
+            uploadConfirmed = true;
+    }
+    if (uploadConfirmed === true) {
+        await uploadFiles(dirName, uploadList, dest, dbManager, dbRemote, options.auth);
+    }
+}
+exports.uploadDirectory = uploadDirectory;
+/**
+ * function buildUploadList
+ * @param dirName
+ * @param dest
+ * @param localList
+ * @param remoteList
+ * @returns
+ */
+function buildUploadList(dirName, dest, localList, remoteList) {
+    const result = [];
+    const remoteMap = new Map();
+    for (let ind = 0; ind < remoteList.length; ind++) {
+        const remote = remoteList[ind];
+        remoteMap.set(remote.path, remote);
+    }
+    for (let ind = 0; ind < localList.length; ind++) {
+        const localDesc = localList[ind];
+        const route = dest + localDesc.path.substring(dirName.length);
+        const remoteDesc = remoteMap.get(route);
+        if (remoteDesc === undefined || remoteDesc.mtime.getTime() + 1000 < localDesc.mtime.getTime()) {
+            if (remoteDesc === undefined)
+                logger.debug('remoteDesc undefined');
+            else
+                logger.debug('remoteDesc.mtime ' + remoteDesc.mtime.getTime(), 'localDesc.mtime ' + localDesc.mtime.getTime());
+            logger.info(localDesc.path);
+            result.push(localDesc);
         }
-        return result;
     }
-    //----------------------------------------------------------------------------------------------
-    // scanDir
-    //----------------------------------------------------------------------------------------------
-    scanDir(dirName, result) {
-        const files = fs.readdirSync(dirName);
-        for (let ind = 0; ind < files.length; ind++) {
-            const fileName = files[ind];
-            if (this.file2exclude(fileName) === true)
+    return result;
+}
+/**
+ * function scanDir
+ * @param dirName
+ * @param result
+ */
+function scanDir(dirName, result) {
+    const files = fs.readdirSync(dirName);
+    for (let ind = 0; ind < files.length; ind++) {
+        const fileName = files[ind];
+        if (file2exclude(fileName) === true)
+            continue;
+        const fstat = fs.statSync(dirName + fileName);
+        if (fstat.isDirectory() === true) {
+            scanDir(dirName + fileName + '/', result);
+        }
+        else {
+            if (mimetypeLookup(fileName) === false) {
+                logger.info(fileName + ' file extension is unknown and will not be uploaded');
                 continue;
-            const fstat = fs.statSync(dirName + fileName);
-            if (fstat.isDirectory() === true) {
-                this.scanDir(dirName + fileName + '/', result);
-            }
-            else {
-                if (this.mimetypeLookup(fileName) === false) {
-                    logger.info(fileName + ' file extension is unknown and will not be uploaded');
-                    continue;
-                }
-                //const dbAssetExist = this.dbManager?.dbAssetExist()
-                result.push({ path: dirName + fileName, mtime: fstat.mtime });
-                // logger.debug(dirName + '/' + fileName)
             }
+            //const dbAssetExist = this.dbManager?.dbAssetExist()
+            result.push({ path: dirName + fileName, mtime: fstat.mtime });
+            // logger.debug(dirName + '/' + fileName)
         }
     }
-    file2exclude(fileName) {
-        let result = false;
-        this.ignorePatterns.forEach((pattern) => {
-            if (fileName === pattern)
-                result = true;
-        });
-        return result;
+}
+const ignorePatterns = ['.git', 'node_modules'];
+/**
+ * function file2exclude
+ * @param fileName
+ * @returns
+ */
+function file2exclude(fileName) {
+    let result = false;
+    ignorePatterns.forEach((pattern) => {
+        if (fileName === pattern)
+            result = true;
+    });
+    return result;
+}
+/**
+ * function uploadFiles
+ * @param dirName
+ * @param uploadList
+ * @param dest
+ * @param dbManager
+ * @param dbRemote
+ * @param auth
+ */
+async function uploadFiles(dirName, uploadList, dest, dbManager, dbRemote, 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 uploadAsset(upload, route, dbManager, dbRemote, auth);
     }
-    //----------------------------------------------------------------------------------------------
-    // uploadFiles
-    //----------------------------------------------------------------------------------------------
-    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, auth);
+}
+/**
+ * function uploadAsset
+ * @param upload
+ * @param route
+ * @param dbManager
+ * @param dbRemote
+ * @param auth
+ */
+async function uploadAsset(upload, route, dbManager, dbRemote, auth) {
+    // logger.debug('uploadAsset ' + upload.path + ' to route ' + route + ' with mimetype ' + this.mimetypeLookup(upload.path) + ', auth : ' + auth)
+    try {
+        let dbAsset = await dbManager?.dbAssetExist(route);
+        if (dbAsset === undefined) {
+            dbAsset = new core_1.DBAsset();
         }
-    }
-    //----------------------------------------------------------------------------------------------
-    // uploadAsset
-    //----------------------------------------------------------------------------------------------
-    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) {
-                dbAsset = new core_1.DBAsset();
-            }
-            const mimetype = this.mimetypeLookup(upload.path);
-            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;
-            // const contentBuffer = fs.readFileSync(fileName)
-            // dbAsset.content = contentBuffer
-            // logger.debug('dbAsset.content length ' + dbAsset.content.length)
-            if (dbAsset.id === undefined) {
-                dbAsset.id = await this.dbManager?.dbAssetInsert(dbAsset);
-                logger.info('inserted asset ' + dbAsset.id + ' route ' + dbAsset.route);
-            }
-            else {
-                await this.dbManager?.dbAssetUpdate(dbAsset);
-                logger.info('updated asset ' + dbAsset.route);
-            }
-            await this.uploadAssetContent(dbAsset, upload.path);
+        const mimetype = mimetypeLookup(upload.path);
+        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;
+        // const contentBuffer = fs.readFileSync(fileName)
+        // dbAsset.content = contentBuffer
+        // logger.debug('dbAsset.content length ' + dbAsset.content.length)
+        if (dbAsset.id === undefined) {
+            dbAsset.id = await dbManager?.dbAssetInsert(dbAsset);
+            logger.info('inserted asset ' + dbAsset.id + ' route ' + dbAsset.route);
         }
-        catch (err) {
-            logger.error(err);
+        else {
+            await dbManager?.dbAssetUpdate(dbAsset);
+            logger.info('updated asset ' + dbAsset.route);
         }
+        await uploadAssetContent(dbAsset, upload.path, dbRemote);
     }
-    //----------------------------------------------------------------------------------------------
-    // uploadAssetContent
-    //----------------------------------------------------------------------------------------------
-    async uploadAssetContent(dbAsset, fileName) {
-        logger.debug('uploadAssetContent file ' + fileName + ' to path ' + path_1.default);
-        try {
-            const file = fs.createReadStream(fileName);
-            const form = new form_data_1.default();
-            form.append('uploadFile', file);
-            const route = '/api/upload/cyk_asset/asset_content?asset_id=' + dbAsset.id;
-            const resp = await this.dbRemote?.apiServer.post(route, form);
-            if (resp.status === 200) {
-                logger.info(fileName + ' uploaded');
-            }
-        }
-        catch (err) {
-            logger.error(err);
+    catch (err) {
+        logger.error(err);
+    }
+}
+exports.uploadAsset = uploadAsset;
+/**
+ * function mimetypeLookup
+ * @param filename
+ * @returns
+ */
+function mimetypeLookup(filename) {
+    let result;
+    if (path_1.default.extname(filename) === '.cyk') {
+        result = 'application/xml';
+    }
+    else {
+        result = mime_types_1.default.lookup(filename);
+    }
+    return result;
+}
+/**
+ * function uploadAssetContent
+ * @param dbAsset
+ * @param fileName
+ * @param dbRemote
+ */
+async function uploadAssetContent(dbAsset, fileName, dbRemote) {
+    logger.debug('uploadAssetContent file ' + fileName + ' to path ' + path_1.default);
+    try {
+        const file = fs.createReadStream(fileName);
+        const form = new form_data_1.default();
+        form.append('uploadFile', file);
+        const route = '/api/upload/cyk_asset/asset_content?asset_id=' + dbAsset.id;
+        const resp = await dbRemote?.apiServer.post(route, form);
+        if (resp.status === 200) {
+            logger.info(fileName + ' uploaded');
         }
     }
+    catch (err) {
+        logger.error(err);
+    }
 }

package/build/Cmd.d.ts

@@ -22,16 +22,21 @@ export declare class Cmd extends Command {
         stdout: string;
         stderr: string;
     }>;
-    /**
-     * method runShellCommand
-     * @param command
-     */
-    runShellCommand(command: string, args: string[]): Promise<void>;
-    /**
-     *
-     * @param command
-     * @param args
-     * @returns
-     */
-    spawnCommand(command: string, args: string[]): Promise<void>;
 }
+/**
+ * method runShellCommand
+ * @param command
+ */
+export declare function runShellCommand(command: string, args: string[]): Promise<void>;
+/**
+ * function spawnCommand
+ * @param command
+ * @param args
+ * @returns
+ */
+export declare function spawnCommand(command: string, args: string[]): Promise<void>;
+/**
+ * function readPackageJson
+ * @returns
+ */
+export declare function readPackageJson(): Promise<any>;

package/build/Cmd.js

@@ -1,9 +1,32 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = 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];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cmd = void 0;
+exports.readPackageJson = exports.spawnCommand = exports.runShellCommand = exports.Cmd = void 0;
 const core_1 = require("@cyklang/core");
 const commander_1 = require("commander");
 const dotenv_1 = __importDefault(require("dotenv"));
@@ -12,6 +35,7 @@ const NodeCrypto_1 = require("./NodeCrypto");
 const DBClient_1 = require("./DBClient");
 const child_process_1 = require("child_process");
 const kolorist_1 = require("kolorist");
+const fs = __importStar(require("fs"));
 const logger = loglevel_1.default.getLogger('Cmd.ts');
 logger.setLevel('debug');
 class Cmd extends commander_1.Command {
@@ -100,45 +124,64 @@ class Cmd extends commander_1.Command {
             });
         });
     }
-    /**
-     * method runShellCommand
-     * @param command
-     */
-    async runShellCommand(command, args) {
-        try {
-            await this.spawnCommand(command, args);
-            // console.log(command)
-            // const result = await this.executeCommand(command);
-            // console.log(result.stdout);
-            // if (result.stderr && result.stderr.trim() !== '')
-            //     console.error(result.stderr);
-        }
-        catch (error) {
-            console.error('Error running "' + command + '":', error);
-            throw error;
-        }
+}
+exports.Cmd = Cmd;
+/**
+ * method runShellCommand
+ * @param command
+ */
+async function runShellCommand(command, args) {
+    try {
+        await spawnCommand(command, args);
+        // console.log(command)
+        // const result = await this.executeCommand(command);
+        // console.log(result.stdout);
+        // if (result.stderr && result.stderr.trim() !== '')
+        //     console.error(result.stderr);
     }
-    /**
-     *
-     * @param command
-     * @param args
-     * @returns
-     */
-    spawnCommand(command, args) {
-        console.log();
-        console.log([command, ...args, '...'].join(' '));
-        const child_process = (0, child_process_1.spawn)(command, args, { stdio: 'inherit' });
-        return new Promise((resolve, reject) => {
-            child_process.on('close', (code) => {
-                if (code === 0) {
-                    console.log((0, kolorist_1.green)('*') + ' ' + [command, ...args].join(' '));
-                    resolve();
-                }
-                else {
-                    reject(new Error([command, ...args].join(' ') + ' --> Error ' + code));
-                }
-            });
+    catch (error) {
+        console.error('Error running "' + command + '":', error);
+        throw error;
+    }
+}
+exports.runShellCommand = runShellCommand;
+/**
+ * function spawnCommand
+ * @param command
+ * @param args
+ * @returns
+ */
+function spawnCommand(command, args) {
+    console.log();
+    console.log([command, ...args, '...'].join(' '));
+    const child_process = (0, child_process_1.spawn)(command, args, { stdio: 'inherit' });
+    return new Promise((resolve, reject) => {
+        child_process.on('close', (code) => {
+            if (code === 0) {
+                console.log((0, kolorist_1.green)('*') + ' ' + [command, ...args].join(' '));
+                resolve();
+            }
+            else {
+                reject(new Error([command, ...args].join(' ') + ' --> Error ' + code));
+            }
         });
+    });
+}
+exports.spawnCommand = spawnCommand;
+/**
+ * function readPackageJson
+ * @returns
+ */
+async function readPackageJson() {
+    try {
+        if (!fs.existsSync("package.json"))
+            throw 'package.json not found';
+        const fileContent = fs.readFileSync("package.json");
+        return JSON.parse(fileContent.toString());
+    }
+    catch (err) {
+        console.error(err);
+        throw err;
     }
 }
-exports.Cmd = Cmd;
+exports.readPackageJson = readPackageJson;

package/build/DBClient.js

@@ -123,6 +123,7 @@ class DBClient {
                 throw ('Module ' + dbname + ' not found');
             }
             await this.dbManager.dbModuleDelete(dbModule);
+            logger.info('module ' + dbname + ' (id ' + dbModule.id + ' deleted)');
         }
         catch (err) {
             logger.error(err);