startx 0.3.1 → 0.6.0

package/apps/startx-cli/src/configs/deps.ts

@@ -0,0 +1,45 @@
+import type { WHITELIST_DEPS } from "../types";
+
+/* eslint-disable @typescript-eslint/naming-convention */
+export const DepCheck: WHITELIST_DEPS = {
+	"@biomejs/biome": {
+		tags: ["node", "biome", "root"],
+		version: "catalog:",
+	},
+	"prettier": {
+		tags: ["node", "prettier", "root"],
+		version: "catalog:",
+	},
+	"eslint": {
+		tags: ["node", "eslint", "root"],
+		version: "catalog:",
+	},
+	"vitest": {
+		tags: ["node", "vitest", "root"],
+		version: "catalog:",
+	},
+	"tsdown": {
+		tags: ["node", "tsdown", "root"],
+		version: "catalog:",
+	},
+	"@types/node": {
+		tags: ["node", "root"],
+		version: "catalog:",
+		isDevDependency: true,
+	},
+	"typescript-config": {
+		tags: ["node"],
+		version: "workspace:^",
+		isDevDependency: true,
+	},
+	"eslint-config": {
+		tags: ["node", "eslint"],
+		version: "workspace:^",
+		isDevDependency: true,
+	},
+	"vitest-config": {
+		tags: ["node", "vitest"],
+		version: "workspace:^",
+		isDevDependency: true,
+	},
+} as const;

package/apps/startx-cli/src/configs/files.ts

@@ -0,0 +1,51 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import type { WHITELIST_FILES } from "../types";
+
+export const FileCheck: WHITELIST_FILES = {
+	"startx.json": {
+		tags: ["never"],
+	},
+	".npmignore": {
+		tags: ["never"],
+	},
+	".npmrc": {
+		tags: ["never"],
+	},
+	".prettierignore": {
+		tags: ["prettier"],
+	},
+	".prettier.js": {
+		tags: ["prettier"],
+	},
+	"biome.json": {
+		tags: ["biome"],
+	},
+	"pnpm-lock.yaml": {
+		tags: ["never"],
+	},
+	"pnpm-workspace.yaml": {
+		tags: ["root"],
+	},
+	"turbo.json": {
+		tags: ["root"],
+	},
+	"LICENSE": {
+		tags: ["never"],
+	},
+	".env": {
+		tags: ["never"],
+	},
+	"tsdown.config.ts": {
+		tags: ["tsdown"],
+	},
+	// Handled manually
+	"eslint.config.ts": {
+		tags: ["never"],
+	},
+	"vitest.config.ts": {
+		tags: ["never"],
+	},
+	"package.json": {
+		tags: ["never"],
+	},
+};

package/apps/startx-cli/src/configs/scripts.ts

