@axiom-lattice/gateway 3.0.2 → 3.0.4

package/src/controllers/database-configs.ts

@@ -1,440 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import {
-  getStoreLattice,
-  sqlDatabaseManager,
-} from "@axiom-lattice/core";
-import type {
-  DatabaseConfigStore,
-  DatabaseConfigEntry,
-  CreateDatabaseConfigRequest,
-  UpdateDatabaseConfigRequest,
-  DatabaseConfig,
-} from "@axiom-lattice/protocols";
-import { randomUUID } from "crypto";
-
-/**
- * Database Config Controller
- * Handles database configuration CRUD operations
- */
-
-/**
- * Get tenant ID from authenticated user context
- * Falls back to request headers for backward compatibility
- */
-function getTenantId(request: FastifyRequest): string {
-  // First try to get from authenticated user context
-  const userTenantId = (request as any).user?.tenantId;
-  if (userTenantId) {
-    return userTenantId;
-  }
-
-  // Fallback to request headers for backward compatibility
-  return (request.headers["x-tenant-id"] as string) || "default";
-}
-
-/**
- * Database config list response
- */
-interface DatabaseConfigListResponse {
-  success: boolean;
-  message: string;
-  data: {
-    records: DatabaseConfigEntry[];
-    total: number;
-  };
-}
-
-/**
- * Database config response
- */
-interface DatabaseConfigResponse {
-  success: boolean;
-  message: string;
-  data?: DatabaseConfigEntry;
-}
-
-/**
- * Test connection response
- */
-interface TestConnectionResponse {
-  success: boolean;
-  message: string;
-  data?: {
-    connected: boolean;
-    latency?: number;
-    error?: string;
-  };
-}
-
-/**
- * Get all database configs for a tenant
- */
-export async function getDatabaseConfigList(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<DatabaseConfigListResponse> {
-  const tenantId = getTenantId(request);
-
-  try {
-    const storeLattice = getStoreLattice("default", "database");
-    const store: DatabaseConfigStore = storeLattice.store;
-
-    const configs = await store.getAllConfigs(tenantId);
-    
-    console.log('Backend: getAllConfigs returned:', configs);
-    if (configs.length > 0) {
-      console.log('Backend: First config key:', configs[0].key);
-    }
-
-    return {
-      success: true,
-      message: "Database configurations retrieved successfully",
-      data: {
-        records: configs,
-        total: configs.length,
-      },
-    };
-  } catch (error) {
-    console.error("Failed to get database configs:", error);
-    return {
-      success: false,
-      message: "Failed to retrieve database configurations",
-      data: {
-        records: [],
-        total: 0,
-      },
-    };
-  }
-}
-
-/**
- * Get database config by key
- */
-export async function getDatabaseConfig(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<DatabaseConfigResponse> {
-  const tenantId = getTenantId(request);
-  const { key } = request.params as { key: string };
-
-  try {
-    const storeLattice = getStoreLattice("default", "database");
-    const store: DatabaseConfigStore = storeLattice.store;
-
-    const config = await store.getConfigByKey(tenantId, key);
-
-    if (!config) {
-      return {
-        success: false,
-        message: "Database configuration not found",
-      };
-    }
-
-    return {
-      success: true,
-      message: "Database configuration retrieved successfully",
-      data: config,
-    };
-  } catch (error) {
-    console.error("Failed to get database config:", error);
-    return {
-      success: false,
-      message: "Failed to retrieve database configuration",
-    };
-  }
-}
-
-/**
- * Create new database config
- */
-export async function createDatabaseConfig(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<DatabaseConfigResponse> {
-  const tenantId = getTenantId(request);
-  const body = request.body as CreateDatabaseConfigRequest & { id?: string };
-
-  try {
-    const storeLattice = getStoreLattice("default", "database");
-    const store: DatabaseConfigStore = storeLattice.store;
-
-    // Check if key already exists
-    const existing = await store.getConfigByKey(tenantId, body.key);
-    if (existing) {
-      reply.code(409);
-      return {
-        success: false,
-        message: "Database configuration with this key already exists",
-      };
-    }
-
-    const id = body.id || randomUUID();
-    const config = await store.createConfig(tenantId, id, body);
-
-    // Auto-register to SqlDatabaseManager
-    try {
-      sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
-    } catch (error) {
-      console.warn("Failed to auto-register database:", error);
-    }
-
-    reply.code(201);
-    return {
-      success: true,
-      message: "Database configuration created successfully",
-      data: config,
-    };
-  } catch (error) {
-    console.error("Failed to create database config:", error);
-    return {
-      success: false,
-      message: "Failed to create database configuration",
-    };
-  }
-}
-
-/**
- * Update database config
- */
-export async function updateDatabaseConfig(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<DatabaseConfigResponse> {
-  const tenantId = getTenantId(request);
-  const { key } = request.params as { key: string };
-  const updates = request.body as Partial<UpdateDatabaseConfigRequest>;
-
-  try {
-    const storeLattice = getStoreLattice("default", "database");
-    const store: DatabaseConfigStore = storeLattice.store;
-
-    const existing = await store.getConfigByKey(tenantId, key);
-    if (!existing) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Database configuration not found",
-      };
-    }
-
-    const updated = await store.updateConfig(tenantId, existing.id, updates);
-
-    if (!updated) {
-      return {
-        success: false,
-        message: "Failed to update database configuration",
-      };
-    }
-
-    // Re-register to SqlDatabaseManager if config changed
-    if (updates.config) {
-      try {
-        sqlDatabaseManager.registerDatabase(tenantId, updated.key, updated.config);
-      } catch (error) {
-        console.warn("Failed to re-register database:", error);
-      }
-    }
-
-    return {
-      success: true,
-      message: "Database configuration updated successfully",
-      data: updated,
-    };
-  } catch (error) {
-    console.error("Failed to update database config:", error);
-    return {
-      success: false,
-      message: "Failed to update database configuration",
-    };
-  }
-}
-
-/**
- * Delete database config by key or id
- */
-export async function deleteDatabaseConfig(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<DatabaseConfigResponse> {
-  const tenantId = getTenantId(request);
-  const { keyOrId } = request.params as { keyOrId: string };
-
-  try {
-    const storeLattice = getStoreLattice("default", "database");
-    const store: DatabaseConfigStore = storeLattice.store;
-
-    console.log('Delete request - keyOrId:', keyOrId);
-
-    // Try to find by key first, then by id
-    let config = await store.getConfigByKey(tenantId, keyOrId);
-    let configKey = keyOrId;
-
-    if (!config) {
-      // Try to find by id
-      config = await store.getConfigById(tenantId, keyOrId);
-      if (config) {
-        configKey = config.key;
-      }
-    }
-
-    if (!config) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Database configuration not found",
-      };
-    }
-
-    console.log('Found config to delete:', { id: config.id, key: config.key });
-
-    const deleted = await store.deleteConfig(tenantId, config.id);
-
-    if (!deleted) {
-      return {
-        success: false,
-        message: "Failed to delete database configuration",
-      };
-    }
-
-    // Remove from SqlDatabaseManager
-    try {
-      if (sqlDatabaseManager.hasDatabase(tenantId, configKey)) {
-        await sqlDatabaseManager.removeDatabase(tenantId, configKey);
-      }
-    } catch (error) {
-      console.warn("Failed to remove from SqlDatabaseManager:", error);
-    }
-
-    return {
-      success: true,
-      message: "Database configuration deleted successfully",
-    };
-  } catch (error) {
-    console.error("Failed to delete database config:", error);
-    return {
-      success: false,
-      message: "Failed to delete database configuration",
-    };
-  }
-}
-
-/**
- * Test database connection
- */
-export async function testDatabaseConnection(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<TestConnectionResponse> {
-  const tenantId = getTenantId(request);
-  const { key } = request.params as { key: string };
-
-  try {
-    const storeLattice = getStoreLattice("default", "database");
-    const store: DatabaseConfigStore = storeLattice.store;
-
-    const config = await store.getConfigByKey(tenantId, key);
-    if (!config) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Database configuration not found",
-      };
-    }
-
-    // Register temporarily for testing
-    const testKey = `__test_${key}_${Date.now()}`;
-    sqlDatabaseManager.registerDatabase(tenantId, testKey, config.config);
-
-    const startTime = Date.now();
-    const db = await sqlDatabaseManager.getDatabase(tenantId, testKey);
-
-    try {
-      // Try to connect and list tables
-      await db.connect();
-      await db.listTables();
-      const latency = Date.now() - startTime;
-
-      // Disconnect gracefully with delay to ensure all operations complete
-      await new Promise(resolve => setTimeout(resolve, 100));
-      await db.disconnect();
-      
-      // Cleanup
-      await sqlDatabaseManager.removeDatabase(tenantId, testKey);
-
-      return {
-        success: true,
-        message: "Connection test successful",
-        data: {
-          connected: true,
-          latency,
-        },
-      };
-    } catch (error) {
-      // Cleanup on error
-      try {
-        await db.disconnect();
-        await sqlDatabaseManager.removeDatabase(tenantId, testKey);
-      } catch { /* cleanup error, ignore */ }
-
-      return {
-        success: true,
-        message: "Connection test failed",
-        data: {
-          connected: false,
-          error: error instanceof Error ? error.message : "Unknown error",
-        },
-      };
-    }
-  } catch (error) {
-    console.error("Failed to test database connection:", error);
-    return {
-      success: false,
-      message: "Failed to test database connection",
-      data: {
-        connected: false,
-        error: error instanceof Error ? error.message : "Unknown error",
-      },
-    };
-  }
-}
-
-/**
- * Register database config routes
- */
-export function registerDatabaseConfigRoutes(app: any): void {
-  // Get all configs
-  app.get(
-    "/api/database-configs",
-    getDatabaseConfigList
-  );
-
-  // Get config by key
-  app.get(
-    "/api/database-configs/:key",
-    getDatabaseConfig
-  );
-
-  // Create config
-  app.post(
-    "/api/database-configs",
-    createDatabaseConfig
-  );
-
-  // Update config
-  app.put(
-    "/api/database-configs/:key",
-    updateDatabaseConfig
-  );
-
-  // Delete config by key or id
-  app.delete(
-    "/api/database-configs/:keyOrId",
-    deleteDatabaseConfig
-  );
-
-  // Test connection
-  app.post(
-    "/api/database-configs/:key/test",
-    testDatabaseConnection
-  );
-}

