@geekmidas/cli 0.9.0 → 0.12.0

package/src/__tests__/EndpointGenerator.hooks.spec.ts

@@ -10,195 +10,195 @@ import type { GeneratedConstruct } from '../generators/Generator';
 const mockEndpoint = e.get('/test').handle(async () => ({ ok: true }));
 
 describe('EndpointGenerator hooks generation', () => {
-  const testOutputDir = join(process.cwd(), '.test-output');
-  let generator: EndpointGenerator;
-
-  // Mock endpoint construct for testing
-  const mockConstruct: GeneratedConstruct<typeof mockEndpoint> = {
-    key: 'testEndpoint',
-    construct: mockEndpoint,
-    path: {
-      relative: '/project/src/endpoints/test.ts',
-      absolute: '/project/src/endpoints/test.ts',
-    },
-  };
-
-  beforeEach(async () => {
-    generator = new EndpointGenerator();
-    await mkdir(testOutputDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    await rm(testOutputDir, { recursive: true, force: true });
-  });
-
-  const baseContext: BuildContext = {
-    envParserPath: '/project/src/config/env.ts',
-    envParserImportPattern: '{ envParser }',
-    loggerPath: '/project/src/config/logger.ts',
-    loggerImportPattern: 'logger',
-  };
-
-  describe('generateAppFile', () => {
-    it('should not include hooks when hooks config is undefined', async () => {
-      await generator.build(baseContext, [mockConstruct], testOutputDir, {
-        provider: 'server',
-      });
-
-      const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
-
-      expect(appContent).not.toContain('serverHooks');
-      expect(appContent).not.toContain('beforeSetup');
-      expect(appContent).not.toContain('afterSetup');
-    });
-
-    it('should include hooks imports when hooks config is provided', async () => {
-      const contextWithHooks: BuildContext = {
-        ...baseContext,
-        hooks: {
-          serverHooksPath: '/project/src/config/hooks.ts',
-        },
-      };
-
-      await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
-        provider: 'server',
-      });
-
-      const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
-
-      expect(appContent).toContain('import * as serverHooks from');
-      expect(appContent).toContain('hooks.ts');
-    });
-
-    it('should include beforeSetup hook call', async () => {
-      const contextWithHooks: BuildContext = {
-        ...baseContext,
-        hooks: {
-          serverHooksPath: '/project/src/config/hooks.ts',
-        },
-      };
-
-      await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
-        provider: 'server',
-      });
-
-      const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
-
-      expect(appContent).toContain(
-        "if (typeof serverHooks.beforeSetup === 'function')",
-      );
-      expect(appContent).toContain(
-        'await serverHooks.beforeSetup(honoApp, { envParser, logger })',
-      );
-    });
-
-    it('should include afterSetup hook call', async () => {
-      const contextWithHooks: BuildContext = {
-        ...baseContext,
-        hooks: {
-          serverHooksPath: '/project/src/config/hooks.ts',
-        },
-      };
-
-      await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
-        provider: 'server',
-      });
-
-      const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
-
-      expect(appContent).toContain(
-        "if (typeof serverHooks.afterSetup === 'function')",
-      );
-      expect(appContent).toContain(
-        'await serverHooks.afterSetup(honoApp, { envParser, logger })',
-      );
-    });
-
-    it('should place telescope before beforeSetup, and beforeSetup before endpoints', async () => {
-      const contextWithHooks: BuildContext = {
-        ...baseContext,
-        hooks: {
-          serverHooksPath: '/project/src/config/hooks.ts',
-        },
-        telescope: {
-          enabled: true,
-          path: '/__telescope',
-          maxEntries: 100,
-          recordBody: true,
-          ignore: [],
-          websocket: false,
-        },
-      };
-
-      await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
-        provider: 'server',
-      });
-
-      const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
-
-      // Use specific patterns to find the actual calls (not imports/comments)
-      const telescopeIndex = appContent.indexOf('createMiddleware(telescope)');
-      const beforeSetupCallIndex = appContent.indexOf(
-        'serverHooks.beforeSetup(honoApp',
-      );
-      const setupEndpointsIndex = appContent.indexOf(
-        'await setupEndpoints(honoApp',
-      );
-
-      expect(telescopeIndex).toBeGreaterThan(0);
-      expect(beforeSetupCallIndex).toBeGreaterThan(0);
-      expect(setupEndpointsIndex).toBeGreaterThan(0);
-      // Telescope middleware first (to capture all requests)
-      expect(telescopeIndex).toBeLessThan(beforeSetupCallIndex);
-      // Then beforeSetup hook
-      expect(beforeSetupCallIndex).toBeLessThan(setupEndpointsIndex);
-    });
-
-    it('should place afterSetup after setupEndpoints', async () => {
-      const contextWithHooks: BuildContext = {
-        ...baseContext,
-        hooks: {
-          serverHooksPath: '/project/src/config/hooks.ts',
-        },
-      };
-
-      await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
-        provider: 'server',
-      });
-
-      const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
-
-      // Use specific patterns to find the actual calls (not imports/comments)
-      const setupEndpointsIndex = appContent.indexOf(
-        'await setupEndpoints(honoApp',
-      );
-      const afterSetupCallIndex = appContent.indexOf(
-        'serverHooks.afterSetup(honoApp',
-      );
-
-      expect(setupEndpointsIndex).toBeGreaterThan(0);
-      expect(afterSetupCallIndex).toBeGreaterThan(0);
-      expect(afterSetupCallIndex).toBeGreaterThan(setupEndpointsIndex);
-    });
-
-    it('should generate correct relative import path for hooks', async () => {
-      const contextWithHooks: BuildContext = {
-        ...baseContext,
-        hooks: {
-          serverHooksPath: join(testOutputDir, '../../src/config/hooks.ts'),
-        },
-      };
-
-      await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
-        provider: 'server',
-      });
-
-      const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
-
-      // Should have a relative import path
-      expect(appContent).toMatch(
-        /import \* as serverHooks from '\.\.\/.*hooks\.ts'/,
-      );
-    });
-  });
+	const testOutputDir = join(process.cwd(), '.test-output');
+	let generator: EndpointGenerator;
+
+	// Mock endpoint construct for testing
+	const mockConstruct: GeneratedConstruct<typeof mockEndpoint> = {
+		key: 'testEndpoint',
+		construct: mockEndpoint,
+		path: {
+			relative: '/project/src/endpoints/test.ts',
+			absolute: '/project/src/endpoints/test.ts',
+		},
+	};
+
+	beforeEach(async () => {
+		generator = new EndpointGenerator();
+		await mkdir(testOutputDir, { recursive: true });
+	});
+
+	afterEach(async () => {
+		await rm(testOutputDir, { recursive: true, force: true });
+	});
+
+	const baseContext: BuildContext = {
+		envParserPath: '/project/src/config/env.ts',
+		envParserImportPattern: '{ envParser }',
+		loggerPath: '/project/src/config/logger.ts',
+		loggerImportPattern: 'logger',
+	};
+
+	describe('generateAppFile', () => {
+		it('should not include hooks when hooks config is undefined', async () => {
+			await generator.build(baseContext, [mockConstruct], testOutputDir, {
+				provider: 'server',
+			});
+
+			const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
+
+			expect(appContent).not.toContain('serverHooks');
+			expect(appContent).not.toContain('beforeSetup');
+			expect(appContent).not.toContain('afterSetup');
+		});
+
+		it('should include hooks imports when hooks config is provided', async () => {
+			const contextWithHooks: BuildContext = {
+				...baseContext,
+				hooks: {
+					serverHooksPath: '/project/src/config/hooks.ts',
+				},
+			};
+
+			await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
+				provider: 'server',
+			});
+
+			const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
+
+			expect(appContent).toContain('import * as serverHooks from');
+			expect(appContent).toContain('hooks.ts');
+		});
+
+		it('should include beforeSetup hook call', async () => {
+			const contextWithHooks: BuildContext = {
+				...baseContext,
+				hooks: {
+					serverHooksPath: '/project/src/config/hooks.ts',
+				},
+			};
+
+			await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
+				provider: 'server',
+			});
+
+			const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
+
+			expect(appContent).toContain(
+				"if (typeof serverHooks.beforeSetup === 'function')",
+			);
+			expect(appContent).toContain(
+				'await serverHooks.beforeSetup(honoApp, { envParser, logger })',
+			);
+		});
+
+		it('should include afterSetup hook call', async () => {
+			const contextWithHooks: BuildContext = {
+				...baseContext,
+				hooks: {
+					serverHooksPath: '/project/src/config/hooks.ts',
+				},
+			};
+
+			await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
+				provider: 'server',
+			});
+
+			const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
+
+			expect(appContent).toContain(
+				"if (typeof serverHooks.afterSetup === 'function')",
+			);
+			expect(appContent).toContain(
+				'await serverHooks.afterSetup(honoApp, { envParser, logger })',
+			);
+		});
+
+		it('should place telescope before beforeSetup, and beforeSetup before endpoints', async () => {
+			const contextWithHooks: BuildContext = {
+				...baseContext,
+				hooks: {
+					serverHooksPath: '/project/src/config/hooks.ts',
+				},
+				telescope: {
+					enabled: true,
+					path: '/__telescope',
+					maxEntries: 100,
+					recordBody: true,
+					ignore: [],
+					websocket: false,
+				},
+			};
+
+			await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
+				provider: 'server',
+			});
+
+			const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
+
+			// Use specific patterns to find the actual calls (not imports/comments)
+			const telescopeIndex = appContent.indexOf('createMiddleware(telescope)');
+			const beforeSetupCallIndex = appContent.indexOf(
+				'serverHooks.beforeSetup(honoApp',
+			);
+			const setupEndpointsIndex = appContent.indexOf(
+				'await setupEndpoints(honoApp',
+			);
+
+			expect(telescopeIndex).toBeGreaterThan(0);
+			expect(beforeSetupCallIndex).toBeGreaterThan(0);
+			expect(setupEndpointsIndex).toBeGreaterThan(0);
+			// Telescope middleware first (to capture all requests)
+			expect(telescopeIndex).toBeLessThan(beforeSetupCallIndex);
+			// Then beforeSetup hook
+			expect(beforeSetupCallIndex).toBeLessThan(setupEndpointsIndex);
+		});
+
+		it('should place afterSetup after setupEndpoints', async () => {
+			const contextWithHooks: BuildContext = {
+				...baseContext,
+				hooks: {
+					serverHooksPath: '/project/src/config/hooks.ts',
+				},
+			};
+
+			await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
+				provider: 'server',
+			});
+
+			const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
+
+			// Use specific patterns to find the actual calls (not imports/comments)
+			const setupEndpointsIndex = appContent.indexOf(
+				'await setupEndpoints(honoApp',
+			);
+			const afterSetupCallIndex = appContent.indexOf(
+				'serverHooks.afterSetup(honoApp',
+			);
+
+			expect(setupEndpointsIndex).toBeGreaterThan(0);
+			expect(afterSetupCallIndex).toBeGreaterThan(0);
+			expect(afterSetupCallIndex).toBeGreaterThan(setupEndpointsIndex);
+		});
+
+		it('should generate correct relative import path for hooks', async () => {
+			const contextWithHooks: BuildContext = {
+				...baseContext,
+				hooks: {
+					serverHooksPath: join(testOutputDir, '../../src/config/hooks.ts'),
+				},
+			};
+
+			await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
+				provider: 'server',
+			});
+
+			const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
+
+			// Should have a relative import path
+			expect(appContent).toMatch(
+				/import \* as serverHooks from '\.\.\/.*hooks\.ts'/,
+			);
+		});
+	});
 });