@@ -0,0 +1,158 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import type { SCRIPT } from "../types";
+
+export const scripts: SCRIPT = {
+	"dev": [
+		{
+			script: "turbo run dev",
+			tags: ["runnable", "root"],
+		},
+		{
+			script: "tsx watch src/index.ts",
+			tags: ["runnable", "node", "backend", "dev"],
+		},
+		{
+			script: "email dev --port 3014 --dir ./src",
+			tags: ["node", "mail"],
+		},
+	],
+	"dev:debug": [
+		{
+			script: "turbo run dev:debug",
+			tags: ["node", "runnable", "root"],
+		},
+		{
+			script: "tsx watch --inspect src/index.ts",
+			tags: ["backend", "node", "runnable", "dev"],
+		},
+	],
+	"bun:dev": [
+		{
+			script: "turbo run bun:dev",
+			tags: ["node", "runnable", "root"],
+		},
+		{
+			script: "bun --watch src/index.ts",
+			tags: ["backend", "node", "runnable", "dev"],
+		},
+	],
+	"build": [
+		{
+			script: "turbo run build",
+			tags: ["runnable", "root"],
+		},
+		{
+			script: "tsdown --config-loader unrun",
+			tags: ["runnable", "node"],
+		},
+	],
+	"cli": [
+		{
+			script: "turbo run cli",
+			tags: ["runnable", "node", "cli", "root"],
+		},
+		{
+			script: "tsx src/index.ts",
+			tags: ["runnable", "node", "cli", "commander"],
+		},
+	],
+	"start": [
+		{
+			script: "turbo run start",
+			tags: ["backend", "runnable", "node", "root"],
+		},
+		{
+			script: "node dist/index.mjs",
+			tags: ["node", "runnable"],
+		},
+	],
+	"lint": [
+		{
+			script: "turbo run eslint",
+			tags: ["node", "eslint", "root"],
+		},
+		{
+			script: "eslint .",
+			tags: ["node", "eslint"],
+		},
+	],
+	"lint:fix": [
+		{
+			script: "turbo run lint:fix",
+			tags: ["node", "eslint", "root"],
+		},
+		{
+			script: "eslint . src/**/*.ts --fix",
+			tags: ["node", "eslint"],
+		},
+	],
+	"clean": [
+		{
+			script: "turbo run clean",
+			tags: ["root"],
+		},
+		{
+			script: "rimraf dist .turbo dist",
+			tags: [],
+		},
+	],
+	"deep:clean": [
+		{
+			script: "turbo run deep:clean",
+			tags: ["root"],
+		},
+		{
+			script: "rimraf node_modules dist .turbo",
+			tags: ["node"],
+		},
+	],
+	"typecheck": [
+		{
+			script: "turbo run typecheck",
+			tags: ["node", "root"],
+		},
+		{
+			script: "tsc --noEmit",
+			tags: ["node"],
+		},
+	],
+	"format": [
+		{
+			script: "turbo run format",
+			tags: ["node", "root"],
+		},
+		{
+			script: "biome format --write .",
+			tags: ["node", "biome", "prettier"],
+		},
+		{
+			"script": "prettier --write .",
+			"tags": ["node", "prettier"],
+		},
+	],
+	"format:check": [
+		{
+			script: "turbo run format:check",
+			tags: ["node", "root"],
+		},
+		{
+			script: "biome ci .",
+			tags: ["node", "biome", "prettier"],
+		},
+		{
+			"script": "prettier --check .",
+			"tags": ["node", "prettier"],
+		},
+	],
+	"test": [
+		{
+			script: "turbo run test",
+			tags: ["node", "vitest", "root"],
+		},
+		{
+			script: "vitest run",
+			tags: ["node", "vitest"],
+		},
+	],
+} as const;

package/apps/startx-cli/src/constants.ts

@@ -0,0 +1,4 @@
+export const Constants = {
+	packageManager: "pnpm@10.28.2",
+	node: ">=22",
+};

package/apps/startx-cli/src/index.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { logger } from "@repo/logger";
+import { Command } from "commander";
+
+import { InitCommand } from "./commands/init";
+import { version } from "../../../package.json";
+
+const program = new Command();
+
+program
+	.name("startx")
+	.description("StartX CLI - Your all in one monorepo startup tool.")
+	.version(version);
+
+program.command("ping").action(() => {
+	logger.info("pong");
+});
+
+program.addCommand(InitCommand.command);
+
+program.parse(process.argv);

package/apps/startx-cli/src/types.ts