package/src/controllers/embeddings.ts

@@ -1,22 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import { embeddingsLatticeManager } from "@axiom-lattice/core";
-
-export async function listEmbeddings(
-  _request: FastifyRequest,
-  _reply: FastifyReply
-): Promise<any> {
-  try {
-    const info = embeddingsLatticeManager.getAllEmbeddingsInfo();
-    return {
-      success: true,
-      message: "Successfully retrieved embedding models",
-      data: { records: info, total: info.length },
-    };
-  } catch (error: any) {
-    return {
-      success: false,
-      message: `Failed to retrieve embeddings: ${error.message}`,
-      data: { records: [], total: 0 },
-    };
-  }
-}

package/src/controllers/entries.ts

@@ -1,167 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import { CollectionService } from "../services/collection_service";
-
-const collectionService = new CollectionService();
-
-export async function listEntries(
-  request: FastifyRequest<{ Params: { name: string } }>,
-  reply: FastifyReply
-): Promise<any> {
-  try {
-    const { name } = request.params;
-    const entries = await collectionService.getEntries(request, name);
-    return {
-      success: true,
-      message: "Successfully retrieved entries",
-      data: { records: entries, total: entries.length },
-    };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to retrieve entries: ${error.message}`,
-      data: { records: [], total: 0 },
-    });
-  }
-}
-
-export async function createEntry(
-  request: FastifyRequest<{ Params: { name: string }; Body: { content: string; metadata?: Record<string, unknown> } }>,
-  reply: FastifyReply
-): Promise<any> {
-  try {
-    const { name } = request.params;
-    const data = request.body;
-    if (!data.content) {
-      return reply.status(400).send({ success: false, message: "content is required" });
-    }
-
-    const entry = await collectionService.createEntry(request, name, data);
-    return reply.status(201).send({
-      success: true,
-      message: "Successfully created entry",
-      data: entry,
-    });
-  } catch (error: any) {
-    if (error.message?.includes("not found")) {
-      return reply.status(404).send({ success: false, message: error.message });
-    }
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to create entry: ${error.message}`,
-    });
-  }
-}
-
-export async function getEntry(
-  request: FastifyRequest<{ Params: { name: string; id: string } }>,
-  reply: FastifyReply
-): Promise<any> {
-  try {
-    const { name, id } = request.params;
-    const entry = await collectionService.getEntry(request, name, id);
-
-    if (!entry) {
-      return reply.status(404).send({ success: false, message: "Entry not found" });
-    }
-
-    return {
-      success: true,
-      message: "Successfully retrieved entry",
-      data: entry,
-    };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to retrieve entry: ${error.message}`,
-    });
-  }
-}
-
-export async function updateEntry(
-  request: FastifyRequest<{ Params: { name: string; id: string }; Body: { content?: string; metadata?: Record<string, unknown> } }>,
-  reply: FastifyReply
-): Promise<any> {
-  try {
-    const { name, id } = request.params;
-    const data = request.body;
-
-    const entry = await collectionService.updateEntry(request, name, id, data);
-
-    if (!entry) {
-      return reply.status(404).send({ success: false, message: "Entry not found" });
-    }
-
-    return {
-      success: true,
-      message: "Successfully updated entry",
-      data: entry,
-    };
-  } catch (error: any) {
-    if (error.message?.includes("not found")) {
-      return reply.status(404).send({ success: false, message: error.message });
-    }
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to update entry: ${error.message}`,
-    });
-  }
-}
-
-export async function deleteEntry(
-  request: FastifyRequest<{ Params: { name: string; id: string } }>,
-  reply: FastifyReply
-): Promise<any> {
-  try {
-    const { name, id } = request.params;
-    const result = await collectionService.deleteEntry(request, name, id);
-
-    if (!result) {
-      return reply.status(404).send({ success: false, message: "Entry not found" });
-    }
-
-    return { success: true, message: "Successfully deleted entry" };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to delete entry: ${error.message}`,
-    });
-  }
-}
-
-export async function searchEntries(
-  request: FastifyRequest<{
-    Params: { name: string };
-    Body: { query: string; filter?: Record<string, unknown>; top_k?: number };
-  }>,
-  reply: FastifyReply
-): Promise<any> {
-  try {
-    const { name } = request.params;
-    const { query, filter, top_k } = request.body;
-
-    if (!query) {
-      return reply.status(400).send({ success: false, message: "query is required" });
-    }
-
-    const entries = await collectionService.searchEntries(request, name, {
-      query,
-      filter,
-      top_k,
-    });
-
-    return {
-      success: true,
-      message: "Search completed",
-      data: { records: entries, total: entries.length },
-    };
-  } catch (error: any) {
-    if (error.message?.includes("not found")) {
-      return reply.status(404).send({ success: false, message: error.message });
-    }
-    return reply.status(500).send({
-      success: false,
-      message: `Search failed: ${error.message}`,
-      data: { records: [], total: 0 },
-    });
-  }
-}