@geekmidas/cli 0.9.0 → 0.12.0

package/src/build/providerResolver.ts

@@ -1,17 +1,17 @@
 import type {
-  AWSApiGatewayConfig,
-  AWSLambdaConfig,
-  BuildOptions,
-  GkmConfig,
-  LegacyProvider,
-  MainProvider,
-  ProvidersConfig,
-  ServerConfig,
+	AWSApiGatewayConfig,
+	AWSLambdaConfig,
+	BuildOptions,
+	GkmConfig,
+	LegacyProvider,
+	MainProvider,
+	ProvidersConfig,
+	ServerConfig,
 } from '../types';
 
 export interface ResolvedProviders {
-  providers: LegacyProvider[];
-  enableOpenApi: boolean;
+	providers: LegacyProvider[];
+	enableOpenApi: boolean;
 }
 
 /**
@@ -19,166 +19,166 @@ export interface ResolvedProviders {
  * to the internal legacy format for backward compatibility
  */
 export function resolveProviders(
-  config: GkmConfig,
-  options: BuildOptions,
+	config: GkmConfig,
+	options: BuildOptions,
 ): ResolvedProviders {
-  const providers: LegacyProvider[] = [];
-  let enableOpenApi = options.enableOpenApi || false;
-
-  // Handle legacy providers option (deprecated)
-  if (options.providers) {
-    return {
-      providers: options.providers,
-      enableOpenApi,
-    };
-  }
-
-  // Handle new provider option
-  if (options.provider) {
-    const resolvedProviders = resolveMainProvider(
-      options.provider,
-      config.providers,
-    );
-    providers.push(...resolvedProviders.providers);
-    enableOpenApi = resolvedProviders.enableOpenApi || enableOpenApi;
-  }
-  // Default: build all configured providers
-  else if (config.providers) {
-    const resolvedProviders = resolveAllConfiguredProviders(config.providers);
-    providers.push(...resolvedProviders.providers);
-    enableOpenApi = resolvedProviders.enableOpenApi || enableOpenApi;
-  }
-  // Fallback: use default AWS configuration
-  else {
-    providers.push('aws-apigatewayv2', 'aws-lambda');
-  }
-
-  return {
-    providers: [...new Set(providers)], // Remove duplicates
-    enableOpenApi,
-  };
+	const providers: LegacyProvider[] = [];
+	let enableOpenApi = options.enableOpenApi || false;
+
+	// Handle legacy providers option (deprecated)
+	if (options.providers) {
+		return {
+			providers: options.providers,
+			enableOpenApi,
+		};
+	}
+
+	// Handle new provider option
+	if (options.provider) {
+		const resolvedProviders = resolveMainProvider(
+			options.provider,
+			config.providers,
+		);
+		providers.push(...resolvedProviders.providers);
+		enableOpenApi = resolvedProviders.enableOpenApi || enableOpenApi;
+	}
+	// Default: build all configured providers
+	else if (config.providers) {
+		const resolvedProviders = resolveAllConfiguredProviders(config.providers);
+		providers.push(...resolvedProviders.providers);
+		enableOpenApi = resolvedProviders.enableOpenApi || enableOpenApi;
+	}
+	// Fallback: use default AWS configuration
+	else {
+		providers.push('aws-apigatewayv2', 'aws-lambda');
+	}
+
+	return {
+		providers: [...new Set(providers)], // Remove duplicates
+		enableOpenApi,
+	};
 }
 
 function resolveMainProvider(
-  mainProvider: MainProvider,
-  providersConfig?: ProvidersConfig,
+	mainProvider: MainProvider,
+	providersConfig?: ProvidersConfig,
 ): ResolvedProviders {
-  const providers: LegacyProvider[] = [];
-  let enableOpenApi = false;
-
-  if (mainProvider === 'aws') {
-    const awsConfig = providersConfig?.aws;
-
-    // Resolve API Gateway providers
-    if (awsConfig?.apiGateway) {
-      if (isEnabled(awsConfig.apiGateway.v1)) {
-        providers.push('aws-apigatewayv1');
-      }
-      if (isEnabled(awsConfig.apiGateway.v2)) {
-        providers.push('aws-apigatewayv2');
-      }
-    } else {
-      // Default: enable v2 if no specific config
-      providers.push('aws-apigatewayv2');
-    }
-
-    // Resolve Lambda providers
-    if (awsConfig?.lambda) {
-      if (
-        isEnabled(awsConfig.lambda.functions) ||
-        isEnabled(awsConfig.lambda.crons)
-      ) {
-        providers.push('aws-lambda');
-      }
-    } else {
-      // Default: enable lambda if no specific config
-      providers.push('aws-lambda');
-    }
-  } else if (mainProvider === 'server') {
-    providers.push('server');
-    const serverConfig = providersConfig?.server;
-
-    if (typeof serverConfig === 'object' && serverConfig?.enableOpenApi) {
-      enableOpenApi = true;
-    }
-  }
-
-  return { providers, enableOpenApi };
+	const providers: LegacyProvider[] = [];
+	let enableOpenApi = false;
+
+	if (mainProvider === 'aws') {
+		const awsConfig = providersConfig?.aws;
+
+		// Resolve API Gateway providers
+		if (awsConfig?.apiGateway) {
+			if (isEnabled(awsConfig.apiGateway.v1)) {
+				providers.push('aws-apigatewayv1');
+			}
+			if (isEnabled(awsConfig.apiGateway.v2)) {
+				providers.push('aws-apigatewayv2');
+			}
+		} else {
+			// Default: enable v2 if no specific config
+			providers.push('aws-apigatewayv2');
+		}
+
+		// Resolve Lambda providers
+		if (awsConfig?.lambda) {
+			if (
+				isEnabled(awsConfig.lambda.functions) ||
+				isEnabled(awsConfig.lambda.crons)
+			) {
+				providers.push('aws-lambda');
+			}
+		} else {
+			// Default: enable lambda if no specific config
+			providers.push('aws-lambda');
+		}
+	} else if (mainProvider === 'server') {
+		providers.push('server');
+		const serverConfig = providersConfig?.server;
+
+		if (typeof serverConfig === 'object' && serverConfig?.enableOpenApi) {
+			enableOpenApi = true;
+		}
+	}
+
+	return { providers, enableOpenApi };
 }
 
 function resolveAllConfiguredProviders(
-  providersConfig: ProvidersConfig,
+	providersConfig: ProvidersConfig,
 ): ResolvedProviders {
-  const providers: LegacyProvider[] = [];
-  let enableOpenApi = false;
-
-  // AWS providers
-  if (providersConfig.aws) {
-    const awsProviders = resolveMainProvider('aws', providersConfig);
-    providers.push(...awsProviders.providers);
-  }
-
-  // Server provider
-  if (providersConfig.server && isEnabled(providersConfig.server)) {
-    providers.push('server');
-    if (
-      typeof providersConfig.server === 'object' &&
-      providersConfig.server.enableOpenApi
-    ) {
-      enableOpenApi = true;
-    }
-  }
-
-  return { providers, enableOpenApi };
+	const providers: LegacyProvider[] = [];
+	let enableOpenApi = false;
+
+	// AWS providers
+	if (providersConfig.aws) {
+		const awsProviders = resolveMainProvider('aws', providersConfig);
+		providers.push(...awsProviders.providers);
+	}
+
+	// Server provider
+	if (providersConfig.server && isEnabled(providersConfig.server)) {
+		providers.push('server');
+		if (
+			typeof providersConfig.server === 'object' &&
+			providersConfig.server.enableOpenApi
+		) {
+			enableOpenApi = true;
+		}
+	}
+
+	return { providers, enableOpenApi };
 }
 
 function isEnabled(
-  config:
-    | boolean
-    | AWSApiGatewayConfig
-    | AWSLambdaConfig
-    | ServerConfig
-    | undefined,
+	config:
+		| boolean
+		| AWSApiGatewayConfig
+		| AWSLambdaConfig
+		| ServerConfig
+		| undefined,
 ): boolean {
-  if (config === undefined) return false;
-  if (typeof config === 'boolean') return config;
-  return config.enabled !== false; // Default to true if enabled is not explicitly false
+	if (config === undefined) return false;
+	if (typeof config === 'boolean') return config;
+	return config.enabled !== false; // Default to true if enabled is not explicitly false
 }
 
 /**
  * Gets configuration for a specific AWS service
  */
 export function getAWSServiceConfig<