@@ -0,0 +1,64 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import type { PackageJson } from "type-fest";
+
+export type TAGS =
+	| "required"
+	| "common"
+	| "runnable"
+	| "biome"
+	| "prettier"
+	| "vitest"
+	| "eslint"
+	| "tsdown"
+	| "node"
+	| "backend"
+	| "dev"
+	| "frontend"
+	| "cli"
+	| "commander"
+	| "react"
+	| "extra"
+	| "mail"
+	| "never"
+	| "root";
+
+export type SCRIPT = Record<string, Array<{ script: string; tags: TAGS[] }>>;
+
+export type WHITELIST_DEPS = Record<
+	string,
+	{ tags: TAGS[]; version: string; isDevDependency?: boolean }
+>;
+export type WHITELIST_FILES = Record<string, { tags: TAGS[] }>;
+
+export type PackageDef<T extends string> = {
+	source: string;
+	dependencies?: T[];
+	devDependencies?: T[];
+	optional?: T[];
+	dir?: string[];
+	file?: string[];
+	files?: string[];
+	tags: TAGS[];
+};
+
+type NoInfer<T> = [T][T extends unknown ? 0 : never];
+
+export const Packages = <T extends string>(config: Record<T, PackageDef<NoInfer<T>>>) => config;
+
+export type PnpmWorkspace = {
+	packages: string[];
+	catalog?: Record<string, string>;
+	catalogs?: Record<string, Record<string, string>>;
+};
+
+export type StartXPackageJson = PackageJson & {
+	startx?: {
+		mode?: "silent" | "standalone";
+		tags?: TAGS[]; // self tags (can be used to identify this package)
+		iTags?: TAGS[]; // install tags (must be available to install packages)
+		gTags?: TAGS[]; // global tags (to be pushed globally if installed)
+		requiredDeps?: string[];
+		requiredDevDeps?: string[];
+		ignore?: string[];
+	};
+};

package/apps/startx-cli/src/utils/cli-utils.ts

@@ -0,0 +1,104 @@
+import { defineEnv } from "@repo/env";
+import { fsTool } from "@repo/lib/file-system-module";
+import path from "path";
+import { fileURLToPath } from "url";
+import z from "zod";
+
+import type { PnpmWorkspace, StartXPackageJson } from "../types";
+
+export type RawPackageItem = {
+	type: "apps" | "configs" | "packages";
+	path: string;
+	name: string;
+};
+
+const ENV = defineEnv({
+	STARTX_ENV: z.enum(["development", "production", "test", "staging"]).default("production"),
+});
+export class CliUtils {
+	static getDirectory() {
+		const __filename = fileURLToPath(import.meta.url);
+		let template = path.dirname(__filename);
+		const workspace = process.cwd();
+		if (ENV.STARTX_ENV === "development") {
+			template = path.resolve(template, "../../../../");
+		} else template = path.resolve(template, "../../../");
+
+		return {
+			template,
+			workspace,
+		};
+	}
+	static async getPackageList() {
+		const packages: RawPackageItem[] = [];
+		const cliDirectory = this.getDirectory().template;
+		const safeListDir = async (dir: string): Promise<string[]> => {
+			try {
+				return await fsTool.listDirectories({ dir });
+			} catch (error) {
+				console.error("Error listing directory:", error);
+				return [];
+			}
+		};
+
+		const [availableApps, availableConfigs, availablePackages, availableRepoPackages] =
+			await Promise.all([
+				safeListDir(path.join(cliDirectory, "apps")),
+				safeListDir(path.join(cliDirectory, "configs")),
+				safeListDir(path.join(cliDirectory, "packages")),
+				safeListDir(path.join(cliDirectory, "packages", "@repo")),
+			]);
+
+		// 2. Map Apps
+		availableApps.forEach(name => {
+			packages.push({
+				type: "apps",
+				path: path.join(cliDirectory, "apps", name),
+				name,
+			});
+		});
+
+		availableConfigs.forEach(name => {
+			packages.push({
+				type: "configs",
+				path: path.join(cliDirectory, "configs", name),
+				name,
+			});
+		});
+
+		availablePackages.forEach(name => {
+			if (name === "@repo") return;
+			packages.push({
+				type: "packages",
+				path: path.join(cliDirectory, "packages", name),
+				name,
+			});
+		});
+
+		availableRepoPackages.forEach(name => {
+			packages.push({
+				type: "packages",
+				path: path.join(cliDirectory, "packages", "@repo", name),
+				name: `@repo/${name}`,
+			});
+		});
+
+		return packages;
+	}
+
+	static async parsePackageJson({ dir, file = "package" }: { dir: string; file?: string }) {
+		const packageJson = await fsTool.readJSONFile<StartXPackageJson>({
+			dir,
+			file,
+		});
+		return packageJson;
+	}
+	static async parsePnpmWorkspace({ dir }: { dir: string }) {
+		const yaml = await fsTool.readYamlFile({
+			file: "pnpm-workspace",
+			dir,
+		});
+
+		return yaml?.toJSON() as PnpmWorkspace;
+	}
+}

