Merge pull request #236 from Agbeleshe/HelthCheck

feat:Health Check with Dependency Status

Author: Baskarayelu

.eslintrc.json

@@ -1,3 +1,5 @@
 {
+  "extends": "next/core-web-vitals"
+}
     "extends": "next/core-web-vitals"
-}
+}

app/api/auth/login/route.ts

@@ -1,4 +1,11 @@
 import { NextRequest, NextResponse } from 'next/server';
+import { Keypair } from '@stellar/stellar-sdk';
+import { getAndClearNonce } from '@/lib/auth-cache';
+import {
+  createSession,
+  getSessionCookieHeader,
+} from '@/lib/session';
+
 import { Keypair, StrKey } from '@stellar/stellar-sdk';
 import { getNonce, deleteNonce } from '@/lib/auth/nonce-store';
 
@@ -15,6 +22,17 @@ export const runtime = 'nodejs';
  * - message: The nonce that was signed
  * - signature: Base64-encoded signature
  */
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * Wallet-based auth flow:
+ * 1. Frontend: user connects wallet (e.g. Freighter), gets address.
+ * 2. Frontend: GET /api/auth/nonce?address={address} to get a random nonce.
+ * 3. Frontend: sign the hex nonce with wallet, encode as base64.
+ * 4. Frontend: POST /api/auth/login with { address, signature }.
+ * 5. Backend: verify signature with Keypair; create encrypted session cookie.
+ */
 export async function POST(request: NextRequest) {
   try {
     const body = await request.json();
@@ -80,6 +98,25 @@ export async function POST(request: NextRequest) {
       );
     }
 
+    const sealed = await createSession(address);
+    const cookieHeader = getSessionCookieHeader(sealed);
+
+    return new Response(
+      JSON.stringify({ success: true, address, token: sealed }),
+      {
+        status: 200,
+        headers: {
+          'Content-Type': 'application/json',
+          'Set-Cookie': cookieHeader,
+        },
+      }
+    );
+  } catch (err) {
+    console.error('Login error:', err);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
   } catch (error) {
     console.error('Error during login:', error);
     return NextResponse.json(

app/api/v1/health/route.ts

@@ -0,0 +1,76 @@
+import { NextResponse } from 'next/server';
+import * as StellarSdk from '@stellar/stellar-sdk';
+import prisma from '@/lib/db';
+
+/**
+ * Health check endpoint for monitoring system status and connectivity.
+ * GET /api/health (rewritten to /api/v1/health)
+ */
+export async function GET() {
+  const results = {
+    status: 'ok',
+    database: 'ok' as 'ok' | 'error',
+    rpc: 'ok' as 'ok' | 'error',
+    anchor: 'skipped' as 'ok' | 'error' | 'skipped',
+  };
+
+  let criticalFailure = false;
+
+  // 1. Database Check
+  try {
+    // Run a simple query to ensure connectivity
+    await prisma.$queryRaw`SELECT 1`;
+  } catch (error) {
+    console.error('[Health Check] Database connectivity error:', error);
+    results.database = 'error';
+    criticalFailure = true;
+  }
+
+  // 2. Soroban RPC Check
+  try {
+    // Use configured RPC URL or default to public testnet
+    const rpcUrl = process.env.NEXT_PUBLIC_STELLAR_RPC_URL || 
+                   process.env.NEXT_PUBLIC_SOROBAN_RPC_URL || 
+                   'https://soroban-testnet.stellar.org';
+    
+    // Ping the RPC server
+    const server = new StellarSdk.SorobanRpc.Server(rpcUrl);
+    await server.getLatestLedger();
+  } catch (error) {
+    console.error('[Health Check] Soroban RPC connectivity error:', error);
+    results.rpc = 'error';
+    criticalFailure = true;
+  }
+
+  // 3. Anchor Platform Check (Optional)
+  const anchorUrl = process.env.ANCHOR_PLATFORM_URL;
+  if (anchorUrl) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5000); // 5s timeout
+      
+      // Ping the standard Anchor info endpoint
+      const res = await fetch(`${anchorUrl}/info`, { signal: controller.signal });
+      clearTimeout(timeoutId);
+      
+      if (res.ok) {
+        results.anchor = 'ok';
+      } else {
+        console.warn(`[Health Check] Anchor Platform returned status ${res.status}`);
+        results.anchor = 'error';
+      }
+    } catch (error) {
+      console.error('[Health Check] Anchor Platform connectivity error:', error);
+      results.anchor = 'error';
+      // Anchor is optional, so we don't set criticalFailure = true
+    }
+  }
+
+  // Determine final status
+  if (criticalFailure) {
+    results.status = 'unhealthy';
+    return NextResponse.json(results, { status: 503 });
+  }
+
+  return NextResponse.json(results, { status: 200 });
+}

app/api/webhooks/anchor/route.ts

@@ -54,7 +54,7 @@ export async function POST(request: Request) {
 
 // Internal function to handle the business logic
 async function handleAnchorEvent(payload: any) {
-  const { event_type, transaction_id, status } = payload
+  const { event_type, transaction_id } = payload
 
   console.log(
     `[Webhook] Processing event: ${event_type} for tx: ${transaction_id}`

detailed_lint.txt

@@ -16,6 +16,41 @@ info:
 servers:
   - url: /api/v1
     description: v1 base path (local/dev)
+paths:
+  /health:
+    get:
+      summary: Health check
+      description: Returns system status and connectivity for RPC, DB, and optional anchor.
+      responses:
+        '200':
+          description: All critical dependencies are healthy.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HealthStatus'
+        '503':
+          description: One or more critical dependencies are unhealthy.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HealthStatus'
+components:
+  schemas:
+    HealthStatus:
+      type: object
+      properties:
+        status:
+          type: string
+          enum: [ok, unhealthy]
+        database:
+          type: string
+          enum: [ok, error]
+        rpc:
+          type: string
+          enum: [ok, error]
+        anchor:
+          type: string
+          enum: [ok, error, skipped]
   - url: /api
     description: legacy base path (rewrites to v1)