@geekmidas/cli 9.0.2 → 10.0.0-alpha.0

package/src/workspace/index.ts

@@ -1,433 +0,0 @@
-import { basename } from 'node:path';
-import type { GkmConfig } from '../types.js';
-import { getPublicEnvPrefix } from './publicEnv.js';
-import {
-	formatValidationErrors,
-	safeValidateWorkspaceConfig,
-} from './schema.js';
-import type {
-	AppConfig,
-	AppsRecord,
-	DeployTarget,
-	InferredWorkspaceConfig,
-	LoadedConfig,
-	NormalizedAppConfig,
-	NormalizedWorkspace,
-	WorkspaceConfig,
-	WorkspaceInput,
-} from './types.js';
-import { isWorkspaceConfig } from './types.js';
-
-export {
-	getPublicEnvPrefix,
-	PUBLIC_ENV_PREFIXES,
-	stripPublicPrefix,
-} from './publicEnv.js';
-export {
-	formatValidationErrors,
-	getDeployTargetError,
-	isDeployTargetSupported,
-	isPhase2DeployTarget,
-	PHASE_2_DEPLOY_TARGETS,
-	SUPPORTED_DEPLOY_TARGETS,
-	safeValidateWorkspaceConfig,
-	validateWorkspaceConfig,
-	WorkspaceConfigSchema,
-} from './schema.js';
-// Re-export types
-export type {
-	AppConfig,
-	AppConfigInput,
-	AppInput,
-	AppsRecord,
-	BackendFramework,
-	ConstrainedApps,
-	DeployConfig,
-	DeployTarget,
-	DokployWorkspaceConfig,
-	FrontendFramework,
-	InferAppNames,
-	InferredWorkspaceConfig,
-	LoadedConfig,
-	MailServiceConfig,
-	ModelsConfig,
-	NormalizedAppConfig,
-	NormalizedWorkspace,
-	SecretsConfig,
-	ServiceImageConfig,
-	ServicesConfig,
-	SharedConfig,
-	WorkspaceConfig,
-	WorkspaceInput,
-} from './types.js';
-export { isWorkspaceConfig } from './types.js';
-
-/**
- * Validate that all dependencies reference existing apps.
- * Returns the config if valid, throws otherwise.
- */
-function validateDependencies<TApps extends AppsRecord>(apps: TApps): void {
-	const appNames = new Set(Object.keys(apps));
-
-	for (const [appName, app] of Object.entries(apps)) {
-		for (const dep of app.dependencies ?? []) {
-			if (!appNames.has(dep)) {
-				throw new Error(
-					`Invalid dependency: App "${appName}" depends on "${dep}" which does not exist. ` +
-						`Valid apps are: ${[...appNames].join(', ')}`,
-				);
-			}
-			if (dep === appName) {
-				throw new Error(
-					`Invalid dependency: App "${appName}" cannot depend on itself.`,
-				);
-			}
-		}
-	}
-}
-
-/**
- * Define workspace configuration with full TypeScript support and type inference.
- *
- * Uses `const` type parameter to infer literal app names, providing:
- * - Autocomplete for app names in dependencies
- * - Type errors for invalid dependency references
- * - Full type inference for the returned config
- *
- * @example
- * ```ts
- * // gkm.config.ts
- * import { defineWorkspace } from '@geekmidas/cli';
- *
- * export default defineWorkspace({
- *   name: 'my-saas',
- *   apps: {
- *     api: {
- *       type: 'backend',
- *       path: 'apps/api',
- *       port: 3000,
- *       routes: './src/endpoints/**\/*.ts',
- *       envParser: './src/config/env',
- *       logger: './src/logger',
- *     },
- *     web: {
- *       type: 'web',
- *       framework: 'nextjs',
- *       path: 'apps/web',
- *       port: 3001,
- *       dependencies: ['api'], // <- autocomplete shows 'api' | 'web'
- *     },
- *   },
- *   services: {
- *     db: true,
- *     cache: true,
- *   },
- * });
- *
- * // config.apps.api <- full type inference
- * // config.apps.foo <- TypeScript error
- * ```
- */
-export function defineWorkspace<const TApps extends AppsRecord>(
-	config: WorkspaceInput<TApps>,
-): InferredWorkspaceConfig<TApps> {
-	// Validate dependencies at runtime
-	validateDependencies(config.apps as unknown as TApps);
-
-	// Validate with Zod schema
-	const result = safeValidateWorkspaceConfig(config);
-	if (!result.success && result.error) {
-		throw new Error(formatValidationErrors(result.error));
-	}
-
-	return config as unknown as InferredWorkspaceConfig<TApps>;
-}
-
-/**
- * Get the package name from package.json in the given directory.
- */
-function getPackageName(cwd: string): string | undefined {
-	try {
-		// Dynamic import would be async, so we use require for sync operation
-		// eslint-disable-next-line @typescript-eslint/no-require-imports
-		const pkg = require(`${cwd}/package.json`);
-		return pkg.name?.replace(/^@[^/]+\//, ''); // Remove scope
-	} catch {
-		return undefined;
-	}
-}
-
-/**
- * Normalize a workspace configuration with resolved defaults.
- */
-export function normalizeWorkspace(
-	config: WorkspaceConfig,
-	cwd: string,
-): NormalizedWorkspace {
-	const name = config.name ?? getPackageName(cwd) ?? basename(cwd);
-	const defaultTarget = config.deploy?.default ?? 'dokploy';
-
-	const normalizedApps: Record<string, NormalizedAppConfig> = {};
-
-	for (const [appName, app] of Object.entries(config.apps)) {
-		normalizedApps[appName] = normalizeAppConfig(app, defaultTarget);
-	}
-
-	return {
-		name,
-		root: cwd,
-		apps: normalizedApps,
-		services: config.services ?? {},
-		deploy: config.deploy ?? { default: 'dokploy' },
-		shared: config.shared ?? { packages: ['packages/*'] },
-		secrets: config.secrets ?? {},
-		state: config.state,
-	};
-}
-
-/**
- * Normalize an app configuration with resolved defaults.
- * @param app - App configuration
- * @param defaultTarget - Default deploy target from workspace config
- */
-function normalizeAppConfig(
-	app: AppConfig,
-	defaultTarget: DeployTarget,
-): NormalizedAppConfig {
-	return {
-		...app,
-		type: app.type ?? 'backend',
-		port: app.port,
-		path: app.path,
-		dependencies: app.dependencies ?? [],
-		resolvedDeployTarget: app.deploy ?? defaultTarget,
-	};
-}
-
-/**
- * Wrap a single-app GkmConfig as a workspace.
- * This allows existing single-app configs to work seamlessly.
- */
-export function wrapSingleAppAsWorkspace(
-	config: GkmConfig,
-	cwd: string,
-): NormalizedWorkspace {
-	const name = getPackageName(cwd) ?? basename(cwd);
-
-	// Extract docker compose services if configured
-	const services = config.docker?.compose?.services;
-	const normalizedServices: NormalizedWorkspace['services'] = {};
-
-	if (services) {
-		if (Array.isArray(services)) {
-			// Legacy array format
-			for (const svc of services) {
-				if (svc === 'postgres') normalizedServices.db = true;
-				if (svc === 'redis') normalizedServices.cache = true;
-			}
-		} else {
-			// Object format
-			if (services.postgres) normalizedServices.db = services.postgres;
-			if (services.redis) normalizedServices.cache = services.redis;
-		}
-	}
-
-	const apiApp: NormalizedAppConfig = {
-		type: 'backend',
-		path: '.',
-		port: 3000,
-		dependencies: [],
-		resolvedDeployTarget: 'dokploy',
-		routes: config.routes,
-		functions: config.functions,
-		crons: config.crons,
-		subscribers: config.subscribers,
-		envParser: config.envParser,
-		logger: config.logger,
-		providers: config.providers,
-		hooks: config.hooks,
-		telescope: config.telescope,
-		studio: config.studio,
-		openapi: config.openapi,
-		runtime: config.runtime,
-		env: config.env,
-	};
-
-	return {
-		name,
-		root: cwd,
-		apps: { api: apiApp },
-		services: normalizedServices,
-		deploy: { default: 'dokploy' },
-		shared: { packages: [] },
-		secrets: {},
-	};
-}
-
-/**
- * Process a loaded configuration (either single-app or workspace).
- * Returns a normalized workspace in both cases.
- */
-export function processConfig(
-	config: GkmConfig | WorkspaceConfig,
-	cwd: string,
-): LoadedConfig {
-	if (isWorkspaceConfig(config)) {
-		// Validate workspace config
-		const result = safeValidateWorkspaceConfig(config);
-		if (!result.success && result.error) {
-			throw new Error(formatValidationErrors(result.error));
-		}
-
-		return {
-			type: 'workspace',
-			raw: config,
-			workspace: normalizeWorkspace(config, cwd),
-		};
-	}
-
-	// Single-app config - wrap as workspace
-	return {
-		type: 'single',
-		raw: config,
-		workspace: wrapSingleAppAsWorkspace(config, cwd),
-	};
-}
-
-/**
- * Get the GkmConfig for a specific app in a workspace.
- * Useful for running existing single-app commands on a specific app.
- */
-export function getAppGkmConfig(
-	workspace: NormalizedWorkspace,
-	appName: string,
-): GkmConfig | undefined {
-	const app = workspace.apps[appName];
-	if (!app || app.type !== 'backend') {
-		return undefined;
-	}
-
-	return {
-		routes: app.routes ?? '',
-		functions: app.functions,
-		crons: app.crons,
-		subscribers: app.subscribers,
-		envParser: app.envParser ?? '',
-		logger: app.logger ?? '',
-		providers: app.providers,
-		hooks: app.hooks,
-		telescope: app.telescope,
-		studio: app.studio,
-		openapi: app.openapi,
-		runtime: app.runtime,
-		env: app.env,
-	};
-}
-
-/**
- * Get topologically sorted app names based on dependencies.
- * Apps with no dependencies come first, then apps that depend on them.
- */
-export function getAppBuildOrder(workspace: NormalizedWorkspace): string[] {
-	const appNames = Object.keys(workspace.apps);
-	const visited = new Set<string>();
-	const result: string[] = [];
-
-	function visit(name: string) {
-		if (visited.has(name)) return;
-		visited.add(name);
-
-		const app = workspace.apps[name];
-		if (app) {
-			for (const dep of app.dependencies) {
-				visit(dep);
-			}
-		}
-
-		result.push(name);
-	}
-
-	for (const name of appNames) {
-		visit(name);
-	}
-
-	return result;
-}
-
-/**
- * Generate environment variables for app dependencies.
- *
- * Each dependency gets the un-prefixed `{DEP}_URL` (for server-side use) and,
- * when the consuming app's framework supports a public-var prefix, also the
- * prefixed form (e.g. `NEXT_PUBLIC_{DEP}_URL` for Next.js, `VITE_{DEP}_URL`
- * for Vite/TanStack Start). The prefixed form is what gets bundled into the
- * client at build time.
- */
-export function getDependencyEnvVars(
-	workspace: NormalizedWorkspace,
-	appName: string,
-	urlPrefix = 'http://localhost',
-): Record<string, string> {
-	const app = workspace.apps[appName];
-	if (!app) return {};
-
-	const env: Record<string, string> = {};
-	const publicPrefix = getPublicEnvPrefix(app.framework);
-
-	for (const depName of app.dependencies) {
-		const dep = workspace.apps[depName];
-		if (dep) {
-			const url = `${urlPrefix}:${dep.port}`;
-			const envKey = `${depName.toUpperCase()}_URL`;
-			env[envKey] = url;
-			if (publicPrefix) {
-				env[`${publicPrefix}${envKey}`] = url;
-			}
-		}
-	}
-
-	return env;
-}
-
-/**
- * Resolve the Dokploy endpoint for a specific stage.
- *
- * Uses per-stage endpoint from `endpoints` if available,
- * otherwise falls back to the global `endpoint`.
- *
- * @param dokployConfig - Dokploy workspace configuration
- * @param stage - Deployment stage (e.g., 'development', 'production')
- * @returns The endpoint URL for the stage, or undefined if not configured
- *
- * @example
- * ```ts
- * // With per-stage endpoints
- * const config = {
- *   endpoints: {
- *     development: 'https://dev.dokploy.example.com:3000',
- *     production: 'https://prod.dokploy.example.com:3000',
- *   },
- * };
- * getEndpointForStage(config, 'production'); // => 'https://prod.dokploy.example.com:3000'
- *
- * // With single endpoint
- * const config = { endpoint: 'https://dokploy.example.com:3000' };
- * getEndpointForStage(config, 'production'); // => 'https://dokploy.example.com:3000'
- * ```
- */
-export function getEndpointForStage(
-	dokployConfig:
-		| { endpoint?: string; endpoints?: Record<string, string> }
-		| undefined,
-	stage: string,
-): string | undefined {
-	if (!dokployConfig) return undefined;
-
-	// Check per-stage endpoint first
-	if (dokployConfig.endpoints?.[stage]) {
-		return dokployConfig.endpoints[stage];
-	}
-
-	// Fall back to global endpoint
-	return dokployConfig.endpoint;
-}

package/src/workspace/publicEnv.ts

@@ -1,57 +0,0 @@
-import type { Framework } from './types.js';
-
-/**
- * All public env-var prefixes the toolbox understands.
- *
- * Used when resolving incoming var names back to a dependency
- * (e.g. `VITE_AUTH_URL` → `auth`). A var matching any of these
- * is considered safe to inline into a client bundle.
- */
-export const PUBLIC_ENV_PREFIXES = [
-	'NEXT_PUBLIC_',
-	'VITE_',
-	'EXPO_PUBLIC_',
-] as const;
-
-/**
- * Resolve the public env-var prefix that a frontend framework's bundler
- * inlines into client code at build time:
- *
- *  - `nextjs`         → `NEXT_PUBLIC_`
- *  - `vite`           → `VITE_`
- *  - `tanstack-start` → `VITE_` (uses Vite under the hood)
- *  - `expo`           → `EXPO_PUBLIC_`
- *  - `remix`          → `''` (Remix exposes via loaders, no prefix convention)
- *
- * For backend frameworks or unspecified, falls back to `NEXT_PUBLIC_` to
- * preserve the historical default. Backend apps never read these vars
- * from a bundle, so the prefix only affects scaffolding/symmetry.
- */
-export function getPublicEnvPrefix(framework?: Framework): string {
-	switch (framework) {
-		case 'vite':
-		case 'tanstack-start':
-			return 'VITE_';
-		case 'expo':
-			return 'EXPO_PUBLIC_';
-		case 'remix':
-			return '';
-		case 'nextjs':
-			return 'NEXT_PUBLIC_';
-		default:
-			return 'NEXT_PUBLIC_';
-	}
-}
-
-/**
- * Strip a known public prefix from a var name.
- * Returns the un-prefixed name, or `null` if no prefix matched.
- */
-export function stripPublicPrefix(name: string): string | null {
-	for (const prefix of PUBLIC_ENV_PREFIXES) {
-		if (prefix && name.startsWith(prefix)) {
-			return name.slice(prefix.length);
-		}
-	}
-	return null;
-}