@odvi/create-dtt-framework 0.1.2 → 0.1.5

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

@@ -0,0 +1,75 @@
+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 {
+    // Note: This is a placeholder implementation
+    // In a real setup, you would have an actual edge function deployed
+    // and would invoke it using Supabase's invoke function
+
+    // For now, we'll simulate a successful ping by checking the Supabase connection
+    const { data, error } = await supabaseAdmin
+      .from('_test_connection_')
+      .select('*')
+      .limit(1)
+
+    // Even if the table doesn't exist, if we get a connection error, we know Supabase is reachable
+    // If we get a different error, it means the connection worked
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully pinged Supabase (edge functions placeholder)',
+      data: {
+        note: 'This is a placeholder - deploy an actual edge function to test real functionality',
+        supabaseUrl: env.NEXT_PUBLIC_SUPABASE_URL,
+      },
+    })
+  } 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 {
+    // Note: This is a placeholder implementation
+    // In a real setup, you would invoke an edge function with an auth header
+    // and verify that the function can access and validate the auth token
+
+    // For now, we'll verify that we can create a valid auth header
+    const authHeader = c.req.header('authorization')
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully verified auth header capability (edge functions placeholder)',
+      data: {
+        hasAuthHeader: !!authHeader,
+        note: 'This is a placeholder - deploy an actual edge function to test real functionality',
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to test auth header',
+      },
+      500
+    )
+  }
+})

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

@@ -0,0 +1,45 @@
+import { Hono } from 'hono'
+import { db } from '@/server/db'
+import { sql } from 'drizzle-orm'
+
+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 {
+    // Simple SELECT 1 to verify ORM connection
+    await db.execute(sql`SELECT 1`)
+    
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Drizzle ORM is connected and executing queries',
+      data: {
+        dialect: 'postgres',
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Drizzle ORM 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,67 @@
+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_URL || env.NEXTBANK_API_URL === 'placeholder') {
+    return c.json({
+      status: 'unconfigured',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'NextBank API not configured',
+    })
+  }
+
+  try {
+    const result = await nextbankClient.ping()
+    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
+    )
+  }
+})
+
+nextbankHealthRoutes.get('/auth', async (c) => {
+  const start = performance.now()
+
+  if (!env.NEXTBANK_CLIENT_ID || env.NEXTBANK_CLIENT_ID === 'placeholder') {
+    return c.json({
+      status: 'unconfigured',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'NextBank OAuth not configured',
+    })
+  }
+
+  try {
+    const result = await nextbankClient.authenticate()
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully authenticated with NextBank',
+      data: result,
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Auth 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,
+        database: env.SNOWFLAKE_DATABASE,
+        schema: env.SNOWFLAKE_SCHEMA,
+      },
+    })
+  } 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
+    )
+  }
+})

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

@@ -0,0 +1,163 @@
+import { Hono } from 'hono'
+import { supabaseAdmin } from '@/lib/supabase/admin'
+import { env } from '@/config/env'
+
+const BUCKET_NAME = 'health-check-bucket'
+const TEST_FILE_PATH = 'health-check/test-file.txt'
+
+export const storageHealthRoutes = new Hono()
+
+storageHealthRoutes.post('/upload', async (c) => {
+  const start = performance.now()
+
+  try {
+    // Ensure bucket exists
+    const { data: buckets } = await supabaseAdmin.storage.listBuckets()
+    const bucketExists = buckets?.some((b) => b.name === BUCKET_NAME)
+
+    if (!bucketExists) {
+      // Create bucket if it doesn't exist
+      const { error: createError } = await supabaseAdmin.storage.createBucket(
+        BUCKET_NAME,
+        {
+          public: false,
+        }
+      )
+      if (createError) throw createError
+    }
+
+    // Upload test file
+    const testContent = `Health check test file - ${new Date().toISOString()}`
+    const { data, error } = await supabaseAdmin.storage
+      .from(BUCKET_NAME)
+      .upload(TEST_FILE_PATH, new Blob([testContent], { type: 'text/plain' }), {
+        upsert: true,
+      })
+
+    if (error) throw error
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully uploaded test file to storage',
+      data: {
+        path: data?.path,
+        bucket: BUCKET_NAME,
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to upload to storage',
+      },
+      500
+    )
+  }
+})
+
+storageHealthRoutes.get('/download', async (c) => {
+  const start = performance.now()
+
+  try {
+    // Check if file exists
+    const { data: fileData, error: checkError } = await supabaseAdmin.storage
+      .from(BUCKET_NAME)
+      .list('health-check', {
+        limit: 10,
+      })
+
+    if (checkError) throw checkError
+
+    const testFile = fileData?.find((f) => f.name === 'test-file.txt')
+
+    if (!testFile) {
+      return c.json({
+        status: 'healthy',
+        responseTimeMs: Math.round(performance.now() - start),
+        message: 'Storage connection successful, but no test file found',
+        data: { found: false },
+      })
+    }
+
+    // Get signed URL for download
+    const { data, error } = await supabaseAdmin.storage
+      .from(BUCKET_NAME)
+      .createSignedUrl(TEST_FILE_PATH, 60)
+
+    if (error) throw error
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully generated download URL for test file',
+      data: {
+        found: true,
+        signedUrl: data?.signedUrl,
+        path: TEST_FILE_PATH,
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to download from storage',
+      },
+      500
+    )
+  }
+})
+
+storageHealthRoutes.delete('/delete', async (c) => {
+  const start = performance.now()
+
+  try {
+    // Check if file exists first
+    const { data: fileData, error: checkError } = await supabaseAdmin.storage
+      .from(BUCKET_NAME)
+      .list('health-check', {
+        limit: 10,
+      })
+
+    if (checkError) throw checkError
+
+    const testFile = fileData?.find((f) => f.name === 'test-file.txt')
+
+    if (!testFile) {
+      return c.json({
+        status: 'healthy',
+        responseTimeMs: Math.round(performance.now() - start),
+        message: 'Storage connection successful, but no test file to delete',
+        data: { deleted: false },
+      })
+    }
+
+    // Delete test file
+    const { error } = await supabaseAdmin.storage
+      .from(BUCKET_NAME)
+      .remove([TEST_FILE_PATH])
+
+    if (error) throw error
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully deleted test file from storage',
+      data: {
+        deleted: true,
+        path: TEST_FILE_PATH,
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to delete from storage',
+      },
+      500
+    )
+  }
+})

