@cyklang/cli 0.5.4 → 0.5.5

package/src/InstallCommand.ts

@@ -1,113 +1,195 @@
-import { Cmd } from "./Cmd";
+import { Cmd, readPackageJson, runShellCommand } from "./Cmd";
 import * as fs from "fs"
 import * as path from "path"
-import {green, red, bold} from 'kolorist'
+import { green, red, bold } from 'kolorist'
 
 import loglevel from 'loglevel'
 import { uploadModule } from "./ModuleCommand";
+import { uninstallPackage } from "./UninstallCommand";
+import { DBManager, DBRemote } from "@cyklang/core";
+import { FileDescriptor, uploadAsset, uploadDirectory } from "./AssetCommand";
 const logger = loglevel.getLogger('InstallCommand.ts')
 logger.setLevel('debug')
 
 export class InstallCommand extends Cmd {
+    /**
+     * constructor
+     * @param name 
+     */
     constructor(name: string) {
         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: any, options: any) => {
                 await this.install(node_package, options)
             })
     }
 
+    /**
+     * method install
+     * @param node_package 
+     * @param options 
+     */
     async install(node_package: string, options: any) {
         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: string | undefined
-                const files = fs.readdirSync(xmlFolder)
-                for (let ind = 0; ind < files.length; ind++) {
-                    const file = files[ind]
-                    await uploadModule(path.join(xmlFolder, file), this.dbManager)
-                    if (file.endsWith('_init.xml')) {
-                        initModule = file
-                    }
-                }
-                console.log(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)
         }
     }
+}
+
+export async function installPackage(node_package: string, dbManager: DBManager, dbRemote: DBRemote) {
 
     /**
-     * method installNodePackage
-     * @param node_package 
+     * install the Node Package
      */
-    async installNodePackage(node_package: string) {
+    await installNodePackage(node_package, dbManager)
 
-        try {
-            await this.runShellCommand('npm', ['install', '--save-dev', node_package])
-        } catch (error) {
-            console.error('Error installing ' + node_package + ' :', error);
-            throw error
-        }
+    const installScript = await lookupInstallScript(node_package)
+
+    if (installScript) {
+        /**
+         * execute installScript
+         */
+        const installPath = path.join('node_modules', node_package, 'scripts', installScript)
+        await runShellCommand(installPath, [])
     }
+    else {
+        /**
+         * default install : upload modules and execute _init.xml
+         */
+        await defaultInstallScript(node_package, dbManager, dbRemote)
+    }
+
+}
+
+/**
+ * method defaultInstallScript
+ * @param node_package 
+ */
+async function defaultInstallScript(node_package: string, dbManager: DBManager, dbRemote: DBRemote) {
 
+    console.log()
+    console.log('Default install script')
     /**
-     * method lookupInstallScript
-     * @param node_package 
+     * upload package assets
      */
-    async lookupInstallScript(node_package: string): Promise<string | undefined> {
-        let result: string | undefined
-        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
+    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: string, dbManager: DBManager, dbRemote: 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 ...')
+    
+    if (!dbManager) throw 'dbManager undefined'
+    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 uploadDirectory(itemPath, dest, {yes: true}, dbManager, dbRemote)
         }
-        catch (err) {
-            throw err
+        else {
+            const dest = "/" + item
+            const fd: FileDescriptor = {path: path.join(assetFolder, item), mtime: new Date()}
+            await uploadAsset(fd, dest, dbManager, dbRemote)
         }
+        
     }
+    console.log(green('*') + ' upload assets to server')
+}
+
+/**
+ * function uploadModules
+ * @param node_package 
+ * @param dbManager 
+ */
+async function uploadPackageModules(node_package: string, dbManager: 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: string | undefined
+    const files = fs.readdirSync(moduleFolder)
+    for (let ind = 0; ind < files.length; ind++) {
+        const file = files[ind]
+        if (!dbManager) throw 'dbManager undefined'
+        await uploadModule(path.join(moduleFolder, file), dbManager)
+        if (file.endsWith('_init.xml')) {
+            initModule = file
+        }
+    }
+    console.log(green('*') + ' upload modules to server')
+    if (initModule) {
+        const initPath = path.join(moduleFolder, initModule)
+        await runShellCommand('npx', ['cyk', 'run', initPath])
+    }
+}
+
+/**
+ * method installNodePackage
+ * @param node_package 
+ */
+async function installNodePackage(node_package: string, dbManager: DBManager) {
+
+    try {
+        const packageJson = await 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 uninstallPackage(node_package, dbManager)
+        }
+
+        await 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: string): Promise<string | undefined> {
+    let result: string | undefined
+    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
+    }
 }

