feat(request): add watch option to request command (#50)

* feat(request): add watch option to request command

* docs(request): tweak description of `watch` option

Author: usualoma

README.md

@@ -156,6 +156,7 @@ hono request [file] [options]
 - `-X, --method <method>` - HTTP method (default: GET)
 - `-d, --data <data>` - Request body data
 - `-H, --header <header>` - Custom headers (can be used multiple times)
+- `-w, --watch` - Watch for changes and resend request
 
 **Examples:**
 

src/commands/optimize/index.ts

@@ -29,9 +29,10 @@ export function optimizeCommand(program: Command) {
       }
 
       const appFilePath = realpathSync(appPath)
-      const app: Hono = await buildAndImportApp(appFilePath, {
+      const buildIterator = buildAndImportApp(appFilePath, {
         external: ['@hono/node-server'],
       })
+      const app: Hono = (await buildIterator.next()).value
 
       let routerName
       let importStatement

src/commands/request/index.test.ts

@@ -24,13 +24,27 @@ describe('requestCommand', () => {
   let mockModules: any
   let mockBuildAndImportApp: any
 
+  const createBuildIterator = (app: Hono) => {
+    const iterator = {
+      next: vi
+        .fn()
+        .mockResolvedValueOnce({ value: app, done: false })
+        .mockResolvedValueOnce({ value: undefined, done: true }),
+      return: vi.fn().mockResolvedValue({ value: undefined, done: true }),
+      [Symbol.asyncIterator]() {
+        return this
+      },
+    }
+    return iterator
+  }
+
   const setupBasicMocks = (appPath: string, mockApp: Hono) => {
     mockModules.existsSync.mockReturnValue(true)
     mockModules.realpathSync.mockReturnValue(appPath)
     mockModules.resolve.mockImplementation((cwd: string, path: string) => {
       return `${cwd}/${path}`
     })
-    mockBuildAndImportApp.mockResolvedValue(mockApp)
+    mockBuildAndImportApp.mockReturnValue(createBuildIterator(mockApp))
   }
 
   beforeEach(async () => {
@@ -67,6 +81,41 @@ describe('requestCommand', () => {
     // Verify resolve was called with correct arguments
     expect(mockModules.resolve).toHaveBeenCalledWith(process.cwd(), 'test-app.js')
 
+    expect(mockBuildAndImportApp).toHaveBeenCalledWith(expectedPath, {
+      external: ['@hono/node-server'],
+      watch: false,
+    })
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      JSON.stringify(
+        {
+          status: 200,
+          body: '{"message":"Hello"}',
+          headers: { 'content-type': 'application/json' },
+        },
+        null,
+        2
+      )
+    )
+  })
+
+  it('should handle GET request to specific file', async () => {
+    const mockApp = new Hono()
+    mockApp.get('/', (c) => c.json({ message: 'Hello' }))
+
+    const expectedPath = 'test-app.js'
+    setupBasicMocks(expectedPath, mockApp)
+
+    await program.parseAsync(['node', 'test', 'request', '-w', '-P', '/', 'test-app.js'])
+
+    // Verify resolve was called with correct arguments
+    expect(mockModules.resolve).toHaveBeenCalledWith(process.cwd(), 'test-app.js')
+
+    expect(mockBuildAndImportApp).toHaveBeenCalledWith(expectedPath, {
+      external: ['@hono/node-server'],
+      watch: true,
+    })
+
     expect(consoleLogSpy).toHaveBeenCalledWith(
       JSON.stringify(
         {
@@ -134,7 +183,7 @@ describe('requestCommand', () => {
     mockModules.resolve.mockImplementation((cwd: string, path: string) => {
       return `${cwd}/${path}`
     })
-    mockBuildAndImportApp.mockResolvedValue(mockApp)
+    mockBuildAndImportApp.mockReturnValue(createBuildIterator(mockApp))
 
     await program.parseAsync(['node', 'test', 'request'])
 

src/commands/request/index.ts

@@ -11,6 +11,7 @@ interface RequestOptions {
   data?: string
   header?: string[]
   path?: string
+  watch: boolean
 }
 
 export function requestCommand(program: Command) {
@@ -21,6 +22,7 @@ export function requestCommand(program: Command) {
     .option('-P, --path <path>', 'Request path', '/')
     .option('-X, --method <method>', 'HTTP method', 'GET')
     .option('-d, --data <data>', 'Request body data')
+    .option('-w, --watch', 'Watch for changes and resend request', false)
     .option(
       '-H, --header <header>',
       'Custom headers',
@@ -31,16 +33,19 @@ export function requestCommand(program: Command) {
     )
     .action(async (file: string | undefined, options: RequestOptions) => {
       const path = options.path || '/'
-      const result = await executeRequest(file, path, options)
-      console.log(JSON.stringify(result, null, 2))
+      const watch = options.watch
+      const buildIterator = getBuildIterator(file, watch)
+      for await (const app of buildIterator) {
+        const result = await executeRequest(app, path, options)
+        console.log(JSON.stringify(result, null, 2))
+      }
     })
 }
 
-export async function executeRequest(
+export function getBuildIterator(
   appPath: string | undefined,
-  requestPath: string,
-  options: RequestOptions
-): Promise<{ status: number; body: string; headers: Record<string, string> }> {
+  watch: boolean
+): AsyncGenerator<Hono> {
   // Determine entry file path
   let entry: string
   let resolvedAppPath: string
@@ -62,14 +67,17 @@ export async function executeRequest(
   }
 
   const appFilePath = realpathSync(resolvedAppPath)
-  const app: Hono = await buildAndImportApp(appFilePath, {
+  return buildAndImportApp(appFilePath, {
     external: ['@hono/node-server'],
+    watch,
   })
+}
 
-  if (!app || typeof app.request !== 'function') {
-    throw new Error('No valid Hono app exported from the file')
-  }
-
+export async function executeRequest(
+  app: Hono,
+  requestPath: string,
+  options: RequestOptions
+): Promise<{ status: number; body: string; headers: Record<string, string> }> {
   // Build request
   const url = new URL(requestPath, 'http://localhost')
   const requestInit: RequestInit = {

src/commands/serve/index.test.ts

@@ -1,26 +1,11 @@
 import { Command } from 'commander'
-import { Hono } from 'hono'
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { execFile } from 'node:child_process'
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 
 // Mock dependencies
-vi.mock('node:fs', () => ({
-  existsSync: vi.fn(),
-  realpathSync: vi.fn(),
-}))
-
-vi.mock('node:path', () => ({
-  extname: vi.fn(),
-  resolve: vi.fn(),
-}))
-
-vi.mock('node:url', () => ({
-  pathToFileURL: vi.fn(),
-}))
-
-vi.mock('esbuild', () => ({
-  build: vi.fn(),
-}))
-
 vi.mock('@hono/node-server', () => ({
   serve: vi.fn(),
 }))
@@ -44,6 +29,7 @@ import { serveCommand } from './index.js'
 
 describe('serveCommand', () => {
   let program: Command
+  let mockEsbuild: any
   let mockModules: any
   let mockServe: any
   let mockShowRoutes: any
@@ -53,15 +39,6 @@ describe('serveCommand', () => {
     program = new Command()
     serveCommand(program)
 
-    // Get mocked modules
-    mockModules = {
-      existsSync: vi.mocked((await import('node:fs')).existsSync),
-      realpathSync: vi.mocked((await import('node:fs')).realpathSync),
-      extname: vi.mocked((await import('node:path')).extname),
-      resolve: vi.mocked((await import('node:path')).resolve),
-      pathToFileURL: vi.mocked((await import('node:url')).pathToFileURL),
-    }
-
     mockServe = vi.mocked((await import('@hono/node-server')).serve)
     mockShowRoutes = vi.mocked((await import('hono/dev')).showRoutes)
 
@@ -81,11 +58,6 @@ describe('serveCommand', () => {
   })
 
   it('should start server with default port', async () => {
-    mockModules.existsSync.mockReturnValue(false)
-    mockModules.resolve.mockImplementation((cwd: string, path: string) => {
-      return `${cwd}/${path}`
-    })
-
     await program.parseAsync(['node', 'test', 'serve'])
 
     // Verify serve was called with default port 7070
@@ -99,11 +71,6 @@ describe('serveCommand', () => {
   })
 
   it('should start server with custom port', async () => {
-    mockModules.existsSync.mockReturnValue(false)
-    mockModules.resolve.mockImplementation((cwd: string, path: string) => {
-      return `${cwd}/${path}`
-    })
-
     await program.parseAsync(['node', 'test', 'serve', '-p', '8080'])
 
     // Verify serve was called with custom port
@@ -117,25 +84,39 @@ describe('serveCommand', () => {
   })
 
   it('should serve app that responds correctly to requests', async () => {
-    const mockApp = new Hono()
-    mockApp.get('/', (c) => c.text('Hello World'))
-    mockApp.get('/api', (c) => c.json({ message: 'API response' }))
-
-    const expectedPath = 'app.js'
-    const absolutePath = `${process.cwd()}/${expectedPath}`
-
-    mockModules.existsSync.mockReturnValue(true)
-    mockModules.realpathSync.mockReturnValue(absolutePath)
-    mockModules.extname.mockReturnValue('.js')
-    mockModules.resolve.mockImplementation((cwd: string, path: string) => {
-      return `${cwd}/${path}`
-    })
-    mockModules.pathToFileURL.mockReturnValue(new URL(`file://${absolutePath}`))
+    const appDir = mkdtempSync(join(tmpdir(), 'hono-cli-serve-test'))
+    mkdirSync(appDir, { recursive: true })
+    const appFile = join(appDir, 'app.ts')
+    writeFileSync(
+      appFile,
+      `
+import { Hono } from 'hono'
+
+const app = new Hono()
+app.get('/', (c) => c.text('Hello World'))
+app.get('/api', (c) => c.json({ message: 'API response' }))
 
-    // Mock the import of JS file
-    vi.doMock(absolutePath, () => ({ default: mockApp }))
+export default app
+`
+    )
+    writeFileSync(
+      join(appDir, 'package.json'),
+      JSON.stringify({
+        type: 'module',
+        dependencies: {
+          hono: 'latest',
+        },
+      })
+    )
+    process.chdir(appDir)
+    await new Promise<void>((resolve) => {
+      const child = execFile('npm', ['install'])
+      child.on('exit', () => {
+        resolve()
+      })
+    })
 
-    await program.parseAsync(['node', 'test', 'serve', 'app.js'])
+    await program.parseAsync(['node', 'test', 'serve', appFile])
 
     // Test the captured fetch function
     const rootRequest = new Request('http://localhost:7070/')
@@ -149,11 +130,6 @@ describe('serveCommand', () => {
   })
 
   it('should return 404 for non-existent routes when no app file exists', async () => {
-    mockModules.existsSync.mockReturnValue(false)
-    mockModules.resolve.mockImplementation((cwd: string, path: string) => {
-      return `${cwd}/${path}`
-    })
-
     await program.parseAsync(['node', 'test', 'serve'])
 
     // Test 404 behavior with default empty app
@@ -181,11 +157,6 @@ describe('serveCommand', () => {
   })
 
   it('should handle typical use case: basicAuth + proxy to ramen-api.dev', async () => {
-    mockModules.existsSync.mockReturnValue(false)
-    mockModules.resolve.mockImplementation((cwd: string, path: string) => {
-      return `${cwd}/${path}`
-    })
-
     // Mock basicAuth middleware
     const mockBasicAuth = vi.fn().mockImplementation(() => {
       return async (c: any, next: any) => {

src/commands/serve/index.ts

@@ -48,9 +48,10 @@ export function serveCommand(program: Command) {
             app = new Hono()
           } else {
             const appFilePath = realpathSync(appPath)
-            app = await buildAndImportApp(appFilePath, {
+            const buildIterator = buildAndImportApp(appFilePath, {
               external: ['@hono/node-server'],
             })
+            app = (await buildIterator.next()).value
           }
         }