import os from "node:os";
import path from "node:path";
import * as p from "@clack/prompts";
import figlet from "figlet";
import fsExtra from "fs-extra";
import color from "picocolors";

const HOME_DIR = `${os.homedir()}/.nanoctl`;
const GITHUB_REPO_LOCAL = `${HOME_DIR}/nanoservice-ts`;

export async function createNode(opts) {
	const isDefault = opts.name !== undefined;
	let nodeName = opts.name ? opts.name : "";

	if (!isDefault) {
		console.log(
			figlet.textSync("nanoservice-ts CLI".toUpperCase(), {
				font: "Digital",
				horizontalLayout: "default",
				verticalLayout: "default",
				width: 100,
				whitespaceBreak: true,
			}),
		);
		console.log("");

		p.intro(color.inverse(" Create a new Node "));
		const nanoctlNode = await p.group(
			{
				nodeName: () =>
					p.text({
						message: "Assign a name to the node",
						placeholder: "node-name",
						defaultValue: "",
					}),
				// multiSteps: () =>
				// 	p.multiselect({
				// 		message: "Is it a multi steps node?",
				// 		options: [
				// 			{ label: "FALSE", value: false, hint: "recommended" },
				// 			{ label: "TRUE", value: true }
				// 		],
				// 	}),
			},
			{
				onCancel: () => {
					p.cancel("Operation cancelled.");
					process.exit(0);
				},
			},
		);

		nodeName = nanoctlNode.nodeName;
	}

	const s = p.spinner();
	if (!isDefault) s.start("Creating node...");

	try {
		// Prepare the project
		const mainDirExists = fsExtra.existsSync(GITHUB_REPO_LOCAL);
		if (!mainDirExists)
			throw new Error(
				"nanoservice-ts repository not found. Please run 'nanoctl create project' to clone the repository.",
			);

		const currentDir = `${process.cwd()}/nodes`;
		const nodeProjectDirExists = fsExtra.existsSync(currentDir);
		if (!nodeProjectDirExists) throw new Error("ops1");

		const dirPath = path.join(currentDir, nodeName);

		if (!isDefault) s.message("Copying project files");

		/// Copy the project files
		const nodeDirExists = fsExtra.existsSync(dirPath);
		if (nodeDirExists) throw new Error("ops2");

		fsExtra.copySync(`${GITHUB_REPO_LOCAL}/templates/node`, dirPath);

		// Create a new project
		if (!isDefault) s.stop("Node created successfully");
		console.log(`Node Name: ${nodeName}`);
	} catch (error) {
		if (!isDefault) s.stop("An error occurred");

		const message = error.message;
		if (message === "ops1") {
			console.log(
				"Oops! It seems like you haven't created a project yet... or have you? 🤔\n" +
					"If you already did, you can navigate to it using: cd project-name\n" +
					"Otherwise, you can create a new project with: nanoctl create project",
			);
		}
		if (message === "ops2") {
			console.log(
				"The Node you want to create already exists in the project.\n" +
					"Try using a different name, or you can delete the existing Node to create a new one.",
			);
		}
		if (message !== "ops1" && message !== "ops2") {
			console.log(error.message);
		}
	}
}


import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import * as p from "@clack/prompts";
import figlet from "figlet";
import fsExtra from "fs-extra";
import color from "picocolors";
import simpleGit from "simple-git";

const HOME_DIR = `${os.homedir()}/.nanoctl`;
const GITHUB_REPO_LOCAL = `${HOME_DIR}/nanoservice-ts`;
const GITHUB_REPO_REMOTE = "https://github.com/deskree-inc/nanoservice-ts.git";

fsExtra.ensureDirSync(HOME_DIR);
const options = {
	baseDir: HOME_DIR,
	binary: "git",
	maxConcurrentProcesses: 6,
	trimmed: false,
};

const git = simpleGit(options);

