feat: include doctor command

Author: UlisesGascon

src/__tests__/cli-commands.test.ts

@@ -0,0 +1,91 @@
+/* eslint-env jest */
+
+import { getVersion, runDoctor } from '../cli-commands.js'
+import { getPackageJson } from '../utils.js'
+import { APIHealthResponse } from '../types.js'
+import nock from 'nock'
+
+const pkg = getPackageJson()
+
+describe('CLI Commands', () => {
+  describe('getVersion', () => {
+    it('should return the correct version information', () => {
+      const result = getVersion()
+
+      expect(result).toEqual({
+        messages: [`Your version is: ${pkg.name}@${pkg.version} (${pkg.license})`],
+        success: true
+      })
+    })
+
+    it('should include the package name, version and license', () => {
+      const result = getVersion()
+      const message = result.messages[0]
+
+      expect(message).toContain(pkg.name)
+      expect(message).toContain(pkg.version)
+      expect(message).toContain(pkg.license)
+    })
+  })
+
+  describe('runDoctor', () => {
+    let apiHealthResponse: APIHealthResponse
+    beforeEach(() => {
+      nock.cleanAll()
+      apiHealthResponse = {
+        status: 'ok',
+        timestamp: new Date().toISOString(),
+        version: '0.1.0-beta3',
+        name: 'visionBoard'
+      }
+    })
+
+    it('should return success when API is available and compatible', async () => {
+      nock('http://localhost:3000')
+        .get('/api/v1/__health')
+        .reply(200, apiHealthResponse)
+
+      const result = await runDoctor()
+
+      expect(result.success).toBe(true)
+      expect(result.messages).toContain('✅ API is available and compatible')
+      expect(result.messages).toHaveLength(1)
+    })
+
+    it('should return failure when API is not available (due connection error)', async () => {
+      nock('http://localhost:3000')
+        .get('/api/v1/__health')
+        .reply(500)
+
+      const result = await runDoctor()
+
+      expect(result.success).toBe(false)
+      expect(result.messages).toContain('❌ Seems like the API is not available')
+      expect(result.messages).toHaveLength(1)
+    })
+
+    it('should return failure when API is not available (due internal error)', async () => {
+      nock('http://localhost:3000')
+        .get('/api/v1/__health')
+        .reply(200, { ...apiHealthResponse, status: 'error' })
+
+      const result = await runDoctor()
+
+      expect(result.success).toBe(false)
+      expect(result.messages).toContain('❌ Seems like the API is not available')
+      expect(result.messages).toHaveLength(1)
+    })
+
+    it('should return failure when API version is not compatible', async () => {
+      nock('http://localhost:3000')
+        .get('/api/v1/__health')
+        .reply(200, { ...apiHealthResponse, version: '0.1.0-beta4' })
+
+      const result = await runDoctor()
+
+      expect(result.success).toBe(false)
+      expect(result.messages).toContain('❌ API version is not compatible')
+      expect(result.messages).toHaveLength(1)
+    })
+  })
+})

src/api-client.ts

@@ -0,0 +1,19 @@
+import { getConfig } from './utils.js'
+import { got } from 'got'
+import { APIHealthResponse } from './types.js'
+
+export const apiClient = () => {
+  const config = getConfig()
+  return got.extend({
+    prefixUrl: `${config.visionBoardInstanceUrl}/api/v1`
+  })
+}
+
+export const getAPIDetails = async (): Promise<APIHealthResponse> => {
+  const client = apiClient()
+  const response = await client.get('__health', { responseType: 'json' })
+  if (response.statusCode !== 200) {
+    throw new Error('Failed to get the data from the API')
+  }
+  return response.body as APIHealthResponse
+}

src/cli-commands.ts

@@ -0,0 +1,38 @@
+import { CommandResult } from './types.js'
+import { isApiAvailable, isApiCompatible, getPackageJson } from './utils.js'
+import { getAPIDetails } from './api-client.js'
+
+const pkg = getPackageJson()
+
+export const getVersion = (): CommandResult => {
+  return {
+    messages: [`Your version is: ${pkg.name}@${pkg.version} (${pkg.license})`],
+    success: true
+  }
+}
+
+export const runDoctor = async (): Promise<CommandResult> => {
+  const messages: string[] = []
+  let success = true
+  try {
+    const details = await getAPIDetails()
+
+    if (!isApiAvailable(details)) {
+      messages.push('❌ Seems like the API is not available')
+      success = false
+    } else if (!isApiCompatible(details)) {
+      messages.push('❌ API version is not compatible')
+      success = false
+    } else {
+      messages.push('✅ API is available and compatible')
+    }
+  } catch (error) {
+    messages.push('❌ Seems like the API is not available')
+    success = false
+  }
+
+  return {
+    messages,
+    success
+  }
+}

src/index.ts

@@ -1,22 +1,25 @@
 #!/usr/bin/env node
 
 import { Command } from 'commander'
-import { fileURLToPath } from 'url'
-import { dirname, join } from 'path'
-import { readFileSync } from 'fs'
 
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'))
+import { handleCommandResult } from './utils.js'
+import { getVersion, runDoctor } from './cli-commands.js'
 
 const program = new Command()
 
 program
   .name('visionboard')
   .command('version')
   .description('Show version information')
-  .action(() => {
-    console.log(`Your version is: ${pkg.name}@${pkg.version} (${pkg.license})`)
+  .action(() => handleCommandResult(getVersion()))
+
+program
+  .command('doctor')
+  .description('Check compatibility and availability with the API')
+  .action(async () => {
+    console.log('Checking API availability...')
+    const result = await runDoctor()
+    handleCommandResult(result)
   })
 
 program.parse(process.argv)

src/types.ts

@@ -19,4 +19,7 @@ export interface Config {
   visionBoardInstanceUrl: string
 }
 
-// Add more interfaces as needed
+export interface CommandResult {
+  messages: string[]
+  success: boolean
+}

src/utils.ts

@@ -1,5 +1,15 @@
 import validator from 'validator'
-import { Config, APIHealthResponse } from './types.js'
+import { Config, APIHealthResponse, CommandResult } from './types.js'
+import { readFileSync } from 'fs'
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+export const getPackageJson = () => {
+  return JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'))
+}
 
 export const getConfig = (): Config => {
   const envUrl = process.env.VISIONBOARD_INSTANCE_URL
@@ -24,3 +34,12 @@ export const isApiCompatible = (details: APIHealthResponse) => {
 export const isApiAvailable = (details: APIHealthResponse) => {
   return details.status === 'ok'
 }
+
+export const handleCommandResult = (result: CommandResult) => {
+  if (result.success) {
+    console.log(result.messages.join('\n'))
+  } else {
+    console.error(result.messages.join('\n'))
+    process.exit(1)
+  }
+}