@cocreate/cli 1.48.0 → 1.50.0

package/src/commands/link.js

@@ -1,69 +1,82 @@
-const spawn = require('../spawn');
-const path = require("path")
-const fs = require('fs')
-const { color } = require('../fonts');
+const spawn = require("../spawn");
+const path = require("path");
+const fs = require("fs");
+const { color } = require("../fonts");
 
 module.exports = async (repos, args) => {
-    const failed = [], isLinked = {};
+	const failed = [],
+		isLinked = {};
 
-    try {
-        for (let repo of repos) {
-            if (!repo) continue;
-            if (repo.exclude && repo.exclude.includes('link'))
-                continue
+	try {
+		for (let repo of repos) {
+			if (!repo) continue;
+			if (repo.exclude && repo.exclude.includes("link")) continue;
 
-            if (process.cwd() === repo.absolutePath)
-                continue
+			if (process.cwd() === repo.absolutePath) continue;
 
-            if (repo.packageManager === 'npm') {
-                let dir = path.resolve(process.cwd(), 'node_modules');
-                let dest = path.resolve(path.resolve(repo.absolutePath), 'node_modules');
-                if (dir && dest) {
-                    if (fs.existsSync(dest))
-                        await fs.promises.rm(dest, { recursive: true, force: true });
+			if (repo.packageManager === "npm") {
+				let dir = path.resolve(process.cwd(), "node_modules");
+				let dest = path.resolve(
+					path.resolve(repo.absolutePath),
+					"node_modules"
+				);
+				if (dir && dest) {
+					if (fs.existsSync(dest))
+						await fs.promises.rm(dest, {
+							recursive: true,
+							force: true
+						});
 
-                    await fs.promises.symlink(dir, dest, 'dir');
-                    console.log(repo.packageManager, 'link', repo.packageName)
-                }
-            } else {
+					await fs.promises.symlink(dir, dest, "dir");
+					console.log(repo.packageManager, "link", repo.packageName);
+				}
+			} else {
+				let exitCode = await spawn(repo.packageManager, ["link"], {
+					cwd: repo.absolutePath,
+					shell: true,
+					stdio: "inherit"
+				});
 
-                let exitCode = await spawn(repo.packageManager, ['link'], {
-                    cwd: repo.absolutePath,
-                    shell: true,
-                    stdio: 'inherit'
-                });
+				if (exitCode !== 0) {
+					failed.push({
+						name: repo.name,
+						error: `${repo.packageManager} link failed`
+					});
+					console.error(
+						color.red +
+							`${repo.name}: ${repo.packageManager} link failed` +
+							color.reset
+					);
+				} else {
+					console.log(repo.packageManager, "link", repo.packageName);
 
-                if (exitCode !== 0) {
-                    failed.push({
-                        name: repo.name,
-                        des: `${repo.packageManager} link failed`
-                    })
-                    console.error(color.red + `${repo.name}: ${repo.packageManager} link failed` + color.reset)
-                } else {
-                    console.log(repo.packageManager, 'link', repo.packageName)
+					let exitCode = await spawn(
+						repo.packageManager,
+						["link", repo.packageName],
+						{
+							cwd: process.cwd(),
+							shell: true,
+							stdio: "inherit"
+						}
+					);
+					if (exitCode !== 0) {
+						failed.push({
+							name: repo.name,
+							error: `${repo.packageManager} link ${repo.packageName} failed`
+						});
+						console.error(
+							color.red +
+								`${repo.name}: ${repo.packageManager} link ${repo.packageName} failed` +
+								color.reset
+						);
+					}
+				}
+			}
+		}
+	} catch (err) {
+		failed.push({ name: "GENERAL", error: err.message });
+		console.error(color.red + `${err}` + color.reset);
+	}
 
-                    let exitCode = await spawn(repo.packageManager, ['link', repo.packageName], {
-                        cwd: process.cwd(),
-                        shell: true,
-                        stdio: 'inherit'
-                    })
-                    if (exitCode !== 0) {
-                        failed.push({
-                            name: repo.name,
-                            des: `${repo.packageManager} link ${repo.packageName} failed`
-                        });
-                        console.error(color.red + `${repo.name}: ${repo.packageManager} link ${repo.packageName} failed` + color.reset)
-                    }
-                }
-
-            }
-        }
-
-    }
-    catch (err) {
-        failed.push({ name: 'GENERAL', des: err.message })
-        console.error(color.red + `${err}` + color.reset)
-    }
-
-    return failed;
-}
+	return failed;
+};