package/apps/startx-cli/src/utils/config.ts

@@ -0,0 +1,104 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import { Packages } from "../types";
+
+export const packages = Packages({
+	"eslint-config": {
+		source: "./configs/eslint-config",
+		dependencies: [],
+		devDependencies: ["typescript-config"],
+		optional: ["vitest-config"],
+		dir: ["src"],
+		file: ["plugins.d.ts"],
+		tags: ["common"],
+	},
+	"typescript-config": {
+		source: "./configs/typescript-config",
+		dependencies: [],
+		devDependencies: [],
+		dir: [],
+		files: ["tsconfig.common.json", "tsconfig.frontend.json", "tsconfig.node.json"],
+		tags: ["required"],
+	},
+	"vitest-config": {
+		source: "./configs/vitest-config",
+		dependencies: ["typescript-config"],
+		devDependencies: ["eslint-config"],
+		dir: [],
+		tags: ["required"],
+	},
+	"@repo/ui": {
+		source: "./packages/ui",
+		dependencies: [],
+		devDependencies: ["typescript-config"],
+		optional: ["eslint-config"],
+		dir: [
+			"src/components/lib",
+			"src/components/util",
+			"src/components/ilb",
+			"src/components/util",
+			"src/components/custom",
+			"src/components/extensions",
+			"src/components/hooks",
+			"src/components/ui",
+		],
+		files: [
+			"components.json",
+			"tailwind.config.ts",
+			"postcss.config.ts",
+			"src/globals.css",
+			"src/lucide.ts",
+		],
+		tags: ["common", "react"],
+	},
+	"@repo/constants": {
+		source: "./packages/@repo/constants",
+		dependencies: [],
+		devDependencies: ["typescript-config"],
+		optional: ["eslint-config"],
+		dir: ["src"],
+		tags: ["common"],
+	},
+	"@repo/env": {
+		source: "./packages/@repo/env",
+		dependencies: [],
+		devDependencies: ["typescript-config"],
+		optional: ["eslint-config", "vitest-config"],
+		dir: ["src"],
+		tags: ["common", "node"],
+	},
+	"@repo/db": {
+		source: "./packages/@repo/db",
+		dependencies: ["@repo/env"],
+		devDependencies: ["typescript-config"],
+		optional: ["eslint-config"],
+		dir: ["src"],
+		tags: ["common", "node"],
+	},
+
+	"@repo/lib": {
+		source: "./packages/@repo/lib",
+		dependencies: ["@repo/env", "@repo/mail", "@repo/db"],
+		devDependencies: ["typescript-config"],
+		optional: ["eslint-config", "vitest-config"],
+		dir: ["src"],
+		tags: ["common", "node"],
+	},
+
+	"@repo/mail": {
+		source: "./packages/@repo/mail",
+		dependencies: [],
+		devDependencies: ["typescript-config"],
+		optional: ["eslint-config"],
+		dir: ["src"],
+		tags: ["common", "node"],
+	},
+	"@repo/redis": {
+		source: "./packages/@repo/redis",
+		dependencies: [],
+		devDependencies: ["typescript-config"],
+		optional: ["eslint-config"],
+		dir: ["src"],
+		tags: ["common", "node", "extra"],
+	},
+});

package/apps/startx-cli/src/utils/file-handler.ts

