@odvi/create-dtt-framework 0.1.3 → 0.1.6

package/template/src/server/api/routes/health/database.ts

@@ -0,0 +1,141 @@
+import { Hono } from 'hono'
+import { supabaseAdmin } from '@/lib/supabase/admin'
+
+export const databaseHealthRoutes = new Hono()
+
+const TEST_KEY = 'health-check-test'
+
+databaseHealthRoutes.post('/write', async (c) => {
+  const start = performance.now()
+
+  try {
+    // Delete any existing test row first
+    await supabaseAdmin.from('health_check_tests').delete().eq('test_key', TEST_KEY)
+
+    // Insert a new test row
+    const { data: result, error } = await supabaseAdmin
+      .from('health_check_tests')
+      .insert({
+        test_key: TEST_KEY,
+        test_value: `test-${Date.now()}`,
+      })
+      .select()
+
+    if (error) throw error
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully wrote test row to database',
+      data: {
+        id: result?.[0]?.id,
+        testKey: result?.[0]?.test_key,
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to write to database',
+      },
+      500
+    )
+  }
+})
+
+databaseHealthRoutes.get('/read', async (c) => {
+  const start = performance.now()
+
+  try {
+    const { data: result, error } = await supabaseAdmin
+      .from('health_check_tests')
+      .select('*')
+      .eq('test_key', TEST_KEY)
+      .limit(1)
+
+    if (error) throw error
+
+    if (!result || result.length === 0) {
+      return c.json({
+        status: 'healthy',
+        responseTimeMs: Math.round(performance.now() - start),
+        message: 'Database connection successful, but no test row found',
+        data: { found: false },
+      })
+    }
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully read test row from database',
+      data: {
+        found: true,
+        id: result[0]?.id,
+        testKey: result[0]?.test_key,
+        createdAt: result[0]?.created_at,
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to read from database',
+      },
+      500
+    )
+  }
+})
+
+databaseHealthRoutes.delete('/delete', async (c) => {
+  const start = performance.now()
+
+  try {
+    // Check if row exists first
+    const { data: result, error: readError } = await supabaseAdmin
+      .from('health_check_tests')
+      .select('*')
+      .eq('test_key', TEST_KEY)
+      .limit(1)
+
+    if (readError) throw readError
+
+    if (!result || result.length === 0) {
+      return c.json({
+        status: 'healthy',
+        responseTimeMs: Math.round(performance.now() - start),
+        message: 'Database connection successful, but no test row to delete',
+        data: { deleted: false },
+      })
+    }
+
+    // Delete the row
+    const { error: deleteError } = await supabaseAdmin
+      .from('health_check_tests')
+      .delete()
+      .eq('test_key', TEST_KEY)
+
+    if (deleteError) throw deleteError
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully deleted test row from database',
+      data: {
+        deleted: true,
+        id: result[0]?.id,
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to delete from database',
+      },
+      500
+    )
+  }
+})
+

package/template/src/server/api/routes/health/edge-functions.ts

@@ -0,0 +1,107 @@
+import { Hono } from 'hono'
+import { supabaseAdmin } from '@/lib/supabase/admin'
+import { env } from '@/config/env'
+
+export const edgeFunctionsHealthRoutes = new Hono()
+
+edgeFunctionsHealthRoutes.get('/ping', async (c) => {
+  const start = performance.now()
+
+  try {
+    // Invoke the 'health-check' edge function
+    const { data, error } = await supabaseAdmin.functions.invoke('health-check', {
+      body: { message: 'ping' },
+    })
+
+    if (error) {
+      // Return detailed error information
+      const errorDetails = error as any
+      return c.json({
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        message: 'Edge Function invocation failed',
+        data: {
+          error: error.message,
+          context: errorDetails.context || 'No context available',
+          hint: 'Ensure the function is deployed: "supabase functions deploy health-check"'
+        }
+      })
+    }
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully invoked edge function',
+      data,
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to ping edge function',
+      },
+      500
+    )
+  }
+})
+
+edgeFunctionsHealthRoutes.get('/auth', async (c) => {
+  const start = performance.now()
+
+  try {
+    // Verify that we can create a valid auth header and invoke the function
+    const authHeader = c.req.header('authorization')
+
+    // If no auth header is provided to the health check endpoint, we can't test the downstream auth
+    if (!authHeader) {
+      return c.json({
+        status: 'warning', // Changed from error to warning/skipped if user isn't logged in
+        responseTimeMs: Math.round(performance.now() - start),
+        message: 'No auth header provided - skipping auth propagation check',
+        data: {
+          skipped: true,
+          reason: 'Client request did not include Authorization header',
+        },
+      })
+    }
+
+    const { data, error } = await supabaseAdmin.functions.invoke('health-check', {
+      body: { message: 'auth-check' },
+      headers: {
+        // We send the auth header in a custom header to verify it can be passed through
+        // We avoid overriding 'Authorization' to prevent Supabase Gateway from rejecting
+        // the request if the Clerk token hasn't been configured in Supabase yet.
+        'x-test-auth': authHeader,
+      },
+    })
+
+    if (error) {
+      // If we get an error from the function, it might be due to auth validation failure
+      // or the function crashing. We want to expose the error message.
+      const errorDetails = error as any
+      throw new Error(`Edge function invocation failed: ${error.message || 'Unknown error'}`)
+    }
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully verified auth header with edge function',
+      data,
+    })
+  } catch (error) {
+    // Check if the error is due to a 401/403 from the function itself (which would come as an error response data if handled,
+    // or thrown if using invoke with certain options, but here likely a re-throw)
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to test auth header',
+        data: {
+           details: error instanceof Error ? error.stack : undefined
+        }
+      },
+      500
+    )
+  }
+})

