chore(database-ui): cleanup responses and router code

Author: franklinfollis

packages/cli/src/db-studio/api/http/responses.ts

@@ -1,9 +1,13 @@
 import type { ApiResponse } from "./types.ts";
 
+const SUCCESS_STATUS = 200;
+const ERROR_STATUS = 500;
+const NOT_FOUND_STATUS = 404;
+
 /**
  * Create a JSON response
  */
-export function jsonResponse(data: unknown, status: number = 200): ApiResponse {
+export function jsonResponse(data: unknown, status: number = SUCCESS_STATUS): ApiResponse {
   console.log("returning json response", data);
   return {
     status,
@@ -15,7 +19,7 @@ export function jsonResponse(data: unknown, status: number = 200): ApiResponse {
 /**
  * Create an error response
  */
-export function errorResponse(message: string, status: number = 500): ApiResponse {
+export function errorResponse(message: string, status: number = ERROR_STATUS): ApiResponse {
   return jsonResponse({ error: message }, status);
 }
 
@@ -24,6 +28,12 @@ export function errorResponse(message: string, status: number = 500): ApiRespons
  */
 export function handleDatabaseError(err: unknown, operation: string): ApiResponse {
   const errorMessage = err instanceof Error ? err.message : "Unknown error";
-  return errorResponse(`Failed to ${operation}: ${errorMessage}`, 500);
+  return errorResponse(`Failed to ${operation}: ${errorMessage}`, ERROR_STATUS);
 }
 
+/**
+ * Creates a 404 Not Found response
+ */
+export function notFoundResponse(): ApiResponse {
+  return jsonResponse({ error: "Not Found" }, NOT_FOUND_STATUS);
+}

packages/cli/src/db-studio/api/http/router.ts

@@ -1,26 +1,95 @@
 /**
- * Match a route pattern against a path and extract parameters
+ * Represents a captured route parameter
+ */
+type RouteParameter = {
+  name: string;
+  value: string;
+};
+
+/**
+ * Result of matching a single path segment
+ */
+type SegmentMatchResult = 
+  | { matched: true; parameter: RouteParameter | null }
+  | { matched: false };
+
+/**
+ * Splits a URL path into segments, filtering out empty strings
+ */
+function splitPathIntoSegments(path: string): string[] {
+  return path.split("/").filter(segment => segment.length > 0);
+}
+
+/**
+ * Checks if a pattern segment is a parameter (starts with ':')
+ */
+function isParameterSegment(segment: string): boolean {
+  return segment.startsWith(":");
+}
+
+/**
+ * Extracts the parameter name from a pattern segment (removes the ':' prefix)
+ */
+function extractParameterName(segment: string): string {
+  return segment.slice(1);
+}
+
+/**
+ * Matches a single pattern segment against a path segment
+ * Returns match result indicating success and any captured parameter
+ */
+function matchPathSegment(
+  patternSegment: string,
+  pathSegment: string
+): SegmentMatchResult {
+  if (isParameterSegment(patternSegment)) {
+    return {
+      matched: true,
+      parameter: {
+        name: extractParameterName(patternSegment),
+        value: pathSegment
+      }
+    };
+  }
+  
+  // Literal segment - must match exactly
+  if (patternSegment === pathSegment) {
+    return { matched: true, parameter: null };
+  }
+  
+  return { matched: false };
+}
+
+/**
+ * Matches a route pattern against a path and extracts parameters
+ * 
+ * Pattern segments starting with ':' are treated as parameters.
+ * 
+ * @example
+ * matchRoute("/api/:dbIndex/query", "/api/0/query") 
+ * // Returns: { dbIndex: "0" }
  */
 export function matchRoute(pattern: string, path: string): Record<string, string> | null {
-  const patternParts = pattern.split("/").filter(p => p);
-  const pathParts = path.split("/").filter(p => p);
+  const patternSegments = splitPathIntoSegments(pattern);
+  const pathSegments = splitPathIntoSegments(path);
 
-  if (patternParts.length !== pathParts.length) return null;
+  // Paths must have the same number of segments to match
+  if (patternSegments.length !== pathSegments.length) {
+    return null;
+  }
 
   const params: Record<string, string> = {};
 
-  for (let i = 0; i < patternParts.length; i++) {
-    const patternPart = patternParts[i];
-    const pathPart = pathParts[i];
-
-    if (patternPart.startsWith(":")) {
-      // Parameter segment
-      const paramName = patternPart.slice(1);
-      params[paramName] = pathPart;
-    } else if (patternPart !== pathPart) {
-      // Literal segment doesn't match
+  for (let i = 0; i < patternSegments.length; i++) {
+    const result = matchPathSegment(patternSegments[i], pathSegments[i]);
+    
+    if (!result.matched) {
       return null;
     }
+    
+    if (result.parameter) {
+      params[result.parameter.name] = result.parameter.value;
+    }
   }
 
   return params;

packages/cli/src/db-studio/api/http/server.ts

@@ -2,10 +2,38 @@ import type { DiscoveredDatabase } from "../database.ts";
 import type { ApiResponse, RouteContext, DatabaseConstructor } from "./types.ts";
 import { matchRoute } from "./router.ts";
 import { routes } from "../routes/index.ts";
-import { errorResponse } from "./responses.ts";
+import { errorResponse, notFoundResponse } from "./responses.ts";
 
 /**
- * Handle API requests using Node.js primitives
+ * Extracts the path from a URL, removing query strings
+ */
+function parseUrlPath(url: string): string {
+  return url.split('?')[0];
+}
+
+/**
+ * Attempts to find and execute a matching route handler
+ */
+async function executeMatchingRoute(
+  path: string,
+  method: string,
+  body: string,
+  context: RouteContext
+): Promise<ApiResponse | null> {
+  for (const route of routes) {
+    if (route.method !== method) continue;
+
+    const params = matchRoute(route.pattern, path);
+    if (params) {
+      return await route.handler(params, context, body);
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Main API request handler - routes requests to appropriate handlers
  */
 export async function handleApiRequest(
   url: string,
@@ -14,29 +42,17 @@ export async function handleApiRequest(
   databases: DiscoveredDatabase[],
   Database: DatabaseConstructor
 ): Promise<ApiResponse> {
-  // Parse URL path (remove query string if present)
-  const path = url.split('?')[0];
-
   try {
-    // Try to match against registered routes
+    const path = parseUrlPath(url);
     const context: RouteContext = { databases, Database };
 
-    for (const route of routes) {
-      if (route.method !== method) continue;
-
-      const params = matchRoute(route.pattern, path);
-      if (params) {
-        return await route.handler(params, context, body);
-      }
-    }
-
-    // No route matched - return 404
-    return { status: 404, headers: {}, body: '' };
+    const response = await executeMatchingRoute(path, method, body, context);
+    return response ?? notFoundResponse();
 
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : "Unknown error";
     console.error("Error handling request:", err);
-    return errorResponse(errorMessage, 500);
+    return errorResponse(errorMessage);
   }
 }
 

packages/cli/src/db-studio/api/index.ts

@@ -1,6 +1,8 @@
-import { createServer } from "http";
+import { createServer, IncomingMessage, ServerResponse } from "http";
 import { Database } from "elide:sqlite";
 import { handleApiRequest } from "./http/server.ts";
+import { errorResponse } from "./http/responses.ts";
+import type { ApiResponse } from "./http/types.ts";
 import config from "./config.ts";
 
 /**
@@ -13,50 +15,53 @@ export { Database };
 
 const { port, databases } = config;
 
-// Server options with self-signed certificate for HTTPS/HTTP3
-const certificate = {
-  kind: 'selfSigned',
-  subject: 'localhost'
-};
-
-const options = {
-  elide: {
-    https: { certificate },
-    http3: { certificate },
-  }
-};
-
-// Create HTTP server
-const server = createServer(options, (req, res) => {
-  let body = '';
+/**
+ * Parses the request body from an incoming HTTP request
+ */
+function parseRequestBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    
+    req.on('data', (chunk) => {
+      body += chunk.toString('utf8');
+    });
+    
+    req.on('end', () => resolve(body));
+    req.on('error', (err) => reject(err));
+  });
+}
 
-  req.on('data', (chunk) => {
-    body += chunk.toString('utf8');
+/**
+ * Writes an ApiResponse to the HTTP ServerResponse
+ */
+function writeResponse(res: ServerResponse, response: ApiResponse): void {
+  res.writeHead(response.status, {
+    ...response.headers,
+    'Content-Length': Buffer.byteLength(response.body, 'utf8')
   });
+  res.end(response.body);
+}
 
-  req.on('end', async () => {
-    try {
-      const url = req.url || '/';
-      const method = req.method || 'GET';
+/**
+ * Main request handler - processes incoming HTTP requests
+ */
+async function handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  try {
+    const body = await parseRequestBody(req);
+    const url = req.url || '/';
+    const method = req.method || 'GET';
 
-      const response = await handleApiRequest(url, method, body, databases, Database);
+    const response = await handleApiRequest(url, method, body, databases, Database);
+    writeResponse(res, response);
+  } catch (err) {
+    console.error("Error handling request:", err);
+    const response = errorResponse('Internal server error', 500);
+    writeResponse(res, response);
+  }
+}
 
-      res.writeHead(response.status, {
-        ...response.headers,
-        'Content-Length': Buffer.byteLength(response.body, 'utf8')
-      });
-      res.end(response.body);
-    } catch (err) {
-      console.error("Error handling request:", err);
-      const errorBody = JSON.stringify({ error: 'Internal server error' });
-      res.writeHead(500, {
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(errorBody, 'utf8')
-      });
-      res.end(errorBody);
-    }
-  });
-});
+// Create and configure HTTP server
+const server = createServer(handleRequest);
 
 // Start listening on configured port
 server.listen(port, () => {