@geekmidas/cli 9.0.2 → 10.0.0-alpha.1

package/docs/manifest-refactor-design.md

@@ -1,287 +0,0 @@
-# Manifest Refactoring Design
-
-## Current State
-
-Currently, the CLI generates a single `manifest.json` file at `.gkm/manifest.json` that aggregates all routes, functions, crons, and subscribers across all providers.
-
-```
-.gkm/
-├── manifest.json          # Single JSON manifest
-├── aws-apigatewayv2/      # AWS handlers
-│   ├── getUsers.ts
-│   └── createUser.ts
-└── server/                # Server handlers
-    ├── app.ts
-    └── endpoints.ts
-```
-
-### Problems
-
-1. **Mixed provider data**: AWS and server routes are combined, causing `method: 'ALL'` to appear in manifests used for AWS infrastructure
-2. **JSON format**: No TypeScript types available, consumers must define their own types
-3. **No derived types**: Consumers can't easily extract types like `Authorizer` from the manifest
-
-## Proposed Changes
-
-### 1. Folder Structure
-
-Change from single `manifest.json` to a `manifest/` folder with TypeScript files per provider:
-
-```
-.gkm/
-├── manifest/
-│   ├── aws.ts             # AWS-specific manifest
-│   └── server.ts          # Server-specific manifest
-├── aws-apigatewayv2/
-│   ├── getUsers.ts
-│   └── createUser.ts
-└── server/
-    ├── app.ts
-    └── endpoints.ts
-```
-
-### 2. AWS Manifest (`manifest/aws.ts`)
-
-Contains only AWS routes with actual HTTP methods (no `method: 'ALL'`):
-
-```typescript
-export const manifest = {
-  routes: [
-    {
-      path: '/users',
-      method: 'GET',
-      handler: '.gkm/aws-apigatewayv2/getUsers.handler',
-      timeout: 30,
-      memorySize: 256,
-      environment: ['DATABASE_URL', 'API_KEY'],
-      authorizer: 'jwt',
-    },
-    {
-      path: '/users',
-      method: 'POST',
-      handler: '.gkm/aws-apigatewayv2/createUser.handler',
-      timeout: 30,
-      memorySize: 256,
-      environment: ['DATABASE_URL'],
-      authorizer: 'jwt',
-    },
-  ],
-  functions: [
-    {
-      name: 'processPayment',
-      handler: '.gkm/aws-lambda/processPayment.handler',
-      timeout: 60,
-      memorySize: 512,
-      environment: ['STRIPE_KEY'],
-    },
-  ],
-  crons: [
-    {
-      name: 'dailyReport',
-      handler: '.gkm/aws-lambda/dailyReport.handler',
-      schedule: 'rate(1 day)',
-      timeout: 300,
-      memorySize: 256,
-      environment: [],
-    },
-  ],
-  subscribers: [
-    {
-      name: 'orderCreated',
-      handler: '.gkm/aws-lambda/orderCreated.handler',
-      subscribedEvents: ['order.created'],
-      timeout: 30,
-      memorySize: 256,
-      environment: [],
-    },
-  ],
-} 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];
-
-// Useful union types
-export type Authorizer = Route['authorizer'];
-export type HttpMethod = Route['method'];
-export type RoutePath = Route['path'];
-```
-
-### 3. Server Manifest (`manifest/server.ts`)
-
-Contains server app info and route metadata for documentation/type derivation:
-
-```typescript
-export const manifest = {
-  app: {
-    handler: '.gkm/server/app.ts',
-    endpoints: '.gkm/server/endpoints.ts',
-  },
-  routes: [
-    {
-      path: '/users',
-      method: 'GET',
-      authorizer: 'jwt',
-    },
-    {
-      path: '/users',
-      method: 'POST',
-      authorizer: 'jwt',
-    },
-  ],
-  subscribers: [
-    {
-      name: 'orderCreated',
-      subscribedEvents: ['order.created'],
-    },
-  ],
-} as const;
-
-// Derived types
-export type Route = (typeof manifest.routes)[number];
-export type Subscriber = (typeof manifest.subscribers)[number];
-
-// Useful union types
-export type Authorizer = Route['authorizer'];
-export type HttpMethod = Route['method'];
-export type RoutePath = Route['path'];
-```
-
-## Implementation Details
-
-### Changes to `manifests.ts`
-
-```typescript
-export async function generateManifests(
-  outputDir: string,
-  provider: 'aws' | 'server',
-  routes: RouteInfo[],
-  functions: FunctionInfo[],
-  crons: CronInfo[],
-  subscribers: SubscriberInfo[],
-): Promise<void> {
-  const manifestDir = join(outputDir, 'manifest');
-  await mkdir(manifestDir, { recursive: true });
-
-  if (provider === 'aws') {
-    await generateAwsManifest(manifestDir, routes, functions, crons, subscribers);
-  } else {
-    await generateServerManifest(manifestDir, routes, subscribers);
-  }
-}
-
-async function generateAwsManifest(
-  manifestDir: string,
-  routes: RouteInfo[],
-  functions: FunctionInfo[],
-  crons: CronInfo[],
-  subscribers: SubscriberInfo[],
-): Promise<void> {
-  // Filter out 'ALL' method routes (server-specific)
-  const awsRoutes = routes.filter(r => r.method !== 'ALL');
-
-  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)},
-} 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];
-
-// Useful union types
-export type Authorizer = Route['authorizer'];
-export type HttpMethod = Route['method'];
-export type RoutePath = Route['path'];
-`;
-
-  await writeFile(join(manifestDir, 'aws.ts'), content);
-}
-```
-
-### Changes to Build Flow
-
-Currently `buildCommand` aggregates all providers into one manifest. Change to:
-
-1. Generate per-provider manifests during each provider's build
-2. Remove aggregation step
-3. Each provider generates its own TypeScript manifest file
-
-```typescript
-async function buildForProvider(
-  provider: LegacyProvider,
-  // ...
-): Promise<BuildResult> {
-  // ... existing build logic ...
-
-  // Generate provider-specific manifest
-  const manifestProvider = provider.startsWith('aws') ? 'aws' : 'server';
-  await generateManifests(
-    rootOutputDir,
-    manifestProvider,
-    routes,
-    functionInfos,
-    cronInfos,
-    subscriberInfos,
-  );
-
-  return { routes, functions: functionInfos, crons: cronInfos, subscribers: subscriberInfos };
-}
-```
-
-## Usage Examples
-
-### AWS CDK / SST Integration
-
-```typescript
-import { manifest, type Route, type Authorizer } from './.gkm/manifest/aws';
-
-// Type-safe iteration over routes
-for (const route of manifest.routes) {
-  new ApiGatewayRoute(this, route.path, {
-    method: route.method,
-    handler: route.handler,
-    authorizer: getAuthorizer(route.authorizer),
-  });
-}
-
-// Use derived types
-function getAuthorizer(name: Authorizer): IAuthorizer {
-  switch (name) {
-    case 'jwt':
-      return jwtAuthorizer;
-    case 'apiKey':
-      return apiKeyAuthorizer;
-    case 'none':
-      return undefined;
-  }
-}
-```
-
-### Type Checking Authorizer Values
-
-```typescript
-import type { Authorizer } from './.gkm/manifest/aws';
-
-// Authorizer is a union type of all authorizer values
-// e.g., 'jwt' | 'apiKey' | 'none'
-const authorizer: Authorizer = 'jwt'; // ✓
-const invalid: Authorizer = 'invalid'; // ✗ Type error
-```
-
-## Migration Notes
-
-1. **Breaking change**: Consumers using `manifest.json` need to switch to TypeScript imports
-2. **Benefit**: Full TypeScript support with derived types
-
-## Design Decisions
-
-1. **No backward compatibility**: `manifest.json` will not be generated
-2. **Server manifest includes route metadata**: For documentation and type derivation
-3. **No re-export index**: Each manifest is imported directly

package/examples/cron-example.ts

@@ -1,45 +0,0 @@
-import { c } from '@geekmidas/constructs/crons';
-
-/**
- * Example cron that generates a daily report at 9 AM UTC
- */
-export const dailyReport = c
-	.schedule('cron(0 9 * * ? *)')
-	.timeout(600000) // 10 minutes
-	.handle(async ({ logger }) => {
-		logger.info('Generating daily report');
-
-		const reportDate = new Date().toISOString().split('T')[0];
-
-		// Generate report logic here
-		const reportData = {
-			date: reportDate,
-			totalOrders: 150,
-			totalRevenue: 12500.0,
-			topProducts: [
-				{ id: 'prod-1', name: 'Widget A', sales: 45 },
-				{ id: 'prod-2', name: 'Widget B', sales: 32 },
-			],
-		};
-
-		logger.info(reportData, 'Daily report generated');
-
-		return reportData;
-	});
-
-/**
- * Example cron that runs every hour
- */
-export const hourlyCleanup = c
-	.schedule('rate(1 hour)')
-	.timeout(300000) // 5 minutes
-	.handle(async ({ logger }) => {
-		logger.info('Running hourly cleanup');
-
-		// Cleanup logic here
-		const itemsCleaned = 42;
-
-		logger.info(`Cleaned ${itemsCleaned} items`);
-
-		return { itemsCleaned };
-	});

package/examples/env.ts

@@ -1,33 +0,0 @@
-import { EnvironmentParser } from '@geekmidas/envkit';
-
-export const envParser = new EnvironmentParser(process.env)
-	.create((get) => ({
-		// Database configuration
-		database: {
-			url: get('DATABASE_URL').string().url(),
-			maxConnections: get('DB_MAX_CONNECTIONS')
-				.string()
-				.transform(Number)
-				.default('10'),
-		},
-
-		// API configuration
-		api: {
-			port: get('PORT').string().transform(Number).default('3000'),
-			cors: {
-				origin: get('CORS_ORIGIN').string().default('*'),
-			},
-		},
-
-		// AWS configuration (for Lambda deployments)
-		aws: {
-			region: get('AWS_REGION').string().default('us-east-1'),
-		},
-
-		// Application settings
-		app: {
-			environment: get('NODE_ENV').string().default('development'),
-			logLevel: get('LOG_LEVEL').string().default('info'),
-		},
-	}))
-	.parse();

package/examples/function-example.ts

@@ -1,40 +0,0 @@
-import { f } from '@geekmidas/constructs/functions';
-import { z } from 'zod';
-
-/**
- * Example function that processes an order
- */
-export const processOrder = f
-	.input(
-		z.object({
-			orderId: z.string(),
-			items: z.array(
-				z.object({
-					id: z.string(),
-					quantity: z.number().int().positive(),
-				}),
-			),
-		}),
-	)
-	.output(
-		z.object({
-			orderId: z.string(),
-			status: z.enum(['processing', 'completed', 'failed']),
-			processedAt: z.string().datetime(),
-		}),
-	)
-	.timeout(300000) // 5 minutes
-	.handle(async ({ input, logger }) => {
-		logger.info(`Processing order ${input.orderId}`);
-
-		// Process order logic here
-		for (const item of input.items) {
-			logger.info(`Processing item ${item.id}, quantity: ${item.quantity}`);
-		}
-
-		return {
-			orderId: input.orderId,
-			status: 'completed' as const,
-			processedAt: new Date().toISOString(),
-		};
-	});

package/examples/gkm.config.json

@@ -1,22 +0,0 @@
-{
-	"routes": "./src/endpoints/**/*.ts",
-	"functions": "./src/functions/**/*.ts",
-	"crons": "./src/crons/**/*.ts",
-	"envParser": "./src/env.ts#envParser",
-	"logger": "./src/logger.ts#logger",
-	"providers": {
-		"aws": {
-			"apiGateway": {
-				"v1": false,
-				"v2": true
-			},
-			"lambda": {
-				"functions": true,
-				"crons": true
-			}
-		},
-		"server": {
-			"enableOpenApi": true
-		}
-	}
-}

package/examples/gkm.config.ts

@@ -1,14 +0,0 @@
-import { defineConfig } from '@geekmidas/cli/config';
-
-export default defineConfig({
-	// Glob pattern to find endpoint files
-	routes: 'src/routes/**/*.ts',
-
-	// Environment parser configuration
-	// Format: path#exportName (if no #exportName, treats as default import)
-	envParser: './src/env.ts#envParser',
-
-	// Logger configuration
-	// Format: path#exportName (if no #exportName, treats as default import)
-	logger: './src/logger.ts#logger',
-});

package/examples/gkm.minimal.config.json

@@ -1,7 +0,0 @@
-{
-	"routes": "./src/endpoints/**/*.ts",
-	"functions": "./src/functions/**/*.ts",
-	"crons": "./src/crons/**/*.ts",
-	"envParser": "./src/env.ts#envParser",
-	"logger": "./src/logger.ts#logger"
-}

package/examples/gkm.production.config.json

@@ -1,27 +0,0 @@
-{
-	"routes": "./src/endpoints/**/*.ts",
-	"functions": "./src/functions/**/*.ts",
-	"crons": "./src/crons/**/*.ts",
-	"envParser": "./src/env.ts#envParser",
-	"logger": "./src/logger.ts#logger",
-	"providers": {
-		"aws": {
-			"apiGateway": {
-				"v2": {
-					"enabled": true,
-					"outputDir": "dist/api-gateway"
-				}
-			},
-			"lambda": {
-				"functions": {
-					"enabled": true,
-					"outputDir": "dist/functions"
-				},
-				"crons": {
-					"enabled": true,
-					"outputDir": "dist/crons"
-				}
-			}
-		}
-	}
-}

package/examples/logger.ts

@@ -1,10 +0,0 @@
-import { ConsoleLogger } from '@geekmidas/logger/console';
-
-// Create a console logger instance
-export const logger = new ConsoleLogger({
-	level: process.env.LOG_LEVEL || 'info',
-	pretty: process.env.NODE_ENV !== 'production',
-});
-
-// You can also export a default logger
-export default logger;

package/scripts/sync-versions.ts

@@ -1,108 +0,0 @@
-#!/usr/bin/env tsx
-/**
- * Sync package versions from monorepo package.json files
- *
- * Run: pnpm --filter @geekmidas/cli sync-versions
- */
-
-import { readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const packagesDir = join(__dirname, '../../'); // packages/cli/scripts -> packages/
-
-const PACKAGES = [
-	'audit',
-	'auth',
-	'cache',
-	'client',
-	'cloud',
-	'constructs',
-	'db',
-	'emailkit',
-	'envkit',
-	'errors',
-	'events',
-	'logger',
-	'rate-limit',
-	'schema',
-	'services',
-	'storage',
-	'studio',
-	'telescope',
-	'testkit',
-] as const;
-
-function getPackageVersion(pkgName: string): string {
-	const pkgJsonPath = join(packagesDir, pkgName, 'package.json');
-	try {
-		const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
-		return pkgJson.version;
-	} catch (error) {
-		console.error(`Failed to read version for ${pkgName}:`, error);
-		throw error;
-	}
-}
-
-function generateVersionsFile(): string {
-	const versions: Record<string, string> = {};
-
-	for (const pkg of PACKAGES) {
-		const version = getPackageVersion(pkg);
-		versions[`@geekmidas/${pkg}`] = `~${version}`;
-	}
-
-	const content = `import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-
-// Load package.json - handles both bundled (flat dist/) and source (nested src/init/)
-function loadPackageJson(): { version: string } {
-	try {
-		// Try flat dist path first (../package.json from dist/)
-		return require('../package.json');
-	} catch {
-		// Fall back to nested source path (../../package.json from src/init/)
-		return require('../../package.json');
-	}
-}
-
-const pkg = loadPackageJson();
-
-/**
- * CLI version resolved from package.json at runtime
- */
-export const CLI_VERSION = \`~\${pkg.version}\`;
-
-/**
- * Package versions for @geekmidas packages
- *
- * AUTO-GENERATED (except CLI) - Do not edit manually
- * Run: pnpm --filter @geekmidas/cli sync-versions
- */
-export const GEEKMIDAS_VERSIONS = {
-${Object.entries(versions)
-	.map(([pkg, version]) => `\t'${pkg}': '${version}',`)
-	.join('\n')}
-	'@geekmidas/cli': CLI_VERSION,
-} as const;
-
-export type GeekmidasPackage = keyof typeof GEEKMIDAS_VERSIONS;
-`;
-
-	return content;
-}
-
-// Main
-const versionsPath = join(__dirname, '../src/init/versions.ts');
-const content = generateVersionsFile();
-writeFileSync(versionsPath, content);
-console.log('✓ Updated packages/cli/src/init/versions.ts');
-
-// Show versions
-console.log('\nPackage versions:');
-for (const pkg of PACKAGES) {
-	const version = getPackageVersion(pkg);
-	console.log(`  @geekmidas/${pkg}: ${version}`);
-}