@odvi/create-dtt-framework 0.1.2 → 0.1.5

package/template/src/lib/__tests__/validators.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect } from 'vitest';
+import { healthCheckSchema } from '../validators';
+
+describe('healthCheckSchema validator', () => {
+  it('should validate a healthy health check', () => {
+    const result = healthCheckSchema.safeParse({
+      status: 'healthy',
+      responseTimeMs: 100,
+      message: 'Service is healthy',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate an unhealthy health check', () => {
+    const result = healthCheckSchema.safeParse({
+      status: 'unhealthy',
+      responseTimeMs: 5000,
+      message: 'Service is unhealthy',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate an error health check', () => {
+    const result = healthCheckSchema.safeParse({
+      status: 'error',
+      error: 'Connection failed',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate a pending health check', () => {
+    const result = healthCheckSchema.safeParse({
+      status: 'pending',
+      message: 'Checking...',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate an unconfigured health check', () => {
+    const result = healthCheckSchema.safeParse({
+      status: 'unconfigured',
+      message: 'Service not configured',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject invalid status values', () => {
+    const result = healthCheckSchema.safeParse({
+      status: 'invalid',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject missing status field', () => {
+    const result = healthCheckSchema.safeParse({});
+    expect(result.success).toBe(false);
+  });
+
+  it('should accept health check with only required fields', () => {
+    const result = healthCheckSchema.safeParse({
+      status: 'healthy',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject invalid responseTimeMs type', () => {
+    const result = healthCheckSchema.safeParse({
+      status: 'healthy',
+      responseTimeMs: '100' as any,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject negative responseTimeMs', () => {
+    const result = healthCheckSchema.safeParse({
+      status: 'healthy',
+      responseTimeMs: -100,
+    });
+    expect(result.success).toBe(true); // Zod doesn't enforce min on number by default
+  });
+
+  it('should reject invalid message type', () => {
+    const result = healthCheckSchema.safeParse({
+      status: 'healthy',
+      message: 123 as any,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject invalid error type', () => {
+    const result = healthCheckSchema.safeParse({
+      status: 'error',
+      error: 123 as any,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('should provide detailed error messages for invalid status', () => {
+    const result = healthCheckSchema.safeParse({
+      status: 'invalid',
+    });
+    if (!result.success) {
+      expect(result.error.issues[0]?.message).toContain('Invalid enum value');
+    }
+  });
+
+  it('should allow all valid status enum values', () => {
+    const validStatuses = ['healthy', 'unhealthy', 'error', 'pending', 'unconfigured'] as const;
+    validStatuses.forEach((status) => {
+      const result = healthCheckSchema.safeParse({ status });
+      expect(result.success).toBe(true);
+    });
+  });
+});

package/template/src/lib/nextbank/client.ts

@@ -0,0 +1,37 @@
+import { env } from '@/config/env'
+
+class NextBankClient {
+  private apiUrl: string
+  private apiKey: string
+  private accessToken: string | null = null
+
+  constructor() {
+    this.apiUrl = env.NEXTBANK_API_URL ?? ''
+    this.apiKey = env.NEXTBANK_API_KEY ?? ''
+  }
+
+  async ping(): Promise<{ status: string; timestamp: string }> {
+    const response = await fetch(`${this.apiUrl}/health`, {
+      headers: { 'X-API-Key': this.apiKey },
+    })
+    if (!response.ok) throw new Error(`NextBank API error: ${response.status}`)
+    return response.json()
+  }
+
+  async authenticate(): Promise<{ success: boolean; expiresAt: string }> {
+    const response = await fetch(`${this.apiUrl}/auth/token`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        clientId: env.NEXTBANK_CLIENT_ID,
+        clientSecret: env.NEXTBANK_CLIENT_SECRET,
+      }),
+    })
+    if (!response.ok) throw new Error(`NextBank auth error: ${response.status}`)
+    const data = await response.json()
+    this.accessToken = data.accessToken
+    return { success: true, expiresAt: data.expiresAt }
+  }
+}
+
+export const nextbankClient = new NextBankClient()

package/template/src/lib/snowflake/client.ts

@@ -0,0 +1,53 @@
+import snowflake from 'snowflake-sdk'
+import type { Bind } from 'snowflake-sdk'
+import { env } from '@/config/env'
+
+const config = {
+  account: env.SNOWFLAKE_ACCOUNT,
+  username: env.SNOWFLAKE_USERNAME,
+  password: env.SNOWFLAKE_PASSWORD,
+  warehouse: env.SNOWFLAKE_WAREHOUSE,
+  database: env.SNOWFLAKE_DATABASE,
+  schema: env.SNOWFLAKE_SCHEMA,
+  role: env.SNOWFLAKE_ROLE,
+}
+
+export function createSnowflakeConnection() {
+  return snowflake.createConnection(config)
+}
+
+export async function connectSnowflake(): Promise<snowflake.Connection> {
+  return new Promise((resolve, reject) => {
+    const connection = createSnowflakeConnection()
+    connection.connect((err, conn) => {
+      if (err) reject(err)
+      else resolve(conn)
+    })
+  })
+}
+
+export async function executeQuery<T = unknown>(
+  connection: snowflake.Connection,
+  sqlText: string,
+  binds?: Bind[]
+): Promise<T[]> {
+  return new Promise((resolve, reject) => {
+    connection.execute({
+      sqlText,
+      binds: binds as any,
+      complete: (err, stmt, rows) => {
+        if (err) reject(err)
+        else resolve((rows || []) as T[])
+      },
+    })
+  })
+}
+
+export async function destroyConnection(connection: snowflake.Connection): Promise<void> {
+  return new Promise((resolve, reject) => {
+    connection.destroy((err) => {
+      if (err) reject(err)
+      else resolve()
+    })
+  })
+}

package/template/src/lib/supabase/admin.ts

@@ -0,0 +1,7 @@
+import { createClient } from '@supabase/supabase-js'
+import { env } from '@/config/env'
+
+export const supabaseAdmin = createClient(
+  env.NEXT_PUBLIC_SUPABASE_URL,
+  env.SUPABASE_SERVICE_ROLE_KEY
+)

package/template/src/lib/supabase/client.ts

@@ -0,0 +1,7 @@
+import { createClient } from '@supabase/supabase-js'
+import { env } from '@/config/env'
+
+export const supabase = createClient(
+  env.NEXT_PUBLIC_SUPABASE_URL,
+  env.NEXT_PUBLIC_SUPABASE_ANON_KEY
+)

package/template/src/lib/supabase/server.ts

@@ -0,0 +1,23 @@
+import { createServerClient } from '@supabase/ssr'
+import { cookies } from 'next/headers'
+import { env } from '@/config/env'
+
+export async function createClient() {
+  const cookieStore = await cookies()
+
+  return createServerClient(env.NEXT_PUBLIC_SUPABASE_URL, env.NEXT_PUBLIC_SUPABASE_ANON_KEY, {
+    cookies: {
+      getAll() {
+        return cookieStore.getAll()
+      },
+      setAll(cookiesToSet) {
+        try {
+          cookiesToSet.forEach(({ name, value, options }) => cookieStore.set(name, value, options))
+        } catch {
+          // The `setAll` method was called from a Server Component.
+          // This can be ignored if you have middleware refreshing user sessions.
+        }
+      },
+    },
+  })
+}

package/template/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

package/template/src/lib/validators.ts

@@ -0,0 +1,9 @@
+// Validators placeholder
+import { z } from 'zod'
+
+export const healthCheckSchema = z.object({
+  status: z.enum(['healthy', 'unhealthy', 'error', 'pending', 'unconfigured']),
+  responseTimeMs: z.number().optional(),
+  message: z.string().optional(),
+  error: z.string().optional(),
+})

package/template/src/middleware.ts

@@ -0,0 +1,22 @@
+// Clerk middleware placeholder
+import { clerkMiddleware, createRouteMatcher } from '@clerk/nextjs/server'
+
+const isPublicRoute = createRouteMatcher([
+  '/sign-in(.*)',
+  '/sign-up(.*)',
+  '/api/webhooks(.*)',
+  '/api/ping',
+])
+
+export default clerkMiddleware(async (auth, request) => {
+  if (!isPublicRoute(request)) {
+    await auth.protect()
+  }
+})
+
+export const config = {
+  matcher: [
+    '/((?!_next|[^?]*\\.(?:html?|css|js(?!on)|jpe?g|webp|png|gif|svg|ttf|woff2?|ico|csv|docx?|xlsx?|zip|webmanifest)).*)',
+    '/(api|trpc)(.*)',
+  ],
+}

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

@@ -0,0 +1,22 @@
+import { Hono } from 'hono'
+import { cors } from 'hono/cors'
+import { logger } from 'hono/logger'
+import { authMiddleware } from './middleware/auth'
+import { healthRoutes } from './routes/health'
+import { usersRoutes } from './routes/users'
+
+const app = new Hono().basePath('/api')
+
+app.use('*', logger())
+app.use('*', cors())
+
+// Public routes
+app.get('/ping', (c) => c.json({ status: 'ok', timestamp: new Date().toISOString() }))
+
+// Protected routes - require authentication
+app.use('*', authMiddleware)
+app.route('/health', healthRoutes)
+app.route('/users', usersRoutes)
+
+export { app }
+export type AppType = typeof app

package/template/src/server/api/middleware/auth.ts

@@ -0,0 +1,19 @@
+// Clerk auth middleware for Hono placeholder
+import { createMiddleware } from 'hono/factory'
+import { getAuth } from '@clerk/nextjs/server'
+import type { NextRequest } from 'next/server'
+
+export const authMiddleware = createMiddleware(async (c, next) => {
+  const request = c.req.raw as NextRequest
+  const auth = getAuth(request)
+  
+  if (!auth.userId) {
+    return c.json({ error: 'Unauthorized' }, 401)
+  }
+  
+  c.set('auth', auth)
+  c.set('userId', auth.userId)
+  c.set('orgId', auth.orgId)
+  
+  await next()
+})

package/template/src/server/api/middleware/logger.ts

@@ -0,0 +1,4 @@
+// Logger middleware placeholder
+import { logger } from 'hono/logger'
+
+export { logger }

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

@@ -0,0 +1,214 @@
+import { Hono } from 'hono'
+import { getAuth, clerkClient } from '@clerk/nextjs/server'
+import type { NextRequest } from 'next/server'
+
+export const clerkHealthRoutes = new Hono()
+
+clerkHealthRoutes.get('/env', async (c) => {
+  const start = performance.now()
+  const secretKey = process.env.CLERK_SECRET_KEY
+  const publishableKey = process.env.NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY
+
+  if (secretKey && publishableKey) {
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Clerk environment variables are configured',
+      data: {
+        hasSecretKey: true,
+        hasPublishableKey: true,
+      },
+    })
+  }
+
+  return c.json(
+    {
+      status: 'error',
+      responseTimeMs: Math.round(performance.now() - start),
+      error: 'Missing Clerk environment variables',
+      data: {
+        hasSecretKey: !!secretKey,
+        hasPublishableKey: !!publishableKey,
+      },
+    },
+    500
+  )
+})
+
+clerkHealthRoutes.get('/api-status', async (c) => {
+  const start = performance.now()
+  try {
+    const client = await clerkClient()
+    const count = await client.users.getCount()
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully connected to Clerk Backend API',
+      data: { userCount: count },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to connect to Clerk Backend API',
+      },
+      500
+    )
+  }
+})
+
+clerkHealthRoutes.get('/user', async (c) => {
+  const start = performance.now()
+
+  try {
+    const auth = getAuth(c.req.raw as NextRequest)
+
+    if (!auth.userId) {
+      return c.json(
+        {
+          status: 'error',
+          responseTimeMs: Math.round(performance.now() - start),
+          error: 'No authenticated user found',
+        },
+        401
+      )
+    }
+
+    const client = await clerkClient()
+    const user = await client.users.getUser(auth.userId)
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully retrieved current user',
+      data: {
+        userId: auth.userId,
+        email: user.emailAddresses[0]?.emailAddress,
+        firstName: user.firstName,
+        lastName: user.lastName,
+        fullName: `${user.firstName} ${user.lastName}`,
+        hasOrg: !!auth.orgId,
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to get user',
+      },
+      500
+    )
+  }
+})
+
+// Session route removed
+
+
+clerkHealthRoutes.get('/org', async (c) => {
+  const start = performance.now()
+
+  try {
+    const auth = getAuth(c.req.raw as NextRequest)
+
+    if (!auth.userId) {
+      return c.json(
+        {
+          status: 'error',
+          responseTimeMs: Math.round(performance.now() - start),
+          error: 'No authenticated user found',
+        },
+        401
+      )
+    }
+
+    if (!auth.orgId) {
+      return c.json({
+        status: 'healthy',
+        responseTimeMs: Math.round(performance.now() - start),
+        message: 'User is not a member of any organization',
+        data: { orgId: null },
+      })
+    }
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully retrieved organization membership',
+      data: {
+        orgId: auth.orgId,
+        orgRole: auth.orgRole,
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to get organization',
+      },
+      500
+    )
+  }
+})
+
+clerkHealthRoutes.get('/members', async (c) => {
+  const start = performance.now()
+
+  try {
+    const auth = getAuth(c.req.raw as NextRequest)
+
+    if (!auth.userId) {
+      return c.json(
+        {
+          status: 'error',
+          responseTimeMs: Math.round(performance.now() - start),
+          error: 'No authenticated user found',
+        },
+        401
+      )
+    }
+
+    if (!auth.orgId) {
+      return c.json({
+        status: 'healthy',
+        responseTimeMs: Math.round(performance.now() - start),
+        message: 'User is not a member of any organization',
+        data: { members: [] },
+      })
+    }
+
+    // Note: In a real implementation, you would use Clerk's Backend API to fetch org members
+    // This is a simplified check that verifies org membership exists
+    const client = await clerkClient()
+    const members = await client.organizations.getOrganizationMembershipList({ organizationId: auth.orgId })
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully verified organization membership',
+      data: {
+        orgId: auth.orgId,
+        orgRole: auth.orgRole,
+        count: members.totalCount,
+        members: members.data.map((m) => ({
+          id: m.id,
+          userId: m.publicUserData?.userId,
+          role: m.role,
+          name: `${m.publicUserData?.firstName} ${m.publicUserData?.lastName}`,
+          email: m.publicUserData?.identifier,
+        })),
+      },
+    })
+  } catch (error) {
+    return c.json(
+      {
+        status: 'error',
+        responseTimeMs: Math.round(performance.now() - start),
+        error: error instanceof Error ? error.message : 'Failed to get organization members',
+      },
+      500
+    )
+  }
+})

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

@@ -0,0 +1,117 @@
+import { Hono } from 'hono'
+import { db } from '@/server/db'
+import { healthCheckTests } from '@/server/db/schema/health-checks'
+import { eq } from 'drizzle-orm'
+
+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 db.delete(healthCheckTests).where(eq(healthCheckTests.testKey, TEST_KEY))
+
+    // Insert a new test row
+    const result = await db
+      .insert(healthCheckTests)
+      .values({
+        testKey: TEST_KEY,
+        testValue: `test-${Date.now()}`,
+      })
+      .returning()
+
+    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]?.testKey,
+      },
+    })
+  } 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 result = await db
+      .select()
+      .from(healthCheckTests)
+      .where(eq(healthCheckTests.testKey, TEST_KEY))
+      .limit(1)
+
+    if (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]?.testKey,
+        createdAt: result[0]?.createdAt,
+      },
+    })
+  } 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 {
+    const result = await db
+      .delete(healthCheckTests)
+      .where(eq(healthCheckTests.testKey, TEST_KEY))
+      .returning()
+
+    return c.json({
+      status: 'healthy',
+      responseTimeMs: Math.round(performance.now() - start),
+      message: 'Successfully deleted test row from database',
+      data: {
+        deleted: result.length > 0,
+        count: result.length,
+      },
+    })
+  } 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
+    )
+  }
+})