package/src/commands/nginx.js

@@ -1,25 +1,22 @@
-const { createServer, deleteServer } = require('@cocreate/nginx')
+const { createServer, deleteServer } = require("@cocreate/nginx");
 
 module.exports = async function nginx(repos, args) {
-    let failed = [];
-
-    try {
-        if (args.length) {
-            if (args[0] === 'create') {
-                args.shift()
-                await createServer(args);
-            } else if (args[0] === 'delete') {
-                args.shift()
-                await deleteServer(args);
-            } else
-                await createServer(args);
-        }
-    } catch (err) {
-        failed.push({ name: 'GENERAL', des: err.message });
-        console.error(err.red);
-    } finally {
-        return failed;
-    }
-
-}
+	let failed = [];
 
+	try {
+		if (args.length) {
+			if (args[0] === "create") {
+				args.shift();
+				await createServer(args);
+			} else if (args[0] === "delete") {
+				args.shift();
+				await deleteServer(args);
+			} else await createServer(args);
+		}
+	} catch (err) {
+		failed.push({ name: "GENERAL", error: err.message });
+		console.error(err.red);
+	} finally {
+		return failed;
+	}
+};

package/src/commands/symlink.js

@@ -1,136 +1,153 @@
-const fs = require('fs')
-const path = require("path")
-const spawn = require('../spawn');
+const fs = require("fs");
+const path = require("path");
+const spawn = require("../spawn");
 
 const cwdPath = path.resolve(process.cwd());
-let cwdNodeModulesPath = path.resolve(cwdPath, 'node_modules')
+let cwdNodeModulesPath = path.resolve(cwdPath, "node_modules");
 
-
-let reposLength, failed = [];
+let reposLength,
+	failed = [];
 
 module.exports = async function (repos, args) {
-    reposLength = repos.length
-
-    for (let i = 0; i < repos.length; i++) {
-
-        if (cwdPath === repos[i].absolutePath && !fs.existsSync(cwdNodeModulesPath)) {
-            await install(repos[i], repos)
-            reposLength -= 1
-        } else if (repos[i].install == true) {
-            reposLength -= 1
-            await install(repos[i], repos)
-        } else if (cwdPath !== repos[i].absolutePath) {
-            await createSymlink(repos[i])
-        }
-
-    }
-
-    console.log('symlink complete');
-    return failed;
-
-}
-
+	reposLength = repos.length;
+
+	for (let i = 0; i < repos.length; i++) {
+		if (
+			cwdPath === repos[i].absolutePath &&
+			!fs.existsSync(cwdNodeModulesPath)
+		) {
+			await install(repos[i], repos);
+			reposLength -= 1;
+		} else if (repos[i].install == true) {
+			reposLength -= 1;
+			await install(repos[i], repos);
+		} else if (cwdPath !== repos[i].absolutePath) {
+			await createSymlink(repos[i]);
+		}
+	}
+
+	console.log("symlink complete");
+	return failed;
+};
 
 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)) {
-
-                if (!cwdNodeModulesPath.includes('/CoCreateJS')) {
-                    let isSymlink = await isSymlinkDirectory(dest)
-                    if (isSymlink) {
-                        const targetPath = await getSymlinkTargetPath(dest);
-                        if (targetPath.includes('/CoCreateJS')) {
-                            console.warn('symlink already exists with CoCreateJS')
-                            return
-                        }
-                    }
-                }
-            }
-
-            await symlink(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)
-    }
-
+	let dpath = path.resolve(repo.absolutePath);
+	if (!fs.existsSync(dpath)) {
+		failed.push({
+			name: "createSymlink",
+			error: "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)) {
+				if (!cwdNodeModulesPath.includes("/CoCreateJS")) {
+					let isSymlink = await isSymlinkDirectory(dest);
+					if (isSymlink) {
+						const targetPath = await getSymlinkTargetPath(dest);
+						if (targetPath.includes("/CoCreateJS")) {
+							console.warn(
+								"symlink already exists with CoCreateJS"
+							);
+							return;
+						}
+					}
+				}
+			}
+
+			await symlink(repo.name, dest);
+		}
+	} catch (err) {
+		failed.push({
+			name: "symlink",
+			error: "with response:" + response + err
+		});
+		console.error(
+			repo.name,
+			"failed to aquire symlink",
+			"with response:",
+			response,
+			err
+		);
+	}
 }
 
 async function symlink(name, dest) {
-    try {
-        if (fs.existsSync(dest))
-            await fs.promises.rm(dest, { recursive: true, force: true });
-
-        await fs.promises.symlink(cwdNodeModulesPath, dest, 'dir');
-        console.log(name, 'node_modules symlink added');
-
-    } catch (err) {
-        failed.push({ name: 'symlink', des: 'with response: ' + response, err });
-        console.error(repo.name, 'failed to acquire symlink', 'with response:', response, err);
-    }
+	try {
+		if (fs.existsSync(dest))
+			await fs.promises.rm(dest, { recursive: true, force: true });
+
+		await fs.promises.symlink(cwdNodeModulesPath, dest, "dir");
+		console.log(name, "node_modules symlink added");
+	} catch (err) {
+		failed.push({
+			name: "symlink",
+			error: "with response: " + response,
+			err
+		});
+		console.error(
+			repo.name,
+			"failed to acquire symlink",
+			"with response:",
+			response,
+			err
+		);
+	}
 }
 
