@dotdo/postgres 0.1.0

package/src/worker/health-check-manager.test.ts

@@ -0,0 +1,261 @@
+/**
+ * Health Check Manager Tests
+ *
+ * RED phase tests for health check logic extracted from PostgresDO.
+ * Task: postgres-an18.1 - Add tests for decomposed concerns
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import {
+  HealthCheckManager,
+  createHealthCheckManager,
+  type HealthCheckDependencies,
+} from './health-check-manager'
+
+// Mock PGlite instance
+const createMockPGlite = () => ({
+  query: vi.fn().mockResolvedValue({
+    rows: [],
+    fields: [],
+    affectedRows: 0,
+  }),
+  exec: vi.fn().mockResolvedValue({ rows: [], fields: [] }),
+  close: vi.fn().mockResolvedValue(undefined),
+})
+
+// Mock dependencies
+const createMockDependencies = (): HealthCheckDependencies => ({
+  getPGlite: vi.fn(() => createMockPGlite()),
+  isInitialized: vi.fn(() => true),
+  ensureInitialized: vi.fn().mockResolvedValue(undefined),
+  getShutdownStatus: vi.fn(() => 'running' as const),
+  getQueryStats: vi.fn(() => ({
+    queryCount: 10,
+    totalDurationMs: 500,
+    avgDurationMs: 50,
+    errorCount: 1,
+    lastQueryAt: new Date(),
+  })),
+  getUptime: vi.fn(() => 60000),
+  recordQueryStats: vi.fn(),
+})
+
+describe('HealthCheckManager', () => {
+  let manager: HealthCheckManager
+  let deps: HealthCheckDependencies
+
+  beforeEach(() => {
+    deps = createMockDependencies()
+    manager = createHealthCheckManager(deps)
+  })
+
+  describe('constructor', () => {
+    it('should create a HealthCheckManager instance', () => {
+      expect(manager).toBeInstanceOf(HealthCheckManager)
+    })
+  })
+
+  describe('checkLiveness', () => {
+    it('should return true when PGlite responds', async () => {
+      const mockPGlite = createMockPGlite()
+      mockPGlite.query.mockResolvedValue({
+        rows: [{ alive: 1 }],
+        fields: [],
+        affectedRows: 1,
+      })
+      ;(deps.getPGlite as ReturnType<typeof vi.fn>).mockReturnValue(mockPGlite)
+
+      const result = await manager.checkLiveness()
+
+      expect(result).toBe(true)
+      expect(mockPGlite.query).toHaveBeenCalledWith('SELECT 1 as alive')
+    })
+
+    it('should return false when not initialized', async () => {
+      ;(deps.isInitialized as ReturnType<typeof vi.fn>).mockReturnValue(false)
+
+      const result = await manager.checkLiveness()
+
+      expect(result).toBe(false)
+    })
+
+    it('should return false when query fails', async () => {
+      const mockPGlite = createMockPGlite()
+      mockPGlite.query.mockRejectedValue(new Error('Database error'))
+      ;(deps.getPGlite as ReturnType<typeof vi.fn>).mockReturnValue(mockPGlite)
+
+      const result = await manager.checkLiveness()
+
+      expect(result).toBe(false)
+    })
+  })
+
+  describe('rpcPing', () => {
+    it('should return ok status with duration', async () => {
+      const mockPGlite = createMockPGlite()
+      mockPGlite.query.mockResolvedValue({
+        rows: [{ result: 1 }],
+        fields: [],
+        affectedRows: 1,
+      })
+      ;(deps.getPGlite as ReturnType<typeof vi.fn>).mockReturnValue(mockPGlite)
+
+      const result = await manager.rpcPing()
+
+      expect(result.ok).toBe(true)
+      expect(result.durationMs).toBeDefined()
+      expect(typeof result.durationMs).toBe('number')
+    })
+
+    it('should call ensureInitialized before ping', async () => {
+      const mockPGlite = createMockPGlite()
+      ;(deps.getPGlite as ReturnType<typeof vi.fn>).mockReturnValue(mockPGlite)
+
+      await manager.rpcPing()
+
+      expect(deps.ensureInitialized).toHaveBeenCalled()
+    })
+  })
+
+  describe('rpcVersion', () => {
+    it('should return PostgreSQL version string', async () => {
+      const mockPGlite = createMockPGlite()
+      mockPGlite.query.mockResolvedValue({
+        rows: [{ version: 'PostgreSQL 16.0' }],
+        fields: [{ name: 'version', dataTypeID: 25 }],
+        affectedRows: 1,
+      })
+      ;(deps.getPGlite as ReturnType<typeof vi.fn>).mockReturnValue(mockPGlite)
+
+      const result = await manager.rpcVersion()
+
+      expect(result).toBe('PostgreSQL 16.0')
+    })
+
+    it('should return "unknown" when query fails', async () => {
+      const mockPGlite = createMockPGlite()
+      mockPGlite.query.mockResolvedValue({
+        rows: [],
+        fields: [],
+        affectedRows: 0,
+      })
+      ;(deps.getPGlite as ReturnType<typeof vi.fn>).mockReturnValue(mockPGlite)
+
+      const result = await manager.rpcVersion()
+
+      expect(result).toBe('unknown')
+    })
+  })
+
+  describe('rpcListTables', () => {
+    it('should return list of table names', async () => {
+      const mockPGlite = createMockPGlite()
+      mockPGlite.query.mockResolvedValue({
+        rows: [
+          { tablename: 'users' },
+          { tablename: 'orders' },
+          { tablename: 'products' },
+        ],
+        fields: [{ name: 'tablename', dataTypeID: 25 }],
+        affectedRows: 3,
+      })
+      ;(deps.getPGlite as ReturnType<typeof vi.fn>).mockReturnValue(mockPGlite)
+
+      const result = await manager.rpcListTables()
+
+      expect(result).toEqual(['users', 'orders', 'products'])
+    })
+
+    it('should return empty array when no tables', async () => {
+      const mockPGlite = createMockPGlite()
+      mockPGlite.query.mockResolvedValue({
+        rows: [],
+        fields: [{ name: 'tablename', dataTypeID: 25 }],
+        affectedRows: 0,
+      })
+      ;(deps.getPGlite as ReturnType<typeof vi.fn>).mockReturnValue(mockPGlite)
+
+      const result = await manager.rpcListTables()
+
+      expect(result).toEqual([])
+    })
+  })
+
+  describe('rpcDescribeTable', () => {
+    it('should return table column info', async () => {
+      const mockPGlite = createMockPGlite()
+      mockPGlite.query.mockResolvedValue({
+        rows: [
+          { column_name: 'id', data_type: 'integer', is_nullable: 'NO', column_default: null },
+          { column_name: 'name', data_type: 'text', is_nullable: 'YES', column_default: null },
+          { column_name: 'created_at', data_type: 'timestamp', is_nullable: 'NO', column_default: 'now()' },
+        ],
+        fields: [],
+        affectedRows: 3,
+      })
+      ;(deps.getPGlite as ReturnType<typeof vi.fn>).mockReturnValue(mockPGlite)
+
+      const result = await manager.rpcDescribeTable('users')
+
+      expect(result).toHaveLength(3)
+      expect(result[0]).toEqual({
+        column_name: 'id',
+        data_type: 'integer',
+        is_nullable: false,
+        column_default: null,
+      })
+      expect(result[1]).toEqual({
+        column_name: 'name',
+        data_type: 'text',
+        is_nullable: true,
+        column_default: null,
+      })
+      expect(result[2]).toEqual({
+        column_name: 'created_at',
+        data_type: 'timestamp',
+        is_nullable: false,
+        column_default: 'now()',
+      })
+    })
+
+    it('should query the information_schema with correct table name', async () => {
+      const mockPGlite = createMockPGlite()
+      ;(deps.getPGlite as ReturnType<typeof vi.fn>).mockReturnValue(mockPGlite)
+
+      await manager.rpcDescribeTable('my_table')
+
+      expect(mockPGlite.query).toHaveBeenCalledWith(
+        expect.stringContaining('information_schema.columns'),
+        ['my_table']
+      )
+    })
+  })
+
+  describe('rpcGetStats', () => {
+    it('should return database statistics', async () => {
+      const result = await manager.rpcGetStats()
+
+      expect(result).toEqual({
+        queryCount: 10,
+        totalDurationMs: 500,
+        avgDurationMs: 50,
+        lastQueryAt: expect.any(Date),
+        uptime: 60000,
+        shutdownStatus: 'running',
+      })
+    })
+
+    it('should handle null lastQueryAt', async () => {
+      ;(deps.getQueryStats as ReturnType<typeof vi.fn>).mockReturnValue({
+        queryCount: 0,
+        totalDurationMs: 0,
+        avgDurationMs: 0,
+        errorCount: 0,
+        lastQueryAt: undefined,
+      })
+
+      const result = await manager.rpcGetStats()
+
+      expect(result.lastQueryAt).toBeNull()
+    })
+  })
+})

package/src/worker/health-check-manager.ts

@@ -0,0 +1,231 @@
+/**
+ * Health Check Manager for PostgresDO
+ *
+ * Handles health checks, liveness probes, and database introspection.
+ * Extracted from PostgresDO to reduce class size and separate concerns.
+ *
+ * Task: postgres-an18.2 - Decompose PostgresDO class
+ *
+ * @module worker/health-check-manager
+ */
+
+import type { ShutdownStatus } from './shutdown-manager'
+import type { QueryStats } from './query-stats-manager'
+
+/**
+ * PGlite-like interface for health checks
+ */
+export interface HealthCheckPGlite {
+  query<T = unknown>(
+    sql: string,
+    params?: unknown[]
+  ): Promise<{
+    rows: T[]
+    fields: { name: string; dataTypeID: number }[]
+    affectedRows?: number
+  }>
+}
+
+/**
+ * Dependencies required by HealthCheckManager
+ * This interface allows for dependency injection and testing
+ */
+export interface HealthCheckDependencies {
+  /** Get the PGlite instance */
+  getPGlite: () => HealthCheckPGlite
+  /** Check if PGlite is initialized */
+  isInitialized: () => boolean
+  /** Ensure PGlite is initialized */
+  ensureInitialized: () => Promise<void>
+  /** Get current shutdown status */
+  getShutdownStatus: () => ShutdownStatus
+  /** Get query statistics */
+  getQueryStats: () => QueryStats
+  /** Get uptime in milliseconds */
+  getUptime: () => number
+  /** Record query statistics */
+  recordQueryStats: (durationMs: number, success: boolean) => void
+}
+
+/**
+ * Table column description
+ */
+export interface ColumnDescription {
+  column_name: string
+  data_type: string
+  is_nullable: boolean
+  column_default: string | null
+}
+
+/**
+ * Database statistics
+ */
+export interface DatabaseStats {
+  queryCount: number
+  totalDurationMs: number
+  avgDurationMs: number
+  lastQueryAt: Date | null
+  uptime: number
+  shutdownStatus: ShutdownStatus
+}
+
+/**
+ * HealthCheckManager handles health checks and database introspection for PostgresDO.
+ *
+ * Features:
+ * - Liveness checks (SELECT 1)
+ * - Database version retrieval
+ * - Table listing
+ * - Table schema description
+ * - Statistics retrieval
+ *
+ * @example
+ * ```typescript
+ * const manager = new HealthCheckManager(dependencies)
+ *
+ * // Check if database is alive
+ * const isAlive = await manager.checkLiveness()
+ *
+ * // Get database version
+ * const version = await manager.rpcVersion()
+ *
+ * // List tables
+ * const tables = await manager.rpcListTables()
+ *
+ * // Describe a table
+ * const columns = await manager.rpcDescribeTable('users')
+ * ```
+ */
+export class HealthCheckManager {
+  private deps: HealthCheckDependencies
+
+  constructor(deps: HealthCheckDependencies) {
+    this.deps = deps
+  }
+
+  /**
+   * Check if PGLite is responsive by running a simple query
+   *
+   * @returns true if the database responds, false otherwise
+   */
+  async checkLiveness(): Promise<boolean> {
+    if (!this.deps.isInitialized()) {
+      return false
+    }
+
+    try {
+      const pglite = this.deps.getPGlite()
+      const result = await pglite.query('SELECT 1 as alive')
+      return result.rows.length > 0
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * RPC: Health check ping
+   *
+   * @returns Object with ok status and duration
+   */
+  async rpcPing(): Promise<{ ok: true; durationMs: number }> {
+    await this.deps.ensureInitialized()
+
+    const startTime = performance.now()
+    const pglite = this.deps.getPGlite()
+    await pglite.query('SELECT 1')
+
+    return {
+      ok: true,
+      durationMs: performance.now() - startTime,
+    }
+  }
+
+  /**
+   * RPC: Get database version
+   *
+   * @returns PostgreSQL version string or 'unknown'
+   */
+  async rpcVersion(): Promise<string> {
+    await this.deps.ensureInitialized()
+
+    const pglite = this.deps.getPGlite()
+    const result = await pglite.query<{ version: string }>('SELECT version()')
+    const row = result.rows[0]
+    if (!row) return 'unknown'
+
+    const firstKey = Object.keys(row)[0]
+    return (firstKey ? row[firstKey as keyof typeof row] : null) as string ?? 'unknown'
+  }
+
+  /**
+   * RPC: List all tables in the public schema
+   *
+   * @returns Array of table names
+   */
+  async rpcListTables(): Promise<string[]> {
+    await this.deps.ensureInitialized()
+
+    const pglite = this.deps.getPGlite()
+    const result = await pglite.query<{ tablename: string }>(
+      `SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename`
+    )
+    return result.rows.map((r) => r.tablename)
+  }
+
+  /**
+   * RPC: Get table schema information
+   *
+   * @param tableName - Name of the table to describe
+   * @returns Array of column descriptions
+   */
+  async rpcDescribeTable(tableName: string): Promise<ColumnDescription[]> {
+    await this.deps.ensureInitialized()
+
+    const pglite = this.deps.getPGlite()
+    const result = await pglite.query<{
+      column_name: string
+      data_type: string
+      is_nullable: string
+      column_default: string | null
+    }>(
+      `SELECT column_name, data_type, is_nullable, column_default
+       FROM information_schema.columns
+       WHERE table_schema = 'public' AND table_name = $1
+       ORDER BY ordinal_position`,
+      [tableName]
+    )
+
+    return result.rows.map((r) => ({
+      column_name: r.column_name,
+      data_type: r.data_type,
+      is_nullable: r.is_nullable === 'YES',
+      column_default: r.column_default,
+    }))
+  }
+
+  /**
+   * RPC: Get database statistics
+   *
+   * @returns Database statistics including query counts, durations, and uptime
+   */
+  async rpcGetStats(): Promise<DatabaseStats> {
+    const stats = this.deps.getQueryStats()
+    return {
+      queryCount: stats.queryCount,
+      totalDurationMs: stats.totalDurationMs,
+      avgDurationMs: stats.avgDurationMs,
+      lastQueryAt: stats.lastQueryAt ?? null,
+      uptime: this.deps.getUptime(),
+      shutdownStatus: this.deps.getShutdownStatus(),
+    }
+  }
+}
+
+/**
+ * Create a HealthCheckManager instance
+ */
+export function createHealthCheckManager(
+  deps: HealthCheckDependencies
+): HealthCheckManager {
+  return new HealthCheckManager(deps)
+}