@geekmidas/cli 0.18.0 → 0.20.0

package/src/index.ts

@@ -18,6 +18,7 @@ import {
 	secretsSetCommand,
 	secretsShowCommand,
 } from './secrets';
+import { type TestOptions, testCommand } from './test/index';
 import type { ComposeServiceName, LegacyProvider, MainProvider } from './types';
 
 const program = new Command();
@@ -40,6 +41,7 @@ program
 	.option('-y, --yes', 'Skip prompts, use defaults', false)
 	.option('--monorepo', 'Setup as monorepo with packages/models', false)
 	.option('--api-path <path>', 'API app path in monorepo (default: apps/api)')
+	.option('--pm <manager>', 'Package manager (pnpm, npm, yarn, bun)')
 	.action(async (name: string | undefined, options: InitOptions) => {
 		try {
 			const globalOptions = program.opts();
@@ -157,6 +159,28 @@ program
 		}
 	});
 
+program
+	.command('test')
+	.description('Run tests with secrets loaded from environment')
+	.option('--stage <stage>', 'Stage to load secrets from', 'development')
+	.option('--run', 'Run tests once without watch mode')
+	.option('--watch', 'Enable watch mode')
+	.option('--coverage', 'Generate coverage report')
+	.option('--ui', 'Open Vitest UI')
+	.argument('[pattern]', 'Pattern to filter tests')
+	.action(async (pattern: string | undefined, options: TestOptions) => {
+		try {
+			const globalOptions = program.opts();
+			if (globalOptions.cwd) {
+				process.chdir(globalOptions.cwd);
+			}
+			await testCommand({ ...options, pattern });
+		} catch (error) {
+			console.error(error instanceof Error ? error.message : 'Command failed');
+			process.exit(1);
+		}
+	});
+
 program
 	.command('cron')
 	.description('Manage cron jobs')

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

