everything-dev 0.2.0 → 0.3.0

package/src/config.ts

@@ -1,286 +1,573 @@
-import { dirname, join } from "path";
+import { existsSync, statSync } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { Effect } from "every-plugin/effect";
+import { Graph } from "near-social-js";
 import type {
-  AppConfig,
-  BosConfig,
-  GatewayConfig,
-  HostConfig,
-  PortConfig,
-  RemoteConfig,
-  RuntimeConfig,
-  SourceMode,
+	AppConfig,
+	BosConfig,
+	BosConfigInput,
+	PortConfig,
+	RemoteConfig,
+	RuntimeConfig,
+	SourceMode,
+} from "./types";
+import {
+	BosConfigInputSchema,
+	BosConfigSchema,
+	ConfigCircularExtendsError,
+	ConfigFetchError,
+	ConfigResolutionError,
 } from "./types";
 
-export type { AppConfig, BosConfig, GatewayConfig, HostConfig, PortConfig, RemoteConfig, RuntimeConfig, SourceMode };
+// Re-export types
+export type {
+	AppConfig,
+	BosConfig,
+	PortConfig,
+	RemoteConfig,
+	RuntimeConfig,
+	SourceMode,
+};
 
+// Constants
 export const DEFAULT_DEV_CONFIG: AppConfig = {
-  host: "local",
-  ui: "local",
-  api: "local",
+	host: "local",
+	ui: "local",
+	api: "local",
 };
 
+// Global state (for caching)
+const configCache = new Map<string, { config: BosConfig; timestamp: number }>();
 let cachedConfig: BosConfig | null = null;
-let configDir: string | null = null;
+let projectRoot: string | null = null;
 let configLoaded = false;
 
