@geekmidas/cli 9.0.2 → 10.0.0-alpha.1

package/src/__tests__/loadEnvFiles.spec.ts

@@ -1,131 +0,0 @@
-import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { loadEnvFiles } from '../dev';
-
-describe('loadEnvFiles', () => {
-	let testDir: string;
-	const originalEnv = { ...process.env };
-
-	beforeEach(() => {
-		// Create a temporary test directory
-		testDir = join(tmpdir(), `gkm-test-${Date.now()}`);
-		mkdirSync(testDir, { recursive: true });
-
-		// Reset process.env to original state
-		process.env = { ...originalEnv };
-	});
-
-	afterEach(() => {
-		// Clean up test directory
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-
-		// Reset process.env
-		process.env = originalEnv;
-	});
-
-	it('should load a single .env file', () => {
-		writeFileSync(join(testDir, '.env'), 'TEST_VAR=hello\nANOTHER_VAR=world');
-
-		const { loaded, missing } = loadEnvFiles('.env', testDir);
-
-		expect(loaded).toEqual(['.env']);
-		expect(missing).toEqual([]);
-		expect(process.env.TEST_VAR).toBe('hello');
-		expect(process.env.ANOTHER_VAR).toBe('world');
-	});
-
-	it('should load multiple env files in order', () => {
-		writeFileSync(join(testDir, '.env'), 'VAR1=base\nVAR2=base');
-		writeFileSync(join(testDir, '.env.local'), 'VAR2=local\nVAR3=local');
-
-		const { loaded, missing } = loadEnvFiles(['.env', '.env.local'], testDir);
-
-		expect(loaded).toEqual(['.env', '.env.local']);
-		expect(missing).toEqual([]);
-		expect(process.env.VAR1).toBe('base');
-		expect(process.env.VAR2).toBe('local'); // Overridden by .env.local
-		expect(process.env.VAR3).toBe('local');
-	});
-
-	it('should report missing files when explicitly configured', () => {
-		writeFileSync(join(testDir, '.env'), 'VAR=value');
-
-		const { loaded, missing } = loadEnvFiles(
-			['.env', '.env.local', '.env.missing'],
-			testDir,
-		);
-
-		expect(loaded).toEqual(['.env']);
-		expect(missing).toEqual(['.env.local', '.env.missing']);
-		expect(process.env.VAR).toBe('value');
-	});
-
-	it('should not report missing .env when using default', () => {
-		// No .env file exists
-		const { loaded, missing } = loadEnvFiles(undefined, testDir);
-
-		expect(loaded).toEqual([]);
-		expect(missing).toEqual([]);
-	});
-
-	it('should handle undefined config with default .env', () => {
-		writeFileSync(join(testDir, '.env'), 'DEFAULT_VAR=default');
-
-		const { loaded, missing } = loadEnvFiles(undefined, testDir);
-
-		expect(loaded).toEqual(['.env']);
-		expect(missing).toEqual([]);
-		expect(process.env.DEFAULT_VAR).toBe('default');
-	});
-
-	it('should handle string config as single file', () => {
-		writeFileSync(join(testDir, '.env.production'), 'PROD_VAR=production');
-
-		const { loaded, missing } = loadEnvFiles('.env.production', testDir);
-
-		expect(loaded).toEqual(['.env.production']);
-		expect(missing).toEqual([]);
-		expect(process.env.PROD_VAR).toBe('production');
-	});
-
-	it('should override earlier files with later files', () => {
-		writeFileSync(join(testDir, '.env'), 'SHARED=first\nONLY_FIRST=yes');
-		writeFileSync(join(testDir, '.env.local'), 'SHARED=second');
-		writeFileSync(join(testDir, '.env.dev'), 'SHARED=third\nONLY_DEV=yes');
-
-		const { loaded } = loadEnvFiles(
-			['.env', '.env.local', '.env.dev'],
-			testDir,
-		);
-
-		expect(loaded).toEqual(['.env', '.env.local', '.env.dev']);
-		expect(process.env.SHARED).toBe('third');
-		expect(process.env.ONLY_FIRST).toBe('yes');
-		expect(process.env.ONLY_DEV).toBe('yes');
-	});
-
-	it('should handle empty env files', () => {
-		writeFileSync(join(testDir, '.env'), '');
-
-		const { loaded, missing } = loadEnvFiles('.env', testDir);
-
-		expect(loaded).toEqual(['.env']);
-		expect(missing).toEqual([]);
-	});
-
-	it('should handle env files with comments', () => {
-		writeFileSync(
-			join(testDir, '.env'),
-			'# This is a comment\nVAR=value\n# Another comment',
-		);
-
-		const { loaded } = loadEnvFiles('.env', testDir);
-
-		expect(loaded).toEqual(['.env']);
-		expect(process.env.VAR).toBe('value');
-	});
-});

