@geekmidas/cli 9.0.2 → 10.0.0-alpha.0

package/src/build/manifests.ts

@@ -1,285 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { join, relative } from 'node:path';
-import type {
-	CronInfo,
-	FunctionInfo,
-	QueueInfo,
-	RouteInfo,
-	SubscriberInfo,
-	TopicInfo,
-} from '../types';
-
-const logger = console;
-
-export type ManifestProvider = 'aws' | 'server';
-
-export interface ServerAppInfo {
-	handler: string;
-	endpoints: string;
-}
-
-/**
- * A manifest field is either a flat array (no partition) or
- * an object keyed by partition name (partitioned).
- */
-export type ManifestField<T> = T[] | Record<string, T[]>;
-
-function isPartitioned<T>(
-	field: ManifestField<T>,
-): field is Record<string, T[]> {
-	return !Array.isArray(field);
-}
-
-/**
- * Serialize a manifest field to a TypeScript string.
- * Flat arrays serialize as JSON arrays, partitioned fields as objects of arrays.
- */
-function serializeField<T>(field: ManifestField<T>, indent = 2): string {
-	if (Array.isArray(field)) {
-		return JSON.stringify(field, null, indent);
-	}
-	// Partitioned: { admin: [...], default: [...] }
-	const entries = Object.entries(field)
-		.map(
-			([key, value]) =>
-				`    ${JSON.stringify(key)}: ${JSON.stringify(value, null, indent)}`,
-		)
-		.join(',\n');
-	return `{\n${entries},\n  }`;
-}
-
-/**
- * Count total items across a manifest field (flat or partitioned).
- */
-function countItems<T>(field: ManifestField<T>): number {
-	if (Array.isArray(field)) return field.length;
-	return Object.values(field).reduce((sum, arr) => sum + arr.length, 0);
-}
-
-/**
- * Generate derived types for a construct field.
- * @param fieldName - The field name in the manifest (e.g., 'routes')
- * @param typeName - The exported type name (e.g., 'Route')
- * @param partitioned - Whether this field is partitioned
- */
-function generateDerivedType(
-	fieldName: string,
-	typeName: string,
-	partitioned: boolean,
-): string {
-	if (partitioned) {
-		const partitionTypeName = `${typeName}Partition`;
-		return [
-			`export type ${partitionTypeName} = keyof typeof manifest.${fieldName};`,
-			`export type ${typeName}<P extends ${partitionTypeName} = ${partitionTypeName}> = (typeof manifest.${fieldName})[P][number];`,
-		].join('\n');
-	}
-	return `export type ${typeName} = (typeof manifest.${fieldName})[number];`;
-}
-
-export async function generateAwsManifest(
-	outputDir: string,
-	routes: ManifestField<RouteInfo>,
-	functions: ManifestField<FunctionInfo>,
-	crons: ManifestField<CronInfo>,
-	subscribers: ManifestField<SubscriberInfo>,
-	queues: ManifestField<QueueInfo> = [],
-	topics: ManifestField<TopicInfo> = [],
-): Promise<void> {
-	const manifestDir = join(outputDir, 'manifest');
-	await mkdir(manifestDir, { recursive: true });
-
-	// Filter out 'ALL' method routes (server-specific)
-	const awsRoutes = filterAllRoutes(routes);
-
-	const routesPartitioned = isPartitioned(awsRoutes);
-	const functionsPartitioned = isPartitioned(functions);
-	const cronsPartitioned = isPartitioned(crons);
-	const subscribersPartitioned = isPartitioned(subscribers);
-	const queuesPartitioned = isPartitioned(queues);
-	const topicsPartitioned = isPartitioned(topics);
-
-	const content = `export const manifest = {
-  routes: ${serializeField(awsRoutes)},
-  functions: ${serializeField(functions)},
-  crons: ${serializeField(crons)},
-  subscribers: ${serializeField(subscribers)},
-  queues: ${serializeField(queues)},
-  topics: ${serializeField(topics)},
-} as const;
-
-// Derived types
-${generateDerivedType('routes', 'Route', routesPartitioned)}
-${generateDerivedType('functions', 'Function', functionsPartitioned)}
-${generateDerivedType('crons', 'Cron', cronsPartitioned)}
-${generateDerivedType('subscribers', 'Subscriber', subscribersPartitioned)}
-${generateDerivedType('queues', 'Queue', queuesPartitioned)}
-${generateDerivedType('topics', 'Topic', topicsPartitioned)}
-
-// Useful union types
-export type Authorizer = Route['authorizer'];
-export type HttpMethod = Route['method'];
-export type RoutePath = Route['path'];
-`;
-
-	const manifestPath = join(manifestDir, 'aws.ts');
-	await writeFile(manifestPath, content);
-
-	logger.log(
-		`Generated AWS manifest with ${countItems(awsRoutes)} routes, ${countItems(functions)} functions, ${countItems(crons)} crons, ${countItems(subscribers)} subscribers, ${countItems(queues)} queues, ${countItems(topics)} topics`,
-	);
-	logger.log(`Manifest: ${relative(process.cwd(), manifestPath)}`);
-}
-
-export async function generateServerManifest(
-	outputDir: string,
-	appInfo: ServerAppInfo,
-	routes: ManifestField<RouteInfo>,
-	subscribers: ManifestField<SubscriberInfo>,
-	queues: ManifestField<QueueInfo> = [],
-	topics: ManifestField<TopicInfo> = [],
-): Promise<void> {
-	const manifestDir = join(outputDir, 'manifest');
-	await mkdir(manifestDir, { recursive: true });
-
-	// For server, extract route metadata (path, method, authorizer)
-	const serverRoutes = mapRouteMetadata(filterAllRoutes(routes));
-
-	// Server subscribers only need name and events
-	const serverSubscribers = mapSubscriberMetadata(subscribers);
-
-	// Server queues only need their name (the worker is wired by setupQueues)
-	const serverQueues = mapQueueMetadata(queues);
-
-	// Server topics only need name + events (pg-boss routes by event name locally)
-	const serverTopics = mapTopicMetadata(topics);
-
-	const routesPartitioned = isPartitioned(serverRoutes);
-	const subscribersPartitioned = isPartitioned(serverSubscribers);
-	const queuesPartitioned = isPartitioned(serverQueues);
-	const topicsPartitioned = isPartitioned(serverTopics);
-
-	const content = `export const manifest = {
-  app: ${JSON.stringify(appInfo, null, 2)},
-  routes: ${serializeField(serverRoutes)},
-  subscribers: ${serializeField(serverSubscribers)},
-  queues: ${serializeField(serverQueues)},
-  topics: ${serializeField(serverTopics)},
-} as const;
-
-// Derived types
-${generateDerivedType('routes', 'Route', routesPartitioned)}
-${generateDerivedType('subscribers', 'Subscriber', subscribersPartitioned)}
-${generateDerivedType('queues', 'Queue', queuesPartitioned)}
-${generateDerivedType('topics', 'Topic', topicsPartitioned)}
-
-// Useful union types
-export type Authorizer = Route['authorizer'];
-export type HttpMethod = Route['method'];
-export type RoutePath = Route['path'];
-`;
-
-	const manifestPath = join(manifestDir, 'server.ts');
-	await writeFile(manifestPath, content);
-
-	logger.log(
-		`Generated server manifest with ${countItems(serverRoutes)} routes, ${countItems(serverSubscribers)} subscribers, ${countItems(serverQueues)} queues, ${countItems(serverTopics)} topics`,
-	);
-	logger.log(`Manifest: ${relative(process.cwd(), manifestPath)}`);
-}
-
-/**
- * Filter out 'ALL' method routes from a manifest field (flat or partitioned).
- */
-function filterAllRoutes(
-	routes: ManifestField<RouteInfo>,
-): ManifestField<RouteInfo> {
-	if (Array.isArray(routes)) {
-		return routes.filter((r) => r.method !== 'ALL');
-	}
-	const result: Record<string, RouteInfo[]> = {};
-	for (const [partition, partitionRoutes] of Object.entries(routes)) {
-		result[partition] = partitionRoutes.filter((r) => r.method !== 'ALL');
-	}
-	return result;
-}
-
-/**
- * Map routes to server metadata (path, method, authorizer only).
- */
-function mapRouteMetadata(
-	routes: ManifestField<RouteInfo>,
-): ManifestField<{ path: string; method: string; authorizer: string }> {
-	const mapFn = (r: RouteInfo) => ({
-		path: r.path,
-		method: r.method,
-		authorizer: r.authorizer,
-	});
-
-	if (Array.isArray(routes)) {
-		return routes.map(mapFn);
-	}
-	const result: Record<
-		string,
-		{ path: string; method: string; authorizer: string }[]
-	> = {};
-	for (const [partition, partitionRoutes] of Object.entries(routes)) {
-		result[partition] = partitionRoutes.map(mapFn);
-	}
-	return result;
-}
-
-/**
- * Map subscribers to server metadata (name, subscribedEvents only).
- */
-function mapSubscriberMetadata(
-	subscribers: ManifestField<SubscriberInfo>,
-): ManifestField<{ name: string; subscribedEvents: readonly string[] }> {
-	const mapFn = (s: SubscriberInfo) => ({
-		name: s.name,
-		subscribedEvents: s.subscribedEvents,
-	});
-
-	if (Array.isArray(subscribers)) {
-		return subscribers.map(mapFn);
-	}
-	const result: Record<
-		string,
-		{ name: string; subscribedEvents: readonly string[] }[]
-	> = {};
-	for (const [partition, partitionSubs] of Object.entries(subscribers)) {
-		result[partition] = partitionSubs.map(mapFn);
-	}
-	return result;
-}
-
-function mapQueueMetadata(
-	queues: ManifestField<QueueInfo>,
-): ManifestField<{ name: string }> {
-	const mapFn = (q: QueueInfo) => ({ name: q.name });
-
-	if (Array.isArray(queues)) {
-		return queues.map(mapFn);
-	}
-	const result: Record<string, { name: string }[]> = {};
-	for (const [partition, partitionQueues] of Object.entries(queues)) {
-		result[partition] = partitionQueues.map(mapFn);
-	}
-	return result;
-}
-
-function mapTopicMetadata(
-	topics: ManifestField<TopicInfo>,
-): ManifestField<{ name: string; events: readonly string[] }> {
-	const mapFn = (t: TopicInfo) => ({ name: t.name, events: t.events });
-
-	if (Array.isArray(topics)) {
-		return topics.map(mapFn);
-	}
-	const result: Record<string, { name: string; events: readonly string[] }[]> =
-		{};
-	for (const [partition, partitionTopics] of Object.entries(topics)) {
-		result[partition] = partitionTopics.map(mapFn);
-	}
-	return result;
-}