-  T extends AWSApiGatewayConfig | AWSLambdaConfig,
+	T extends AWSApiGatewayConfig | AWSLambdaConfig,
 >(
-  config: GkmConfig,
-  service: 'apiGateway' | 'lambda',
-  subService?: 'v1' | 'v2' | 'functions' | 'crons',
+	config: GkmConfig,
+	service: 'apiGateway' | 'lambda',
+	subService?: 'v1' | 'v2' | 'functions' | 'crons',
 ): T | undefined {
-  const awsConfig = config.providers?.aws;
-  if (!awsConfig) return undefined;
-
-  if (service === 'apiGateway' && awsConfig.apiGateway) {
-    const apiConfig = subService
-      ? awsConfig.apiGateway[subService as 'v1' | 'v2']
-      : undefined;
-    return typeof apiConfig === 'object' ? (apiConfig as T) : undefined;
-  }
-
-  if (service === 'lambda' && awsConfig.lambda) {
-    const lambdaConfig = subService
-      ? awsConfig.lambda[subService as 'functions' | 'crons']
-      : undefined;
-    return typeof lambdaConfig === 'object' ? (lambdaConfig as T) : undefined;
-  }
-
-  return undefined;
+	const awsConfig = config.providers?.aws;
+	if (!awsConfig) return undefined;
+
+	if (service === 'apiGateway' && awsConfig.apiGateway) {
+		const apiConfig = subService
+			? awsConfig.apiGateway[subService as 'v1' | 'v2']
+			: undefined;
+		return typeof apiConfig === 'object' ? (apiConfig as T) : undefined;
+	}
+
+	if (service === 'lambda' && awsConfig.lambda) {
+		const lambdaConfig = subService
+			? awsConfig.lambda[subService as 'functions' | 'crons']
+			: undefined;
+		return typeof lambdaConfig === 'object' ? (lambdaConfig as T) : undefined;
+	}
+
+	return undefined;
 }
 
 /**
  * Gets server configuration
  */
 export function getServerConfig(config: GkmConfig): ServerConfig | undefined {
-  const serverConfig = config.providers?.server;
-  return typeof serverConfig === 'object' ? serverConfig : undefined;
+	const serverConfig = config.providers?.server;
+	return typeof serverConfig === 'object' ? serverConfig : undefined;
 }

