@geekmidas/cli 0.26.0 → 0.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "description": "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs",
   "private": false,
   "type": "module",
@@ -48,11 +48,11 @@
     "lodash.kebabcase": "^4.1.1",
     "openapi-typescript": "^7.4.2",
     "prompts": "~2.4.2",
-    "@geekmidas/constructs": "~0.6.0",
-    "@geekmidas/envkit": "~0.4.0",
     "@geekmidas/logger": "~0.4.0",
-    "@geekmidas/schema": "~0.1.0",
-    "@geekmidas/errors": "~0.1.0"
+    "@geekmidas/errors": "~0.1.0",
+    "@geekmidas/envkit": "~0.4.0",
+    "@geekmidas/constructs": "~0.6.0",
+    "@geekmidas/schema": "~0.1.0"
   },
   "devDependencies": {
     "@types/lodash.kebabcase": "^4.1.9",

package/src/init/__tests__/generators.spec.ts

@@ -297,7 +297,8 @@ describe('generateModelsPackage', () => {
 		const paths = files.map((f) => f.path);
 		expect(paths).toContain('packages/models/package.json');
 		expect(paths).toContain('packages/models/tsconfig.json');
-		expect(paths).toContain('packages/models/src/index.ts');
+		expect(paths).toContain('packages/models/src/common.ts');
+		expect(paths).toContain('packages/models/src/user.ts');
 	});
 
 	it('should use correct package name', () => {
@@ -335,12 +336,17 @@ describe('generateModelsPackage', () => {
 			apiPath: 'apps/api',
 		};
 		const files = generateModelsPackage(options);
-		const indexTs = files.find(
-			(f) => f.path === 'packages/models/src/index.ts',
+		const userTs = files.find(
+			(f) => f.path === 'packages/models/src/user.ts',
 		);
-		expect(indexTs?.content).toContain('userSchema');
-		expect(indexTs?.content).toContain('paginationSchema');
-		expect(indexTs?.content).toContain("import { z } from 'zod'");
+		const commonTs = files.find(
+			(f) => f.path === 'packages/models/src/common.ts',
+		);
+		expect(userTs?.content).toContain('UserSchema');
+		expect(userTs?.content).toContain('UserResponseSchema');
+		expect(userTs?.content).toContain("import { z } from 'zod'");
+		expect(commonTs?.content).toContain('PaginationSchema');
+		expect(commonTs?.content).toContain('IdSchema');
 	});
 
 	it('should extend root tsconfig', () => {

package/src/init/__tests__/init.spec.ts

@@ -176,7 +176,10 @@ describe('initCommand', () => {
 			expect(
 				existsSync(join(projectDir, 'packages/models/tsconfig.json')),
 			).toBe(true);
-			expect(existsSync(join(projectDir, 'packages/models/src/index.ts'))).toBe(
+			expect(existsSync(join(projectDir, 'packages/models/src/common.ts'))).toBe(
+				true,
+			);
+			expect(existsSync(join(projectDir, 'packages/models/src/user.ts'))).toBe(
 				true,
 			);
 		});
@@ -265,14 +268,23 @@ describe('initCommand', () => {
 			expect(pkg.name).toBe('@my-monorepo/models');
 			expect(pkg.dependencies.zod).toBeDefined();
 
-			const indexPath = join(
+			const userPath = join(
+				tempDir,
+				'my-monorepo',
+				'packages/models/src/user.ts',
+			);
+			const userContent = await readFile(userPath, 'utf-8');
+			expect(userContent).toContain('UserSchema');
+			expect(userContent).toContain('UserResponseSchema');
+
+			const commonPath = join(
 				tempDir,
 				'my-monorepo',
-				'packages/models/src/index.ts',
+				'packages/models/src/common.ts',
 			);
-			const indexContent = await readFile(indexPath, 'utf-8');
-			expect(indexContent).toContain('userSchema');
-			expect(indexContent).toContain('paginationSchema');
+			const commonContent = await readFile(commonPath, 'utf-8');
+			expect(commonContent).toContain('PaginationSchema');
+			expect(commonContent).toContain('IdSchema');
 		});
 
 		it('should support custom API path', async () => {

package/src/init/generators/models.ts

@@ -20,18 +20,9 @@ export function generateModelsPackage(
 		private: true,
 		type: 'module',
 		exports: {
-			'.': {
-				types: './dist/index.d.ts',
-				import: './dist/index.js',
-			},
-			'./*': {
-				types: './dist/*.d.ts',
-				import: './dist/*.js',
-			},
+			'./*': './src/*.ts',
 		},
 		scripts: {
-			build: 'tsc',
-			'build:watch': 'tsc --watch',
 			typecheck: 'tsc --noEmit',
 		},
 		dependencies: {
@@ -42,7 +33,7 @@ export function generateModelsPackage(
 		},
 	};
 
-	// tsconfig.json for models - library package that builds to dist
+	// tsconfig.json for models - extends root config
 	const tsConfig = {
 		extends: '../../tsconfig.json',
 		compilerOptions: {
@@ -55,26 +46,26 @@ export function generateModelsPackage(
 		exclude: ['node_modules', 'dist'],
 	};
 
-	// Main index.ts with example schemas
-	const indexTs = `import { z } from 'zod';
+	// common.ts - shared utility schemas
+	const commonTs = `import { z } from 'zod';
 
 // ============================================
 // Common Schemas
 // ============================================
 
-export const idSchema = z.string().uuid();
+export const IdSchema = z.string().uuid();
 
-export const timestampsSchema = z.object({
+export const TimestampsSchema = z.object({
   createdAt: z.coerce.date(),
   updatedAt: z.coerce.date(),
 });
 
-export const paginationSchema = z.object({
+export const PaginationSchema = z.object({
   page: z.coerce.number().int().positive().default(1),
   limit: z.coerce.number().int().positive().max(100).default(20),
 });
 
-export const paginatedResponseSchema = <T extends z.ZodTypeAny>(itemSchema: T) =>
+export const PaginatedResponseSchema = <T extends z.ZodTypeAny>(itemSchema: T) =>
   z.object({
     items: z.array(itemSchema),
     total: z.number(),
@@ -83,35 +74,61 @@ export const paginatedResponseSchema = <T extends z.ZodTypeAny>(itemSchema: T) =
     totalPages: z.number(),
   });
 
+// ============================================
+// Type Exports
+// ============================================
+
+export type Id = z.infer<typeof IdSchema>;
+export type Timestamps = z.infer<typeof TimestampsSchema>;
+export type Pagination = z.infer<typeof PaginationSchema>;
+`;
+
+	// user.ts - user-related schemas
+	const userTs = `import { z } from 'zod';
+import { IdSchema, TimestampsSchema } from './common.js';
+
 // ============================================
 // User Schemas
 // ============================================
 
-export const userSchema = z.object({
-  id: idSchema,
+export const UserSchema = z.object({
+  id: IdSchema,
   email: z.string().email(),
   name: z.string().min(1).max(100),
-  ...timestampsSchema.shape,
+  ...TimestampsSchema.shape,
 });
 
-export const createUserSchema = userSchema.omit({
+export const CreateUserSchema = UserSchema.omit({
   id: true,
   createdAt: true,
   updatedAt: true,
 });
 
-export const updateUserSchema = createUserSchema.partial();
+export const UpdateUserSchema = CreateUserSchema.partial();
+
+// ============================================
+// Response Schemas
+// ============================================
+
+export const UserResponseSchema = UserSchema.pick({
+  id: true,
+  name: true,
+  email: true,
+});
+
+export const ListUsersResponseSchema = z.object({
+  users: z.array(UserSchema.pick({ id: true, name: true })),
+});
 
 // ============================================
 // Type Exports
 // ============================================
 
-export type Id = z.infer<typeof idSchema>;
-export type Timestamps = z.infer<typeof timestampsSchema>;
-export type Pagination = z.infer<typeof paginationSchema>;
-export type User = z.infer<typeof userSchema>;
-export type CreateUser = z.infer<typeof createUserSchema>;
-export type UpdateUser = z.infer<typeof updateUserSchema>;
+export type User = z.infer<typeof UserSchema>;
+export type CreateUser = z.infer<typeof CreateUserSchema>;
+export type UpdateUser = z.infer<typeof UpdateUserSchema>;
+export type UserResponse = z.infer<typeof UserResponseSchema>;
+export type ListUsersResponse = z.infer<typeof ListUsersResponseSchema>;
 `;
 
 	return [
@@ -124,8 +141,12 @@ export type UpdateUser = z.infer<typeof updateUserSchema>;
 			content: `${JSON.stringify(tsConfig, null, 2)}\n`,
 		},
 		{
-			path: 'packages/models/src/index.ts',
-			content: indexTs,
+			path: 'packages/models/src/common.ts',
+			content: commonTs,
+		},
+		{
+			path: 'packages/models/src/user.ts',
+			content: userTs,
 		},
 	];
 }

package/src/init/index.ts

@@ -395,6 +395,21 @@ export async function initCommand(
 		}
 	}
 
+	// Initialize git repository
+	console.log('\n📦 Initializing git repository...\n');
+	try {
+		execSync('git init', { cwd: targetDir, stdio: 'pipe' });
+		execSync('git branch -M main', { cwd: targetDir, stdio: 'pipe' });
+		execSync('git add .', { cwd: targetDir, stdio: 'pipe' });
+		execSync('git commit -m "🎉 Project created with @geekmidas/toolbox"', {
+			cwd: targetDir,
+			stdio: 'pipe',
+		});
+		console.log('  Initialized git repository on branch main');
+	} catch {
+		console.log('  Could not initialize git repository (git may not be installed)');
+	}
+
 	// Print success message with next steps
 	printNextSteps(name, templateOptions, pkgManager);
 }

package/src/init/templates/api.ts

@@ -15,6 +15,7 @@ export const apiTemplate: TemplateConfig = {
 		'@geekmidas/envkit': GEEKMIDAS_VERSIONS['@geekmidas/envkit'],
 		'@geekmidas/events': GEEKMIDAS_VERSIONS['@geekmidas/events'],
 		'@geekmidas/logger': GEEKMIDAS_VERSIONS['@geekmidas/logger'],
+		'@geekmidas/rate-limit': GEEKMIDAS_VERSIONS['@geekmidas/rate-limit'],
 		'@geekmidas/schema': GEEKMIDAS_VERSIONS['@geekmidas/schema'],
 		'@geekmidas/services': GEEKMIDAS_VERSIONS['@geekmidas/services'],
 		'@geekmidas/errors': GEEKMIDAS_VERSIONS['@geekmidas/errors'],
@@ -46,13 +47,16 @@ export const apiTemplate: TemplateConfig = {
 	},
 
 	files: (options: TemplateOptions): GeneratedFile[] => {
-		const { loggerType, routesStructure } = options;
+		const { loggerType, routesStructure, monorepo, name } = options;
 
 		const loggerContent = `import { createLogger } from '@geekmidas/logger/${loggerType}';
 
 export const logger = createLogger();
 `;
 
+		// Models package import path for monorepo
+		const modelsImport = monorepo ? `@${name}/models` : null;
+
 		// Get route path based on structure
 		const getRoutePath = (file: string) => {
 			switch (routesStructure) {
@@ -100,9 +104,14 @@ export const config = envParser
 			{
 				path: getRoutePath('health.ts'),
 				content: `import { e } from '@geekmidas/constructs/endpoints';
+import { z } from 'zod';
 
 export const healthEndpoint = e
   .get('/health')
+  .output(z.object({
+    status: z.string(),
+    timestamp: z.string(),
+  }))
   .handle(async () => ({
     status: 'ok',
     timestamp: new Date().toISOString(),
@@ -113,10 +122,33 @@ export const healthEndpoint = e
 			// users endpoints
 			{
 				path: getRoutePath('users/list.ts'),
-				content: `import { e } from '@geekmidas/constructs/endpoints';
+				content: modelsImport
+					? `import { e } from '@geekmidas/constructs/endpoints';
+import { ListUsersResponseSchema } from '${modelsImport}/user';
 
 export const listUsersEndpoint = e
   .get('/users')
+  .output(ListUsersResponseSchema)
+  .handle(async () => ({
+    users: [
+      { id: '1', name: 'Alice' },
+      { id: '2', name: 'Bob' },
+    ],
+  }));
+`
+					: `import { e } from '@geekmidas/constructs/endpoints';
+import { z } from 'zod';
+
+const UserSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+});
+
+export const listUsersEndpoint = e
+  .get('/users')
+  .output(z.object({
+    users: z.array(UserSchema),
+  }))
   .handle(async () => ({
     users: [
       { id: '1', name: 'Alice' },
@@ -127,12 +159,32 @@ export const listUsersEndpoint = e
 			},
 			{
 				path: getRoutePath('users/get.ts'),
-				content: `import { e } from '@geekmidas/constructs/endpoints';
+				content: modelsImport
+					? `import { e } from '@geekmidas/constructs/endpoints';
+import { z } from 'zod';
+import { UserResponseSchema } from '${modelsImport}/user';
+
+export const getUserEndpoint = e
+  .get('/users/:id')
+  .params(z.object({ id: z.string() }))
+  .output(UserResponseSchema)
+  .handle(async ({ params }) => ({
+    id: params.id,
+    name: 'Alice',
+    email: 'alice@example.com',
+  }));
+`
+					: `import { e } from '@geekmidas/constructs/endpoints';
 import { z } from 'zod';
 
 export const getUserEndpoint = e
   .get('/users/:id')
   .params(z.object({ id: z.string() }))
+  .output(z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string().email(),
+  }))
   .handle(async ({ params }) => ({
     id: params.id,
     name: 'Alice',

package/src/init/templates/minimal.ts

@@ -14,6 +14,7 @@ export const minimalTemplate: TemplateConfig = {
 		'@geekmidas/constructs': GEEKMIDAS_VERSIONS['@geekmidas/constructs'],
 		'@geekmidas/envkit': GEEKMIDAS_VERSIONS['@geekmidas/envkit'],
 		'@geekmidas/logger': GEEKMIDAS_VERSIONS['@geekmidas/logger'],
+		'@geekmidas/rate-limit': GEEKMIDAS_VERSIONS['@geekmidas/rate-limit'],
 		'@geekmidas/schema': GEEKMIDAS_VERSIONS['@geekmidas/schema'],
 		'@hono/node-server': '~1.14.1',
 		hono: '~4.8.2',
@@ -91,9 +92,14 @@ export const config = envParser
 			{
 				path: getRoutePath('health.ts'),
 				content: `import { e } from '@geekmidas/constructs/endpoints';
+import { z } from 'zod';
 
 export const healthEndpoint = e
   .get('/health')
+  .output(z.object({
+    status: z.string(),
+    timestamp: z.string(),
+  }))
   .handle(async () => ({
     status: 'ok',
     timestamp: new Date().toISOString(),

package/src/init/templates/serverless.ts

@@ -15,6 +15,7 @@ export const serverlessTemplate: TemplateConfig = {
 		'@geekmidas/envkit': GEEKMIDAS_VERSIONS['@geekmidas/envkit'],
 		'@geekmidas/logger': GEEKMIDAS_VERSIONS['@geekmidas/logger'],
 		'@geekmidas/cloud': GEEKMIDAS_VERSIONS['@geekmidas/cloud'],
+		'@geekmidas/rate-limit': GEEKMIDAS_VERSIONS['@geekmidas/rate-limit'],
 		'@geekmidas/schema': GEEKMIDAS_VERSIONS['@geekmidas/schema'],
 		'@hono/node-server': '~1.14.1',
 		hono: '~4.8.2',
@@ -93,9 +94,15 @@ export const config = envParser
 			{
 				path: getRoutePath('health.ts'),
 				content: `import { e } from '@geekmidas/constructs/endpoints';
+import { z } from 'zod';
 
 export const healthEndpoint = e
   .get('/health')
+  .output(z.object({
+    status: z.string(),
+    timestamp: z.string(),
+    region: z.string(),
+  }))
   .handle(async () => ({
     status: 'ok',
     timestamp: new Date().toISOString(),

package/src/init/templates/worker.ts

@@ -15,6 +15,7 @@ export const workerTemplate: TemplateConfig = {
 		'@geekmidas/envkit': GEEKMIDAS_VERSIONS['@geekmidas/envkit'],
 		'@geekmidas/events': GEEKMIDAS_VERSIONS['@geekmidas/events'],
 		'@geekmidas/logger': GEEKMIDAS_VERSIONS['@geekmidas/logger'],
+		'@geekmidas/rate-limit': GEEKMIDAS_VERSIONS['@geekmidas/rate-limit'],
 		'@geekmidas/schema': GEEKMIDAS_VERSIONS['@geekmidas/schema'],
 		'@hono/node-server': '~1.14.1',
 		hono: '~4.8.2',
@@ -92,9 +93,14 @@ export const config = envParser
 			{
 				path: getRoutePath('health.ts'),
 				content: `import { e } from '@geekmidas/constructs/endpoints';
+import { z } from 'zod';
 
 export const healthEndpoint = e
   .get('/health')
+  .output(z.object({
+    status: z.string(),
+    timestamp: z.string(),
+  }))
   .handle(async () => ({
     status: 'ok',
     timestamp: new Date().toISOString(),

package/src/workspace/__tests__/index.spec.ts

@@ -41,20 +41,19 @@ describe('defineWorkspace', () => {
 		);
 	});
 
-	it('should throw with descriptive error for missing routes', () => {
+	it('should allow backend apps without routes (e.g., auth servers)', () => {
 		const config = {
 			apps: {
-				api: {
+				auth: {
 					type: 'backend',
-					path: 'apps/api',
+					path: 'apps/auth',
 					port: 3000,
 				},
 			},
 		} as WorkspaceConfig;
 
-		expect(() => defineWorkspace(config)).toThrow(
-			'Backend apps must have routes defined',
-		);
+		// Should not throw - routes are optional for backend apps
+		expect(() => defineWorkspace(config)).not.toThrow();
 	});
 });
 

package/src/workspace/__tests__/schema.spec.ts

@@ -142,21 +142,21 @@ describe('WorkspaceConfigSchema', () => {
 			expect(result.error).toBeDefined();
 		});
 
-		it('should reject backend app without routes', () => {
+		it('should allow backend app without routes (e.g., auth servers)', () => {
 			const config = {
 				apps: {
-					api: {
+					auth: {
 						type: 'backend' as const,
-						path: 'apps/api',
+						path: 'apps/auth',
 						port: 3000,
-						// Missing routes
+						// Routes are optional for backend apps
 					},
 				},
 			};
 
 			const result = safeValidateWorkspaceConfig(config);
 
-			expect(result.success).toBe(false);
+			expect(result.success).toBe(true);
 		});
 
 		it('should reject frontend app without framework', () => {

package/src/workspace/schema.ts

@@ -203,19 +203,7 @@ const AppConfigSchema = z
 		framework: z.enum(['nextjs']).optional(),
 		client: ClientConfigSchema.optional(),
 	})
-	.refine(
-		(data) => {
-			// Backend apps must have routes
-			if (data.type === 'backend' && !data.routes) {
-				return false;
-			}
-			return true;
-		},
-		{
-			message: 'Backend apps must have routes defined',
-			path: ['routes'],
-		},
-	)
+	// Note: routes is optional for backend apps - some backends like auth servers don't use routes
 	.refine(
 		(data) => {
 			// Frontend apps must have framework