@cyklang/cli 0.5.4 → 0.5.6

package/build/InstallCommand.d.ts

@@ -1,15 +1,16 @@
 import { Cmd } from "./Cmd";
+import { DBManager, DBRemote } from "@cyklang/core";
 export declare class InstallCommand extends Cmd {
-    constructor(name: string);
-    install(node_package: string, options: any): Promise<void>;
     /**
-     * method installNodePackage
-     * @param node_package
+     * constructor
+     * @param name
      */
-    installNodePackage(node_package: string): Promise<void>;
+    constructor(name: string);
     /**
-     * method lookupInstallScript
+     * method install
      * @param node_package
+     * @param options
      */
-    lookupInstallScript(node_package: string): Promise<string | undefined>;
+    install(node_package: string, options: any): Promise<void>;
 }
+export declare function installPackage(node_package: string, dbManager: DBManager, dbRemote: DBRemote): Promise<void>;

package/build/InstallCommand.js

@@ -26,109 +26,183 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InstallCommand = void 0;
+exports.installPackage = exports.InstallCommand = void 0;
 const Cmd_1 = require("./Cmd");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const kolorist_1 = require("kolorist");
 const loglevel_1 = __importDefault(require("loglevel"));
 const ModuleCommand_1 = require("./ModuleCommand");