package/src/build/types.ts

@@ -5,68 +5,89 @@ import type { Function } from '@geekmidas/constructs/functions';
 import type { CronInfo, FunctionInfo, RouteInfo } from '../types';
 
 export interface ProcessedEndpoint {
-  file: string;
-  exportName: string;
-  endpoint: Endpoint<any, any, any, any, any, any>;
-  routeInfo: RouteInfo;
+	file: string;
+	exportName: string;
+	endpoint: Endpoint<any, any, any, any, any, any>;
+	routeInfo: RouteInfo;
 }
 
 export interface ProcessedFunction {
-  file: string;
-  exportName: string;
-  fn: Function<any, any, any, any, any>;
+	file: string;
+	exportName: string;
+	fn: Function<any, any, any, any, any>;
 }
 
 export interface ProcessedCron {
-  file: string;
-  exportName: string;
-  cron: Cron<any, any, any, any>;
-  schedule?: string;
+	file: string;
+	exportName: string;
+	cron: Cron<any, any, any, any>;
+	schedule?: string;
 }
 
 export interface NormalizedTelescopeConfig {
-  enabled: boolean;
-  /** Path to user's telescope module (if provided) */
-  telescopePath?: string;
-  /** Import pattern for telescope (e.g., '{ telescope }' or 'telescope') */
-  telescopeImportPattern?: string;
-  /** UI path for telescope dashboard */
-  path: string;
-  ignore: string[];
-  recordBody: boolean;
-  maxEntries: number;
-  websocket: boolean;
+	enabled: boolean;
+	/** Path to user's telescope module (if provided) */
+	telescopePath?: string;
+	/** Import pattern for telescope (e.g., '{ telescope }' or 'telescope') */
+	telescopeImportPattern?: string;
+	/** UI path for telescope dashboard */
+	path: string;
+	ignore: string[];
+	recordBody: boolean;
+	maxEntries: number;
+	websocket: boolean;
 }
 
 export interface NormalizedStudioConfig {
-  enabled: boolean;
-  /** Path to user's studio module (if provided) */
-  studioPath?: string;
-  /** Import pattern for studio (e.g., '{ studio }' or 'studio') */
-  studioImportPattern?: string;
-  /** UI path for studio dashboard */
-  path: string;
-  /** Database schema to introspect */
-  schema: string;
+	enabled: boolean;
+	/** Path to user's studio module (if provided) */
+	studioPath?: string;
+	/** Import pattern for studio (e.g., '{ studio }' or 'studio') */
+	studioImportPattern?: string;
+	/** UI path for studio dashboard */
+	path: string;
+	/** Database schema to introspect */
+	schema: string;
 }
 
 export interface NormalizedHooksConfig {
-  /** Path to server hooks module */
-  serverHooksPath: string;
+	/** Path to server hooks module */
+	serverHooksPath: string;
+}
+
+export interface NormalizedProductionConfig {
+	enabled: boolean;
+	bundle: boolean;
+	minify: boolean;
+	healthCheck: string;
+	gracefulShutdown: boolean;
+	external: string[];
+	subscribers: 'include' | 'exclude';
+	openapi: boolean;
+	/**
+	 * Enable build-time optimized handler generation
+	 * When true, generates specialized handlers based on endpoint tier:
+	 * - minimal: Near-raw-Hono performance for simple endpoints
+	 * - standard: Optimized handlers for auth/services
+	 * - full: Uses HonoEndpoint.addRoutes for complex endpoints
+	 */
+	optimizedHandlers: boolean;
 }
 
 export interface BuildContext {
-  envParserPath: string;
-  envParserImportPattern: string;
-  loggerPath: string;
-  loggerImportPattern: string;
-  telescope?: NormalizedTelescopeConfig;
-  studio?: NormalizedStudioConfig;
-  hooks?: NormalizedHooksConfig;
+	envParserPath: string;
+	envParserImportPattern: string;
+	loggerPath: string;
+	loggerImportPattern: string;
+	telescope?: NormalizedTelescopeConfig;
+	studio?: NormalizedStudioConfig;
+	hooks?: NormalizedHooksConfig;
+	/** Production build configuration */
+	production?: NormalizedProductionConfig;
 }
 
 export interface ProviderBuildResult {
-  routes: RouteInfo[];
-  functions: FunctionInfo[];
-  crons: CronInfo[];
+	routes: RouteInfo[];
+	functions: FunctionInfo[];
+	crons: CronInfo[];
 }