package/src/__tests__/config.spec.ts

@@ -5,22 +5,22 @@ import { loadConfig } from '../config';
 import { cleanupDir, createTempDir } from './test-helpers';
 
 describe('loadConfig', () => {
-  let tempDir: string;
-  let originalCwd: string;
-
-  beforeEach(async () => {
-    tempDir = await createTempDir();
-    originalCwd = process.cwd();
-    process.chdir(tempDir);
-  });
-
-  afterEach(async () => {
-    process.chdir(originalCwd);
-    await cleanupDir(tempDir);
-  });
-
-  it('should load configuration from gkm.config.ts', async () => {
-    const configContent = `
+	let tempDir: string;
+	let originalCwd: string;
+
+	beforeEach(async () => {
+		tempDir = await createTempDir();
+		originalCwd = process.cwd();
+		process.chdir(tempDir);
+	});
+
+	afterEach(async () => {
+		process.chdir(originalCwd);
+		await cleanupDir(tempDir);
+	});
+
+	it('should load configuration from gkm.config.ts', async () => {
+		const configContent = `
 export default {
   routes: './src/endpoints/**/*.ts',
   functions: './src/functions/**/*.ts',
@@ -29,82 +29,82 @@ export default {
   logger: './src/config/logger',
 };
 `;
-    await writeFile(join(tempDir, 'gkm.config.ts'), configContent);
+		await writeFile(join(tempDir, 'gkm.config.ts'), configContent);
 
-    const config = await loadConfig();
+		const config = await loadConfig();
 
-    expect(config).toEqual({
-      routes: './src/endpoints/**/*.ts',
-      functions: './src/functions/**/*.ts',
-      crons: './src/crons/**/*.ts',
-      envParser: './src/config/env',
-      logger: './src/config/logger',
-    });
-  });
+		expect(config).toEqual({
+			routes: './src/endpoints/**/*.ts',
+			functions: './src/functions/**/*.ts',
+			crons: './src/crons/**/*.ts',
+			envParser: './src/config/env',
+			logger: './src/config/logger',
+		});
+	});
 
-  it('should load configuration from gkm.config.js', async () => {
-    const configContent = `
+	it('should load configuration from gkm.config.js', async () => {
+		const configContent = `
 module.exports = {
   routes: './api/**/*.js',
   envParser: './config/environment',
   logger: './config/logging',
 };
 `;
-    await writeFile(join(tempDir, 'gkm.config.js'), configContent);
+		await writeFile(join(tempDir, 'gkm.config.js'), configContent);
 
-    const config = await loadConfig();
+		const config = await loadConfig();
 
-    expect(config.routes).toBe('./api/**/*.js');
-    expect(config.envParser).toBe('./config/environment');
-    expect(config.logger).toBe('./config/logging');
-  });
+		expect(config.routes).toBe('./api/**/*.js');
+		expect(config.envParser).toBe('./config/environment');
+		expect(config.logger).toBe('./config/logging');
+	});
 
-  it('should handle configuration with only envParser override', async () => {
-    const configContent = `
+	it('should handle configuration with only envParser override', async () => {
+		const configContent = `
 export default {
   envParser: './my-env#myEnvParser',
   logger: './my-logger#myLogger',
 };
 `;
-    await writeFile(join(tempDir, 'gkm.config.ts'), configContent);
+		await writeFile(join(tempDir, 'gkm.config.ts'), configContent);
 
-    const config = await loadConfig();
+		const config = await loadConfig();
 
-    expect(config.envParser).toBe('./my-env#myEnvParser');
-    expect(config.logger).toBe('./my-logger#myLogger');
-  });
+		expect(config.envParser).toBe('./my-env#myEnvParser');
+		expect(config.logger).toBe('./my-logger#myLogger');
+	});
 
-  it('should handle malformed config file gracefully', async () => {
-    const invalidConfigContent = `
+	it('should handle malformed config file gracefully', async () => {
+		const invalidConfigContent = `
 export default {
   routes: './endpoints/**/*.ts'
   // Missing comma - syntax error
   functions: './functions/**/*.ts'
 };
 `;
-    await writeFile(join(tempDir, 'gkm.config.ts'), invalidConfigContent);
+		await writeFile(join(tempDir, 'gkm.config.ts'), invalidConfigContent);
 
-    // Should fall back to defaults when config file has syntax errors
-    await expect(loadConfig()).rejects.toThrow();
-  });
+		// Should fall back to defaults when config file has syntax errors
+		await expect(loadConfig()).rejects.toThrow();
+	});
 
-  it('should prefer .ts config over .js config', async () => {
-    const jsConfigContent = `
+	it('should prefer .ts config over .js config', async () => {
+		const jsConfigContent = `
 module.exports = {
   routes: './js-routes/**/*.js',
 };
 `;
-    const tsConfigContent = `
+		const tsConfigContent = `
 export default {
   routes: './ts-routes/**/*.ts',
 };
 `;
 
-    await writeFile(join(tempDir, 'gkm.config.js'), jsConfigContent);
-    await writeFile(join(tempDir, 'gkm.config.ts'), tsConfigContent);
+		await writeFile(join(tempDir, 'gkm.config.js'), jsConfigContent);
+		await writeFile(join(tempDir, 'gkm.config.ts'), tsConfigContent);
 
-    const config = await loadConfig();
+		const config = await loadConfig();
 
-    expect(config.routes).toBe('./ts-routes/**/*.ts');
-  });
+		expect(config.routes).toBe('./ts-routes/**/*.ts');
+	});
 });