-
 async function install(repo, repos) {
-    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 {
-        console.log('installing', repo.name)
-        let exitCode = await spawn(repo.packageManager, ['install'], {
-            cwd: repo.absolutePath,
-            shell: true,
-            stdio: 'inherit'
-        });
-
-        if (exitCode !== 0) {
-            failed.push({
-                name: repo.name,
-                des: `${repo.packageManager} install failed`
-            })
-            console.error(`${repo.name}: ${repo.packageManager} install failed`.red)
-        } else {
-            console.log(`${repo.name}: ${repo.packageManager} install succesful`.green)
-
-        }
-
-    }
-    catch (err) {
-        console.error(repo.name, 'did not install', err)
-    }
-
+	let dpath = repo.absolutePath;
+	if (!fs.existsSync(dpath)) {
+		failed.push({ name: "install", error: "path doesn't exist:" + dpath });
+		return console.error(dpath, "not exist");
+	}
+	try {
+		console.log("installing", repo.name);
+		let exitCode = await spawn(repo.packageManager, ["install"], {
+			cwd: repo.absolutePath,
+			shell: true,
+			stdio: "inherit"
+		});
+
+		if (exitCode !== 0) {
+			failed.push({
+				name: repo.name,
+				error: `${repo.packageManager} install failed`
+			});
+			console.error(
+				`${repo.name}: ${repo.packageManager} install failed`.red
+			);
+		} else {
+			console.log(
+				`${repo.name}: ${repo.packageManager} install succesful`.green
+			);
+		}
+	} catch (err) {
+		console.error(repo.name, "did not install", err);
+	}
 }
 
 async function isSymlinkDirectory(path) {
-    try {
-        const stats = await fs.promises.lstat(path);
-        return stats.isSymbolicLink();
-    } catch (err) {
-        throw err;
-    }
+	try {
+		const stats = await fs.promises.lstat(path);
+		return stats.isSymbolicLink();
+	} catch (err) {
+		throw err;
+	}
 }
 
 async function getSymlinkTargetPath(symlinkPath) {
-    try {
-        const target = await fs.promises.readlink(symlinkPath);
-        const targetPath = fs.realpathSync(target);
-        return targetPath;
-    } catch (err) {
-        throw err;
-    }
+	try {
+		const target = await fs.promises.readlink(symlinkPath);
+		const targetPath = fs.realpathSync(target);
+		return targetPath;
+	} catch (err) {
+		throw err;
+	}
 }
 