package/template/src/server/api/routes/health/framework.ts

@@ -0,0 +1,48 @@
+import { Hono } from 'hono'
+import { supabaseAdmin } from '@/lib/supabase/admin'
+
+export const frameworkHealthRoutes = new Hono()
+
+frameworkHealthRoutes.get('/hono', (c) => {
+  const start = performance.now()
+  return c.json({
+    status: 'healthy',
+    responseTimeMs: Math.round(performance.now() - start),
+    message: 'Hono framework is running correctly',
+    data: {
+      version: '4.11.3', // matching package.json
+      environment: process.env.NODE_ENV,
+    },
+  })
+})
+
+frameworkHealthRoutes.get('/drizzle', async (c) => {
+  const start = performance.now()
+  try {
+    // Note: Edge Runtime doesn't support direct Drizzle + postgres.js connection
+    // We check Supabase connection instead as a proxy for DB health
+    const { error } = await supabaseAdmin.from('health_check_tests').select('count').limit(1)
+    
+    if (error) throw error
+    
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Database access via Supabase Client is working (Edge compatible)',
+      data: {
+        mode: 'http-client',
+        platform: 'supabase',
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Database check failed',
+      },
+      500
+    )
+  }
+})
+

package/template/src/server/api/routes/health/index.ts

@@ -0,0 +1,102 @@
+import { Hono } from 'hono'
+import { clerkHealthRoutes } from './clerk'
+import { databaseHealthRoutes } from './database'
+import { storageHealthRoutes } from './storage'
+import { edgeFunctionsHealthRoutes } from './edge-functions'
+import { snowflakeHealthRoutes } from './snowflake'
+import { nextbankHealthRoutes } from './nextbank'
+import { frameworkHealthRoutes } from './framework'
+
+export const healthRoutes = new Hono()
+
+healthRoutes.route('/clerk', clerkHealthRoutes)
+healthRoutes.route('/database', databaseHealthRoutes)
+healthRoutes.route('/storage', storageHealthRoutes)
+healthRoutes.route('/edge', edgeFunctionsHealthRoutes)
+healthRoutes.route('/snowflake', snowflakeHealthRoutes)
+healthRoutes.route('/nextbank', nextbankHealthRoutes)
+healthRoutes.route('/framework', frameworkHealthRoutes)
+
+healthRoutes.get('/all', async (c) => {
+  const start = performance.now()
+  const baseUrl = new URL(c.req.url).origin
+
+  // Define all health check endpoints to call
+  const checks = [
+    { name: 'Clerk User', url: `${baseUrl}/api/health/clerk/user` },
+    { name: 'Clerk Org', url: `${baseUrl}/api/health/clerk/org` },
+    { name: 'Clerk Members', url: `${baseUrl}/api/health/clerk/members` },
+    { name: 'Database Write', url: `${baseUrl}/api/health/database/write`, method: 'POST' as const },
+    { name: 'Database Read', url: `${baseUrl}/api/health/database/read` },
+    { name: 'Database Delete', url: `${baseUrl}/api/health/database/delete`, method: 'DELETE' as const },
+    { name: 'Storage Upload', url: `${baseUrl}/api/health/storage/upload`, method: 'POST' as const },
+    { name: 'Storage Download', url: `${baseUrl}/api/health/storage/download` },
+    { name: 'Storage Delete', url: `${baseUrl}/api/health/storage/delete`, method: 'DELETE' as const },
+    { name: 'Edge Ping', url: `${baseUrl}/api/health/edge/ping` },
+    { name: 'Edge Auth', url: `${baseUrl}/api/health/edge/auth` },
+    { name: 'Snowflake Connect', url: `${baseUrl}/api/health/snowflake/connect` },
+    { name: 'Snowflake Query', url: `${baseUrl}/api/health/snowflake/query` },
+    { name: 'NextBank Ping', url: `${baseUrl}/api/health/nextbank/ping` },
+    { name: 'NextBank Auth', url: `${baseUrl}/api/health/nextbank/auth` },
+  ]
+
+  // Run all checks in parallel
+  const results = await Promise.allSettled(
+    checks.map(async (check) => {
+      const checkStart = performance.now()
+      try {
+        const response = await fetch(check.url, {
+          method: check.method || 'GET',
+          headers: {
+            'Content-Type': 'application/json',
+            // Forward auth header if present
+            ...(c.req.header('authorization') && {
+              authorization: c.req.header('authorization')!,
+            }),
+          },
+        })
+
+        const data = await response.json()
+
+        return {
+          name: check.name,
+          status: response.ok ? data.status || 'healthy' : 'error',
+          responseTimeMs: Math.round(performance.now() - checkStart),
+          httpStatus: response.status,
+          data,
+        }
+      } catch (error) {
+        return {
+          name: check.name,
+          status: 'error',
+          responseTimeMs: Math.round(performance.now() - checkStart),
+          httpStatus: 500,
+          error: error instanceof Error ? error.message : 'Check failed',
+        }
+      }
+    })
+  )
+
+  // Aggregate results by service
+  const services = {
+    clerk: results.filter((r) => r.status === 'fulfilled' && r.value.name.includes('Clerk')),
+    database: results.filter((r) => r.status === 'fulfilled' && r.value.name.includes('Database')),
+    storage: results.filter((r) => r.status === 'fulfilled' && r.value.name.includes('Storage')),
+    edge: results.filter((r) => r.status === 'fulfilled' && r.value.name.includes('Edge')),
+    snowflake: results.filter((r) => r.status === 'fulfilled' && r.value.name.includes('Snowflake')),
+    nextbank: results.filter((r) => r.status === 'fulfilled' && r.value.name.includes('NextBank')),
+  }
+
+  // Determine overall status
+  const allResults = results.map((r) => (r.status === 'fulfilled' ? r.value : null))
+  const hasErrors = allResults.some((r) => r && (r.status === 'error' || r.httpStatus >= 400))
+  const allHealthy = allResults.every((r) => r && r.status === 'healthy')
+
+  return c.json({
+    status: hasErrors ? 'unhealthy' : allHealthy ? 'healthy' : 'partial',
+    responseTimeMs: Math.round(performance.now() - start),
+    timestamp: new Date().toISOString(),
+    services: services,
+    checks: allResults,
+  })
+})

