buncargo 1.0.26 → 3.0.0

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;
-}