package/template/src/server/api/routes/users.ts

@@ -0,0 +1,95 @@
+import { Hono } from 'hono'
+import { db } from '@/server/db'
+import { users } from '@/server/db/schema/users'
+import { eq, desc } from 'drizzle-orm'
+
+export const usersRoutes = new Hono()
+
+usersRoutes.get('/', async (c) => {
+  const start = performance.now()
+
+  try {
+    const allUsers = await db
+      .select({
+        id: users.id,
+        email: users.email,
+        firstName: users.firstName,
+        lastName: users.lastName,
+        imageUrl: users.imageUrl,
+        clerkOrgId: users.clerkOrgId,
+        createdAt: users.createdAt,
+        updatedAt: users.updatedAt,
+      })
+      .from(users)
+      .orderBy(desc(users.createdAt))
+      .limit(100)
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully retrieved users',
+      data: {
+        users: allUsers,
+        count: allUsers.length,
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to retrieve users',
+      },
+      500
+    )
+  }
+})
+
+usersRoutes.get('/:id', async (c) => {
+  const start = performance.now()
+  const id = c.req.param('id')
+
+  try {
+    const user = await db
+      .select({
+        id: users.id,
+        email: users.email,
+        firstName: users.firstName,
+        lastName: users.lastName,
+        imageUrl: users.imageUrl,
+        clerkOrgId: users.clerkOrgId,
+        createdAt: users.createdAt,
+        updatedAt: users.updatedAt,
+      })
+      .from(users)
+      .where(eq(users.id, id))
+      .limit(1)
+
+    if (user.length === 0) {
+      return c.json(
+        {
+          status: 'error',
+          responseTimeMs: Math.round(performance.now() - start),
+          error: 'User not found',
+        },
+        404
+      )
+    }
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully retrieved user',
+      data: { user: user[0] },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to retrieve user',
+      },
+      500
+    )
+  }
+})

package/template/src/server/db/index.ts

@@ -0,0 +1,17 @@
+import { drizzle } from 'drizzle-orm/postgres-js'
+import postgres from 'postgres'
+import { env } from '@/config/env'
+import * as schema from './schema'
+
+/**
+ * Cache the database connection in development. This avoids creating a new connection on every HMR
+ * update.
+ */
+const globalForDb = globalThis as unknown as {
+  conn: postgres.Sql | undefined
+}
+
+const conn = globalForDb.conn ?? postgres(env.DATABASE_URL, { prepare: false })
+if (env.NODE_ENV !== 'production') globalForDb.conn = conn
+
+export const db = drizzle(conn, { schema })

package/template/src/server/db/queries/users.ts

@@ -0,0 +1,8 @@
+import { db } from '../index'
+import { users } from '../schema/users'
+import { eq } from 'drizzle-orm'
+
+export async function getUserById(id: string) {
+  const user = await db.select().from(users).where(eq(users.id, id)).limit(1)
+  return user[0] ?? null
+}

package/template/src/server/db/schema/__tests__/health-checks.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import { healthCheckTests, type HealthCheckTest } from '../health-checks';
+
+describe('healthCheckTests schema', () => {
+  it('should have healthCheckTests table defined', () => {
+    expect(healthCheckTests).toBeDefined();
+  });
+
+  it('should export HealthCheckTest type', () => {
+    const healthCheckTest: HealthCheckTest = {
+      id: 'test-uuid',
+      testKey: 'test-key',
+      testValue: 'test-value',
+      createdAt: new Date(),
+    };
+    expect(healthCheckTest).toBeDefined();
+    expect(healthCheckTest.testKey).toBe('test-key');
+  });
+
+  it('should allow HealthCheckTest with null testValue', () => {
+    const healthCheckTest: HealthCheckTest = {
+      id: 'test-uuid',
+      testKey: 'test-key',
+      testValue: null,
+      createdAt: new Date(),
+    };
+    expect(healthCheckTest).toBeDefined();
+    expect(healthCheckTest.testKey).toBe('test-key');
+    expect(healthCheckTest.testValue).toBeNull();
+  });
+});