@cocreate/cli 1.14.30 → 1.16.0

package/src/commands/git/gitConfig.js

@@ -1,79 +1,71 @@
-const getRepoList = require('../repoList');
 let fs = require('fs');
 const path = require("path");
-let list = getRepoList()
-console.log(list)
 
-const prompt = require('prompt');
+module.exports = async function linkPackages(repos) {
+    const failed = []
+    const prompt = require('prompt');
 
-prompt.start();
+    prompt.start();
 
-const properties = [
-    {
-        name: 'email',
-    },
-    {
-        name: 'name',
-    },
-    {
-        name: 'username',
-    },
-    {
-        name: 'password',
-        hidden: true
-    }
-];
+    const properties = [
+        {
+            name: 'email',
+        },
+        {
+            name: 'name',
+        },
+        {
+            name: 'username',
+        },
+        {
+            name: 'password',
+            hidden: true
+        }
+    ];
 
-prompt.get(properties, async function (err, result) {
-    if (err) { return console.error(err); }
-    await updateConfig(result);
-});
+    prompt.get(properties, async function (err, result) {
+        if (err) 
+            return [{
+                name: 'gitConfig',
+                des: err
+            }]
 
+        await updateConfig(result);
+    });
 
-let metaYarnLink = list.map(meta => {
-    let repoName = path.basename(meta.path);
-    try {
-        let ppath = path.resolve(meta.path);
-        return { ...meta, repoName, ppath,  };
-    }
-    catch (err) {
-        console.error('error: ', repoName, err.message);
-        return meta;
+    async function updateConfig(result){
+        (async() => {
+            for (let repo of repos) {
+                await update(repo, result);
+            }
+            console.log('finished');
+            return failed
+        })();
     }
 
-});
+    function update(param, result) {
+        if (!param) return;
+        let { absoutePath, name } = param;
+        let fileContent = `[core]
+        repositoryformatversion = 0
+        filemode = true
+        bare = false
+        logallrefupdates = true
+    [user]
+        name = ${result.name}
+        email = ${result.email}	
+    [remote "origin"]
+        url = https://${result.username}:${result.password}@github.com/CoCreate-app/${name}.git
+        fetch = +refs/heads/*:refs/remotes/origin/*
+    [branch "master"]
+        remote = origin
+        merge = refs/heads/master
 
-async function updateConfig(result){
-    (async() => {
-        for (let meta of metaYarnLink) {
-            await update(meta, result);
-        }
-        console.log('finished');
-    })();
-}
+    `;
 
-function update(param, result) {
-    if (!param) return;
-    let { ppath, repoName } = param;
-    let fileContent = `[core]
-	repositoryformatversion = 0
-	filemode = true
-	bare = false
-	logallrefupdates = true
-[user]
-	name = ${result.name}
-	email = ${result.email}	
-[remote "origin"]
-	url = https://${result.username}:${result.password}@github.com/CoCreate-app/${repoName}.git
-	fetch = +refs/heads/*:refs/remotes/origin/*
-[branch "master"]
-	remote = origin
-	merge = refs/heads/master
-
-`;
-
-    let MdPath = path.resolve(ppath, '.git/config');
-    if (fs.existsSync(MdPath))
-        fs.unlinkSync(MdPath);
-    fs.writeFileSync(MdPath, fileContent);
-}
+        let MdPath = path.resolve(absoutePath, '.git/config');
+        if (fs.existsSync(MdPath))
+            fs.unlinkSync(MdPath);
+        fs.writeFileSync(MdPath, fileContent);
+    }
+}

package/src/commands/gitConfig.js

@@ -66,5 +66,7 @@ async function updateConfig(repos, result){
         fs.writeFileSync(MdPath, fileContent);
         console.log('configured: ', meta.repo);
     }
-        console.log('finished');
+    console.log('finished');
+    return failed
+
 }

package/src/commands/install.js

