feat(database-ui): spread server routes and handlers out to separate files

Author: franklinfollis

packages/cli/src/db-studio/api/.dev/dependencies/npm/package-lock.kdl

@@ -0,0 +1 @@
+/Users/francis/code/millpointlabs/elide/elide/packages/cli/src/db-studio/api/package-lock.kdl

packages/cli/src/db-studio/api/.dev/dependencies/npm/package.json

@@ -0,0 +1,13 @@
+{
+    "name": "db-studio-api",
+    "version": "1.0.0",
+    "description": "Database Studio API Server",
+    "main": "index.ts",
+    "scripts": {},
+    "dependencies": {
+        "zod": "4"
+    },
+    "devDependencies": {
+        "@elide-dev/types": "1.0.0-beta10"
+    }
+}

packages/cli/src/db-studio/api/.dev/elide.lock.bin

@@ -9,10 +9,10 @@
  *
  * NOTE: This module does NOT import "elide:sqlite" directly because Elide's
  * module loader can only handle that special protocol in the entry point file.
- * The Database class must be passed from index.tsx.
+ * The Database class must be passed from index.ts.
  */
 
-import { Database, Statement } from "elide:sqlite";
+import type { Database, Statement } from "elide:sqlite";
 
 /**
  * Log SQL queries to console
@@ -167,7 +167,6 @@ export function validateDatabase(db: Database): boolean {
   try {
     // Try a simple query to verify the database is valid
     const sql = "SELECT 1";
-    logQuery(sql);
     const query = db.query(sql);
     query.get();
     return true;

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

@@ -6,7 +6,7 @@ version = "1.0.0"
 description = "Database Studio API Server"
 
 entrypoint {
-  "index.tsx"
+  "index.ts"
 }
 
 dependencies {

packages/cli/src/db-studio/api/elide.pkl

@@ -0,0 +1,18 @@
+import type { ApiResponse, RouteContext, RouteHandler, DatabaseHandler } from "./types.ts";
+import { validateDatabaseIndex } from "../utils/validation.ts";
+
+/**
+ * Middleware that validates database index and provides database instance to handler
+ */
+export function withDatabase(handler: DatabaseHandler): RouteHandler {
+  return async (params: Record<string, string>, context: RouteContext, body: string): Promise<ApiResponse> => {
+    const result = validateDatabaseIndex(params.dbIndex, context.databases);
+    if ("error" in result) return result.error;
+
+    const { database } = result;
+    const db = new context.Database(database.path);
+
+    return handler(params, { ...context, database, db }, body);
+  };
+}
+

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

@@ -0,0 +1,29 @@
+import type { ApiResponse } from "./types.ts";
+
+/**
+ * Create a JSON response
+ */
+export function jsonResponse(data: unknown, status: number = 200): ApiResponse {
+  console.log("returning json response", data);
+  return {
+    status,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(data),
+  };
+}
+
+/**
+ * Create an error response
+ */
+export function errorResponse(message: string, status: number = 500): ApiResponse {
+  return jsonResponse({ error: message }, status);
+}
+
+/**
+ * Handle database operation errors
+ */
+export function handleDatabaseError(err: unknown, operation: string): ApiResponse {
+  const errorMessage = err instanceof Error ? err.message : "Unknown error";
+  return errorResponse(`Failed to ${operation}: ${errorMessage}`, 500);
+}
+

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

@@ -0,0 +1,28 @@
+/**
+ * Match a route pattern against a path and extract parameters
+ */
+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);
+
+  if (patternParts.length !== pathParts.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
+      return null;
+    }
+  }
+
+  return params;
+}
+

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

@@ -0,0 +1,42 @@
+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";
+
+/**
+ * Handle API requests using Node.js primitives
+ */
+export async function handleApiRequest(
+  url: string,
+  method: string,
+  body: string,
+  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 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: '' };
+
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : "Unknown error";
+    console.error("Error handling request:", err);
+    return errorResponse(errorMessage, 500);
+  }
+}
+

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

@@ -0,0 +1,61 @@
+import type { DiscoveredDatabase } from "../database.ts";
+import type { Database } from "elide:sqlite";
+
+/**
+ * Database constructor type
+ */
+export type DatabaseConstructor = typeof Database;
+
+/**
+ * API response structure
+ */
+export type ApiResponse = {
+  status: number;
+  headers: Record<string, string>;
+  body: string;
+};
+
+/**
+ * Context passed to all route handlers
+ */
+export type RouteContext = {
+  databases: DiscoveredDatabase[];
+  Database: DatabaseConstructor;
+};
+
+/**
+ * Route handler function signature
+ */
+export type RouteHandler = (
+  params: Record<string, string>,
+  context: RouteContext,
+  body: string
+) => Promise<ApiResponse>;
+
+/**
+ * Route definition
+ */
+export type Route = {
+  method: string;
+  pattern: string;
+  handler: RouteHandler;
+};
+
+/**
+ * Extended context for database-specific handlers
+ */
+export type DatabaseHandlerContext = {
+  database: DiscoveredDatabase;
+  db: Database;
+  databases: DiscoveredDatabase[];
+};
+
+/**
+ * Database-specific handler function signature
+ */
+export type DatabaseHandler = (
+  params: Record<string, string>,
+  context: DatabaseHandlerContext,
+  body: string
+) => Promise<ApiResponse>;
+