export async function createProject(opts) {
	const isDefault = opts.name !== undefined;
	let projectName = opts.name ? opts.name : "";
	let trigger = "http";

	if (!isDefault) {
		console.log(
			figlet.textSync("nanoservice-ts CLI".toUpperCase(), {
				font: "Digital",
				horizontalLayout: "default",
				verticalLayout: "default",
				width: 100,
				whitespaceBreak: true,
			}),
		);
		console.log("");
		p.intro(color.inverse(" Create a new Project "));

		const nanoctlProject = await p.group(
			{
				projectName: () =>
					p.text({
						message: "Assign a name to the project",
						placeholder: "nano-service",
						defaultValue: "nano-service",
					}),
				trigger: () =>
					p.select({
						message: "Choose the trigger to install",
						options: [
							{ label: "HTTP", value: "http", hint: "recommended" },
							//{ label: "CRON", value: "cron" }
						],
					}),
			},
			{
				onCancel: () => {
					p.cancel("Operation cancelled.");
					process.exit(0);
				},
			},
		);

		projectName = nanoctlProject.projectName;
		trigger = nanoctlProject.trigger;
	}

	const s = p.spinner();
	if (!isDefault) s.start("Creating project...");

	try {
		// Prepare the project
		const dirPath = path.join(process.cwd(), projectName);

		if (!isDefault) s.message("Collecting project files");

		const githubLocalExists = fsExtra.existsSync(GITHUB_REPO_LOCAL);
		if (githubLocalExists) {
			fsExtra.removeSync(GITHUB_REPO_LOCAL);
		}
		await git.clone(GITHUB_REPO_REMOTE, GITHUB_REPO_LOCAL);

		if (!isDefault) s.message("Copying project files");

		/// Copy the project files
		const projectDirExists = fsExtra.existsSync(dirPath);
		if (projectDirExists) throw new Error("Project exists in the current directory. Please remove it and try again.");

		fsExtra.copySync(`${GITHUB_REPO_LOCAL}/triggers/${trigger}`, dirPath);

		if (!isDefault) s.message("Installing the examples of workflows and nodes");
		const nodesDir = `${dirPath}/nodes`;
		const workflowsDir = `${dirPath}/workflows`;
		fs.unlinkSync(nodesDir);
		fs.unlinkSync(workflowsDir);
		fsExtra.ensureDirSync(nodesDir);
		fsExtra.copySync(`${GITHUB_REPO_LOCAL}/workflows`, workflowsDir);

		// Create a new project
		if (!isDefault) s.stop("Project created successfully");
		console.log(`Project Name: ${projectName}`);
		console.log(`Trigger: ${trigger}`);
	} catch (error) {
		if (!isDefault) s.stop(error.message);
		if (isDefault) console.log(error.message);
	}
}


#! /usr/bin/env node
import { Command } from "commander";
import { createNode } from "./commands/create/node.js";
import { createProject } from "./commands/create/project.js";
import { getPackageVersion } from "./services/utils.js";

async function main() {
	try {
		const program = new Command();
		const version = await getPackageVersion();
		program
			.name("nanoctl")
			.version(`${version}`, "-v, --version")
			.description(`Nanoservice CLI ${version}`)
			.action(() => {
				console.log(`Nanoservice CLI: ${version}`);
			});

		const create = program.command("create").description("Create a new nanoservice component");

		const project = program
			.command("project")
			.description("Create a new Project")
			.option("-n, --name <value>", "Create a default Project")
			.action((options) => {
				createProject(options);
			});

		const node = program
			.command("node")
			.description("Create a new Node")
			.option("-n, --name <value>", "Create a default Node")
			.action((options) => {
				createNode(options);
			});

		create.addCommand(project);
		create.addCommand(node);

		program.parse(process.argv);
	} catch (err) {
		console.log(err.message);
	}
}

main();


import path, { dirname } from "node:path";
import { fileURLToPath } from "node:url";
import fs from "fs-extra";
import fsExtra from "fs-extra/esm";

export async function getPackageVersion() {
	const __filename = dirname(fileURLToPath(import.meta.url));
	const __dirname = dirname(__filename);
	const pkgJsonPath = path.join(__dirname, "..", "..", "package.json");

	const content = await fsExtra.readJSON(pkgJsonPath);
	return content.version;
}


Introduction

Core Concepts

IDE

Projects & Application

Understanding Projects & Applications

Applications: The Purpose of Grouping Workflows

Current & Future Capabilities

What You Can Do Today

What’s Coming Soon

Getting Started

Next Steps

Introduction

Core Concepts

IDE

​Understanding Projects & Applications

​Applications: The Purpose of Grouping Workflows

​Current & Future Capabilities

​What You Can Do Today

​What’s Coming Soon

​Getting Started

​Next Steps