@@ -1,24 +1,17 @@
-const spawn = require('../spawn');
-const execute = require('../execute')
-module.exports = async function( repos, allRepos,) {
+const addMeta = require('../addMeta');
+
+module.exports = async function(repos) {
     let failed = [];
     try {
-        
         let cloneFailed = await require('./clone.js')(repos)
+        repos = await addMeta(repos, failed)
 
-        let installFailed = await require('./yarnInstall.js')(repos)
-
-        let linkFailed = await require('./link.js')( repos, allRepos)
-        failed = [...cloneFailed, ...installFailed, ...linkFailed];
-
-        let exitCode = spawn('yarn', ['start', '-w'], { cwd: '../CoCreateJS' })
-        if (exitCode !== 0) {
-            failed.push({ name: 'cocreatejs', des: `yarn start failed` })
-        }
+        let symlinkFailed = await require('./symlink.js')(repos)
+        let linkFailed = await require('./link.js')(repos)
+        failed = [...cloneFailed, ...symlinkFailed, ...linkFailed];
     } catch (err) {
         console.error(err);
         failed.push({ name: 'general', des: err.message })
-
     }
     return failed;
 }

package/src/commands/link.js

@@ -1,113 +1,81 @@
-const fs = require('fs')
-const path = require("path")
-const {
-    promisify
-} = require('util');
 const spawn = require('../spawn');
 const colors = require('colors');
-const addMeta = require('../addMeta');
 
+module.exports = async function linkPackages(repos) {
+    const failed = [], isLinked = {};
 
-
-
-
-module.exports = async function updateYarnInstall(repos, allrepo) {
-
-    const failed = [],
-        isLinked = {};
     try {
-        repos = addMeta(repos, failed)
-        allrepo = addMeta(allrepo, failed)
-
-    }
-    catch (err) {
-        failed.push({
-            name: 'GENERAL',
-            des: err.message
-        })
-        console.log(err)
-    }
-
-    try {
-        //   console.log(repos)
-
         for (let repo of repos) {
+            if (!repo) continue;
 
-            if (!repo)
-                continue;
-
-
-            let {
-                ppath,
-                packageName,
-                deps,
-                devDeps,
-                name
-            } = repo;
-
-            console.log(packageName, 'configuring ...')
-            await doLink(deps, repo, allrepo, failed, isLinked)
-            await doLink(devDeps, repo, allrepo, failed, isLinked)
+            console.log(repo.packageName, 'configuring ...')
+            await doLink(repo.deps, repo, repos, failed, isLinked)
+            await doLink(repo.devDeps, repo, repos, failed, isLinked)
         }
     }
     catch (err) {
         failed.push({ name: 'GENERAL', des: err.message })
-        console.error(err.red)
+        console.error(`${err}`.red)
     }
 
     return failed;
 }
 
 
-async function doLink(deps, repo, allrepo, failed, isLinked) {
+async function doLink(deps, repo, repos, failed, isLinked) {
+    let { packageManager } = repo;
+
     for (let dep of deps) {
-        let depMeta = allrepo.find(meta => meta.packageName === dep);
-        //                 console.log(depMeta)
-        // return failed;
+        let depMeta = repos.find(meta => meta.packageName === dep);
         try {
             if (!depMeta) {
+                // ToDo: search file system for a package.json containing the package.name
                 failed.push({
                     name: repo.name,
-                    des: `"${depMeta.packageName}" component can not be found in repositories.js`
+                    des: `"${dep}" component can not be found in repositories.js`
                 })
-                console.error(`${repo.name}: "${depMeta.packageName}" component can not be found in repositories.js`.red)
+                console.error(`${repo.name}: "${dep}" component can not be found in repositories.js`.red)
                 continue;
             }
 
 
 
             if (!isLinked[depMeta.packageName]) {
+
                 isLinked[depMeta.packageName] = true;
-                let exitCode = await spawn('yarn', ['link'], {
+                let exitCode = await spawn(packageManager, ['link'], {
                     cwd: depMeta.ppath,
-                    stdio: 'inherit',
+                    shell: true,
+                    stdio: 'inherit'
                 });
+                
                 if (exitCode !== 0) {
                     failed.push({
                         name: depMeta.name,
-                        des: `yarn link failed`
+                        des: `${packageManager} link failed`
                     })
-                    console.error(`${depMeta.name}: yarn link failed`.red)
+                    console.error(`${depMeta.name}: ${packageManager} link failed`.red)
                 }
             }
             console.log(repo.packageName, 'linking', depMeta.packageName, '...')
 
-            let exitCode = await spawn('yarn', ['link', depMeta.packageName], {
+            let exitCode = await spawn(packageManager, ['link', depMeta.packageName], {
                 cwd: repo.ppath,
-                stdio: 'inherit',
+                shell: true,
+                stdio: 'inherit'
             })
             if (exitCode !== 0) {
                 failed.push({
                     name: repo.name,
-                    des: `yarn link ${depMeta.packageName} failed`
+                    des: `${packageManager} link ${depMeta.packageName} failed`
                 });
-                console.error(`${repo.name}: yarn link ${depMeta.packageName} failed`.red)
+                console.error(`${repo.name}: ${packageManager} link ${depMeta.packageName} failed`.red)
             }
 
         }
         catch (err) {
             failed.push({ name: repo.packageName, des: err.message })
-            console.error(err.red)
+            console.error(`${err}`.red)
         }
 
     }

package/src/commands/{add.js → other/add.js}

@@ -1,8 +1,8 @@
 const fs = require('fs')
 const path = require("path")
-const spawn = require('../spawn');
+const spawn = require('../../spawn');
 const colors = require('colors');
-const addMeta = require('../addMeta');
+const addMeta = require('../../addMeta');
 
 
 module.exports = async function updateYarnLink(repos) {

package/src/commands/{symbolic.js → other/symbolic.js}

@@ -3,9 +3,9 @@ const path = require("path")
 const {
     promisify
 } = require('util');
-const spawn = require('../spawn');
+const spawn = require('../../spawn');
 const colors = require('colors');
-const addMeta = require('../addMeta');
+const addMeta = require('../../addMeta');
 
 
 

package/src/commands/{yarnInstall.js → other/yarnInstall.js}

@@ -1,8 +1,8 @@
 const fs = require('fs');
 const path = require("path");
-const spawn = require('../spawn');
+const spawn = require('../../spawn');
 const colors = require('colors');
-const addMeta = require('../addMeta');
+const addMeta = require('../../addMeta');
 
 
 module.exports = async function updateYarnLink(repos) {

package/src/commands/symlink.js

@@ -0,0 +1,109 @@
+const fs = require('fs')
+const path = require("path")
+const util = require('node:util');
+const exec = util.promisify(require('node:child_process').exec);
+
+const cwdPath = path.resolve(process.cwd());
+const cwdNodeModulesPath = path.resolve(cwdPath, 'node_modules')
+
+
+// let doInstall = process.argv[2];
+// console.log('doInstall', doInstall)
+let reposLength, failed = [];
+
+module.exports = async function symlink(repos) {
+    reposLength = repos.length
+
+    for (let i = 0; i < repos.length; i++) {
+        if (repos[i].install == true) {
+            reposLength -= 1
+            await install(repos[i])
+        } else if (cwdPath !== repos[i].absolutePath) {
+            await createSymlink(repos[i])
+        }
+
+    }
+}
+
+
+async function createSymlink(repo) {
+    let dpath = path.resolve(repo.absolutePath);
+    if (!fs.existsSync(dpath)) {
+        failed.push({name: 'createSymlink', des: 'path doesn\'t exist:' + dpath})
+        return console.error(dpath, 'not exist')
+    }
+    let response = ''
+
+    try {
+        let dest = path.resolve(dpath, 'node_modules');
+        if (dest) {
+            if (fs.existsSync(dest)) {
+                fs.rm(dest, { recursive: true, force: true }, function (err) {
+                    if (err) {
+                        console.log('failed');
+                    }
+                    erSymlink(repo.name, dest)
+                });
+            } else {
+                erSymlink(repo.name, dest)
+            }
+        }
+    }
+    catch (err) {
+        failed.push({name: 'symlink', des: 'with response:' + response + err})
+        console.error(repo.name, 'failed to aquire symlink', 'with response:', response, err)
+    }
+
+}
+
+function erSymlink(name, dest){
+    fs.symlink( cwdNodeModulesPath, dest, 'dir', (err) => {
+        reposLength -= 1
+
+        if (err)
+          console.log(err);
+        else {
+          console.log(name, "node_modules symlink added");
+        }
+
+        if (!reposLength) {
+            console.log('symlink complete')
+            return failed
+        }
+    
+    })
+
+}
+
+
+async function install(repo) {
+    let dpath = repo.absolutePath
+    if (!fs.existsSync(dpath)) {
+        failed.push({name: 'install', des: 'path doesn\'t exist:' + dpath})
+        return console.error(dpath, 'not exist')
+    }
+    try {
+        // let node_modules = path.resolve(dpath, 'node_modules');
+        // if (fs.existsSync(node_modules)) {
+        //     fs.rm(node_modules, { recursive: true, force: true }, function (err) {
+        //         if (err) {
+        //             console.log('failed');
+        //         } else {
+        //             erSymlink(repo.name, dest)
+        //         }
+        //     });
+        // }
+        let {error} = await exec(`${repo.packageManager} install `, { cwd: dpath })
+        if (!error)
+            console.log(repo.name, 'installed')
+        else {
+            failed.push({name: 'install ', des: error})
+            console.error(repo.name, 'failed to install', error)
+        }
+
+    }
+    catch (err) {
+        console.error(repo.name, 'did not install', err)
+    }
+
+}

package/src/execute.js

@@ -1,54 +1,41 @@
 const colors = require('colors');
 const path = require("path");
 const fs = require("fs");
-const {
-    promisify
-} = require('util');
 const spawn = require('./spawn');
-const exec = promisify(require('child_process').exec);
+const util = require('node:util');
+const exec = util.promisify(require('node:child_process').exec);
 
-module.exports = async function execute(command, repos, config) {
 
+module.exports = async function execute(command, repos, config) {
     let failed = [];
     let predefined = path.resolve(__dirname, 'commands', command + '.js');
+
     if (fs.existsSync(predefined)) {
         console.warn(`executing a predefined command in ${predefined}`.blue);
-
-        if (config.doAllRepo) {
+   
+        if (repos.length == 1)
+            console.log(`running on ${repos[0].name} repo`.blue)
+        else
             console.log('running on all repos'.blue)
-            failed = require(predefined)(repos, repos )
-        }
-        else {
-            let currentRepoConfig = repos.find(m => m.name === path.basename(process.cwd()).toLowerCase());
-            if (currentRepoConfig && currentRepoConfig.ppath == path.resolve(process.cwd())) {
-                console.log(`running on ${currentRepoConfig.name} repo`.blue)
-                failed = require(predefined)([currentRepoConfig], repos )
-            }
-            else {
-                console.error(`${currentRepoConfig.name} can not be found or have diferent path`.red)
-            }
-        }
-
-
-    }
-    else {
 
+        failed = require(predefined)(repos)
 
+    } else {
+        let type = command.split(' ')[0]
         for (let repo of repos) {
-            if (!repo)
-                console.log(repo, repos)
-            // let repo = {name: 'aa', ppath: '/home/ubuntu/environment/CoCreate-plugins/CoCreate-sendgrid'}
             try {
-                const {
-                    name
-                } = repo;
-                console.log(`${name}: `.green, command)
+                if (repo.exclude && repo.exclude.includes(type)) 
+                    continue
+                console.log(`${repo.name}: `.green, command)
                 let exitCode;
-                if (config.hideMessage)
-                    exitCode = await exec(command, {
+                if (config.hideMessage) {
+                    const { error } = await exec(command, {
                         cwd: repo.ppath,
-                    })
-                else
+                    });
+                
+                    if (error)
+                        exitCode = 1
+                } else
                     exitCode = await spawn(command, null, {
                         cwd: repo.ppath,
                         shell: true,
@@ -57,27 +44,18 @@ module.exports = async function execute(command, repos, config) {
 
                 if (exitCode !== 0)
                     failed.push({
-                        name,
+                        name: repo.name,
                         des: 'command failed: ' + command
                     })
 
 
             }
             catch (err) {
-
                 console.error(`an error occured executing command in ${repo.name} repository`.red, err.message);;
-
             }
         }
-
-
-
     }
 
-
-
     return failed;
 
-
-
 }

package/src/commands/other/symbolic-link.js

@@ -1,116 +0,0 @@
-// install nodejs 14 from: https://github.com/nodesource/distributions/blob/master/README.md#installation-instructions
-// install yarn from https://classic.yarnpkg.com/en/docs/install/#debian-stable
-// -> alternatives -> debian/ununtu -> run the 3 commands there consecutively
-
-// both node and nodejs --version should be the same and > then v12
-const fs = require('fs')
-const path = require("path")
-const { promisify } = require('util');
-const exec = promisify(require('child_process').exec)
-let list = require('../repositories.js');
-
-let pathList = list.map(o => o.path);
-let nameList = pathList.map(fn => path.basename(fn).toLowerCase());
-
-let CoCreateJsPath = path.resolve('../CoCreateJS');
-// console.log(syarnInstall);
-// process.exit()
-
-const ignore = [
-    'CoCreateJS',
-    'CoCreate-repositories',
-    'CoCreate-charts',
-    'CoCreate-codemirror',
-    'CoCreate-crdt',
-    'CoCreate-croppie',
-    'CoCreate-docs',
-    'CoCreate-domain',
-    'CoCreate-facebook',
-    'CoCreate-fullcalendar',
-    'CoCreate-google-auth',
-    'CoCreate-instagram',
-    'CoCreate-lighthouse',
-    'CoCreate-linkedin',
-    'CoCreate-monaco',
-    'CoCreate-pinterest',
-    'CoCreate-pickr',
-    'CoCreate-progress-bar',
-    'CoCreate-quill',
-    'CoCreate-s3',
-    'CoCreate-sengrid',
-    'CoCreate-shipengine',
-    'CoCreate-stripe',
-    'CoCreate-twilio',
-    'CoCreate-twitter',
-    'CoCreate-uppy',
-];
-
-
-let doInstall = process.argv[2];
-
-
-
-
-(async() => {
-    for (let i = 0; i < ignore.length; i++) {
-        ignore[i] = ignore[i].toLowerCase();
-    }
-    for (let [index, name] of nameList.entries()) {
-        if (ignore.includes(name.toLowerCase()))
-        {
-            if (doInstall == "true")
-         await updateYarnInstall(pathList[index], name)
-        }
-        else
-            await updateSymbolic(pathList[index], name)
-
-    }
-})()
-
-
-
-async function updateSymbolic(dpath, name) {
-    // let packageName = path.basename(dpath);
-    let res1, res2;
-    dpath = path.resolve(dpath);
-    if (!fs.existsSync(dpath))
-        return console.error(dpath, 'not exist')
-
-    try {
-        let dest = path.resolve(dpath, 'node_modules');
-        if (fs.existsSync(dest))
-            fs.rmdirSync(dest, { recursive: true })
-        console.log('copying node_modules to', name);
-        res2 = await exec(`ln -sf ${CoCreateJsPath}/node_modules ${dest} `, { cwd: CoCreateJsPath })
-
-        console.log(name, 'is finished')
-    }
-    catch (err) {
-        console.error(name, 'had error for command', err.cmd, 'with response:', res1, res2, err)
-    }
-
-}
-
-
-
-async function updateYarnInstall(dpath, name) {
-    // let packageName = path.basename(dpath);
-    let res1, res2;
-    dpath = path.resolve(dpath);
-    if (!fs.existsSync(dpath))
-        return console.error(dpath, 'not exist')
-
-    try {
-        let node_modules = path.resolve(dpath, 'node_modules');
-        if (fs.existsSync(node_modules))
-            fs.rmdirSync(node_modules,{ recursive: true })
-        console.log('yarn install inside', name);
-        res2 = await exec(`yarn install `, { cwd: dpath })
-
-        console.log(name, 'is finished', '\n')
-    }
-    catch (err) {
-        console.error(name, 'had error for command', err.cmd, 'with response:', res1, res2, err)
-    }
-
-}