@cocreate/cli 1.15.0 → 1.16.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.16.0](https://github.com/CoCreate-app/CoCreate-cli/compare/v1.15.0...v1.16.0) (2023-02-21)
+
+
+### Features
+
+* run symlink on coc install ([c4bdf15](https://github.com/CoCreate-app/CoCreate-cli/commit/c4bdf15d7b7f6c6cbe90a68904ca6042f2d6db38))
+
 # [1.15.0](https://github.com/CoCreate-app/CoCreate-cli/compare/v1.14.30...v1.15.0) (2023-02-18)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/cli",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "description": "Polyrepo management bash CLI tool. Run all git commands and yarn commands on multiple repositories. Also includes a few custom macros for cloning, installing, etc.",
   "keywords": [
     "cli",
@@ -77,7 +77,6 @@
     "colors": "latest",
     "glob": "^7.1.7",
     "got": "latest",
-    "minimist": "latest",
     "prettier": "^2.3.2",
     "prompt": "^1.2.0"
   }

package/repositories.js

@@ -87,7 +87,7 @@ module.exports = [
         'repo': 'github.com/CoCreate-app/CoCreate-elements.git'
     },
     {
-        'path': '../CoCreate-components/CoCreate-events',
+        'path': '/home/ubuntu/CoCreateServer/CoCreate-components/CoCreate-events',
         'repo': 'github.com/CoCreate-app/CoCreate-events.git'
     },
     {
@@ -214,10 +214,6 @@ module.exports = [
         'path': '/home/ubuntu/CoCreateServer/CoCreate-components/CoCreate-select',
         'repo': 'github.com/CoCreate-app/CoCreate-select.git'
     },
-    {
-        'path': '/home/ubuntu/CoCreateServer/CoCreate-components/CoCreate-selected',
-        'repo': 'github.com/CoCreate-app/CoCreate-selected.git'
-    },
     {
         'path': '/home/ubuntu/CoCreateServer/CoCreate-components/CoCreate-selection',
         'repo': 'github.com/CoCreate-app/CoCreate-selection.git'
@@ -238,10 +234,6 @@ module.exports = [
         'path': '/home/ubuntu/CoCreateServer/CoCreate-components/CoCreate-text',
         'repo': 'github.com/CoCreate-app/CoCreate-text.git'
     },
-    // {
-    //     'path': '/home/ubuntu/CoCreateServer/CoCreate-components/CoCreate-toggle',
-    //     'repo': 'github.com/CoCreate-app/CoCreate-toggle.git'
-    // },
     {
         'path': '/home/ubuntu/CoCreateServer/CoCreate-components/CoCreate-toolbar',
         'repo': 'github.com/CoCreate-app/CoCreate-toolbar.git'
@@ -350,10 +342,6 @@ module.exports = [
         'path': '/home/ubuntu/CoCreateServer/CoCreate-plugins/CoCreate-linkedin',
         'repo': 'github.com/CoCreate-app/CoCreate-linkedin.git'
     },
-    // {
-    //     'path': '/home/ubuntu/CoCreateServer/CoCreate-plugins/CoCreate-monaco',
-    //     'repo': 'github.com/CoCreate-app/CoCreate-monaco.git'
-    // },
     {
         'path': '/home/ubuntu/CoCreateServer/CoCreate-plugins/CoCreate-pickr',
         'repo': 'github.com/CoCreate-app/CoCreate-pickr.git'
@@ -370,10 +358,6 @@ module.exports = [
         'path': '/home/ubuntu/CoCreateServer/CoCreate-plugins/CoCreate-prism',
         'repo': 'github.com/CoCreate-app/CoCreate-prism.git'
     },
-    // {
-    //     'path': '/home/ubuntu/CoCreateServer/CoCreate-plugins/CoCreate-quill',
-    //     'repo': 'github.com/CoCreate-app/CoCreate-quill.git'
-    // },
     {
         'path': '/home/ubuntu/CoCreateServer/CoCreate-plugins/CoCreate-s3',
         'repo': 'github.com/CoCreate-app/CoCreate-s3.git'
@@ -409,14 +393,14 @@ module.exports = [
 
 
 
-    // {
-    //     'path': '/home/ubuntu/CoCreateServer/CoCreateWS',
-    //     'repo': 'github.com/CoCreate-app/CoCreateWS.git'
-    // },
-    // {
-    //     'path': '/home/ubuntu/CoCreateServer/CoCreateApi',
-    //     'repo': 'github.com/CoCreate-app/CoCreateApi.git'
-    // },
+    {
+        'path': '/home/ubuntu/CoCreateServer/CoCreateWS',
+        'repo': 'github.com/CoCreate-app/CoCreateWS.git'
+    },
+    {
+        'path': '/home/ubuntu/CoCreateServer/CoCreateApi',
+        'repo': 'github.com/CoCreate-app/CoCreateApi.git'
+    },
     
     {
         'path': '/home/ubuntu/CoCreateServer/CoCreateLB',
@@ -479,14 +463,6 @@ module.exports = [
         'path': '/home/ubuntu/CoCreateServer/CoCreate-components/CoCreate-keepalived',
         'repo': 'github.com/CoCreate-app/CoCreate-keepalived.git'
     },
-    // {
-    //     'path': '/home/ubuntu/CoCreateServer/CoCreate-components/CoCreate-mongodb',
-    //     'repo': 'github.com/CoCreate-app/CoCreate-mongodb.git'
-    // },
-    // {
-    //     'path': '/home/ubuntu/CoCreateServer/CoCreate-components/CoCreate-openebs',
-    //     'repo': 'github.com/CoCreate-app/CoCreate-openebs.git'
-    // },
     {
         'path': '/home/ubuntu/CoCreateServer/CoCreate-components/CoCreate-ide',
         'repo': 'github.com/CoCreate-app/CoCreate-ide.git'

package/src/addMeta.js

@@ -1,60 +1,65 @@
 const fs = require('fs')
 const path = require("path")
+const util = require('node:util');
+const exec = util.promisify(require('node:child_process').exec);
+
+module.exports = async function addMeta(repos, failed, directory) {
+    let packageManager;
+    for (let i = 0; i < repos.length; i++) {
+        repos[i].name = path.basename(repos[i].path);
+        repos[i].plainName = repos[i].name.substr(9);
+
+        if (directory) {
+            repos[i].ppath = path.resolve(directory, repos[i].path);
+            repos[i].absolutePath = path.resolve(directory, repos[i].path);
+            repos[i].directory = directory;        
+        }
 
-module.exports = function addMeta(repos, failed) {
-    return repos.map(repo => {
-        let {
-            name,
-            ppath
-        } = repo;
-
-
-
-        let packagejson = path.resolve(ppath, 'package.json');
+        let packagejson = path.resolve(repos[i].absolutePath, 'package.json');
         if (!fs.existsSync(packagejson)) {
-            console.error('package json not found for', name);
+            console.error('package json not found for', repos[i].name);
             failed.push({
-                name,
+                name: repos[i].name,
                 des: 'package json not found'
             })
-            return false;
         }
+
         let packageObj
         try {
             packageObj = require(packagejson);
-
         }
         catch (err) {
-            console.error(err.message)
-            return false;
+            console.error('packageObj', err.message)
         }
 
 
-        let packageName = name.startsWith('cocreate-') ?
-            '@cocreate/' + name.substr(9) : packageObj.name;
+        repos[i].packageName = packageObj.name;
 
-        let deps = Object.keys(packageObj['dependencies'] || {})
+        repos[i].deps = Object.keys(packageObj['dependencies'] || {})
             .filter(packageName => packageName.startsWith('@cocreate/'));
-        let devDeps = Object.keys(packageObj['devDependencies'] || {})
+        repos[i].devDeps = Object.keys(packageObj['devDependencies'] || {})
             .filter(packageName => packageName.startsWith('@cocreate/'));
-
-        // let nodeModulePath = path.resolve(ppath, './node_modules/@cocreate');
-
-        // let deps  = fs.existsSync(nodeModulePath) ?
-        // fs.readdirSync(nodeModulePath).map(name => '@cocreate/' + name):
-        // [];
-
-        return { ...repo,
-            name,
-            packageName,
-            ppath,
-            deps,
-            devDeps
-
+        
+        if (!repos[i].packageManager) {
+            if (packageManager)
+                repos[i].packageManager = packageManager
+            else {
+                repos[i].packageManager = 'npm'
+                let lockFile = path.resolve(repos[i].absolutePath, 'package-lock.json');
+                if (!fs.existsSync(lockFile)) {
+                    lockFile = path.resolve(repos[i].absolutePath, 'yarn.lock');
+                    if (fs.existsSync(lockFile))
+                        repos[i].packageManager = 'yarn'
+                    else {
+                        const { error } = await exec('yarn --version');
+                        if (!error)
+                            repos[i].packageManager = 'yarn'
+                    }
+                    packageManager = repos[i].packageManager
+                }
+            }
         }
+    }
 
-
-
-    })
-
+    return repos
 } 

package/src/coc.js

@@ -1,32 +1,30 @@
 #!/usr/bin/env node
-
-const minimist = require('minimist');
-
 const path = require("path");
 const fs = require("fs");
 const execute = require('./execute');
 const argv = process.argv.slice(2);
-console.log('bumper')
+const addMeta = require('./addMeta');
+
 
 if (argv.length < 1) {
     console.error("enter some command to do something");
     process.exit(1);
 }
+let repos, command, config = {};
+
+const options = ['-self']
+for (let option of options) {
+    if (argv.includes(option)) {
+        config.self = true
+        const index = argv.indexOf(option);
+        delete argv[index];
+    }
+}
 
-
-let config = minimist(argv, {
-    alias: { config: 'c', absolutePath: 'cf', hideMessage: 'h' },
-    stopEarly: true
-});
-
-
-let repos, command;
-
-command = config['_']
+command = argv
     .map((part) => part.match(/ |'|"/) ? `'${part.replace(/'/,'\\\'')}'` : part)
     .join(" ");
 
-
 function getRepositories(path) {
     try {
         return require(path);
@@ -38,23 +36,18 @@ function getRepositories(path) {
 }
 
 const currentRepoPath = path.resolve(process.cwd(), "./repositories.js");
-// let cliRepoPath = path.resolve(__dirname, '..', 'repositories.js');
 let packageJsonPath = path.resolve(process.cwd(), './package.json');
-let repoDir, doAllRepo;
+let directory
 
-if (fs.existsSync(config['c'])) {
+if (config['c'] && fs.existsSync(config['c'])) {
     repos = getRepositories(config['c']);
-        repoDir = path.dirname(config['c']);
-        doAllRepo = false;
-      console.warn(`using ${config['c']} configuration`.yellow);
-}
-else if (fs.existsSync(currentRepoPath)) {
+    directory = path.dirname(config['c']);
+    console.warn(`using ${config['c']} configuration`.yellow);
+} else if (!config['self'] && fs.existsSync(currentRepoPath)) {
     repos = getRepositories(currentRepoPath);
-    repoDir = path.dirname(currentRepoPath);
-    doAllRepo = true;
+    directory = path.dirname(currentRepoPath);
     console.warn(`using ${currentRepoPath} configuration`.yellow);
-}
-else if (fs.existsSync(packageJsonPath)) {
+} else if (fs.existsSync(packageJsonPath)) {
     let repoPath = path.resolve(process.cwd());
     let packageObj = require(packageJsonPath);
     let repoUrl = packageObj.repository.url.substr(12);
@@ -62,53 +55,18 @@ else if (fs.existsSync(packageJsonPath)) {
         path: `${repoPath}`,
         repo: `${repoUrl}`
     }];
-    repoDir = path.dirname(packageJsonPath);
-    doAllRepo = false;
+    directory = path.dirname(packageJsonPath);
     console.warn(`using ${packageJsonPath} configuration`.yellow);
-}
-// else if (fs.existsSync(cliRepoPath)) {
-  
-//     repos = getRepositories(cliRepoPath)
-//         repoDir = path.dirname(cliRepoPath);
-//         doAllRepo = false;
-//       console.warn(`using ${cliRepoPath} configuration`.yellow)
-
-// }
-else {
+} else {
     console.error(`a configuration file can not be found`.red);
     process.exit(1);
 }
-config = {hideMessage: false, ...config, repoDir, doAllRepo };
-
-let repoFullMeta = repos.map(meta => {
-    let name = path.basename(meta.path).toLowerCase();
-    let plainName = name.substr(9);
-    let ppath = path.resolve(repoDir, meta.path);
-    try {
-        if (!fs.existsSync(ppath))
-            console.error(`${ppath} not found`.red);
-
-        return { ...meta, name, ppath, plainName };
-    }
-    catch (err) {
-        console.error(name.red, err.message.red, ppath);
-        // process.exit(1)
-    }
-
-});
+config = {hideMessage: false, ...config };
 
 (async() => {
-    if (command == 'bump'){
-        console.log('bumping')
-        let predefined = path.resolve(__dirname, 'commands', command + '.js');
-        require(predefined)(repos, repos )
-    }
-    if (command == 'gitConfig'){
-        let predefined = path.resolve(__dirname, 'commands', command + '.js');
-        require(predefined)(repos, repos )
-    }
-    else {
-        let failed = await execute(command, repoFullMeta, config);
+    repos = await addMeta(repos, [], directory)
+    let failed = await execute(command, repos, config);
+    if (failed) {
         if (failed.length === 0)
             process.exit(0);
         else {
@@ -118,5 +76,4 @@ let repoFullMeta = repos.map(meta => {
 
         }
     }
-    // console.log(`success: ${report.success}`.green, `failed: ${report.fail}`.red);
 })();

package/src/commands/bump.js

@@ -1,126 +1,85 @@
-
 let fs = require('fs');
-const prettier = require("prettier");
-let list = require('../../../repositories.js');
 const path = require("path")
-
-const spawn = require('../spawn');
 const colors = require('colors');
-const addMeta = require('../addMeta');
-
-let pathList = list.map(o => o.path)
-let nameList = pathList.map(fn => path.basename(fn).toLowerCase());
-console.log('pathList', pathList)
-console.log('pathList', nameList)
-let item = {}
-
-// ToDo: excute using command coc bump. when executed it will check for a repository.js file. same as other commands/
-// (async() => {
-
-//     for (let [index, name] of nameList.entries()) {
-//         getVersions(pathList[index] + '/package.json', name).
-//     }
-//     // console.log('bump versions', item)
-//     // for (let [index, name] of nameList.entries()) {
-//     //     await bumpVersion(pathList[index] + '/package.json', name)
-//     // }
-
-
-// })();
-
-// module.exports = async function run() {
-//     try {
-//         for (let [index, name] of nameList.entries()) {
-//             getVersions(pathList[index] + '/package.json', `@${name}`)
-//          }
-//          console.log('bump versions', item)
-     
-//          for (let [index, name] of nameList.entries()) {
-//              await bumpVersion(pathList[index] + '/package.json', name)
-//          }
-//     } catch (err) {
-//         failed.push({ name: 'GENERAL', des: err.message })
-//     }
-
-//     console.log('completed')
-//     return failed
-//     // process.exit()  
-// }
-
-
-async function run() {
-//     let failed = [];
-
-//     try {
-//         repos = addMeta(repos, failed)
-
-//     }
-//     catch (err) {
-//         failed.push({
-//             name: 'GENERAL',
-//             des: err.message
-//         })
+const util = require('node:util');
+const exec = util.promisify(require('node:child_process').exec);
+
+
+let pathList, nameList, item = {}, failed = [];
+
+module.exports = async function bump(repos) {
+    pathList = repos.map(o => o.path)
+    if (repos.length === 1) {
+        let packageJsonPath = path.resolve(process.cwd(), './package.json');
+
+        if (fs.existsSync(packageJsonPath)) {
+            let object = require(packageJsonPath)
+            if (object.dependencies) {
+                for (let key of Object.keys(object.dependencies)) {
+                    if (key.startsWith("@cocreate/")) {
+                        const version = await exec(`npm view ${key} version`);
+                        item[key] = `^${version.stdout}`.trim()
+                    }
+                }
+                console.log('bump versions', item)
+
+                for (let name of Object.keys(item)) {
+                    bumpVersion(packageJsonPath, name)
+                }
+            }
+        }
 
-//     }
+    } else {
+        nameList = pathList.map(fn => path.basename(fn).toLowerCase());
 
-//     // console.log(repos)
-//     // return [];
-//     for (let repo of repos) {
-//         await reAdd(repo.deps, repo, failed, '')
-//         await reAdd(repo.devDeps, repo, failed, '-D ')
-//     }
-//     return failed;
+        for (let [index, name] of nameList.entries()) {
+            getVersions(pathList[index] + '/package.json', `@${name}`)
+        }
 
-// }
+        console.log('bump versions', item)
 
-    for (let [index, name] of nameList.entries()) {
-       getVersions(pathList[index] + '/package.json', `@${name}`)
-    }
-    console.log('bump versions', item)
+        for (let [index, name] of nameList.entries()) {
+            bumpVersion(pathList[index] + '/package.json', name)
+        }
 
-    for (let [index, name] of nameList.entries()) {
-        await bumpVersion(pathList[index] + '/package.json', name)
     }
 
     console.log('completed')
-    // process.exit()  
+    return failed;
 }
 
-function getVersions(path, name) {
-    if (!fs.existsSync(path))
-        return console.error('path doesn\'t exist:', path)
-    let object = require(path)
-    if (object.name && object.version) {
-        item[object.name] = `^${object.version}`
+function getVersions(filePath) {
+    if (fs.existsSync(filePath)) {
+        let object = require(filePath)
+        if (object.name && object.version) {
+            item[object.name] = `^${object.version}`
+        }
+    } else {
+        failed.push({name: 'get version', des: 'path doesn\'t exist:' + filePath})
     }
 }
 
 function bumpVersion(filePath, name) {
-    if (!fs.existsSync(filePath))
-        return console.error('path doesn\'t exist:', path)
     let object = require(filePath)
-    let newObject = {...object}
-
-    if (!object.dependencies)
-        return console.log(name, 'not updated')
-    else {
-        for (const name of Object.keys(object.dependencies)) {
-            if (item[name]) {
-                newObject.dependencies[name] = item[name]
+    if (object) {
+        let newObject = {...object}
+    
+        if (!object.dependencies)
+            return console.log(name, 'not updated')
+        else {
+            for (const name of Object.keys(object.dependencies)) {
+                if (item[name]) {
+                    newObject.dependencies[name] = item[name]
+                }
             }
-        }
-
-        // let str = JSON.stringify(object, null, 2)
-        // let formated = prettier.format(str, { semi: false, parser: "json" });
 
-        filePath = filePath.replace('/package.json', '')
-        let Path = path.resolve(filePath, 'package.json')
-        if (fs.existsSync(Path)){
-            fs.unlinkSync(Path)
+            if (fs.existsSync(filePath)){
+                fs.unlinkSync(filePath)
+            }
+    
+            fs.writeFileSync(filePath, JSON.stringify(object, null, 2))
         }
-
-        fs.writeFileSync(Path, JSON.stringify(object, null, 2))
+    } else {
+        failed.push({name: 'bump version', des: 'path doesn\'t exist:' + filePath})
     }
 }
-
-// run()

package/src/commands/clone.js

@@ -5,22 +5,21 @@ const path = require('path');
 
 module.exports = async function gitClone(repos) {
     const failed = [];
-    for (let meta of repos) {
-
-        let { repo, path: ppath, name } = meta;
-        let usernamePrompt = true;
-
-        let dirPath = path.dirname(ppath);
-        let exitCode = await spawn('mkdir', ['-p', dirPath], { stdio: 'inherit', cwd: process.cwd() })
-        if (exitCode !== 0) {
-            failed.push({ name, des: `creating directory failed` })
-
-        }
-
-        exitCode = await spawn('git', ['clone', `https://${repo}`], { stdio: 'inherit', cwd: dirPath })
-        if (exitCode !== 0) {
-            failed.push({ name, des: `cloning ${name} failed` })
-
+    const cwdPath = path.resolve(process.cwd());
+
+    for (let i = 0; i < repos.length; i++) {
+        if (cwdPath !== repos[i].absolutePath) {
+            let exitCode = await spawn('mkdir', ['-p', repos[i].directory], { stdio: 'inherit', cwd: process.cwd() })
+            if (exitCode !== 0) {
+                failed.push({ name: repos[i].name, des: `creating directory failed` })
+            }
+    
+            exitCode = await spawn('git', ['clone', `https://${repos[i].repo}`], { stdio: 'inherit', cwd: repos[i].directory })
+            if (exitCode !== 0) {
+                failed.push({ name: repos[i].name, des: `cloning failed` })
+    
+            }
+    
         }
     }
 

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,30 +1,14 @@
-const util = require('node:util');
-const exec = util.promisify(require('node:child_process').exec);
-const spawn = require('../spawn');
+const addMeta = require('../addMeta');
 
-module.exports = async function( repos, allRepos,) {
+module.exports = async function(repos) {
     let failed = [];
     try {
-        
         let cloneFailed = await require('./clone.js')(repos)
+        repos = await addMeta(repos, failed)
 
-        let linkFailed = await require('./link.js')( repos, allRepos)
-        failed = [...cloneFailed, ...linkFailed];
-        
-        let packageManager = 'npm'
-        const { error } = await exec('yarn --version');
-        if (!error)
-            packageManager = 'yarn';
-    
-            
-        let exitCode = spawn(packageManager, ['start'], { 
-            cwd: '../CoCreateJS',
-            shell: true,
-            stdio: 'inherit'
-        })
-        if (exitCode !== 0) {
-            failed.push({ name: 'cocreatejs', des: `${packageManager} 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 })

package/src/commands/link.js

@@ -1,45 +1,16 @@
 const spawn = require('../spawn');
 const colors = require('colors');
-const addMeta = require('../addMeta');
-
-const util = require('node:util');
-const exec = util.promisify(require('node:child_process').exec);
-
-module.exports = async function linkPackages(repos, allrepo) {
-    let packageManager = 'npm'
-    const { error } = await exec('yarn --version');
-    if (!error)
-        packageManager = 'yarn';
 
+module.exports = async function linkPackages(repos) {
     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 {
         for (let repo of repos) {
+            if (!repo) continue;
 
-            if (!repo)
-                continue;
-
-            let {
-                packageName,
-                deps,
-                devDeps,
-            } = repo;
-
-            console.log(packageName, 'configuring ...')
-            await doLink(deps, repo, allrepo, failed, isLinked, packageManager)
-            await doLink(devDeps, repo, allrepo, failed, isLinked, packageManager)
+            console.log(repo.packageName, 'configuring ...')
+            await doLink(repo.deps, repo, repos, failed, isLinked)
+            await doLink(repo.devDeps, repo, repos, failed, isLinked)
         }
     }
     catch (err) {
@@ -51,16 +22,19 @@ module.exports = async function linkPackages(repos, allrepo) {
 }
 
 
-async function doLink(deps, repo, allrepo, failed, isLinked, packageManager) {
+async function doLink(deps, repo, repos, failed, isLinked) {
+    let { packageManager } = repo;
+
     for (let dep of deps) {
-        let depMeta = allrepo.find(meta => meta.packageName === dep);
+        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;
             }
 

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

@@ -7,45 +7,29 @@ const exec = util.promisify(require('node:child_process').exec);
 
 
 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) {
-                    const strCommand = command.join(' ');
-                    const { error } = await exec(strCommand, {
+                    const { error } = await exec(command, {
                         cwd: repo.ppath,
                     });
                 
@@ -60,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)
-    }
-
-}

package/src/repoList.js

@@ -1,44 +0,0 @@
-const path = require("path");
-const fs = require("fs");
-
-module.exports = async function getRepoList(){
-    const currentRepoPath = path.resolve(process.cwd(), "./repositories.js");
-    const  packageJsonPath = path.resolve(process.cwd(), './package.json');
-    
-    let repos, repoDir, doAllRepo;
-    
-    if (fs.existsSync(currentRepoPath)) {
-        repos = getRepositories(currentRepoPath);
-        repoDir = path.dirname(currentRepoPath);
-        doAllRepo = true;
-        console.warn(`using ${currentRepoPath} configuration`.yellow);
-    }
-    else if (fs.existsSync(packageJsonPath)) {
-        let repoPath = path.resolve(process.cwd());
-        let packageObj = require(packageJsonPath);
-        let repoUrl = packageObj.repository.url.substr(12);
-        repos = [{
-            path: `${repoPath}`,
-            repo: `${repoUrl}`
-        }];
-        repoDir = path.dirname(packageJsonPath);
-        doAllRepo = false;
-        console.warn(`using ${packageJsonPath} configuration`.yellow);
-    }
-    else {
-        console.error(`a configuration file can not be found`.red);
-        process.exit(1);
-    }
-    
-    return repos;
-}
-
-function getRepositories(path) {
-    try {
-        return require(path);
-    }
-    catch (err) {
-        console.error('can not read repository file in'.red, path, 'error:'.red, err.message.red);
-        process.exit(1);
-    }
-}