@@ -35,13 +35,13 @@ describe('generatePackageJson', () => {
 	it('should include telescope when enabled', () => {
 		const files = generatePackageJson(baseOptions, minimalTemplate);
 		const pkg = JSON.parse(files[0].content);
-		expect(pkg.dependencies['@geekmidas/telescope']).toBe('workspace:*');
+		expect(pkg.dependencies['@geekmidas/telescope']).toMatch(/^~/);
 	});
 
 	it('should include database dependencies when enabled', () => {
 		const files = generatePackageJson(baseOptions, minimalTemplate);
 		const pkg = JSON.parse(files[0].content);
-		expect(pkg.dependencies['@geekmidas/db']).toBe('workspace:*');
+		expect(pkg.dependencies['@geekmidas/db']).toMatch(/^~/);
 		expect(pkg.dependencies.kysely).toBeDefined();
 		expect(pkg.dependencies.pg).toBeDefined();
 	});
@@ -53,12 +53,12 @@ describe('generatePackageJson', () => {
 		expect(pkg.dependencies['@geekmidas/telescope']).toBeUndefined();
 	});
 
-	it('should use workspace:* for @geekmidas packages', () => {
+	it('should use tilde versions for @geekmidas packages', () => {
 		const files = generatePackageJson(baseOptions, minimalTemplate);
 		const pkg = JSON.parse(files[0].content);
-		expect(pkg.dependencies['@geekmidas/constructs']).toBe('workspace:*');
-		expect(pkg.dependencies['@geekmidas/envkit']).toBe('workspace:*');
-		expect(pkg.dependencies['@geekmidas/logger']).toBe('workspace:*');
+		expect(pkg.dependencies['@geekmidas/constructs']).toMatch(/^~/);
+		expect(pkg.dependencies['@geekmidas/envkit']).toMatch(/^~/);
+		expect(pkg.dependencies['@geekmidas/logger']).toMatch(/^~/);
 	});
 
 	it('should use tilde versions for external packages', () => {
@@ -169,38 +169,31 @@ describe('generateConfigFiles', () => {
 });
 
 describe('generateEnvFiles', () => {
-	it('should generate all env files for non-monorepo', () => {
+	it('should only generate .gitignore for non-monorepo', () => {
+		// .env files are no longer generated - secrets are encrypted instead
 		const files = generateEnvFiles(baseOptions, minimalTemplate);
 		const paths = files.map((f) => f.path);
-		expect(paths).toContain('.env');
-		expect(paths).toContain('.env.example');
-		expect(paths).toContain('.env.development');
-		expect(paths).toContain('.env.test');
 		expect(paths).toContain('.gitignore');
+		expect(paths).not.toContain('.env');
+		expect(paths).not.toContain('.env.example');
+		expect(paths).not.toContain('.env.development');
+		expect(paths).not.toContain('.env.test');
 	});
 
-	it('should not generate .gitignore for monorepo', () => {
+	it('should not generate any files for monorepo (gitignore at root)', () => {
 		const options: TemplateOptions = {
 			...baseOptions,
 			monorepo: true,
 			apiPath: 'apps/api',
 		};
 		const files = generateEnvFiles(options, minimalTemplate);
-		const paths = files.map((f) => f.path);
-		expect(paths).not.toContain('.gitignore');
+		expect(files).toHaveLength(0);
 	});
 
-	it('should include DATABASE_URL when database is enabled', () => {
+	it('should include .gkm in gitignore', () => {
 		const files = generateEnvFiles(baseOptions, minimalTemplate);
-		const envFile = files.find((f) => f.path === '.env');
-		expect(envFile?.content).toContain('DATABASE_URL');
-	});
-
-	it('should include RABBITMQ_URL for worker template', () => {
-		const options = { ...baseOptions, template: 'worker' as const };
-		const files = generateEnvFiles(options, workerTemplate);
-		const envFile = files.find((f) => f.path === '.env');
-		expect(envFile?.content).toContain('RABBITMQ_URL');
+		const gitignore = files.find((f) => f.path === '.gitignore');
+		expect(gitignore?.content).toContain('.gkm/');
 	});
 });
 

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

@@ -37,9 +37,10 @@ describe('initCommand', () => {
 			expect(existsSync(join(projectDir, 'biome.json'))).toBe(true);
 			expect(existsSync(join(projectDir, 'turbo.json'))).toBe(true);
 			expect(existsSync(join(projectDir, 'docker-compose.yml'))).toBe(true);
-			expect(existsSync(join(projectDir, '.env'))).toBe(true);
-			expect(existsSync(join(projectDir, '.env.development'))).toBe(true);
-			expect(existsSync(join(projectDir, '.env.test'))).toBe(true);
+			// Secrets are now encrypted instead of .env files
+			expect(
+				existsSync(join(projectDir, '.gkm/secrets/development.json')),
+			).toBe(true);
 			expect(existsSync(join(projectDir, '.gitignore'))).toBe(true);
 			expect(existsSync(join(projectDir, 'src/config/env.ts'))).toBe(true);
 			expect(existsSync(join(projectDir, 'src/config/logger.ts'))).toBe(true);
@@ -61,8 +62,8 @@ describe('initCommand', () => {
 
 			expect(pkg.name).toBe('my-api');
 			expect(pkg.type).toBe('module');
-			expect(pkg.dependencies['@geekmidas/constructs']).toBe('workspace:*');
-			expect(pkg.dependencies['@geekmidas/telescope']).toBe('workspace:*');
+			expect(pkg.dependencies['@geekmidas/constructs']).toMatch(/^~/);
+			expect(pkg.dependencies['@geekmidas/telescope']).toMatch(/^~/);
 			expect(pkg.dependencies.zod).toMatch(/^~/);
 			expect(pkg.devDependencies['@biomejs/biome']).toBeDefined();
 			expect(pkg.devDependencies.turbo).toBeDefined();
@@ -298,6 +299,157 @@ describe('initCommand', () => {
 		});
 	});
 
+	describe('fullstack template', () => {
+		it('should create monorepo with api and web apps', async () => {
+			await initCommand('my-fullstack', {
+				template: 'fullstack',
+				yes: true,
+				skipInstall: true,
+			});
+
+			const projectDir = join(tempDir, 'my-fullstack');
+
+			// Root files
+			expect(existsSync(join(projectDir, 'package.json'))).toBe(true);
+			expect(existsSync(join(projectDir, 'pnpm-workspace.yaml'))).toBe(true);
+			expect(existsSync(join(projectDir, 'tsconfig.json'))).toBe(true);
+			expect(existsSync(join(projectDir, 'biome.json'))).toBe(true);
+			expect(existsSync(join(projectDir, 'turbo.json'))).toBe(true);
+			expect(existsSync(join(projectDir, 'gkm.config.ts'))).toBe(true);
+
+			// API app files
+			expect(existsSync(join(projectDir, 'apps/api/package.json'))).toBe(true);
+			expect(existsSync(join(projectDir, 'apps/api/tsconfig.json'))).toBe(true);
+			expect(
+				existsSync(join(projectDir, 'apps/api/src/endpoints/health.ts')),
+			).toBe(true);
+
+			// Web app files
+			expect(existsSync(join(projectDir, 'apps/web/package.json'))).toBe(true);
+			expect(existsSync(join(projectDir, 'apps/web/next.config.ts'))).toBe(
+				true,
+			);
+			expect(existsSync(join(projectDir, 'apps/web/tsconfig.json'))).toBe(true);
+			expect(existsSync(join(projectDir, 'apps/web/src/app/layout.tsx'))).toBe(
+				true,
+			);
+			expect(existsSync(join(projectDir, 'apps/web/src/app/page.tsx'))).toBe(
+				true,
+			);
+
+			// Models package
+			expect(existsSync(join(projectDir, 'packages/models/package.json'))).toBe(
+				true,
+			);
+		});
+
+		it('should create workspace config with defineWorkspace', async () => {
+			await initCommand('my-fullstack', {
+				template: 'fullstack',
+				yes: true,
+				skipInstall: true,
+			});
+
+			const configPath = join(tempDir, 'my-fullstack', 'gkm.config.ts');
+			const content = await readFile(configPath, 'utf-8');
+
+			expect(content).toContain('import { defineWorkspace }');
+			expect(content).toContain("name: 'my-fullstack'");
+			expect(content).toContain("type: 'backend'");
+			expect(content).toContain("path: 'apps/api'");
+			expect(content).toContain("type: 'frontend'");
+			expect(content).toContain("framework: 'nextjs'");
+			expect(content).toContain("path: 'apps/web'");
+			expect(content).toContain("packages: ['packages/*']");
+		});
+
+		it('should create root package.json with gkm commands', async () => {
+			await initCommand('my-fullstack', {
+				template: 'fullstack',
+				yes: true,
+				skipInstall: true,
+			});
+
+			const pkgPath = join(tempDir, 'my-fullstack', 'package.json');
+			const content = await readFile(pkgPath, 'utf-8');
+			const pkg = JSON.parse(content);
+
+			expect(pkg.scripts.dev).toBe('gkm dev');
+			expect(pkg.scripts.build).toBe('gkm build');
+			expect(pkg.devDependencies['@geekmidas/cli']).toBeDefined();
+		});
+
+		it('should create Next.js web app with models dependency', async () => {
+			await initCommand('my-fullstack', {
+				template: 'fullstack',
+				yes: true,
+				skipInstall: true,
+			});
+
+			const pkgPath = join(tempDir, 'my-fullstack', 'apps/web/package.json');
+			const content = await readFile(pkgPath, 'utf-8');
+			const pkg = JSON.parse(content);
+
+			expect(pkg.name).toBe('@my-fullstack/web');
+			expect(pkg.dependencies['@my-fullstack/models']).toBe('workspace:*');
+			expect(pkg.dependencies.next).toBeDefined();
+			expect(pkg.dependencies.react).toBeDefined();
+			expect(pkg.scripts.dev).toContain('next dev');
+		});
+
+		it('should include services config in workspace', async () => {
+			await initCommand('my-fullstack', {
+				template: 'fullstack',
+				yes: true,
+				skipInstall: true,
+			});
+
+			const configPath = join(tempDir, 'my-fullstack', 'gkm.config.ts');
+			const content = await readFile(configPath, 'utf-8');
+
+			expect(content).toContain('services:');
+			expect(content).toContain('db: true');
+			expect(content).toContain('cache: true');
+			expect(content).toContain('mail: true');
+		});
+
+		it('should include deploy config for dokploy', async () => {
+			await initCommand('my-fullstack', {
+				template: 'fullstack',
+				yes: true,
+				skipInstall: true,
+			});
+
+			const configPath = join(tempDir, 'my-fullstack', 'gkm.config.ts');
+			const content = await readFile(configPath, 'utf-8');
+
+			expect(content).toContain('deploy:');
+			expect(content).toContain("default: 'dokploy'");
+
+			const pkgPath = join(tempDir, 'my-fullstack', 'package.json');
+			const pkgContent = await readFile(pkgPath, 'utf-8');
+			const pkg = JSON.parse(pkgContent);
+
+			expect(pkg.scripts.deploy).toContain('gkm deploy');
+		});
+
+		it('should NOT create app-level gkm.config.ts for api', async () => {
+			await initCommand('my-fullstack', {
+				template: 'fullstack',
+				yes: true,
+				skipInstall: true,
+			});
+
+			// Config should be at root only, not in apps/api
+			expect(existsSync(join(tempDir, 'my-fullstack', 'gkm.config.ts'))).toBe(
+				true,
+			);
+			expect(
+				existsSync(join(tempDir, 'my-fullstack', 'apps/api/gkm.config.ts')),
+			).toBe(false);
+		});
+	});
+
 	describe('docker-compose', () => {
 		it('should include postgres for database-enabled projects', async () => {
 			await initCommand('my-api', {

package/src/init/generators/auth.ts

@@ -0,0 +1,220 @@
+import type { GeneratedFile, TemplateOptions } from '../templates/index.js';
+import { GEEKMIDAS_VERSIONS } from '../versions.js';
+
+/**
+ * Generate auth app files for fullstack template
+ * Uses better-auth with magic link authentication
+ */
+export function generateAuthAppFiles(
+	options: TemplateOptions,
+): GeneratedFile[] {
+	if (!options.monorepo || options.template !== 'fullstack') {
+		return [];
+	}
+
+	const packageName = `@${options.name}/auth`;
+	const modelsPackage = `@${options.name}/models`;
+
+	// package.json for auth app
+	const packageJson = {
+		name: packageName,
+		version: '0.0.1',
+		private: true,
+		type: 'module',
+		scripts: {
+			dev: 'tsx watch src/index.ts',
+			build: 'tsc',
+			start: 'node dist/index.js',
+			typecheck: 'tsc --noEmit',
+		},
+		dependencies: {
+			[modelsPackage]: 'workspace:*',
+			'@geekmidas/envkit': GEEKMIDAS_VERSIONS['@geekmidas/envkit'],
+			'@geekmidas/logger': GEEKMIDAS_VERSIONS['@geekmidas/logger'],
+			'@hono/node-server': '~1.13.0',
+			'better-auth': '~1.2.0',
+			hono: '~4.8.0',
+			kysely: '~0.27.0',
+			pg: '~8.13.0',
+		},
+		devDependencies: {
+			'@types/node': '~22.0.0',
+			'@types/pg': '~8.11.0',
+			tsx: '~4.20.0',
+			typescript: '~5.8.2',
+		},
+	};
+
+	// tsconfig.json for auth app
+	const tsConfig = {
+		extends: '../../tsconfig.json',
+		compilerOptions: {
+			noEmit: true,
+			baseUrl: '.',
+			paths: {
+				[`@${options.name}/*`]: ['../../packages/*/src'],
+			},
+		},
+		include: ['src/**/*.ts'],
+		exclude: ['node_modules', 'dist'],
+	};
+
+	// src/config/env.ts
+	const envTs = `import { Credentials } from '@geekmidas/envkit/credentials';
+import { EnvironmentParser } from '@geekmidas/envkit';
+
+export const envParser = new EnvironmentParser({ ...process.env, ...Credentials });
+
+// Global config - only minimal shared values
+// Service-specific config should be parsed where needed
+export const config = envParser
+  .create((get) => ({
+    nodeEnv: get('NODE_ENV').enum(['development', 'test', 'production']).default('development'),
+    stage: get('STAGE').enum(['development', 'staging', 'production']).default('development'),
+  }))
+  .parse();
+`;
+
+	// src/config/logger.ts
+	const loggerTs = `import { createLogger } from '@geekmidas/logger/${options.loggerType}';
+
+export const logger = createLogger();
+`;
+
+	// src/auth.ts - better-auth instance with magic link
+	const authTs = `import { betterAuth } from 'better-auth';
+import { magicLink } from 'better-auth/plugins';
+import { Pool } from 'pg';
+import { envParser } from './config/env.js';
+import { logger } from './config/logger.js';
+
+// Parse auth-specific config (no defaults - values from secrets)
+const authConfig = envParser
+  .create((get) => ({
+    databaseUrl: get('DATABASE_URL').string(),
+    baseUrl: get('BETTER_AUTH_URL').string(),
+    trustedOrigins: get('BETTER_AUTH_TRUSTED_ORIGINS').string(),
+    secret: get('BETTER_AUTH_SECRET').string(),
+  }))
+  .parse();
+
+export const auth = betterAuth({
+  database: new Pool({
+    connectionString: authConfig.databaseUrl,
+  }),
+  baseURL: authConfig.baseUrl,
+  trustedOrigins: authConfig.trustedOrigins.split(','),
+  secret: authConfig.secret,
+  plugins: [
+    magicLink({
+      sendMagicLink: async ({ email, url }) => {
+        // TODO: Implement email sending using @geekmidas/emailkit
+        // For development, log the magic link
+        logger.info({ email, url }, 'Magic link generated');
+        console.log('\\n================================');
+        console.log('MAGIC LINK FOR:', email);
+        console.log(url);
+        console.log('================================\\n');
+      },
+      expiresIn: 300, // 5 minutes
+    }),
+  ],
+  emailAndPassword: {
+    enabled: false, // Only magic link for now
+  },
+});
+
+export type Auth = typeof auth;
+`;
+
+	// src/index.ts - Hono app entry point
+	const indexTs = `import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { serve } from '@hono/node-server';
+import { auth } from './auth.js';
+import { envParser } from './config/env.js';
+import { logger } from './config/logger.js';
+
+// Parse server config (no defaults - values from secrets)
+const serverConfig = envParser
+  .create((get) => ({
+    port: get('PORT').string().transform(Number),
+    trustedOrigins: get('BETTER_AUTH_TRUSTED_ORIGINS').string(),
+  }))
+  .parse();
+
+const app = new Hono();
+
+// CORS must be registered before routes
+app.use(
+  '/api/auth/*',
+  cors({
+    origin: serverConfig.trustedOrigins.split(','),
+    allowHeaders: ['Content-Type', 'Authorization'],
+    allowMethods: ['POST', 'GET', 'OPTIONS'],
+    credentials: true,
+  }),
+);
+
+// Health check endpoint
+app.get('/health', (c) => {
+  return c.json({
+    status: 'ok',
+    service: 'auth',
+    timestamp: new Date().toISOString(),
+  });
+});
+
+// Mount better-auth handler
+app.on(['POST', 'GET'], '/api/auth/*', (c) => {
+  return auth.handler(c.req.raw);
+});
+
+logger.info({ port: serverConfig.port }, 'Starting auth server');
+
+serve({
+  fetch: app.fetch,
+  port: serverConfig.port,
+}, (info) => {
+  logger.info({ port: info.port }, 'Auth server running');
+});
+`;
+
+	// .gitignore for auth app
+	const gitignore = `node_modules/
+dist/
+.env.local
+*.log
+`;
+
+	return [
+		{
+			path: 'apps/auth/package.json',
+			content: `${JSON.stringify(packageJson, null, 2)}\n`,
+		},
+		{
+			path: 'apps/auth/tsconfig.json',
+			content: `${JSON.stringify(tsConfig, null, 2)}\n`,
+		},
+		{
+			path: 'apps/auth/src/config/env.ts',
+			content: envTs,
+		},
+		{
+			path: 'apps/auth/src/config/logger.ts',
+			content: loggerTs,
+		},
+		{
+			path: 'apps/auth/src/auth.ts',
+			content: authTs,
+		},
+		{
+			path: 'apps/auth/src/index.ts',
+			content: indexTs,
+		},
+		{
+			path: 'apps/auth/.gitignore',
+			content: gitignore,
+		},
+	];
+}

package/src/init/generators/config.ts

@@ -14,6 +14,7 @@ export function generateConfigFiles(
 	const { telescope, studio, routesStructure } = options;
 	const isServerless = template.name === 'serverless';
 	const hasWorker = template.name === 'worker';
+	const isFullstack = options.template === 'fullstack';
 
 	// Get routes glob pattern based on structure
 	const getRoutesGlob = () => {
@@ -27,7 +28,21 @@ export function generateConfigFiles(
 		}
 	};
 
-	// Build gkm.config.ts
+	// For fullstack template, generate workspace config at root
+	// Single app config is still generated for non-fullstack monorepo setups
+	if (isFullstack) {
+		// Workspace config is generated in monorepo.ts for fullstack
+		return generateSingleAppConfigFiles(options, template, {
+			telescope,
+			studio,
+			routesStructure,
+			isServerless,
+			hasWorker,
+			getRoutesGlob,
+		});
+	}
+
+	// Build gkm.config.ts for single-app
 	let gkmConfig = `import { defineConfig } from '@geekmidas/cli/config';
 
 export default defineConfig({
@@ -70,12 +85,12 @@ export default defineConfig({
 `;
 
 	// Build tsconfig.json - extends root for monorepo, standalone for non-monorepo
+	// Using noEmit: true since typecheck is done via turbo
 	const tsConfig = options.monorepo
 		? {
 				extends: '../../tsconfig.json',
 				compilerOptions: {
-					outDir: './dist',
-					rootDir: './src',
+					noEmit: true,
 					baseUrl: '.',
 					paths: {
 						[`@${options.name}/*`]: ['../../packages/*/src'],
@@ -120,7 +135,7 @@ export default defineConfig({
 
 	// Build biome.json
 	const biomeConfig = {
-		$schema: 'https://biomejs.dev/schemas/1.9.4/schema.json',
+		$schema: 'https://biomejs.dev/schemas/2.3.0/schema.json',
 		vcs: {
 			enabled: true,
 			clientKind: 'git',
@@ -213,3 +228,45 @@ export default defineConfig({
 		},
 	];
 }
+
+/**
+ * Helper to generate config files for API app in fullstack template
+ * (workspace config is at root, so no gkm.config.ts for app)
+ */
+interface ConfigHelperOptions {
+	telescope: boolean;
+	studio: boolean;
+	routesStructure: string;
+	isServerless: boolean;
+	hasWorker: boolean;
+	getRoutesGlob: () => string;
+}
+
+function generateSingleAppConfigFiles(
+	options: TemplateOptions,
+	_template: TemplateConfig,
+	_helpers: ConfigHelperOptions,
+): GeneratedFile[] {
+	// For fullstack, only generate tsconfig.json for the API app
+	// The workspace gkm.config.ts is generated in monorepo.ts
+	// Using noEmit: true since typecheck is done via turbo
+	const tsConfig = {
+		extends: '../../tsconfig.json',
+		compilerOptions: {
+			noEmit: true,
+			baseUrl: '.',
+			paths: {
+				[`@${options.name}/*`]: ['../../packages/*/src'],
+			},
+		},
+		include: ['src/**/*.ts'],
+		exclude: ['node_modules', 'dist'],
+	};
+
+	return [
+		{
+			path: 'tsconfig.json',
+			content: `${JSON.stringify(tsConfig, null, 2)}\n`,
+		},
+	];
+}