+const UninstallCommand_1 = require("./UninstallCommand");
+const AssetCommand_1 = require("./AssetCommand");
 const logger = loglevel_1.default.getLogger('InstallCommand.ts');
 logger.setLevel('debug');
 class InstallCommand extends Cmd_1.Cmd {
+    /**
+     * constructor
+     * @param name
+     */
     constructor(name) {
         super(name);
-        this.description('npm install and upload xml modules to Cyk server')
+        this.description('npm install and run install script')
             .argument('<node_package>', 'Node Package installed as dev dependency')
             .action(async (node_package, options) => {
             await this.install(node_package, options);
         });
     }
+    /**
+     * method install
+     * @param node_package
+     * @param options
+     */
     async install(node_package, options) {
         try {
             await this.prologue(options);
-            if (this.dbManager === undefined)
-                throw 'dbManager undefined';
-            /**
-             * install the Node Package
-             */
-            await this.installNodePackage(node_package);
-            const installScript = await this.lookupInstallScript(node_package);
-            if (installScript) {
-                /**
-                 * execute installScript
-                 */
-                const installPath = path.join('node_modules', node_package, 'scripts', installScript);
-                await this.runShellCommand(installPath, []);
-            }
-            else {
-                /**
-                 * default install : upload modules and execute _init.xml
-                 */
-                console.log();
-                console.log('upload modules to server ...');
-                const xmlFolder = path.join('node_modules', node_package, 'xml');
-                if (!fs.existsSync(xmlFolder) || !fs.statSync(xmlFolder).isDirectory()) {
-                    throw 'xml folder not found ( ' + xmlFolder + ' )';
-                }
-                /**
-                 * upload modules to the server
-                 */
-                let initModule;
-                const files = fs.readdirSync(xmlFolder);
-                for (let ind = 0; ind < files.length; ind++) {
-                    const file = files[ind];
-                    await (0, ModuleCommand_1.uploadModule)(path.join(xmlFolder, file), this.dbManager);
-                    if (file.endsWith('_init.xml')) {
-                        initModule = file;
-                    }
-                }
-                console.log((0, kolorist_1.green)('*') + ' upload modules to server');
-                if (initModule) {
-                    const initPath = path.join(xmlFolder, initModule);
-                    await this.runShellCommand('npx', ['cyk', 'run', initPath]);
-                }
-            }
+            if (this.dbManager === undefined || !this.dbRemote)
+                throw 'dbManager or dbRemote undefined';
+            await installPackage(node_package, this.dbManager, this.dbRemote);
         }
         catch (err) {
             logger.error(err);
         }
     }
+}
+exports.InstallCommand = InstallCommand;
+async function installPackage(node_package, dbManager, dbRemote) {
     /**
-     * method installNodePackage
-     * @param node_package
+     * install the Node Package
      */
-    async installNodePackage(node_package) {
-        try {
-            await this.runShellCommand('npm', ['install', '--save-dev', node_package]);
-        }
-        catch (error) {
-            console.error('Error installing ' + node_package + ' :', error);
-            throw error;
-        }
+    await installNodePackage(node_package, dbManager, dbRemote);
+    const installScript = await lookupInstallScript(node_package);
+    if (installScript) {
+        /**
+         * execute installScript
+         */
+        const installPath = path.join('node_modules', node_package, 'scripts', installScript);
+        await (0, Cmd_1.runShellCommand)(installPath, []);
     }
+    else {
+        /**
+         * default install : upload modules and execute _init.xml
+         */
+        await defaultInstallScript(node_package, dbManager, dbRemote);
+    }
+}
+exports.installPackage = installPackage;
+/**
+ * method defaultInstallScript
+ * @param node_package
+ */
+async function defaultInstallScript(node_package, dbManager, dbRemote) {
+    console.log();
+    console.log('Default install script');
     /**
-     * method lookupInstallScript
-     * @param node_package
+     * upload package assets
      */
-    async lookupInstallScript(node_package) {
-        let result;
-        try {
-            const scriptsFolder = path.join('node_modules', node_package, 'scripts');
-            if (fs.existsSync(scriptsFolder) && fs.statSync(scriptsFolder).isDirectory()) {
-                const files = fs.readdirSync(scriptsFolder);
-                for (let ind = 0; ind < files.length; ind++) {
-                    const file = files[ind];
-                    if (file.startsWith('install.')) {
-                        result = file;
-                    }
+    await uploadPackageAssets(node_package, dbManager, dbRemote);
+    /**
+     * upload package modules to the server
+     */
+    await uploadPackageModules(node_package, dbManager);
+}
+/**
+ * function uploadPackageAssets
+ * @param node_package
+ * @param dbManager
+ */
+async function uploadPackageAssets(node_package, dbManager, dbRemote) {
+    const assetFolder = path.join('node_modules', node_package, 'asset');
+    if (!fs.existsSync(assetFolder) || !fs.statSync(assetFolder).isDirectory()) {
+        return;
+    }
+    console.log();
+    console.log('upload assets to server ...');
+    const items = fs.readdirSync(assetFolder);
+    for (let ind = 0; ind < items.length; ind++) {
+        const item = items[ind];
+        const itemPath = path.join(assetFolder, item);
+        if (fs.statSync(itemPath).isDirectory()) {
+            const dest = "/" + item + "/";
+            await (0, AssetCommand_1.uploadDirectory)(itemPath, dest, { yes: true }, dbManager, dbRemote);
+        }
+        else {
+            const dest = "/" + item;
+            const fd = { path: path.join(assetFolder, item), mtime: new Date() };
+            await (0, AssetCommand_1.uploadAsset)(fd, dest, dbManager, dbRemote);
+        }
+    }
+    console.log((0, kolorist_1.green)('*') + ' upload assets to server');
+}
+/**
+ * function uploadModules
+ * @param node_package
+ * @param dbManager
+ */
+async function uploadPackageModules(node_package, dbManager) {
+    const moduleFolder = path.join('node_modules', node_package, 'module');
+    if (!fs.existsSync(moduleFolder) || !fs.statSync(moduleFolder).isDirectory()) {
+        return;
+    }
+    console.log();
+    console.log('upload modules to server ...');
+    let initModule;
+    const files = fs.readdirSync(moduleFolder);
+    for (let ind = 0; ind < files.length; ind++) {
+        const file = files[ind];
+        if (!dbManager)
+            throw 'dbManager undefined';
+        await (0, ModuleCommand_1.uploadModule)(path.join(moduleFolder, file), dbManager);
+        if (file.endsWith('_init.xml')) {
+            initModule = file;
+        }
+    }
+    console.log((0, kolorist_1.green)('*') + ' upload modules to server');
+    if (initModule) {
+        const initPath = path.join(moduleFolder, initModule);
+        await (0, Cmd_1.runShellCommand)('npx', ['cyk', 'run', initPath]);
+    }
+}
+/**
+ * method installNodePackage
+ * @param node_package
+ */
+async function installNodePackage(node_package, dbManager, dbRemote) {
+    try {
+        const packageJson = await (0, Cmd_1.readPackageJson)();
+        if (packageJson.devDependencies && packageJson.devDependencies[node_package]
+            || packageJson.dependencies && packageJson.dependencies[node_package]) {
+            console.log(node_package + ' already installed. We uninstall it first');
+            if (!dbManager)
+                throw 'dbManager undefined';
+            await (0, UninstallCommand_1.uninstallPackage)(node_package, dbManager, dbRemote);
+        }
+        await (0, Cmd_1.runShellCommand)('npm', ['install', '--save-dev', node_package]);
+    }
+    catch (error) {
+        console.error('Error installing ' + node_package + ' :', error);
+        throw error;
+    }
+}
+/**
+ * function lookupInstallScript
+ * @param node_package
+ */
+async function lookupInstallScript(node_package) {
+    let result;
+    try {
+        const scriptsFolder = path.join('node_modules', node_package, 'scripts');
+        if (fs.existsSync(scriptsFolder) && fs.statSync(scriptsFolder).isDirectory()) {
+            const files = fs.readdirSync(scriptsFolder);
+            for (let ind = 0; ind < files.length; ind++) {
+                const file = files[ind];
+                if (file.startsWith('install.')) {
+                    result = file;
                 }
             }
-            return result;
-        }
-        catch (err) {
-            throw err;
         }
+        return result;
+    }
+    catch (err) {
+        throw err;
     }
 }
-exports.InstallCommand = InstallCommand;

package/build/ModuleCommand.d.ts

@@ -10,3 +10,9 @@ export declare class ModuleCommand extends Command {
  * @param dbManager
  */
 export declare function uploadModule(file: string, dbManager: DBManager): Promise<void>;
+/**
+ * function deleteModule
+ * @param dbname
+ * @param dbManager
+ */
+export declare function deleteModule(dbname: string, dbManager: DBManager): Promise<void>;

package/build/ModuleCommand.js

@@ -27,7 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadModule = exports.ModuleCommand = void 0;
+exports.deleteModule = exports.uploadModule = exports.ModuleCommand = void 0;
 const core_1 = require("@cyklang/core");
 const fs = __importStar(require("fs"));
 const loglevel_1 = __importDefault(require("loglevel"));
@@ -166,6 +166,7 @@ async function uploadModule(file, dbManager) {
         logger.info('module ' + dbname + ' added with ID ' + id);
     }
     else {
+        logger.debug('module exists : ' + dbModuleExist.dbname + ', id ' + dbModuleExist.id);
         // update
         dbModuleExist.source = source;
         dbModuleExist.access = tag.attributes.ACCESS;
@@ -280,3 +281,13 @@ class ModuleDelete extends Cmd_1.Cmd {
         }
     }
 }
+/**
+ * function deleteModule
+ * @param dbname
+ * @param dbManager
+ */
+async function deleteModule(dbname, dbManager) {
+    const dbClient = new DBClient_1.DBClient(dbManager);
+    await dbClient.deleteModule(dbname);
+}
+exports.deleteModule = deleteModule;

package/build/UninstallCommand.d.ts

@@ -0,0 +1,20 @@
+import { Cmd } from "./Cmd";
+import { DBManager, DBRemote } from "@cyklang/core";
+export declare class UninstallCommand extends Cmd {
+    /**
+     * constructor
+     * @param name
+     */
+    constructor(name: string);
+    /**
+     * method uninstall
+     * @param node_package
+     * @param options
+     */
+    uninstall(node_package: string, options: any): Promise<void>;
+}
+/**
+ * function uninstallPackage
+ * @param node_package
+ */
+export declare function uninstallPackage(node_package: string, dbManager: DBManager, dbRemote: DBRemote): Promise<void>;

package/build/UninstallCommand.js

@@ -0,0 +1,211 @@
+"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.uninstallPackage = exports.UninstallCommand = void 0;
+const Cmd_1 = require("./Cmd");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const kolorist_1 = require("kolorist");
+const loglevel_1 = __importDefault(require("loglevel"));
+const ModuleCommand_1 = require("./ModuleCommand");
+const logger = loglevel_1.default.getLogger('UninstallCommand.ts');
+logger.setLevel('debug');
+class UninstallCommand extends Cmd_1.Cmd {
+    /**
+     * constructor
+     * @param name
+     */
+    constructor(name) {
+        super(name);
+        this.description('run uninstall script and npm uninstall command')
+            .argument('<node_package>', 'Node Package installed as dev dependency')
+            .action(async (node_package, options) => {
+            await this.uninstall(node_package, options);
+        });
+    }
+    /**
+     * method uninstall
+     * @param node_package
+     * @param options
+     */
+    async uninstall(node_package, options) {
+        try {
+            await this.prologue(options);
+            if (!this.dbManager || !this.dbRemote)
+                throw 'dbManager or dbRemote undefined';
+            await uninstallPackage(node_package, this.dbManager, this.dbRemote);
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    }
+}
+exports.UninstallCommand = UninstallCommand;
+/**
+ * function uninstallPackage
+ * @param node_package
+ */
+async function uninstallPackage(node_package, dbManager, dbRemote) {
+    const uninstallScript = await lookupUninstallScript(node_package);
+    if (uninstallScript) {
+        /**
+         * run scripts/uninstall
+         */
+        const uninstallPath = path.join('node_modules', node_package, 'scripts', uninstallScript);
+        await (0, Cmd_1.runShellCommand)(uninstallPath, []);
+    }
+    else {
+        /**
+         * default uninstall :
+         */
+        await defaultUninstallScript(node_package, dbManager, dbRemote);
+    }
+    /**
+     * uninstall the node package
+     */
+    await uninstallNodePackage(node_package);
+}
+exports.uninstallPackage = uninstallPackage;
+/**
+ * method defaultUninstallScript
+ * @param node_package
+ */
+async function defaultUninstallScript(node_package, dbManager, dbRemote) {
+    console.log();
+    console.log('Default uninstall script');
+    /**
+     * delete package modules from server
+     */
+    await deletePackageModules(node_package, dbManager);
+    /**
+     * delete package assets from server
+     */
+    await deletePackageAssets(node_package, dbManager, dbRemote);
+}
+/**
+ * function deletePackageAssets
+ * @param node_package
+ * @param dbManager
+ * @param dbRemote
+ */
+async function deletePackageAssets(node_package, dbManager, dbRemote) {
+    const assetFolder = path.join('node_modules', node_package, 'asset');
+    if (!fs.existsSync(assetFolder) || !fs.statSync(assetFolder).isDirectory()) {
+        return;
+    }
+    console.log();
+    console.log('delete assets from server ...');
+    await browseFolder(assetFolder, async (filePath) => {
+        const route = '/' + path.relative(assetFolder, filePath);
+        const dbAsset = await dbManager.dbAssetExist(route);
+        if (!dbAsset) {
+            logger.info('asset ' + route + ' not found');
+            return;
+        }
+        await dbManager.dbAssetDelete(dbAsset);
+        logger.info('asset ' + route + ' deleted');
+    });
+    console.log((0, kolorist_1.green)('*') + ' delete assets from server');
+}
+/**
+ * browseFolder
+ * @param folder
+ * @param treatment
+ */
+async function browseFolder(folder, treatment) {
+    const files = fs.readdirSync(folder);
+    for (let ind = 0; ind < files.length; ind++) {
+        const file = files[ind];
+        const pathName = folder + '/' + file;
+        if (fs.statSync(pathName).isDirectory()) {
+            await browseFolder(pathName, treatment);
+        }
+        else {
+            await treatment(pathName);
+        }
+    }
+}
+/**
+ * function deletePackageModules
+ * @param node_package
+ * @param dbManager
+ * @returns
+ */
+async function deletePackageModules(node_package, dbManager) {
+    const moduleFolder = path.join('node_modules', node_package, 'module');
+    if (!fs.existsSync(moduleFolder) || !fs.statSync(moduleFolder).isDirectory()) {
+        return;
+    }
+    console.log();
+    console.log('delete modules from server ...');
+    const files = fs.readdirSync(moduleFolder);
+    for (let ind = 0; ind < files.length; ind++) {
+        const file = files[ind];
+        if (!dbManager)
+            throw 'dbManager undefined';
+        const fileInfo = path.parse(file);
+        await (0, ModuleCommand_1.deleteModule)(fileInfo.name, dbManager);
+    }
+    console.log((0, kolorist_1.green)('*') + ' delete modules from server');
+}
+/**
+ * function uninstallNodePackage
+ * @param node_package
+ */
+async function uninstallNodePackage(node_package) {
+    try {
+        await (0, Cmd_1.runShellCommand)('npm', ['uninstall', '--save-dev', node_package]);
+    }
+    catch (error) {
+        console.error('Error uninstalling ' + node_package + ' :', error);
+        throw error;
+    }
+}
+/**
+ * function lookupUninstallScript
+ * @param node_package
+ */
+async function lookupUninstallScript(node_package) {
+    let result;
+    try {
+        const scriptsFolder = path.join('node_modules', node_package, 'scripts');
+        if (fs.existsSync(scriptsFolder) && fs.statSync(scriptsFolder).isDirectory()) {
+            const files = fs.readdirSync(scriptsFolder);
+            for (let ind = 0; ind < files.length; ind++) {
+                const file = files[ind];
+                if (file.startsWith('uninstall.')) {
+                    result = file;
+                }
+            }
+        }
+        return result;
+    }
+    catch (err) {
+        throw err;
+    }
+}

package/build/index.js

@@ -15,13 +15,15 @@ const RunCommand_1 = require("./RunCommand");
 const InstallCommand_1 = require("./InstallCommand");
 const AssetCommand_1 = require("./AssetCommand");
 const OpenCommand_1 = require("./OpenCommand");
+const UninstallCommand_1 = require("./UninstallCommand");
 const logger = loglevel_1.default.getLogger("index.ts");
 logger.setLevel("debug");
 const program = new commander_1.Command();
 program.name('cyk').description('cyklang CLI')
-    .version('0.5.4');
+    .version('0.5.6');
 program.addCommand(new InstallCommand_1.InstallCommand('install'));
 program.addCommand(new InstallCommand_1.InstallCommand('i'));
+program.addCommand(new UninstallCommand_1.UninstallCommand('uninstall'));
 program.addCommand(new AssetCommand_1.AssetCommand('asset', 'manage assets'));
 program.addCommand(new AssetCommand_1.AssetCommand('a', 'manage assets'));
 program.addCommand(new ModuleCommand_1.ModuleCommand('module'));

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@cyklang/cli",
-   "version": "0.5.4",
+   "version": "0.5.6",
    "description": "cyklang CLI",
    "main": "build/index.js",
    "scripts": {
@@ -17,7 +17,7 @@
    "author": "",
    "license": "ISC",
    "dependencies": {
-      "@cyklang/core": "^0.5.2",
+      "@cyklang/core": "^0.5.3",
       "commander": "^9.4.0",
       "dotenv": "^16.0.1",
       "form-data": "^4.0.0",