package/src/config.ts

@@ -1,5 +1,5 @@
-import { existsSync } from 'fs';
-import { join } from 'path';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import type { GkmConfig } from './types.ts';
 
 export type { GkmConfig } from './types.ts';
@@ -21,12 +21,12 @@ export type { GkmConfig } from './types.ts';
  * ```
  */
 export function defineConfig(config: GkmConfig): GkmConfig {
-  return config;
+	return config;
 }
 
 export interface ParsedModuleConfig {
-  path: string;
-  importPattern: string;
+	path: string;
+	importPattern: string;
 }
 
 /**
@@ -47,45 +47,47 @@ export interface ParsedModuleConfig {
  * // { path: './src/config/env', importPattern: '{ myEnv as envParser }' }
  */
 export function parseModuleConfig(
-  configString: string,
-  defaultAlias: string,
+	configString: string,
+	defaultAlias: string,
 ): ParsedModuleConfig {
-  const [path, exportName] = configString.split('#');
-  const importPattern = !exportName
-    ? defaultAlias
-    : exportName === defaultAlias
-      ? `{ ${defaultAlias} }`
-      : `{ ${exportName} as ${defaultAlias} }`;
+	const parts = configString.split('#');
+	const path = parts[0] ?? configString;
+	const exportName = parts[1];
+	const importPattern = !exportName
+		? defaultAlias
+		: exportName === defaultAlias
+			? `{ ${defaultAlias} }`
+			: `{ ${exportName} as ${defaultAlias} }`;
 
-  return { path, importPattern };
+	return { path, importPattern };
 }
 
 export async function loadConfig(
-  cwd: string = process.cwd(),
+	cwd: string = process.cwd(),
 ): Promise<GkmConfig> {
-  const files = ['gkm.config.json', 'gkm.config.ts', 'gkm.config.js'];
-  let configPath = '';
+	const files = ['gkm.config.json', 'gkm.config.ts', 'gkm.config.js'];
+	let configPath = '';
 
-  for (const file of files) {
-    const path = join(cwd, file);
-    if (existsSync(path)) {
-      configPath = path;
-      break;
-    }
-  }
+	for (const file of files) {
+		const path = join(cwd, file);
+		if (existsSync(path)) {
+			configPath = path;
+			break;
+		}
+	}
 
-  if (!configPath) {
-    throw new Error(
-      'Configuration file not found. Please create gkm.config.json, gkm.config.ts, or gkm.config.js in the project root.',
-    );
-  }
+	if (!configPath) {
+		throw new Error(
+			'Configuration file not found. Please create gkm.config.json, gkm.config.ts, or gkm.config.js in the project root.',
+		);
+	}
 
-  try {
-    const config = await import(configPath);
-    return config.default;
-  } catch (error) {
-    throw new Error(
-      `Failed to load gkm.config.json: ${(error as Error).message}`,
-    );
-  }
+	try {
+		const config = await import(configPath);
+		return config.default;
+	} catch (error) {
+		throw new Error(
+			`Failed to load gkm.config.json: ${(error as Error).message}`,
+		);
+	}
 }

package/src/deploy/__tests__/docker.spec.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it } from 'vitest';
+import type { GkmConfig } from '../../types';
+import { getImageRef, resolveDockerConfig } from '../docker';
+
+describe('getImageRef', () => {
+	it('should return image with registry prefix', () => {
+		const result = getImageRef('ghcr.io/myorg', 'myapp', 'v1.0.0');
+		expect(result).toBe('ghcr.io/myorg/myapp:v1.0.0');
+	});
+
+	it('should return image without registry when undefined', () => {
+		const result = getImageRef(undefined, 'myapp', 'v1.0.0');
+		expect(result).toBe('myapp:v1.0.0');
+	});
+
+	it('should handle different tag formats', () => {
+		expect(getImageRef('docker.io', 'app', 'latest')).toBe(
+			'docker.io/app:latest',
+		);
+		expect(getImageRef('docker.io', 'app', 'sha-abc123')).toBe(
+			'docker.io/app:sha-abc123',
+		);
+		expect(getImageRef('docker.io', 'app', '1.2.3-beta.1')).toBe(
+			'docker.io/app:1.2.3-beta.1',
+		);
+	});
+
+	it('should handle registry with port', () => {
+		const result = getImageRef('localhost:5000', 'myapp', 'dev');
+		expect(result).toBe('localhost:5000/myapp:dev');
+	});
+
+	it('should handle nested registry paths', () => {
+		const result = getImageRef('gcr.io/my-project/images', 'api', 'prod');
+		expect(result).toBe('gcr.io/my-project/images/api:prod');
+	});
+});
+
+describe('resolveDockerConfig', () => {
+	it('should return empty config when docker not configured', () => {
+		const config: GkmConfig = {
+			routes: './src/endpoints',
+			envParser: './src/env',
+			logger: './src/logger',
+		};
+
+		const dockerConfig = resolveDockerConfig(config);
+
+		expect(dockerConfig.registry).toBeUndefined();
+		expect(dockerConfig.imageName).toBeUndefined();
+	});
+
+	it('should return registry from docker config', () => {
+		const config: GkmConfig = {
+			routes: './src/endpoints',
+			envParser: './src/env',
+			logger: './src/logger',
+			docker: {
+				registry: 'ghcr.io/myorg',
+			},
+		};
+
+		const dockerConfig = resolveDockerConfig(config);
+
+		expect(dockerConfig.registry).toBe('ghcr.io/myorg');
+	});
+
+	it('should return imageName from docker config', () => {
+		const config: GkmConfig = {
+			routes: './src/endpoints',
+			envParser: './src/env',
+			logger: './src/logger',
+			docker: {
+				imageName: 'my-api',
+			},
+		};
+
+		const dockerConfig = resolveDockerConfig(config);
+
+		expect(dockerConfig.imageName).toBe('my-api');
+	});
+
+	it('should return both registry and imageName', () => {
+		const config: GkmConfig = {
+			routes: './src/endpoints',
+			envParser: './src/env',
+			logger: './src/logger',
+			docker: {
+				registry: 'docker.io/company',
+				imageName: 'backend-api',
+			},
+		};
+
+		const dockerConfig = resolveDockerConfig(config);
+
+		expect(dockerConfig.registry).toBe('docker.io/company');
+		expect(dockerConfig.imageName).toBe('backend-api');
+	});
+
+	it('should handle empty docker object', () => {
+		const config: GkmConfig = {
+			routes: './src/endpoints',
+			docker: {},
+		};
+
+		const dockerConfig = resolveDockerConfig(config);
+
+		expect(dockerConfig.registry).toBeUndefined();
+		expect(dockerConfig.imageName).toBeUndefined();
+	});
+});