@@ -0,0 +1,130 @@
+import { DepCheck } from "../configs/deps";
+import { scripts } from "../configs/scripts";
+import { Constants } from "../constants";
+import type { StartXPackageJson, TAGS } from "../types";
+
+export class FileHandler {
+	private static objSorter(obj: Record<string, unknown>, sorter: string[] = []) {
+		const cleaned = Object.fromEntries(
+			Object.entries(obj).filter(([, v]) => v !== null && v !== undefined)
+		);
+
+		const sortedEntries: Array<[string, unknown]> = [];
+
+		for (const key of sorter) {
+			if (key in cleaned) {
+				sortedEntries.push([key, cleaned[key]]);
+				delete cleaned[key];
+			}
+		}
+
+		for (const entry of Object.entries(cleaned)) {
+			sortedEntries.push(entry);
+		}
+		return Object.fromEntries(sortedEntries);
+	}
+	static handlePackageJson(props: {
+		name?: string;
+		app: StartXPackageJson;
+		tags: TAGS[];
+		dependencies?: Record<string, string>;
+	}) {
+		const isWorkspace = !!props.app.devDependencies?.turbo;
+
+		const tags = isWorkspace ? [...props.tags, "root"] : [...props.tags];
+		const workspaceAttr: Record<string, unknown> = isWorkspace
+			? {
+					version: "1.0.0",
+					packageManager: Constants.packageManager,
+					engines: {
+						node: Constants.node,
+					},
+				}
+			: {};
+
+		const packageScript = Object.fromEntries(
+			Object.entries(scripts)
+				.map(([key, value]) => {
+					const script = value.find(e => e.tags.every(tag => tags.includes(tag)));
+					return script ? [key, script.script] : null;
+				})
+				.filter((v): v is [string, string] => v !== null)
+		);
+
+		const filterDeps = (deps?: Record<string, string>) =>
+			Object.fromEntries(
+				Object.entries(deps ?? {}).filter(([key]) => {
+					const selected = DepCheck[key];
+					return !selected || selected.tags.every(tag => tags.includes(tag));
+				})
+			);
+
+		const dependencies = filterDeps(props.app.dependencies as Record<string, string>);
+		const devDependencies = filterDeps(props.app.devDependencies as Record<string, string>);
+
+		// Removing all workspace dependencies
+		for (const [key, value] of Object.entries(devDependencies)) {
+			if (value.includes("workspace:")) {
+				delete devDependencies[key];
+			}
+		}
+
+		// Adding required
+		if (props.dependencies) {
+			for (const [key, value] of Object.entries(props.dependencies)) {
+				if (!dependencies[key]) {
+					dependencies[key] = value;
+				}
+			}
+		}
+
+		// Adding rest
+		for (const [key, value] of Object.entries(DepCheck)) {
+			if (!value.tags.every(tag => tags.includes(tag))) continue;
+			if (isWorkspace && !value.tags.includes("root")) continue;
+			const isDev = value.isDevDependency;
+			if (isDev && !devDependencies[key]) {
+				devDependencies[key] = value.version;
+			} else if (!dependencies[key]) {
+				dependencies[key] = value.version;
+			}
+		}
+
+		// Removing ignore
+		for (const value of props.app.startx?.ignore ?? []) {
+			delete dependencies[value];
+			delete devDependencies[value];
+		}
+
+		const packageJson = {
+			name: props.name || props.app.name,
+			description: props.app.description,
+			type: "module",
+			exports: props.app.exports,
+			files: props.app.files,
+			scripts: packageScript,
+			dependencies,
+			devDependencies,
+			...workspaceAttr,
+		};
+
+		const sorter = [
+			"name",
+			"description",
+			"version",
+			"type",
+			"scripts",
+			"files",
+			"exports",
+			"dependencies",
+			"devDependencies",
+			"packageManager",
+			"engines",
+		];
+
+		return {
+			packageJson: this.objSorter(packageJson, sorter),
+			isWorkspace,
+		};
+	}
+}