package/src/build/partitions.ts

@@ -1,58 +0,0 @@
-import type { Construct } from '@geekmidas/constructs';
-import type { GeneratedConstruct } from '../generators/Generator';
-
-export const DEFAULT_PARTITION = 'default';
-
-/**
- * Group constructs by their partition field.
- * Constructs without a partition are placed in the 'default' group.
- */
-export function groupByPartition<T extends Construct>(
-	constructs: GeneratedConstruct<T>[],
-): Map<string, GeneratedConstruct<T>[]> {
-	const groups = new Map<string, GeneratedConstruct<T>[]>();
-
-	for (const construct of constructs) {
-		const partition = construct.partition ?? DEFAULT_PARTITION;
-		const group = groups.get(partition);
-		if (group) {
-			group.push(construct);
-		} else {
-			groups.set(partition, [construct]);
-		}
-	}
-
-	return groups;
-}
-
-/**
- * Check if any construct across the given arrays has a non-undefined partition.
- * When true, the manifest should use the partitioned shape for that construct type.
- */
-export function hasPartitions<T extends Construct>(
-	constructs: GeneratedConstruct<T>[],
-): boolean {
-	return constructs.some((c) => c.partition !== undefined);
-}
-
-/**
- * Group an info array by partition, using the partition values from
- * the corresponding construct array. Both arrays must be the same length
- * and in the same order.
- */
-export function groupInfosByPartition<T>(
-	infos: T[],
-	constructs: GeneratedConstruct<any>[],
-): Record<string, T[]> {
-	const groups: Record<string, T[]> = {};
-
-	for (let i = 0; i < infos.length; i++) {
-		const partition = constructs[i]?.partition ?? DEFAULT_PARTITION;
-		if (!groups[partition]) {
-			groups[partition] = [];
-		}
-		groups[partition].push(infos[i]!);
-	}
-
-	return groups;
-}