package/src/ModuleCommand.ts

@@ -147,6 +147,7 @@ export async function uploadModule(file: string, dbManager: 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
@@ -273,3 +274,14 @@ class ModuleDelete extends Cmd {
     }
 }
 
+/**
+ * function deleteModule
+ * @param dbname 
+ * @param dbManager 
+ */
+export async function deleteModule(dbname: string, dbManager: DBManager) {
+
+    const dbClient = new DBClient(dbManager)
+    await dbClient.deleteModule(dbname)
+}
+

package/src/UninstallCommand.ts

@@ -0,0 +1,145 @@
+import { Cmd, runShellCommand } from "./Cmd";
+import * as fs from "fs"
+import * as path from "path"
+import { green, red, bold } from 'kolorist'
+
+import loglevel from 'loglevel'
+import { deleteModule } from "./ModuleCommand";
+import { DBManager } from "@cyklang/core";
+const logger = loglevel.getLogger('UninstallCommand.ts')
+logger.setLevel('debug')
+
+export class UninstallCommand extends Cmd {
+    /**
+     * constructor
+     * @param name 
+     */
+    constructor(name: string) {
+        super(name)
+        this.description('run uninstall script and npm uninstall command')
+            .argument('<node_package>', 'Node Package installed as dev dependency')
+            .action(async (node_package: any, options: any) => {
+                await this.uninstall(node_package, options)
+            })
+    }
+
+    /**
+     * method uninstall
+     * @param node_package 
+     * @param options 
+     */
+    async uninstall(node_package: string, options: any) {
+        try {
+            await this.prologue(options)
+            if (this.dbManager === undefined) throw 'dbManager undefined'
+
+            await uninstallPackage(node_package, this.dbManager)
+        }
+        catch (err) {
+            logger.error(err)
+        }
+    }
+}
+
+/**
+ * function uninstallPackage
+ * @param node_package 
+ */
+export async function uninstallPackage(node_package: string, dbManager: DBManager) {
+
+    const uninstallScript = await lookupUninstallScript(node_package)
+    if (uninstallScript) {
+        /**
+         * run scripts/uninstall
+         */
+        const uninstallPath = path.join('node_modules', node_package, 'scripts', uninstallScript)
+        await runShellCommand(uninstallPath, [])
+    }
+    else {
+        /**
+         * default uninstall : 
+         */
+        await defaultUninstallScript(node_package, dbManager)
+    }
+
+    /**
+     * uninstall the node package
+     */
+    await uninstallNodePackage(node_package)
+
+}
+/**
+ * method defaultUninstallScript
+ * @param node_package 
+ */
+async function defaultUninstallScript(node_package: string, dbManager: DBManager) {
+    console.log()
+    console.log('Default uninstall script')
+    /**
+     * delete package modules from server
+     */
+    await deletePackageModules(node_package, dbManager)
+
+}
+
+/**
+ * function deletePackageModules
+ * @param node_package 
+ * @param dbManager 
+ * @returns 
+ */
+async function deletePackageModules(node_package: string, dbManager: 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 deleteModule(fileInfo.name, dbManager)
+    }
+    console.log(green('*') + ' delete modules from server')
+}
+
+/**
+ * function uninstallNodePackage
+ * @param node_package 
+ */
+async function uninstallNodePackage(node_package: string) {
+
+    try {
+        await 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: string): Promise<string | undefined> {
+    let result: string | undefined
+    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/src/index.ts

@@ -10,15 +10,17 @@ import { RunCommand } from './RunCommand'
 import { InstallCommand } from './InstallCommand'
 import { AssetCommand } from './AssetCommand'
 import { OpenCommand } from './OpenCommand'
+import { UninstallCommand } from './UninstallCommand'
 const logger = loglevel.getLogger("index.ts")
 logger.setLevel("debug")
 
 const program = new Command()
 program.name('cyk').description('cyklang CLI')
-    .version('0.5.4')
+    .version('0.5.5')
 
 program.addCommand(new InstallCommand('install'))
 program.addCommand(new InstallCommand('i'))
+program.addCommand(new UninstallCommand('uninstall'))
 program.addCommand(new AssetCommand('asset', 'manage assets'))
 program.addCommand(new AssetCommand('a', 'manage assets'))
 program.addCommand(new ModuleCommand('module'))