package/template/src/server/api/routes/health/nextbank.ts

@@ -0,0 +1,46 @@
+import { Hono } from 'hono'
+import { nextbankClient } from '@/lib/nextbank/client'
+import { env } from '@/config/env'
+
+export const nextbankHealthRoutes = new Hono()
+
+nextbankHealthRoutes.get('/ping', async (c) => {
+  const start = performance.now()
+
+  if (!env.NEXTBANK_API || env.NEXTBANK_API === 'placeholder') {
+    return c.json({
+      status: 'unconfigured',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'NextBank API not configured',
+    })
+  }
+
+  // Generate fingerprint based on request headers
+  const userAgent = c.req.header('user-agent') || 'unknown'
+  const ipAddress = c.req.header('x-forwarded-for')?.split(',')[0] || 
+                    c.req.header('x-real-ip') || 
+                    '127.0.0.1'
+  const acceptLanguage = c.req.header('accept-language') || ''
+
+  const fingerprintString = `${userAgent}-${ipAddress}-${acceptLanguage}`
+  const fingerprint = Buffer.from(fingerprintString).toString('base64')
+
+  try {
+    const result = await nextbankClient.ping(fingerprint)
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully pinged NextBank API',
+      data: result,
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Ping failed',
+      },
+      500
+    )
+  }
+})

package/template/src/server/api/routes/health/snowflake.ts

@@ -0,0 +1,83 @@
+import { Hono } from 'hono'
+import { connectSnowflake, executeQuery, destroyConnection } from '@/lib/snowflake/client'
+import { env } from '@/config/env'
+
+export const snowflakeHealthRoutes = new Hono()
+
+snowflakeHealthRoutes.get('/connect', async (c) => {
+  const start = performance.now()
+
+  if (!env.SNOWFLAKE_ACCOUNT || env.SNOWFLAKE_ACCOUNT === 'placeholder') {
+    return c.json({
+      status: 'unconfigured',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Snowflake not configured',
+    })
+  }
+
+  try {
+    const connection = await connectSnowflake()
+    await destroyConnection(connection)
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully connected to Snowflake',
+      data: {
+        account: env.SNOWFLAKE_ACCOUNT,
+        warehouse: env.SNOWFLAKE_WAREHOUSE,
+        authenticator: env.SNOWFLAKE_AUTHENTICATOR,
+        role: env.SNOWFLAKE_ROLE,
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Connection failed',
+      },
+      500
+    )
+  }
+})
+
+snowflakeHealthRoutes.get('/query', async (c) => {
+  const start = performance.now()
+
+  if (!env.SNOWFLAKE_ACCOUNT || env.SNOWFLAKE_ACCOUNT === 'placeholder') {
+    return c.json({
+      status: 'unconfigured',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Snowflake not configured',
+    })
+  }
+
+  try {
+    const connection = await connectSnowflake()
+    const rows = await executeQuery<{ CURRENT_TIMESTAMP: string }>(
+      connection,
+      'SELECT CURRENT_TIMESTAMP() as CURRENT_TIMESTAMP'
+    )
+    await destroyConnection(connection)
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Query executed successfully',
+      data: {
+        timestamp: rows[0]?.CURRENT_TIMESTAMP,
+        rowCount: rows.length,
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Query failed',
+      },
+      500
+    )
+  }
+})