package/src/__tests__/normalizeHooksConfig.spec.ts

@@ -1,63 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { normalizeHooksConfig } from '../dev';
-
-describe('normalizeHooksConfig', () => {
-	const _originalCwd = process.cwd();
-
-	beforeEach(() => {
-		vi.spyOn(process, 'cwd').mockReturnValue('/test/project');
-	});
-
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it('should return undefined when hooks config is undefined', () => {
-		const result = normalizeHooksConfig(undefined);
-		expect(result).toBeUndefined();
-	});
-
-	it('should return undefined when hooks config is empty object', () => {
-		const result = normalizeHooksConfig({});
-		expect(result).toBeUndefined();
-	});
-
-	it('should return undefined when server hooks path is not provided', () => {
-		const result = normalizeHooksConfig({ server: undefined });
-		expect(result).toBeUndefined();
-	});
-
-	it('should normalize path with .ts extension', () => {
-		const result = normalizeHooksConfig({ server: './src/hooks.ts' });
-
-		expect(result).toBeDefined();
-		expect(result?.serverHooksPath).toBe('/test/project/src/hooks.ts');
-	});
-
-	it('should add .ts extension when missing', () => {
-		const result = normalizeHooksConfig({ server: './src/hooks' });
-
-		expect(result).toBeDefined();
-		expect(result?.serverHooksPath).toBe('/test/project/src/hooks.ts');
-	});
-
-	it('should resolve relative paths from cwd', () => {
-		const result = normalizeHooksConfig({ server: 'config/server-hooks' });
-
-		expect(result).toBeDefined();
-		expect(result?.serverHooksPath).toBe(
-			'/test/project/config/server-hooks.ts',
-		);
-	});
-
-	it('should handle nested directory paths', () => {
-		const result = normalizeHooksConfig({
-			server: './src/config/hooks/server',
-		});
-
-		expect(result).toBeDefined();
-		expect(result?.serverHooksPath).toBe(
-			'/test/project/src/config/hooks/server.ts',
-		);
-	});
-});

package/src/__tests__/openapi-react-query.spec.ts