-export function findConfigPath(startDir: string): string | null {
-  let dir = startDir;
-  while (dir !== "/") {
-    const configPath = join(dir, "bos.config.json");
-    if (Bun.file(configPath).size > 0) {
-      try {
-        Bun.file(configPath).text();
-        return configPath;
-      } catch {
-        // File doesn't exist or can't be read
-      }
-    }
-    dir = dirname(dir);
-  }
-  return null;
-}
-
-function findConfigPathSync(startDir: string): string | null {
-  let dir = startDir;
-  while (dir !== "/") {
-    const configPath = join(dir, "bos.config.json");
-    const file = Bun.file(configPath);
-    if (file.size > 0) {
-      return configPath;
-    }
-    dir = dirname(dir);
-  }
-  return null;
-}
-
-export function loadConfig(cwd?: string): BosConfig | null {
-  if (configLoaded) return cachedConfig;
-
-  const startDir = cwd ?? process.cwd();
-  const configPath = findConfigPathSync(startDir);
-
-  if (!configPath) {
-    configLoaded = true;
-    configDir = startDir;
-    return null;
-  }
-
-  configDir = dirname(configPath);
-  const content = require(configPath);
-  cachedConfig = content as BosConfig;
-  configLoaded = true;
-  return cachedConfig;
+// ============================================================================
+// PUBLIC API (6 methods)
+// ============================================================================
+
+/**
+ * Clear the config cache. Used by --force flag.
+ */
+export function clearConfigCache(): void {
+	configCache.clear();
+	cachedConfig = null;
+	projectRoot = null;
+	configLoaded = false;
 }
 
-export function setConfig(config: BosConfig, dir?: string): void {
-  cachedConfig = config;
-  configDir = dir ?? process.cwd();
-  configLoaded = true;
+/**
+ * Find the path to bos.config.json by walking up the directory tree.
+ */
+export function findConfigPath(cwd?: string): string | null {
+	let dir = cwd ?? process.cwd();
+	while (dir !== "/") {
+		const configPath = join(dir, "bos.config.json");
+		if (existsSync(configPath) && statSync(configPath).size > 0) {
+			return configPath;
+		}
+		dir = dirname(dir);
+	}
+	return null;
 }
 
-export function getConfigDir(): string {
-  if (!configLoaded) {
-    loadConfig();
-  }
-  return configDir!;
+/**
+ * Get the cached config. Returns null if not loaded yet.
+ */
+export function getConfig(): BosConfig | null {
+	return cachedConfig;
 }
 
-export function getRemotes(): string[] {
-  const config = loadConfig();
-  if (!config) return [];
-  return Object.keys(config.app).filter((k) => k !== "host");
+/**
+ * Get the project root directory (where bos.config.json is located).
+ * Throws if config hasn't been loaded.
+ */
+export function getProjectRoot(): string {
+	if (!configLoaded || !projectRoot) {
+		throw new Error("Config not loaded. Call loadConfig() first.");
+	}
+	return projectRoot;
 }
 
-export function getPackages(): string[] {
-  const config = loadConfig();
-  if (!config) return [];
-  return Object.keys(config.app);
+/**
+ * Result of loading config - includes everything needed by callers.
+ */
+export interface ConfigResult {
+	/** The validated BosConfig */
+	config: BosConfig;
+	/** Environment-specific runtime config */
+	runtime: RuntimeConfig;
+	/** Information about where/how the config was loaded */
+	source: {
+		path: string;
+		extended?: string[];
+		remote?: boolean;
+	};
+	/** Package information */
+	packages: {
+		all: string[];
+		resolved: PackageResolution[];
+	};
 }
 
-export function getRemote(name: string): RemoteConfig | undefined {
-  const config = loadConfig();
-  if (!config) return undefined;
-  const remote = config.app[name];
-  if (remote && "name" in remote) {
-    return remote as RemoteConfig;
-  }
-  return undefined;
+/**
+ * Resolution info for a single package.
+ */
+export interface PackageResolution {
+	name: string;
+	mode: SourceMode;
+	exists: boolean;
+	port: number;
+	url: string;
 }
 
-export function getHost(): HostConfig {
-  const config = loadConfig();
-  if (!config) {
-    throw new Error("No bos.config.json found");
-  }
-  return config.app.host;
+/**
+ * Primary config loader - handles everything.
+ * - Local config loading
+ * - Config inheritance (extends)
+ * - BOS URL fetching
+ * - Caching
+ * - Runtime config generation
+ */
+export async function loadConfig(options?: {
+	cwd?: string;
+	path?: string;
+	force?: boolean;
+	env?: "development" | "production";
+}): Promise<ConfigResult | null> {
+	// Return cached result if available and not forcing reload
+	if (configLoaded && cachedConfig && !options?.force) {
+		const runtime = buildRuntimeConfig(
+			cachedConfig,
+			options?.env ?? "development",
+		);
+		return {
+			config: cachedConfig,
+			runtime,
+			source: { path: join(projectRoot!, "bos.config.json") },
+			packages: {
+				all: Object.keys(cachedConfig.app),
+				resolved: [], // Will be populated by resolvePackages
+			},
+		};
+	}
+
+	// Find or use explicit config path
+	const configPath = options?.path ?? findConfigPath(options?.cwd);
+	if (!configPath) {
+		configLoaded = true;
+		projectRoot = options?.cwd ?? process.cwd();
+		return null;
+	}
+
+	const baseDir = dirname(configPath);
+
+	// Check cache for this specific file
+	const cached = configCache.get(configPath);
+	if (cached && !options?.force) {
+		projectRoot = baseDir;
+		cachedConfig = cached.config;
+		configLoaded = true;
+		const runtime = buildRuntimeConfig(
+			cached.config,
+			options?.env ?? "development",
+		);
+		return {
+			config: cached.config,
+			runtime,
+			source: { path: configPath },
+			packages: {
+				all: Object.keys(cached.config.app),
+				resolved: [],
+			},
+		};
+	}
+
+	try {
+		// Resolve config with extends
+		const extendedChain: string[] = [];
+		const rawConfig = await resolveConfigWithExtends(
+			configPath,
+			baseDir,
+			new Set(),
+			extendedChain,
+		);
+
+		// Validate with strict schema
+		const validated = BosConfigSchema.parse(rawConfig);
+
+		// Cache result
+		configCache.set(configPath, { config: validated, timestamp: Date.now() });
+		projectRoot = baseDir;
+		cachedConfig = validated;
+		configLoaded = true;
+
+		// Build runtime config
+		const runtime = buildRuntimeConfig(
+			validated,
+			options?.env ?? "development",
+		);
+
+		return {
+			config: validated,
+			runtime,
+			source: {
+				path: configPath,
+				extended: extendedChain.length > 0 ? extendedChain : undefined,
+				remote: extendedChain.some((e) => e.startsWith("bos://")),
+			},
+			packages: {
+				all: Object.keys(validated.app),
+				resolved: [],
+			},
+		};
+	} catch (error) {
+		if (error instanceof ConfigCircularExtendsError) {
+			throw error;
+		}
+		if (error instanceof ConfigFetchError) {
+			throw error;
+		}
+		if (error instanceof ConfigResolutionError) {
+			throw error;
+		}
+		throw new ConfigResolutionError(
+			`Failed to load config from ${configPath}: ${error}`,
+		);
+	}
 }
 
-export function getUrl(
-  packageName: string,
-  env: "development" | "production" = "development"
-): string | undefined {
-  const config = loadConfig();
-  if (!config) return undefined;
-  const pkg = config.app[packageName];
-  if (!pkg) return undefined;
-  return pkg[env];
+/**
+ * Resolve packages with modes, existence checks, and auto-remote detection.
+ * Merges functionality of resolvePackageModes() and getExistingPackages().
+ */
+export async function resolvePackages(
+	packages: string[],
+	requestedModes: Record<string, SourceMode>,
+): Promise<{
+	resolved: Record<string, PackageResolution>;
+	autoRemote: string[];
+}> {
+	const dir = getProjectRoot();
+	const resolved: Record<string, PackageResolution> = {};
+	const autoRemote: string[] = [];
+
+	// Get config for port calculations
+	const config = getConfig();
+
+	for (const pkg of packages) {
+		const exists = await fileExists(`${dir}/${pkg}/package.json`);
+		const requestedMode = requestedModes[pkg] ?? "local";
+
+		// Auto-switch to remote if package doesn't exist locally
+		const mode =
+			!exists && requestedMode === "local" ? "remote" : requestedMode;
+		if (!exists && requestedMode === "local") {
+			autoRemote.push(pkg);
+		}
+
+		// Calculate port and URL
+		let port = 0;
+		let url = "";
+
+		if (config && pkg in config.app) {
+			const pkgConfig = config.app[pkg];
+			if (pkg === "host") {
+				port = parsePort(pkgConfig.development);
+				url = mode === "remote" ? pkgConfig.production : pkgConfig.development;
+			} else {
+				// For ui/api and other packages, access via index signature
+				const devUrl = (pkgConfig as { development?: string }).development;
+				const prodUrl = (pkgConfig as { production?: string }).production;
+				if (devUrl) {
+					port = parsePort(devUrl);
+					url = mode === "remote" ? (prodUrl ?? devUrl) : devUrl;
+				}
+			}
+		}
+
+		resolved[pkg] = { name: pkg, mode, exists, port, url };
+	}
+
+	return { resolved, autoRemote };
 }
 
-export function getAccount(): string {
-  const config = loadConfig();
-  if (!config) {
-    throw new Error("No bos.config.json found");
-  }
-  return config.account;
-}
-
-export function getComponentUrl(
-  component: "host" | "ui" | "api",
-  source: SourceMode
-): string {
-  const config = loadConfig();
-  if (!config) {
-    throw new Error("No bos.config.json found");
-  }
-
-  if (component === "host") {
-    return source === "remote" ? config.app.host.production : config.app.host.development;
-  }
-
-  const componentConfig = config.app[component];
-  if (!componentConfig || !("name" in componentConfig)) {
-    throw new Error(`Component ${component} not found in bos.config.json`);
-  }
-
-  return source === "remote" ? componentConfig.production : componentConfig.development;
-}
+// ============================================================================
+// INTERNAL HELPERS
+// ============================================================================
 
+/**
+ * Parse port from URL string.
+ */
 export function parsePort(url: string): number {
-  try {
-    const parsed = new URL(url);
-    return parsed.port ? parseInt(parsed.port, 10) : (parsed.protocol === "https:" ? 443 : 80);
-  } catch {
-    return 3000;
-  }
-}
-
-export function getPortsFromConfig(): PortConfig {
-  const config = loadConfig();
-  if (!config) {
-    return { host: 3000, ui: 3002, api: 3014 };
-  }
-  return {
-    host: parsePort(config.app.host.development),
-    ui: config.app.ui ? parsePort((config.app.ui as RemoteConfig).development) : 3002,
-    api: config.app.api ? parsePort((config.app.api as RemoteConfig).development) : 3014,
-  };
+	try {
+		const parsed = new URL(url);
+		return parsed.port
+			? parseInt(parsed.port, 10)
+			: parsed.protocol === "https:"
+				? 443
+				: 80;
+	} catch {
+		return 3000;
+	}
 }
 
-export function getConfigPath(): string {
-  if (!configDir) {
-    loadConfig();
-  }
-  return `${configDir}/bos.config.json`;
+/**
+ * Check if a file exists.
+ */
+async function fileExists(path: string): Promise<boolean> {
+	return access(path)
+		.then(() => true)
+		.catch(() => false);
 }
 
-export function getHostRemoteUrl(): string | undefined {
-  const config = loadConfig();
-  if (!config) return undefined;
-  return config.app.host.production || undefined;
+/**
+ * Resolve BOS URL to Graph path.
+ * bos://{account}/{gateway} → {account}/bos/gateways/{gateway}/bos.config.json
+ */
+function resolveBosUrl(bosUrl: string): string {
+	const match = bosUrl.match(/^bos:\/\/([^/]+)\/(.+)$/);
+	if (!match) {
+		throw new ConfigResolutionError(
+			`Invalid BOS URL format: ${bosUrl}. Expected: bos://{account}/{gateway}`,
+		);
+	}
+	const [, account, gateway] = match;
+	return `${account}/bos/gateways/${gateway}/bos.config.json`;
 }
 
-export function getGatewayUrl(env: "development" | "production" = "development"): string {
-  const config = loadConfig();
-  if (!config) {
-    throw new Error("No bos.config.json found");
-  }
-  return config.gateway[env];
+/**
+ * Fetch config from NEAR Social (BOS URL) with 10s timeout.
+ */
+async function fetchBosConfig(bosUrl: string): Promise<BosConfigInput> {
+	const configPath = resolveBosUrl(bosUrl);
+	const graph = new Graph();
+
+	try {
+		const data = await Effect.runPromise(
+			Effect.tryPromise({
+				try: () =>
+					Promise.race([
+						graph.get({ keys: [configPath] }),
+						new Promise<never>((_, reject) =>
+							setTimeout(() => reject(new Error("Timeout after 10s")), 10000),
+						),
+					]),
+				catch: (e) => new ConfigFetchError(bosUrl, e),
+			}),
+		);
+
+		if (!data) {
+			throw new ConfigFetchError(bosUrl, "No data returned");
+		}
+
+		// Navigate nested structure
+		const parts = configPath.split("/");
+		let current: unknown = data;
+		for (const part of parts) {
+			if (current && typeof current === "object" && part in current) {
+				current = (current as Record<string, unknown>)[part];
+			} else {
+				throw new ConfigFetchError(bosUrl, `Path not found: ${configPath}`);
+			}
+		}
+
+		if (typeof current !== "string") {
+			throw new ConfigFetchError(bosUrl, "Config is not a string");
+		}
+
+		return JSON.parse(current) as BosConfigInput;
+	} catch (error) {
+		if (error instanceof ConfigFetchError) {
+			throw error;
+		}
+		throw new ConfigFetchError(bosUrl, error);
+	}
 }
 
-export async function packageExists(pkg: string): Promise<boolean> {
-  const dir = getConfigDir();
-  return Bun.file(`${dir}/${pkg}/package.json`).exists();
+/**
+ * Load a single config file (local or BOS URL).
+ */
+async function loadConfigFile(
+	configPath: string,
+	baseDir?: string,
+): Promise<BosConfigInput> {
+	// BOS URL
+	if (configPath.startsWith("bos://")) {
+		return fetchBosConfig(configPath);
+	}
+
+	// Local file
+	const resolvedPath = isAbsolute(configPath)
+		? configPath
+		: baseDir
+			? resolve(baseDir, configPath)
+			: resolve(process.cwd(), configPath);
+
+	const text = await readFile(resolvedPath, "utf-8");
+	return JSON.parse(text) as BosConfigInput;
 }
 
-export async function resolvePackageModes(
-  packages: string[],
-  input: Record<string, SourceMode | undefined>
-): Promise<{ modes: Record<string, SourceMode>; autoRemote: string[] }> {
-  const dir = getConfigDir();
-  const modes: Record<string, SourceMode> = {};
-  const autoRemote: string[] = [];
-
-  for (const pkg of packages) {
-    const exists = await Bun.file(`${dir}/${pkg}/package.json`).exists();
-    const requestedMode = input[pkg] ?? "local";
-
-    if (!exists && requestedMode === "local") {
-      modes[pkg] = "remote";
-      autoRemote.push(pkg);
-    } else {
-      modes[pkg] = requestedMode;
-    }
-  }
-
-  return { modes, autoRemote };
+/**
+ * Deep merge configs with inheritance.
+ * - Objects: recursive merge
+ * - Arrays: child replaces parent
+ * - Primitives: child wins
+ */
+function mergeConfigs(
+	parent: BosConfigInput,
+	child: BosConfigInput,
+): BosConfigInput {
+	const merged: BosConfigInput = { ...parent, ...child };
+
+	// Merge app configs deeply
+	if (parent.app || child.app) {
+		merged.app = { ...parent.app, ...child.app };
+		const parentApps = parent.app || {};
+		const childApps = child.app || {};
+
+		for (const key of new Set([
+			...Object.keys(parentApps),
+			...Object.keys(childApps),
+		])) {
+			const parentApp = parentApps[key as keyof typeof parentApps];
+			const childApp = childApps[key as keyof typeof childApps];
+
+			if (parentApp && childApp) {
+				(merged.app as Record<string, unknown>)[key] = {
+					...parentApp,
+					...childApp,
+				};
+			} else if (childApp) {
+				(merged.app as Record<string, unknown>)[key] = childApp;
+			} else if (parentApp) {
+				(merged.app as Record<string, unknown>)[key] = parentApp;
+			}
+		}
+	}
+
+	// Merge shared deps deeply
+	if (parent.shared || child.shared) {
+		merged.shared = { ...parent.shared, ...child.shared };
+		const parentShared = parent.shared || {};
+		const childShared = child.shared || {};
+
+		// Deep merge each shared category (ui, api, etc.)
+		for (const category of new Set([
+			...Object.keys(parentShared),
+			...Object.keys(childShared),
+		])) {
+			const parentCategory =
+				parentShared[category as keyof typeof parentShared];
+			const childCategory = childShared[category as keyof typeof childShared];
+
+			if (parentCategory && childCategory) {
+				(merged.shared as Record<string, unknown>)[category] = {
+					...parentCategory,
+					...childCategory,
+				};
+			} else if (childCategory) {
+				(merged.shared as Record<string, unknown>)[category] = childCategory;
+			} else if (parentCategory) {
+				(merged.shared as Record<string, unknown>)[category] = parentCategory;
+			}
+		}
+	}
+
+	return merged;
 }
 
-export async function getExistingPackages(packages: string[]): Promise<{ existing: string[]; missing: string[] }> {
-  const dir = getConfigDir();
-  const existing: string[] = [];
-  const missing: string[] = [];
-
-  for (const pkg of packages) {
-    const exists = await Bun.file(`${dir}/${pkg}/package.json`).exists();
-    if (exists) {
-      existing.push(pkg);
-    } else {
-      missing.push(pkg);
-    }
-  }
-
-  return { existing, missing };
+/**
+ * Recursively resolve config with extends inheritance.
+ */
+async function resolveConfigWithExtends(
+	configPath: string,
+	baseDir: string,
+	visited: Set<string>,
+	chain: string[],
+): Promise<BosConfigInput> {
+	// Check for circular dependencies
+	if (visited.has(configPath)) {
+		throw new ConfigCircularExtendsError([...visited, configPath]);
+	}
+
+	// Load current config
+	const config = await loadConfigFile(configPath, baseDir);
+
+	// Track in chain if it's a BOS URL
+	if (configPath.startsWith("bos://")) {
+		chain.push(configPath);
+	}
+
+	// If no extends, return as-is
+	if (!config.extends) {
+		return config;
+	}
+
+	// Mark as visited
+	const newVisited = new Set(visited);
+	newVisited.add(configPath);
+
+	// Resolve parent
+	const parentPath = config.extends;
+	const parentBaseDir = parentPath.startsWith("bos://")
+		? baseDir
+		: isAbsolute(parentPath)
+			? dirname(parentPath)
+			: baseDir;
+
+	const parentConfig = await resolveConfigWithExtends(
+		parentPath,
+		parentBaseDir,
+		newVisited,
+		chain,
+	);
+
+	// Merge and return
+	return mergeConfigs(parentConfig, config);
 }
 
-export async function loadBosConfig(
-  env: "development" | "production" = "production"
-): Promise<RuntimeConfig> {
-  const configPath = process.env.BOS_CONFIG_PATH;
-  
-  let bosConfig: BosConfig;
-  if (configPath) {
-    const file = Bun.file(configPath);
-    const text = await file.text();
-    bosConfig = JSON.parse(text) as BosConfig;
-  } else {
-    const config = loadConfig();
-    if (!config) {
-      throw new Error("No bos.config.json found");
-    }
-    bosConfig = config;
-  }
-
-  const uiConfig = bosConfig.app.ui as RemoteConfig;
-  const apiConfig = bosConfig.app.api as RemoteConfig;
-
-  return {
-    env,
-    account: bosConfig.account,
-    title: bosConfig.account,
-    hostUrl: bosConfig.app.host[env],
-    shared: bosConfig.shared,
-    ui: {
-      name: uiConfig.name,
-      url: uiConfig[env],
-      ssrUrl: uiConfig.ssr,
-      source: "remote",
-    },
-    api: {
-      name: apiConfig.name,
-      url: apiConfig[env],
-      source: "remote",
-      proxy: apiConfig.proxy,
-      variables: apiConfig.variables,
-      secrets: apiConfig.secrets,
-    },
-  };
+/**
+ * Build runtime config from BosConfig.
+ */
+function buildRuntimeConfig(
+	config: BosConfig,
+	env: "development" | "production",
+): RuntimeConfig {
+	const uiConfig = config.app.ui as RemoteConfig | undefined;
+	const apiConfig = config.app.api as RemoteConfig | undefined;
+
+	// Extract properties from api config
+	const apiProxy = apiConfig?.proxy;
+	const apiVariables = apiConfig?.variables;
+	const apiSecrets = apiConfig?.secrets;
+
+	// Env var overrides
+	const uiUrlOverride = process.env.BOS_UI_URL;
+	const uiSsrUrlOverride = process.env.BOS_UI_SSR_URL;
+
+	return {
+		env,
+		account: config.account,
+		title: config.account,
+		hostUrl: config.app.host[env],
+		shared: config.shared,
+		ui: {
+			name: uiConfig?.name ?? "ui",
+			url: uiUrlOverride ?? uiConfig?.[env] ?? "",
+			entry: `${uiUrlOverride ?? uiConfig?.[env] ?? ""}/remoteEntry.js`,
+			ssrUrl: uiSsrUrlOverride ?? uiConfig?.ssr,
+			source: env === "development" ? "local" : "remote",
+		},
+		api: {
+			name: apiConfig?.name ?? "api",
+			url: apiConfig?.[env] ?? "",
+			entry: `${apiConfig?.[env] ?? ""}/remoteEntry.js`,
+			source: env === "development" ? "local" : "remote",
+			proxy: apiProxy,
+			variables: apiVariables,
+			secrets: apiSecrets,
+		},
+	};
 }