-// module.exports = { symlink }
+// module.exports = { symlink }

package/src/execute.js

@@ -1,65 +1,78 @@
 const path = require("path");
 const fs = require("fs");
-const spawn = require('./spawn');
-const util = require('node:util');
-const exec = util.promisify(require('node:child_process').exec);
-const { color } = require('./fonts');
+const spawn = require("./spawn");
+const util = require("node:util");
+const exec = util.promisify(require("node:child_process").exec);
+const { color } = require("./fonts");
 
 module.exports = async function execute(command, repos = [], config) {
-    let failed = [];
-    let args = command.replaceAll("'", '"').trim().split(' ')
-    let type = args[0]
-    args.shift()
+	let failed = [];
+	let [filename, ...args] = command.replaceAll("'", '"').trim().split(" ");
 
-    let predefined = path.resolve(__dirname, 'commands', type + '.js');
+	let type;
 
-    if (fs.existsSync(predefined)) {
-        console.warn(color.blue + `executing a predefined command in ${predefined}` + color.reset);
+	if (filename.endsWith(".js")) {
+		type = filename.slice(0, -3);
+	} else {
+		type = filename;
+		filename += ".js";
+	}
 
-        if (repos.length == 1)
-            console.log(color.blue + `running on ${repos[0].name} repo` + color.reset)
-        else if (repos.length)
-            console.log(color.blue + 'running on all repos' + color.reset)
+	let predefined = path.resolve(__dirname, "commands", filename);
+	let isPredefined = fs.existsSync(predefined);
+	let repositories = [];
 
-        failed = require(predefined)(repos, args)
+	for (let repo of repos) {
+		try {
+			if (
+				repo.exclude &&
+				(repo.exclude.includes(type) || repo.exclude.includes(filename))
+			) {
+				continue;
+			}
 
-    } else {
+			const packageJsonPath = path.resolve(repo.path, "package.json");
+			const packageObj = require(packageJsonPath);
+			repo.entry = packageObj.main;
 
-        for (let repo of repos) {
-            try {
-                if (repo.exclude && repo.exclude.includes(type))
-                    continue
-                console.log(color.green + `${repo.name}: ` + color.reset, command)
-                let exitCode;
-                if (config.hideMessage) {
-                    const { error } = await exec(command, {
-                        cwd: repo.absolutePath,
-                    });
+			if (isPredefined) {
+				repositories.push(repo);
+				continue;
+			}
 
-                    if (error)
-                        exitCode = 1
-                } else {
-                    exitCode = await spawn(type, args, {
-                        cwd: repo.absolutePath,
-                        shell: true,
-                        stdio: 'inherit'
-                    })
-                }
+			console.log(color.green + `${repo.name}: ` + color.reset, command);
+			let exitCode;
+			if (config.hideMessage) {
+				const { error } = await exec(command, {
+					cwd: repo.absolutePath
+				});
 
-                if (exitCode !== 0)
-                    failed.push({
-                        name: repo.name,
-                        des: 'command failed: ' + command
-                    })
+				if (error) exitCode = 1;
+			} else {
+				exitCode = await spawn(type, args, {
+					cwd: repo.absolutePath,
+					shell: true,
+					stdio: "inherit"
+				});
+			}
 
+			if (exitCode !== 0) {
+				repo.error = "command failed: " + command;
+				failed.push(repo);
+			}
+		} catch (err) {
+			console.error(
+				color.red +
+					`an error occured executing command in ${repo.name} repository` +
+					color.reset,
+				err.message
+			);
+		}
+	}
 
-            }
-            catch (err) {
-                console.error(color.red + `an error occured executing command in ${repo.name} repository` + color.reset, err.message);;
-            }
-        }
-    }
+	if (isPredefined) {
+		failed = require(predefined)(repositories, args);
+	}
 
-    return failed;
-
-}
+	return failed;
+};

package/src/index.js

@@ -0,0 +1,3 @@
+const config = require("./commands/config.js");
+
+module.exports = { config };