@@ -1,506 +0,0 @@
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { generateReactQueryCommand } from '../openapi-react-query';
-import { cleanupDir, createTempDir, createTestFile } from './test-helpers';
-
-describe('React Query Generation', () => {
-	let tempDir: string;
-
-	beforeEach(async () => {
-		tempDir = await createTempDir('react-query-test-');
-	});
-
-	afterEach(async () => {
-		await cleanupDir(tempDir);
-		vi.restoreAllMocks();
-	});
-
-	describe('generateReactQueryCommand', () => {
-		it('should generate React Query hooks from OpenAPI spec', async () => {
-			// Create mock OpenAPI spec
-			const spec = {
-				openapi: '3.0.0',
-				info: {
-					title: 'Test API',
-					version: '1.0.0',
-				},
-				paths: {
-					'/users': {
-						get: {
-							operationId: 'getUsers',
-							responses: {
-								'200': {
-									description: 'Success',
-									content: {
-										'application/json': {
-											schema: {
-												type: 'array',
-												items: {
-													type: 'object',
-													properties: {
-														id: { type: 'string' },
-														name: { type: 'string' },
-													},
-												},
-											},
-										},
-									},
-								},
-							},
-						},
-						post: {
-							operationId: 'createUser',
-							requestBody: {
-								content: {
-									'application/json': {
-										schema: {
-											type: 'object',
-											properties: {
-												name: { type: 'string' },
-											},
-										},
-									},
-								},
-							},
-							responses: {
-								'201': {
-									description: 'Created',
-								},
-							},
-						},
-					},
-				},
-			};
-
-			const inputPath = join(tempDir, 'openapi.json');
-			await createTestFile(tempDir, 'openapi.json', JSON.stringify(spec));
-
-			const outputPath = join(tempDir, 'hooks.ts');
-
-			vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-
-			await generateReactQueryCommand({
-				input: inputPath,
-				output: outputPath,
-				name: 'TestAPI',
-			});
-
-			// Verify hooks file was created
-			expect(existsSync(outputPath)).toBe(true);
-
-			// Verify content
-			const content = await readFile(outputPath, 'utf-8');
-
-			expect(content).toContain('createTypedQueryClient');
-			expect(content).toContain('testapi');
-			expect(content).toContain('useGetUsers');
-			expect(content).toContain('useCreateUser');
-			expect(content).toContain('export');
-		});
-
-		it('should throw error when OpenAPI spec not found', async () => {
-			vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-
-			await expect(
-				generateReactQueryCommand({
-					input: join(tempDir, 'nonexistent.json'),
-				}),
-			).rejects.toThrow(/OpenAPI spec not found/);
-		});
-
-		it('should use default input and output paths', async () => {
-			// Create spec in default location
-			const spec = {
-				openapi: '3.0.0',
-				info: { title: 'API', version: '1.0.0' },
-				paths: {
-					'/test': {
-						get: {
-							operationId: 'test',
-							responses: { '200': { description: 'OK' } },
-						},
-					},
-				},
-			};
-
-			await createTestFile(tempDir, 'openapi.json', JSON.stringify(spec));
-
-			vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-
-			await generateReactQueryCommand();
-
-			// Should create in default location
-			const defaultPath = join(tempDir, 'src', 'api', 'hooks.ts');
-			expect(existsSync(defaultPath)).toBe(true);
-		});
-
-		it('should generate query hooks for GET requests', async () => {
-			const spec = {
-				openapi: '3.0.0',
-				info: { title: 'API', version: '1.0.0' },
-				paths: {
-					'/users': {
-						get: {
-							operationId: 'listUsers',
-							responses: { '200': { description: 'Success' } },
-						},
-					},
-					'/users/{id}': {
-						get: {
-							operationId: 'getUser',
-							parameters: [
-								{
-									name: 'id',
-									in: 'path',
-									required: true,
-									schema: { type: 'string' },
-								},
-							],
-							responses: { '200': { description: 'Success' } },
-						},
-					},
-				},
-			};
-
-			const inputPath = join(tempDir, 'openapi.json');
-			await createTestFile(tempDir, 'openapi.json', JSON.stringify(spec));
-
-			const outputPath = join(tempDir, 'hooks.ts');
-			vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-
-			await generateReactQueryCommand({
-				input: inputPath,
-				output: outputPath,
-			});
-
-			const content = await readFile(outputPath, 'utf-8');
-
-			expect(content).toContain('useListUsers');
-			expect(content).toContain('useGetUser');
-			expect(content).toContain('Query Hooks');
-		});
-
-		it('should generate mutation hooks for non-GET requests', async () => {
-			const spec = {
-				openapi: '3.0.0',
-				info: { title: 'API', version: '1.0.0' },
-				paths: {
-					'/users': {
-						post: {
-							operationId: 'createUser',
-							responses: { '201': { description: 'Created' } },
-						},
-					},
-					'/users/{id}': {
-						put: {
-							operationId: 'updateUser',
-							responses: { '200': { description: 'Updated' } },
-						},
-						delete: {
-							operationId: 'deleteUser',
-							responses: { '204': { description: 'Deleted' } },
-						},
-					},
-				},
-			};
-
-			const inputPath = join(tempDir, 'openapi.json');
-			await createTestFile(tempDir, 'openapi.json', JSON.stringify(spec));
-
-			const outputPath = join(tempDir, 'hooks.ts');
-			vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-
-			await generateReactQueryCommand({
-				input: inputPath,
-				output: outputPath,
-			});
-
-			const content = await readFile(outputPath, 'utf-8');
-
-			expect(content).toContain('useCreateUser');
-			expect(content).toContain('useUpdateUser');
-			expect(content).toContain('useDeleteUser');
-			expect(content).toContain('Mutation Hooks');
-		});
-
-		it('should create output directory if it does not exist', async () => {
-			const spec = {
-				openapi: '3.0.0',
-				info: { title: 'API', version: '1.0.0' },
-				paths: {
-					'/test': {
-						get: {
-							operationId: 'test',
-							responses: { '200': { description: 'OK' } },
-						},
-					},
-				},
-			};
-
-			const inputPath = join(tempDir, 'openapi.json');
-			await createTestFile(tempDir, 'openapi.json', JSON.stringify(spec));
-
-			const outputPath = join(tempDir, 'nested', 'dir', 'hooks.ts');
-			vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-
-			await generateReactQueryCommand({
-				input: inputPath,
-				output: outputPath,
-			});
-
-			expect(existsSync(outputPath)).toBe(true);
-		});
-
-		it('should generate TypeScript types file', async () => {
-			const spec = {
-				openapi: '3.0.0',
-				info: { title: 'API', version: '1.0.0' },
-				paths: {
-					'/test': {
-						get: {
-							operationId: 'test',
-							responses: { '200': { description: 'OK' } },
-						},
-					},
-				},
-			};
-
-			const inputPath = join(tempDir, 'openapi.json');
-			await createTestFile(tempDir, 'openapi.json', JSON.stringify(spec));
-
-			const outputPath = join(tempDir, 'hooks.ts');
-			vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-
-			await generateReactQueryCommand({
-				input: inputPath,
-				output: outputPath,
-			});
-
-			// Should generate openapi-types.d.ts
-			const typesPath = join(tempDir, 'openapi-types.d.ts');
-			expect(existsSync(typesPath)).toBe(true);
-
-			const typesContent = await readFile(typesPath, 'utf-8');
-			expect(typesContent).toContain('export interface paths');
-		});
-
-		it('should handle operations without operationId', async () => {
-			const spec = {
-				openapi: '3.0.0',
-				info: { title: 'API', version: '1.0.0' },
-				paths: {
-					'/with-id': {
-						get: {
-							operationId: 'withId',
-							responses: { '200': { description: 'OK' } },
-						},
-					},
-					'/without-id': {
-						get: {
-							// No operationId
-							responses: { '200': { description: 'OK' } },
-						},
-					},
-				},
-			};
-
-			const inputPath = join(tempDir, 'openapi.json');
-			await createTestFile(tempDir, 'openapi.json', JSON.stringify(spec));
-
-			const outputPath = join(tempDir, 'hooks.ts');
-			vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-
-			await generateReactQueryCommand({
-				input: inputPath,
-				output: outputPath,
-			});
-
-			const content = await readFile(outputPath, 'utf-8');
-
-			// Should only generate hook for operation with ID
-			expect(content).toContain('useWithId');
-			expect(content).not.toContain('useWithoutId');
-		});
-
-		it('should log generation progress', async () => {
-			const spec = {
-				openapi: '3.0.0',
-				info: { title: 'API', version: '1.0.0' },
-				paths: {
-					'/test': {
-						get: {
-							operationId: 'test',
-							responses: { '200': { description: 'OK' } },
-						},
-					},
-				},
-			};
-
-			const inputPath = join(tempDir, 'openapi.json');
-			await createTestFile(tempDir, 'openapi.json', JSON.stringify(spec));
-
-			const outputPath = join(tempDir, 'hooks.ts');
-			vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-			const consoleSpy = vi.spyOn(console, 'log');
-
-			await generateReactQueryCommand({
-				input: inputPath,
-				output: outputPath,
-			});
-
-			expect(consoleSpy).toHaveBeenCalledWith(
-				expect.stringContaining('Generating TypeScript types'),
-			);
-			expect(consoleSpy).toHaveBeenCalledWith(
-				expect.stringContaining('React Query hooks generated'),
-			);
-			expect(consoleSpy).toHaveBeenCalledWith(
-				expect.stringContaining('Generated'),
-			);
-			expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('hooks'));
-		});
-
-		it('should handle invalid JSON in OpenAPI spec', async () => {
-			const inputPath = join(tempDir, 'invalid.json');
-			await createTestFile(tempDir, 'invalid.json', 'not valid json {[}]');
-
-			vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-
-			await expect(
-				generateReactQueryCommand({ input: inputPath }),
-			).rejects.toThrow(/React Query generation failed/);
-		});
-
-		it('should use custom API name', async () => {
-			const spec = {
-				openapi: '3.0.0',
-				info: { title: 'API', version: '1.0.0' },
-				paths: {
-					'/test': {
-						get: {
-							operationId: 'test',
-							responses: { '200': { description: 'OK' } },
-						},
-					},
-				},
-			};
-
-			const inputPath = join(tempDir, 'openapi.json');
-			await createTestFile(tempDir, 'openapi.json', JSON.stringify(spec));
-
-			const outputPath = join(tempDir, 'hooks.ts');
-			vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-
-			await generateReactQueryCommand({
-				input: inputPath,
-				output: outputPath,
-				name: 'MyCustomAPI',
-			});
-
-			const content = await readFile(outputPath, 'utf-8');
-
-			expect(content).toContain('mycustomapi');
-		});
-
-		it('should generate hooks with parameters', async () => {
-			const spec = {
-				openapi: '3.0.0',
-				info: { title: 'API', version: '1.0.0' },
-				paths: {
-					'/users/{userId}/posts/{postId}': {
-						get: {
-							operationId: 'getUserPost',
-							parameters: [
-								{ name: 'userId', in: 'path', required: true },
-								{ name: 'postId', in: 'path', required: true },
-								{ name: 'include', in: 'query' },
-							],
-							responses: { '200': { description: 'OK' } },
-						},
-					},
-				},
-			};
-
-			const inputPath = join(tempDir, 'openapi.json');
-			await createTestFile(tempDir, 'openapi.json', JSON.stringify(spec));
-
-			const outputPath = join(tempDir, 'hooks.ts');
-			vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-
-			await generateReactQueryCommand({
-				input: inputPath,
-				output: outputPath,
-			});
-
-			const content = await readFile(outputPath, 'utf-8');
-
-			expect(content).toContain('useGetUserPost');
-			// Should generate hook with params
-			expect(content).toContain('config');
-		});
-
-		it('should generate type exports', async () => {
-			const spec = {
-				openapi: '3.0.0',
-				info: { title: 'API', version: '1.0.0' },
-				paths: {
-					'/users': {
-						get: {
-							operationId: 'getUsers',
-							responses: { '200': { description: 'OK' } },
-						},
-						post: {
-							operationId: 'createUser',
-							responses: { '201': { description: 'Created' } },
-						},
-					},
-				},
-			};
-
-			const inputPath = join(tempDir, 'openapi.json');
-			await createTestFile(tempDir, 'openapi.json', JSON.stringify(spec));
-
-			const outputPath = join(tempDir, 'hooks.ts');
-			vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-
-			await generateReactQueryCommand({
-				input: inputPath,
-				output: outputPath,
-			});
-
-			const content = await readFile(outputPath, 'utf-8');
-
-			expect(content).toContain('Type exports for convenience');
-			expect(content).toContain('GetUsersResponse');
-			expect(content).toContain('CreateUserResponse');
-		});
-
-		it('should handle spec with no paths', async () => {
-			const spec = {
-				openapi: '3.0.0',
-				info: { title: 'API', version: '1.0.0' },
-				paths: {},
-			};
-
-			const inputPath = join(tempDir, 'openapi.json');
-			await createTestFile(tempDir, 'openapi.json', JSON.stringify(spec));
-
-			const outputPath = join(tempDir, 'hooks.ts');
-			vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-
-			await generateReactQueryCommand({
-				input: inputPath,
-				output: outputPath,
-			});
-
-			const content = await readFile(outputPath, 'utf-8');
-
-			// Should still generate base structure
-			expect(content).toContain('createTypedQueryClient');
-			expect(content).toContain('Query Hooks');
-			expect(content).toContain('Mutation Hooks');
-		});
-	});
-});