@cocreate/cli 1.15.0 → 1.16.1

package/src/commands/fs/readme.js

@@ -10,10 +10,10 @@ let list = require('../repositories.js');
 let metaYarnLink = list.map(meta => {
     let name = path.basename(meta.path).toLowerCase();
     try {
-        let ppath = path.resolve(meta.path);
+        let absolutePath = path.resolve(meta.path);
 
 
-        let packagejson = path.resolve(ppath, 'package.json');
+        let packagejson = path.resolve(absolutePath, 'package.json');
         if (!fs.existsSync(packagejson)) {
             console.error('package json not found for', name);
             return false;
@@ -23,7 +23,7 @@ let metaYarnLink = list.map(meta => {
         let packageName = name.startsWith('cocreate-') ?
             '@cocreate/' + name.substr(9) : packageObj.name;
 
-        return { ...meta, name, packageName, ppath, packageObj }
+        return { ...meta, name, packageName, absolutePath, packageObj }
     }
     catch (err) {
         console.error('error: ', name, err.message);
@@ -35,7 +35,6 @@ let metaYarnLink = list.map(meta => {
 (async() => {
     for (let meta of metaYarnLink) {
         await update(meta)
-        // await updateYarnLink(metaYarnLink[0])
     }
 })();
 
@@ -43,7 +42,7 @@ let metaYarnLink = list.map(meta => {
 function update(param) {
     // component name
     if (!param) return;
-    let { packageObj, ppath } = param;
+    let { packageObj, absolutePath } = param;
     let { name, description } = packageObj;
     let shortName = name.substr(10);
     let fileContent = `# CoCreate-${shortName}
@@ -127,7 +126,7 @@ We appreciate your continued support, thank you!
 
 `;
 
-    let MdPath = path.resolve(ppath, 'README.md')
+    let MdPath = path.resolve(absolutePath, 'README.md')
     let formated = prettier.format(fileContent, { semi: false, parser: "markdown" });
     if (fs.existsSync(MdPath))
         fs.unlinkSync(MdPath)

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,26 +22,30 @@ 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) {
-                failed.push({
-                    name: repo.name,
-                    des: `"${depMeta.packageName}" component can not be found in repositories.js`
-                })
-                console.error(`${repo.name}: "${depMeta.packageName}" component can not be found in repositories.js`.red)
-                continue;
-            }
+            // if (!depMeta) {
+            //     // ToDo: search file system for a package.json containing the package.name
+
+            //     failed.push({
+            //         name: repo.name,
+            //         des: `"${dep}" component can not be found in repositories.js`
+            //     })
+            //     console.error(`${repo.name}: "${dep}" component can not be found in repositories.js`.red)
+            //     continue;
+            // }
 
 
 
-            if (!isLinked[depMeta.packageName]) {
+            if (depMeta && !isLinked[depMeta.packageName]) {
 
                 isLinked[depMeta.packageName] = true;
                 let exitCode = await spawn(packageManager, ['link'], {
-                    cwd: depMeta.ppath,
+                    cwd: depMeta.absolutePath,
                     shell: true,
                     stdio: 'inherit'
                 });
@@ -83,10 +58,13 @@ async function doLink(deps, repo, allrepo, failed, isLinked, packageManager) {
                     console.error(`${depMeta.name}: ${packageManager} link failed`.red)
                 }
             }
+
+            if (!depMeta)
+                depMeta = {packageName: dep}
             console.log(repo.packageName, 'linking', depMeta.packageName, '...')
 
             let exitCode = await spawn(packageManager, ['link', depMeta.packageName], {
-                cwd: repo.ppath,
+                cwd: repo.absolutePath,
                 shell: true,
                 stdio: 'inherit'
             })

package/src/commands/other/add.js

@@ -41,7 +41,7 @@ async function reAdd(deps, repo, failed, param = '') {
             console.log(`${repo.name}: `.green, `yarn ${packageListLog}`);
             // let exitCode = await spawn(`yarn`, ['add', ...param && [param], packageList], {
             let exitCode = await spawn(  'yarn', packageList, {
-                cwd: repo.ppath, stdio: 'inherit',
+                cwd: repo.absolutePath, stdio: 'inherit',
             });
             if (exitCode !== 0) {
                 failed.push({

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,80 +7,55 @@ 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, {
-                        cwd: repo.ppath,
+                    const { error } = await exec(command, {
+                        cwd: repo.absolutePath,
                     });
                 
                     if (error)
                         exitCode = 1
                 } else
                     exitCode = await spawn(command, null, {
-                        cwd: repo.ppath,
+                        cwd: repo.absolutePath,
                         shell: true,
                         stdio: 'inherit'
                     })
 
                 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-crdt.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('../CoCreate-components/CoCreate-crdt');
-// 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)
-    }
-
-}