package/src/build/providerResolver.ts

@@ -1,184 +0,0 @@
-import type {
-	AWSApiGatewayConfig,
-	AWSLambdaConfig,
-	BuildOptions,
-	GkmConfig,
-	LegacyProvider,
-	MainProvider,
-	ProvidersConfig,
-	ServerConfig,
-} from '../types';
-
-export interface ResolvedProviders {
-	providers: LegacyProvider[];
-	enableOpenApi: boolean;
-}
-
-/**
- * Resolves provider configuration from the new simplified system
- * to the internal legacy format for backward compatibility
- */
-export function resolveProviders(
-	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,
-	};
-}
-
-function resolveMainProvider(
-	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 };
-}
-
-function resolveAllConfiguredProviders(
-	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 };
-}
-
-function isEnabled(
-	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
-}
-
-/**
- * Gets configuration for a specific AWS service
- */
-export function getAWSServiceConfig<
-	T extends AWSApiGatewayConfig | AWSLambdaConfig,
->(
-	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;
-}
-
-/**
- * Gets server configuration
- */
-export function getServerConfig(config: GkmConfig): ServerConfig | undefined {
-	const serverConfig = config.providers?.server;
-	return typeof serverConfig === 'object' ? serverConfig : undefined;
-}

package/src/build/types.ts

@@ -1,104 +0,0 @@
-import type { Cron } from '@geekmidas/constructs/crons';
-import type { Endpoint } from '@geekmidas/constructs/endpoints';
-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;
-}
-
-export interface ProcessedFunction {
-	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;
-}
-
-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;
-}
-
-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;
-}
-
-export interface NormalizedHooksConfig {
-	/** 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;
-	/** Production build configuration */
-	production?: NormalizedProductionConfig;
-	/** Docker compose services for auto-populating env vars */
-	dockerServices?: {
-		postgres?: boolean;
-		redis?: boolean;
-		rabbitmq?: boolean;
-	};
-	/**
-	 * When true, optional env vars get a `?` suffix in each construct's
-	 * environment array (e.g. `PORT?` instead of `PORT`).
-	 */
-	markOptional?: boolean;
-}
-
-export interface ProviderBuildResult {
-	routes: RouteInfo[];
-	functions: FunctionInfo[];
-	crons: CronInfo[];
-}