@geekmidas/cli 1.9.1 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "1.9.1",
+  "version": "1.10.0",
   "description": "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs",
   "private": false,
   "type": "module",
@@ -56,11 +56,11 @@
     "prompts": "~2.4.2",
     "tsx": "~4.20.3",
     "yaml": "~2.8.2",
-    "@geekmidas/constructs": "~2.0.0",
+    "@geekmidas/constructs": "~3.0.0",
     "@geekmidas/envkit": "~1.0.3",
+    "@geekmidas/errors": "~1.0.0",
     "@geekmidas/logger": "~1.0.0",
-    "@geekmidas/schema": "~1.0.0",
-    "@geekmidas/errors": "~1.0.0"
+    "@geekmidas/schema": "~1.0.0"
   },
   "devDependencies": {
     "@types/lodash.kebabcase": "^4.1.9",

package/src/build/__tests__/manifests.spec.ts

@@ -8,6 +8,7 @@ import type {
 	RouteInfo,
 	SubscriberInfo,
 } from '../../types';
+import type { ManifestField } from '../manifests';
 import { generateAwsManifest, generateServerManifest } from '../manifests';
 
 describe('generateAwsManifest', () => {
@@ -344,3 +345,173 @@ describe('generateServerManifest', () => {
 		logSpy.mockRestore();
 	});
 });
+
+describe('generateAwsManifest (partitioned)', () => {
+	itWithDir(
+		'should generate manifest with partitioned routes and flat functions',
+		async ({ dir }) => {
+			const routes: ManifestField<RouteInfo> = {
+				admin: [
+					{
+						path: '/admin/users',
+						method: 'GET',
+						handler: '.gkm/aws/adminGetUsers.handler',
+						authorizer: 'jwt',
+					},
+				],
+				public: [
+					{
+						path: '/users',
+						method: 'GET',
+						handler: '.gkm/aws/getUsers.handler',
+						authorizer: 'none',
+					},
+				],
+			};
+
+			const functions: FunctionInfo[] = [
+				{
+					name: 'processData',
+					handler: '.gkm/aws/processData.handler',
+					timeout: 300,
+					memorySize: 512,
+					environment: [],
+				},
+			];
+
+			await generateAwsManifest(dir, routes, functions, [], []);
+
+			const manifestPath = join(dir, 'manifest', 'aws.ts');
+			const content = await readFile(manifestPath, 'utf-8');
+
+			// Routes should be partitioned (nested object)
+			expect(content).toContain('"admin":');
+			expect(content).toContain('"public":');
+			expect(content).toContain('/admin/users');
+			expect(content).toContain('/users');
+
+			// Functions should be flat (array)
+			expect(content).toContain('processData');
+
+			// Partitioned routes should have partition-aware derived types
+			expect(content).toContain('RoutePartition');
+			expect(content).toContain('keyof typeof manifest.routes');
+
+			// Flat functions should have standard derived types
+			expect(content).toContain(
+				'export type Function = (typeof manifest.functions)[number]',
+			);
+		},
+	);
+
+	itWithDir(
+		'should generate flat manifest when all fields are arrays',
+		async ({ dir }) => {
+			const routes: RouteInfo[] = [
+				{
+					path: '/users',
+					method: 'GET',
+					handler: '.gkm/aws/getUsers.handler',
+					authorizer: 'jwt',
+				},
+			];
+
+			await generateAwsManifest(dir, routes, [], [], []);
+
+			const manifestPath = join(dir, 'manifest', 'aws.ts');
+			const content = await readFile(manifestPath, 'utf-8');
+
+			// Should have flat derived types (no partition types)
+			expect(content).toContain(
+				'export type Route = (typeof manifest.routes)[number]',
+			);
+			expect(content).not.toContain('RoutePartition');
+		},
+	);
+
+	itWithDir(
+		'should filter ALL method from partitioned routes',
+		async ({ dir }) => {
+			const routes: ManifestField<RouteInfo> = {
+				admin: [
+					{
+						path: '/admin/users',
+						method: 'GET',
+						handler: '.gkm/aws/adminGetUsers.handler',
+						authorizer: 'jwt',
+					},
+					{
+						path: '*',
+						method: 'ALL',
+						handler: '.gkm/server/app.ts',
+						authorizer: 'none',
+					},
+				],
+			};
+
+			await generateAwsManifest(dir, routes, [], [], []);
+
+			const manifestPath = join(dir, 'manifest', 'aws.ts');
+			const content = await readFile(manifestPath, 'utf-8');
+
+			expect(content).toContain('/admin/users');
+			expect(content).not.toContain('"ALL"');
+		},
+	);
+});
+
+describe('generateServerManifest (partitioned)', () => {
+	itWithDir(
+		'should generate manifest with partitioned routes',
+		async ({ dir }) => {
+			const appInfo = {
+				handler: '.gkm/server/app.ts',
+				endpoints: '.gkm/server/endpoints.ts',
+			};
+
+			const routes: ManifestField<RouteInfo> = {
+				admin: [
+					{
+						path: '/admin/users',
+						method: 'GET',
+						handler: '',
+						authorizer: 'jwt',
+					},
+				],
+				default: [
+					{
+						path: '/health',
+						method: 'GET',
+						handler: '',
+						authorizer: 'none',
+					},
+				],
+			};
+
+			const subscribers: SubscriberInfo[] = [
+				{
+					name: 'orderHandler',
+					handler: '.gkm/server/orderHandler.ts',
+					subscribedEvents: ['order.created'],
+					timeout: 30,
+					memorySize: 256,
+					environment: [],
+				},
+			];
+
+			await generateServerManifest(dir, appInfo, routes, subscribers);
+
+			const manifestPath = join(dir, 'manifest', 'server.ts');
+			const content = await readFile(manifestPath, 'utf-8');
+
+			// Routes should be partitioned
+			expect(content).toContain('"admin":');
+			expect(content).toContain('"default":');
+			expect(content).toContain('RoutePartition');
+
+			// Subscribers should be flat
+			expect(content).toContain('orderHandler');
+			expect(content).not.toContain('SubscriberPartition');
+		},
+	);
+});

package/src/build/__tests__/partitions.spec.ts

@@ -0,0 +1,110 @@
+import type { Construct } from '@geekmidas/constructs';
+import { describe, expect, it } from 'vitest';
+import type { GeneratedConstruct } from '../../generators/Generator';
+import {
+	DEFAULT_PARTITION,
+	groupByPartition,
+	groupInfosByPartition,
+	hasPartitions,
+} from '../partitions';
+
+function makeConstruct(
+	name: string,
+	partition?: string,
+): GeneratedConstruct<Construct> {
+	return {
+		key: name,
+		name,
+		construct: {} as Construct,
+		path: { absolute: `/src/${name}.ts`, relative: `src/${name}.ts` },
+		partition,
+	};
+}
+
+describe('groupByPartition', () => {
+	it('should group all constructs into default when no partition set', () => {
+		const constructs = [makeConstruct('a'), makeConstruct('b')];
+		const groups = groupByPartition(constructs);
+
+		expect(groups.size).toBe(1);
+		expect(groups.get(DEFAULT_PARTITION)).toHaveLength(2);
+	});
+
+	it('should group constructs by partition name', () => {
+		const constructs = [
+			makeConstruct('a', 'admin'),
+			makeConstruct('b', 'public'),
+			makeConstruct('c', 'admin'),
+		];
+		const groups = groupByPartition(constructs);
+
+		expect(groups.size).toBe(2);
+		expect(groups.get('admin')).toHaveLength(2);
+		expect(groups.get('public')).toHaveLength(1);
+	});
+
+	it('should handle mix of partitioned and un-partitioned', () => {
+		const constructs = [
+			makeConstruct('a', 'admin'),
+			makeConstruct('b'), // no partition → default
+			makeConstruct('c', 'admin'),
+		];
+		const groups = groupByPartition(constructs);
+
+		expect(groups.size).toBe(2);
+		expect(groups.get('admin')).toHaveLength(2);
+		expect(groups.get(DEFAULT_PARTITION)).toHaveLength(1);
+	});
+
+	it('should return empty map for empty input', () => {
+		const groups = groupByPartition([]);
+		expect(groups.size).toBe(0);
+	});
+});
+
+describe('hasPartitions', () => {
+	it('should return false when no constructs have partitions', () => {
+		const constructs = [makeConstruct('a'), makeConstruct('b')];
+		expect(hasPartitions(constructs)).toBe(false);
+	});
+
+	it('should return true when any construct has a partition', () => {
+		const constructs = [makeConstruct('a', 'admin'), makeConstruct('b')];
+		expect(hasPartitions(constructs)).toBe(true);
+	});
+
+	it('should return false for empty array', () => {
+		expect(hasPartitions([])).toBe(false);
+	});
+});
+
+describe('groupInfosByPartition', () => {
+	it('should group infos matching construct partitions', () => {
+		const constructs = [
+			makeConstruct('a', 'admin'),
+			makeConstruct('b', 'public'),
+			makeConstruct('c', 'admin'),
+		];
+		const infos = [
+			{ name: 'a', handler: 'a.handler' },
+			{ name: 'b', handler: 'b.handler' },
+			{ name: 'c', handler: 'c.handler' },
+		];
+
+		const grouped = groupInfosByPartition(infos, constructs);
+
+		expect(grouped.admin).toHaveLength(2);
+		expect(grouped.public).toHaveLength(1);
+		expect(grouped.admin![0]).toEqual({ name: 'a', handler: 'a.handler' });
+		expect(grouped.admin![1]).toEqual({ name: 'c', handler: 'c.handler' });
+	});
+
+	it('should use default partition for un-partitioned constructs', () => {
+		const constructs = [makeConstruct('a'), makeConstruct('b')];
+		const infos = [{ name: 'a' }, { name: 'b' }];
+
+		const grouped = groupInfosByPartition(infos, constructs);
+
+		expect(grouped[DEFAULT_PARTITION]).toHaveLength(2);
+	});
+});

package/src/build/index.ts

@@ -26,11 +26,13 @@ import {
 	type GeneratedConstruct,
 	SubscriberGenerator,
 } from '../generators';
-import type {
-	BuildOptions,
-	BuildResult,
-	LegacyProvider,
-	RouteInfo,
+import {
+	type BuildOptions,
+	type BuildResult,
+	isPartitionedRoutes,
+	type LegacyProvider,
+	type RouteInfo,
+	type Routes,
 } from '../types';
 import {
 	getAppBuildOrder,
@@ -40,8 +42,10 @@ import {
 import {
 	generateAwsManifest,
 	generateServerManifest,
+	type ManifestField,
 	type ServerAppInfo,
 } from './manifests';
+import { groupInfosByPartition, hasPartitions } from './partitions';
 import { resolveProviders } from './providerResolver';
 import type { BuildContext } from './types';
 
@@ -89,15 +93,15 @@ export async function buildCommand(
 	}
 
 	logger.log(`Building with providers: ${resolved.providers.join(', ')}`);
-	logger.log(`Loading routes from: ${config.routes}`);
+	logger.log(`Loading routes from: ${formatRoutes(config.routes)}`);
 	if (config.functions) {
-		logger.log(`Loading functions from: ${config.functions}`);
+		logger.log(`Loading functions from: ${formatRoutes(config.functions)}`);
 	}
 	if (config.crons) {
-		logger.log(`Loading crons from: ${config.crons}`);
+		logger.log(`Loading crons from: ${formatRoutes(config.crons)}`);
 	}
 	if (config.subscribers) {
-		logger.log(`Loading subscribers from: ${config.subscribers}`);
+		logger.log(`Loading subscribers from: ${formatRoutes(config.subscribers)}`);
 	}
 	logger.log(`Using envParser: ${config.envParser}`);
 
@@ -258,6 +262,15 @@ async function buildForProvider(
 		`Generated ${routes.length} routes, ${functionInfos.length} functions, ${cronInfos.length} crons, ${subscriberInfos.length} subscribers for ${provider}`,
 	);
 
+	// Assemble manifest fields (flat or partitioned per construct type)
+	const manifestRoutes = assembleManifestField(routes, endpoints);
+	const manifestFunctions = assembleManifestField(functionInfos, functions);
+	const manifestCrons = assembleManifestField(cronInfos, crons);
+	const manifestSubscribers = assembleManifestField(
+		subscriberInfos,
+		subscribers,
+	);
+
 	// Generate provider-specific manifest
 	if (provider === 'server') {
 		// For server, collect actual route metadata from endpoint constructs
@@ -270,6 +283,8 @@ async function buildForProvider(
 			})),
 		);
 
+		const serverRouteField = assembleManifestField(routeMetadata, endpoints);
+
 		const appInfo: ServerAppInfo = {
 			handler: relative(process.cwd(), join(outputDir, 'app.ts')),
 			endpoints: relative(process.cwd(), join(outputDir, 'endpoints.ts')),
@@ -278,8 +293,8 @@ async function buildForProvider(
 		await generateServerManifest(
 			rootOutputDir,
 			appInfo,
-			routeMetadata,
-			subscriberInfos,
+			serverRouteField,
+			manifestSubscribers,
 		);
 
 		// Bundle for production if enabled
@@ -324,10 +339,10 @@ async function buildForProvider(
 		// For AWS providers, generate AWS manifest
 		await generateAwsManifest(
 			rootOutputDir,
-			routes,
-			functionInfos,
-			cronInfos,
-			subscriberInfos,
+			manifestRoutes,
+			manifestFunctions,
+			manifestCrons,
+			manifestSubscribers,
 		);
 	}
 
@@ -504,3 +519,31 @@ function getAppOutputPath(
 		return join(appPath, '.gkm');
 	}
 }
+
+/**
+ * Format routes for logging, handling PartitionedRoutes.
+ */
+function formatRoutes(routes: Routes): string {
+	if (isPartitionedRoutes(routes)) {
+		const paths = Array.isArray(routes.paths)
+			? routes.paths.join(', ')
+			: routes.paths;
+		return `${paths} (partitioned)`;
+	}
+	return Array.isArray(routes) ? routes.join(', ') : routes;
+}
+
+/**
+ * Assemble a ManifestField from build infos and constructs.
+ * If any construct has a partition, returns a Record<string, T[]>.
+ * Otherwise, returns a flat T[].
+ */
+function assembleManifestField<T>(
+	infos: T[],
+	constructs: GeneratedConstruct<any>[],
+): ManifestField<T> {
+	if (!hasPartitions(constructs)) {
+		return infos;
+	}
+	return groupInfosByPartition(infos, constructs);
+}

package/src/build/manifests.ts

@@ -16,31 +16,95 @@ export interface ServerAppInfo {
 	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: RouteInfo[],
-	functions: FunctionInfo[],
-	crons: CronInfo[],
-	subscribers: SubscriberInfo[],
+	routes: ManifestField<RouteInfo>,
+	functions: ManifestField<FunctionInfo>,
+	crons: ManifestField<CronInfo>,
+	subscribers: ManifestField<SubscriberInfo>,
 ): Promise<void> {
 	const manifestDir = join(outputDir, 'manifest');
 	await mkdir(manifestDir, { recursive: true });
 
 	// Filter out 'ALL' method routes (server-specific)
-	const awsRoutes = routes.filter((r) => r.method !== 'ALL');
+	const awsRoutes = filterAllRoutes(routes);
+
+	const routesPartitioned = isPartitioned(awsRoutes);
+	const functionsPartitioned = isPartitioned(functions);
+	const cronsPartitioned = isPartitioned(crons);
+	const subscribersPartitioned = isPartitioned(subscribers);
 
 	const content = `export const manifest = {
-  routes: ${JSON.stringify(awsRoutes, null, 2)},
-  functions: ${JSON.stringify(functions, null, 2)},
-  crons: ${JSON.stringify(crons, null, 2)},
-  subscribers: ${JSON.stringify(subscribers, null, 2)},
+  routes: ${serializeField(awsRoutes)},
+  functions: ${serializeField(functions)},
+  crons: ${serializeField(crons)},
+  subscribers: ${serializeField(subscribers)},
 } as const;
 
 // Derived types
-export type Route = (typeof manifest.routes)[number];
-export type Function = (typeof manifest.functions)[number];
-export type Cron = (typeof manifest.crons)[number];
-export type Subscriber = (typeof manifest.subscribers)[number];
+${generateDerivedType('routes', 'Route', routesPartitioned)}
+${generateDerivedType('functions', 'Function', functionsPartitioned)}
+${generateDerivedType('crons', 'Cron', cronsPartitioned)}
+${generateDerivedType('subscribers', 'Subscriber', subscribersPartitioned)}
 
 // Useful union types
 export type Authorizer = Route['authorizer'];
@@ -52,7 +116,7 @@ export type RoutePath = Route['path'];
 	await writeFile(manifestPath, content);
 
 	logger.log(
-		`Generated AWS manifest with ${awsRoutes.length} routes, ${functions.length} functions, ${crons.length} crons, ${subscribers.length} subscribers`,
+		`Generated AWS manifest with ${countItems(awsRoutes)} routes, ${countItems(functions)} functions, ${countItems(crons)} crons, ${countItems(subscribers)} subscribers`,
 	);
 	logger.log(`Manifest: ${relative(process.cwd(), manifestPath)}`);
 }
@@ -60,36 +124,30 @@ export type RoutePath = Route['path'];
 export async function generateServerManifest(
 	outputDir: string,
 	appInfo: ServerAppInfo,
-	routes: RouteInfo[],
-	subscribers: SubscriberInfo[],
+	routes: ManifestField<RouteInfo>,
+	subscribers: ManifestField<SubscriberInfo>,
 ): Promise<void> {
 	const manifestDir = join(outputDir, 'manifest');
 	await mkdir(manifestDir, { recursive: true });
 
 	// For server, extract route metadata (path, method, authorizer)
-	const serverRoutes = routes
-		.filter((r) => r.method !== 'ALL')
-		.map((r) => ({
-			path: r.path,
-			method: r.method,
-			authorizer: r.authorizer,
-		}));
+	const serverRoutes = mapRouteMetadata(filterAllRoutes(routes));
 
 	// Server subscribers only need name and events
-	const serverSubscribers = subscribers.map((s) => ({
-		name: s.name,
-		subscribedEvents: s.subscribedEvents,
-	}));
+	const serverSubscribers = mapSubscriberMetadata(subscribers);
+
+	const routesPartitioned = isPartitioned(serverRoutes);
+	const subscribersPartitioned = isPartitioned(serverSubscribers);
 
 	const content = `export const manifest = {
   app: ${JSON.stringify(appInfo, null, 2)},
-  routes: ${JSON.stringify(serverRoutes, null, 2)},
-  subscribers: ${JSON.stringify(serverSubscribers, null, 2)},
+  routes: ${serializeField(serverRoutes)},
+  subscribers: ${serializeField(serverSubscribers)},
 } as const;
 
 // Derived types
-export type Route = (typeof manifest.routes)[number];
-export type Subscriber = (typeof manifest.subscribers)[number];
+${generateDerivedType('routes', 'Route', routesPartitioned)}
+${generateDerivedType('subscribers', 'Subscriber', subscribersPartitioned)}
 
 // Useful union types
 export type Authorizer = Route['authorizer'];
@@ -101,7 +159,70 @@ export type RoutePath = Route['path'];
 	await writeFile(manifestPath, content);
 
 	logger.log(
-		`Generated server manifest with ${serverRoutes.length} routes, ${serverSubscribers.length} subscribers`,
+		`Generated server manifest with ${countItems(serverRoutes)} routes, ${countItems(serverSubscribers)} subscribers`,
 	);
 	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: 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: string[] }[]> =
+		{};
+	for (const [partition, partitionSubs] of Object.entries(subscribers)) {
+		result[partition] = partitionSubs.map(mapFn);
+	}
+	return result;
+}