buncargo 1.0.29 → 3.0.0

package/bin.ts

@@ -1,192 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * CLI Entry Point for buncargo
- *
- * Usage:
- *   bunx buncargo dev           # Start containers + dev servers
- *   bunx buncargo dev --down    # Stop containers
- *   bunx buncargo dev --reset   # Stop + remove volumes
- *   bunx buncargo typecheck     # Run TypeScript typecheck
- *   bunx buncargo prisma ...    # Run prisma commands
- *   bunx buncargo help          # Show help
- */
-
-import { runCli } from "./cli";
-import { loadDevEnv } from "./loader";
-
-/**
- * Load the dev environment with CLI-friendly error output.
- */
-async function loadEnv() {
-	try {
-		return await loadDevEnv();
-	} catch (error) {
-		console.error(`❌ ${error instanceof Error ? error.message : error}`);
-		process.exit(1);
-	}
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Command Handlers
-// ═══════════════════════════════════════════════════════════════════════════
-
-async function handleDev(args: string[]): Promise<void> {
-	const env = await loadEnv();
-	await runCli(env, { args });
-}
-
-async function handlePrisma(args: string[]): Promise<void> {
-	const env = await loadEnv();
-
-	if (!env.prisma) {
-		console.error("❌ Prisma is not configured in your dev config.");
-		console.error("");
-		console.error("   Add prisma to your config:");
-		console.error("");
-		console.error("   export default defineDevConfig({");
-		console.error("     ...");
-		console.error("     prisma: {");
-		console.error("       cwd: 'packages/prisma'");
-		console.error("     }");
-		console.error("   })");
-		process.exit(1);
-	}
-
-	// Ensure database is running
-	const running = await env.isRunning();
-	if (!running) {
-		console.log("🐳 Starting database container...");
-		await env.start({ startServers: false, wait: true });
-	}
-
-	const exitCode = await env.prisma.run(args);
-	process.exit(exitCode);
-}
-
-async function handleEnv(): Promise<void> {
-	const env = await loadEnv();
-	console.log(
-		JSON.stringify(
-			{
-				projectName: env.projectName,
-				ports: env.ports,
-				urls: env.urls,
-				portOffset: env.portOffset,
-				isWorktree: env.isWorktree,
-				localIp: env.localIp,
-				root: env.root,
-			},
-			null,
-			2,
-		),
-	);
-}
-
-async function handleTypecheck(): Promise<void> {
-	const env = await loadEnv();
-	const { runWorkspaceTypecheck } = await import("./lint");
-	const result = await runWorkspaceTypecheck({
-		root: env.root,
-		verbose: true,
-	});
-	process.exit(result.success ? 0 : 1);
-}
-
-function showHelp(): void {
-	console.log(`
-buncargo - Development environment CLI
-
-USAGE:
-  bunx buncargo <command> [options]
-
-COMMANDS:
-  dev                 Start the development environment
-  typecheck           Run TypeScript typecheck across workspaces
-  prisma <args>       Run Prisma CLI with correct DATABASE_URL
-  env                 Print environment info as JSON
-  help                Show this help message
-  version             Show version
-
-EXAMPLES:
-  bunx buncargo dev              # Start everything
-  bunx buncargo dev --help       # Show dev command options
-  bunx buncargo dev --down       # Stop containers
-  bunx buncargo typecheck        # Run typecheck
-  bunx buncargo prisma studio    # Open Prisma Studio
-  bunx buncargo env              # Get ports/urls as JSON
-
-CONFIG:
-  Create a dev.config.ts with a default export:
-
-  import { defineDevConfig } from 'buncargo'
-
-  export default defineDevConfig({
-    projectPrefix: 'myapp',
-    services: { ... },
-    apps: { ... }
-  })
-
-Run "bunx buncargo dev --help" for dev command options.
-`);
-}
-
-function showVersion(): void {
-	const pkg = require("./package.json");
-	console.log(`buncargo v${pkg.version}`);
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Main
-// ═══════════════════════════════════════════════════════════════════════════
-
-async function main(): Promise<void> {
-	const args = process.argv.slice(2);
-	const command = args[0];
-	const commandArgs = args.slice(1);
-
-	if (
-		!command ||
-		command === "help" ||
-		command === "--help" ||
-		command === "-h"
-	) {
-		showHelp();
-		process.exit(0);
-	}
-
-	if (command === "version" || command === "--version" || command === "-v") {
-		showVersion();
-		process.exit(0);
-	}
-
-	switch (command) {
-		case "dev":
-			await handleDev(commandArgs);
-			break;
-
-		case "typecheck":
-			await handleTypecheck();
-			break;
-
-		case "prisma":
-			await handlePrisma(commandArgs);
-			break;
-
-		case "env":
-			await handleEnv();
-			break;
-
-		default:
-			console.error(`❌ Unknown command: ${command}`);
-			console.error("");
-			console.error('   Run "bunx buncargo help" for available commands.');
-			process.exit(1);
-	}
-}
-
-main().catch((error) => {
-	const message = error instanceof Error ? error.message : String(error);
-	console.error(`❌ ${message}`);
-	process.exit(1);
-});

package/config.ts

@@ -1,194 +0,0 @@
-import type {
-	AppConfig,
-	DevConfig,
-	DevHooks,
-	DevOptions,
-	EnvVarsBuilder,
-	MigrationConfig,
-	PrismaConfig,
-	SeedConfig,
-	ServiceConfig,
-} from "./types";
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Config Factory
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * Define a dev environment configuration with full TypeScript inference.
- *
- * @example
- * ```typescript
- * const config = defineDevConfig({
- *   projectPrefix: 'myapp',
- *   services: {
- *     postgres: { port: 5432, healthCheck: 'pg_isready' },
- *     redis: { port: 6379 },
- *   },
- *   apps: {
- *     api: { port: 3000, devCommand: 'bun run dev', cwd: 'apps/backend' },
- *     web: { port: 5173, devCommand: 'bun run dev', cwd: 'apps/frontend' },
- *   },
- *   envVars: (ports, urls) => ({
- *     DATABASE_URL: urls.postgres,
- *     REDIS_URL: urls.redis,
- *     API_PORT: String(ports.api),
- *   }),
- * })
- * ```
- */
-export function defineDevConfig<
-	TServices extends Record<string, ServiceConfig>,
-	TApps extends Record<string, AppConfig> = Record<string, never>,
->(config: {
-	/** Prefix for Docker project name (e.g., 'myapp' -> 'myapp-main') */
-	projectPrefix: string;
-	/** Docker Compose services to manage */
-	services: TServices;
-	/** Applications to start (optional) */
-	apps?: TApps;
-	/**
-	 * Environment variables builder. Define all env vars here.
-	 *
-	 * @example
-	 * ```typescript
-	 * envVars: (ports, urls, { localIp }) => ({
-	 *   DATABASE_URL: urls.postgres,
-	 *   BASE_URL: urls.api,
-	 *   VITE_PORT: ports.platform,
-	 *   EXPO_API_URL: `http://${localIp}:${ports.api}`
-	 * })
-	 * ```
-	 */
-	envVars?: EnvVarsBuilder<TServices, TApps>;
-	/** Lifecycle hooks (optional) */
-	hooks?: DevHooks<TServices, TApps>;
-	/** Migrations to run after containers are ready (optional). Runs in parallel. */
-	migrations?: MigrationConfig[];
-	/** Seed configuration (optional). Runs after migrations, before servers. */
-	seed?: SeedConfig<TServices, TApps>;
-	/** Prisma configuration (optional). When set, dev.prisma is available. */
-	prisma?: PrismaConfig;
-	/** Additional options (optional) */
-	options?: DevOptions;
-}): DevConfig<TServices, TApps> {
-	return config as DevConfig<TServices, TApps>;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Config Validation
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * Validate a dev config and return any errors.
- */
-export function validateConfig<
-	TServices extends Record<string, ServiceConfig>,
-	TApps extends Record<string, AppConfig>,
->(config: DevConfig<TServices, TApps>): string[] {
-	const errors: string[] = [];
-
-	// Check project prefix
-	if (!config.projectPrefix) {
-		errors.push("projectPrefix is required");
-	} else if (!/^[a-z][a-z0-9-]*$/.test(config.projectPrefix)) {
-		errors.push(
-			"projectPrefix must start with a letter and contain only lowercase letters, numbers, and hyphens",
-		);
-	}
-
-	// Check services
-	if (!config.services || Object.keys(config.services).length === 0) {
-		errors.push("At least one service is required");
-	}
-
-	for (const [name, service] of Object.entries(config.services ?? {})) {
-		if (!service.port || typeof service.port !== "number") {
-			errors.push(`Service "${name}" must have a valid port number`);
-		}
-		if (service.port < 1 || service.port > 65535) {
-			errors.push(`Service "${name}" port must be between 1 and 65535`);
-		}
-	}
-
-	// Check apps
-	for (const [name, app] of Object.entries(config.apps ?? {})) {
-		if (!app.port || typeof app.port !== "number") {
-			errors.push(`App "${name}" must have a valid port number`);
-		}
-		if (!app.devCommand) {
-			errors.push(`App "${name}" must have a devCommand`);
-		}
-	}
-
-	// Check migrations
-	for (const migration of config.migrations ?? []) {
-		if (!migration.name) {
-			errors.push("Migration must have a name");
-		}
-		if (!migration.command) {
-			errors.push(`Migration "${migration.name}" must have a command`);
-		}
-	}
-
-	// Check seed
-	if (config.seed && !config.seed.command) {
-		errors.push("Seed must have a command");
-	}
-
-	return errors;
-}
-
-/**
- * Validate config and throw if invalid.
- */
-export function assertValidConfig<
-	TServices extends Record<string, ServiceConfig>,
-	TApps extends Record<string, AppConfig>,
->(config: DevConfig<TServices, TApps>): void {
-	const errors = validateConfig(config);
-	if (errors.length > 0) {
-		throw new Error(`Invalid dev config:\n  - ${errors.join("\n  - ")}`);
-	}
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Config Helpers
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * Merge two configs, with the second taking precedence.
- */
-export function mergeConfigs<
-	TServices extends Record<string, ServiceConfig>,
-	TApps extends Record<string, AppConfig>,
->(
-	base: DevConfig<TServices, TApps>,
-	overrides: Partial<DevConfig<TServices, TApps>>,
-): DevConfig<TServices, TApps> {
-	return {
-		...base,
-		...overrides,
-		services: { ...base.services, ...overrides.services } as TServices,
-		apps: { ...base.apps, ...overrides.apps } as TApps,
-		hooks: { ...base.hooks, ...overrides.hooks },
-		migrations: overrides.migrations ?? base.migrations,
-		seed: overrides.seed ?? base.seed,
-		options: { ...base.options, ...overrides.options },
-	};
-}
-
-/**
- * Create a partial config that can be merged later.
- */
-export function definePartialConfig<
-	TServices extends Record<string, ServiceConfig> = Record<
-		string,
-		ServiceConfig
-	>,
-	TApps extends Record<string, AppConfig> = Record<string, AppConfig>,
->(
-	config: Partial<DevConfig<TServices, TApps>>,
-): Partial<DevConfig<TServices, TApps>> {
-	return config;
-}

package/loader.ts

@@ -1,126 +0,0 @@
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { createDevEnvironment } from "./environment";
-import type { AppConfig, DevEnvironment, ServiceConfig } from "./types";
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Config Loader
-// ═══════════════════════════════════════════════════════════════════════════
-
-export const CONFIG_FILES = [
-	"dev.config.ts",
-	"dev.config.js",
-	"dev-tools.config.ts",
-	"dev-tools.config.js",
-];
-
-/**
- * Find a config file by traversing up from the starting directory.
- * Returns the full path to the config file, or null if not found.
- */
-export function findConfigFile(startDir: string): string | null {
-	let currentDir = startDir;
-
-	while (true) {
-		// Check for any config file in the current directory
-		for (const file of CONFIG_FILES) {
-			const configPath = join(currentDir, file);
-			if (existsSync(configPath)) {
-				return configPath;
-			}
-		}
-
-		// Move to parent directory
-		const parentDir = dirname(currentDir);
-
-		// Stop if we've reached the root (parent equals current)
-		if (parentDir === currentDir) {
-			return null;
-		}
-
-		currentDir = parentDir;
-	}
-}
-
-let cachedEnv: DevEnvironment<
-	Record<string, ServiceConfig>,
-	Record<string, AppConfig>
-> | null = null;
-
-/**
- * Load the dev environment from the config file.
- * Caches the result for subsequent calls.
- *
- * @example
- * ```typescript
- * import { loadDevEnv } from 'buncargo'
- *
- * const env = await loadDevEnv()
- * console.log(env.ports.postgres)  // 5432 (or offset port)
- * console.log(env.urls.api)        // http://localhost:3000
- * ```
- */
-export async function loadDevEnv(options?: {
-	/** Directory to search for config file. Defaults to process.cwd() */
-	cwd?: string;
-	/** Skip cache and reload config */
-	reload?: boolean;
-}): Promise<
-	DevEnvironment<Record<string, ServiceConfig>, Record<string, AppConfig>>
-> {
-	if (cachedEnv && !options?.reload) {
-		return cachedEnv;
-	}
-
-	const cwd = options?.cwd ?? process.cwd();
-	const configPath = findConfigFile(cwd);
-
-	if (configPath) {
-		const mod = await import(configPath);
-		const config = mod.default;
-
-		if (!config?.projectPrefix || !config?.services) {
-			throw new Error(
-				`Invalid config in "${configPath}". Use defineDevConfig() and export as default.`,
-			);
-		}
-
-		cachedEnv = createDevEnvironment(config);
-		return cachedEnv;
-	}
-
-	throw new Error(
-		`No config file found. Create dev.config.ts with: export default defineDevConfig({ ... })`,
-	);
-}
-
-/**
- * Get the cached dev environment synchronously.
- * Throws if loadDevEnv() hasn't been called yet.
- *
- * @example
- * ```typescript
- * // First load async
- * await loadDevEnv()
- *
- * // Then use sync getter anywhere
- * import { getDevEnv } from 'buncargo'
- * const env = getDevEnv()
- * ```
- */
-export function getDevEnv(): DevEnvironment<
-	Record<string, ServiceConfig>,
-	Record<string, AppConfig>
-> {
-	if (!cachedEnv) {
-		throw new Error("Dev environment not loaded. Call loadDevEnv() first.");
-	}
-	return cachedEnv;
-}
-
-/**
- * Clear the cached environment.
- */
-export function clearDevEnvCache(): void {
-	cachedEnv = null;
-}