@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/controllers/channel-installations.ts

@@ -1,409 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import { randomUUID } from "crypto";
-import {
-  ChannelInstallationStore,
-  ChannelInstallation,
-  CreateChannelInstallationRequest,
-  UpdateChannelInstallationRequest,
-  ChannelInstallationType,
-} from "@axiom-lattice/protocols";
-import type { ChannelAdapterRegistry } from "../channels/registry";
-
-/**
- * Controller-scoped deps for channel lifecycle management.
- * Set by the gateway during route registration so that
- * enable/disable/deletion can start/stop live connections.
- */
-let _adapterRegistry: ChannelAdapterRegistry | undefined;
-let _router: { dispatch(msg: unknown): Promise<unknown> } | undefined;
-
-export function setChannelControllerDeps(deps: {
-  adapterRegistry: ChannelAdapterRegistry;
-  router: { dispatch(msg: unknown): Promise<unknown> };
-}): void {
-  _adapterRegistry = deps.adapterRegistry;
-  _router = deps.router;
-}
-
-/**
- * Channel Installation Controller
- * Handles channel installation CRUD operations for Lark/Feishu and future channels
- * All operations are scoped to a tenant ID
- */
-
-/**
- * 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";
-}
-
-/**
- * Channel installation list response
- */
-interface ChannelInstallationListResponse {
-  success: boolean;
-  message: string;
-  data: {
-    records: ChannelInstallation[];
-    total: number;
-  };
-}
-
-/**
- * Channel installation response
- */
-interface ChannelInstallationResponse {
-  success: boolean;
-  message: string;
-  data?: ChannelInstallation;
-}
-
-/**
- * Get channel installation store
- */
-async function getInstallationStore(): Promise<ChannelInstallationStore> {
-  // Use registered store from StoreLatticeManager (supports both PG and in-memory)
-  const { getStoreLattice } = await import("@axiom-lattice/core");
-  const store = getStoreLattice("default", "channelInstallation").store as ChannelInstallationStore | undefined;
-  if (store) return store;
-
-  // Fallback: create PG store directly (legacy path)
-  const { PostgreSQLChannelInstallationStore } = await import("@axiom-lattice/pg-stores");
-  const databaseUrl = process.env.DATABASE_URL;
-  if (!databaseUrl) {
-    throw new Error("DATABASE_URL is required for channel installation store");
-  }
-  return new PostgreSQLChannelInstallationStore({
-    poolConfig: databaseUrl,
-  });
-}
-
-/**
- * Get all channel installations for a tenant
- */
-export async function getChannelInstallationList(
-  request: FastifyRequest<{
-    Querystring: { channel?: ChannelInstallationType };
-  }>,
-  reply: FastifyReply,
-): Promise<ChannelInstallationListResponse> {
-  const tenantId = getTenantId(request);
-  const { channel } = request.query;
-
-  try {
-    const store = await getInstallationStore();
-    const installations = await store.getInstallationsByTenant(tenantId, channel);
-
-    return {
-      success: true,
-      message: "Channel installations retrieved successfully",
-      data: {
-        records: installations,
-        total: installations.length,
-      },
-    };
-  } catch (error) {
-    console.error("Failed to get channel installations:", error);
-    return {
-      success: false,
-      message: "Failed to retrieve channel installations",
-      data: {
-        records: [],
-        total: 0,
-      },
-    };
-  }
-}
-
-/**
- * Get a single channel installation by ID
- */
-export async function getChannelInstallation(
-  request: FastifyRequest<{
-    Params: { installationId: string };
-  }>,
-  reply: FastifyReply,
-): Promise<ChannelInstallationResponse> {
-  const tenantId = getTenantId(request);
-  const { installationId } = request.params;
-
-  try {
-    const store = await getInstallationStore();
-    const installation = await store.getInstallationById(installationId);
-
-    if (!installation) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Channel installation not found",
-      };
-    }
-
-    // Verify tenant access
-    if (installation.tenantId !== tenantId) {
-      reply.code(403);
-      return {
-        success: false,
-        message: "Access denied",
-      };
-    }
-
-    return {
-      success: true,
-      message: "Channel installation retrieved successfully",
-      data: installation,
-    };
-  } catch (error) {
-    console.error("Failed to get channel installation:", error);
-    return {
-      success: false,
-      message: "Failed to retrieve channel installation",
-    };
-  }
-}
-
-/**
- * Create new channel installation
- */
-export async function createChannelInstallation(
-  request: FastifyRequest<{
-    Body: CreateChannelInstallationRequest & { id?: string };
-  }>,
-  reply: FastifyReply,
-): Promise<ChannelInstallationResponse> {
-  const tenantId = getTenantId(request);
-  const body = request.body;
-
-  try {
-    // Validate required fields
-    if (!body.channel) {
-      reply.code(400);
-      return {
-        success: false,
-        message: "Channel type is required",
-      };
-    }
-
-    if (!body.config) {
-      reply.code(400);
-      return {
-        success: false,
-        message: "Configuration is required",
-      };
-    }
-
-    // Validate Lark-specific config
-    if (body.channel === "lark") {
-      const larkConfig = body.config;
-      if (!larkConfig.appId || !larkConfig.appSecret) {
-        reply.code(400);
-        return {
-          success: false,
-          message: "appId and appSecret are required for Lark installations",
-        };
-      }
-      if (!larkConfig.assistantId) {
-        reply.code(400);
-        return {
-          success: false,
-          message: "assistantId is required for Lark installations",
-        };
-      }
-    }
-
-    const store = await getInstallationStore();
-    const installationId = body.id || randomUUID();
-    
-    const installation = await store.createInstallation(
-      tenantId,
-      installationId,
-      body,
-    );
-
-    // Start live connection for channels that need it (e.g. WeChat polling, Lark WS)
-    if (body.enabled !== false && _adapterRegistry) {
-      const adapter = _adapterRegistry.get(body.channel);
-      if (adapter?.connect) {
-        try {
-          await adapter.connect(installation, { router: _router });
-        } catch (err) {
-          console.error("Failed to start channel connection after creation:", err);
-        }
-      }
-    }
-
-    reply.code(201);
-    return {
-      success: true,
-      message: "Channel installation created successfully",
-      data: installation,
-    };
-  } catch (error: any) {
-    console.error("Failed to create channel installation:", error);
-    
-    // Check for duplicate key error
-    if (error.message?.includes("duplicate") || error.code === "23505") {
-      reply.code(409);
-      return {
-        success: false,
-        message: "Channel installation with this ID already exists",
-      };
-    }
-
-    return {
-      success: false,
-      message: "Failed to create channel installation",
-    };
-  }
-}
-
-/**
- * Update channel installation
- */
-export async function updateChannelInstallation(
-  request: FastifyRequest<{
-    Params: { installationId: string };
-    Body: UpdateChannelInstallationRequest;
-  }>,
-  reply: FastifyReply,
-): Promise<ChannelInstallationResponse> {
-  const tenantId = getTenantId(request);
-  const { installationId } = request.params;
-  const body = request.body;
-
-  try {
-    const store = await getInstallationStore();
-
-    // Verify installation exists and belongs to tenant
-    const existing = await store.getInstallationById(installationId);
-    if (!existing) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Channel installation not found",
-      };
-    }
-
-    if (existing.tenantId !== tenantId) {
-      reply.code(403);
-      return {
-        success: false,
-        message: "Access denied",
-      };
-    }
-
-    const installation = await store.updateInstallation(
-      tenantId,
-      installationId,
-      body,
-    );
-
-    if (!installation) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Channel installation not found",
-      };
-    }
-
-    // Handle enable/disable — start/stop live connections
-    if (body.enabled !== undefined && body.enabled !== existing.enabled) {
-      const adapter = _adapterRegistry?.get(existing.channel);
-      if (body.enabled && adapter?.connect) {
-        // Re-connect: pass router deps so the adapter can dispatch messages
-        await adapter.connect(installation, { router: _router });
-      } else if (!body.enabled && adapter?.disconnect) {
-        await adapter.disconnect(installationId);
-      }
-    }
-
-    return {
-      success: true,
-      message: "Channel installation updated successfully",
-      data: installation,
-    };
-  } catch (error) {
-    console.error("Failed to update channel installation:", error);
-    return {
-      success: false,
-      message: "Failed to update channel installation",
-    };
-  }
-}
-
-/**
- * Delete channel installation
- */
-export async function deleteChannelInstallation(
-  request: FastifyRequest<{
-    Params: { installationId: string };
-  }>,
-  reply: FastifyReply,
-): Promise<{ success: boolean; message: string }> {
-  const tenantId = getTenantId(request);
-  const { installationId } = request.params;
-
-  try {
-    const store = await getInstallationStore();
-
-    // Verify installation exists and belongs to tenant
-    const existing = await store.getInstallationById(installationId);
-    if (!existing) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Channel installation not found",
-      };
-    }
-
-    if (existing.tenantId !== tenantId) {
-      reply.code(403);
-      return {
-        success: false,
-        message: "Access denied",
-      };
-    }
-
-    // Disconnect live connection before removing from DB
-    if (_adapterRegistry) {
-      const adapter = _adapterRegistry.get(existing.channel);
-      if (adapter?.disconnect) {
-        try {
-          await adapter.disconnect(installationId);
-        } catch (err) {
-          console.error("Failed to disconnect channel adapter:", err);
-        }
-      }
-    }
-
-    const deleted = await store.deleteInstallation(tenantId, installationId);
-
-    if (!deleted) {
-      reply.code(404);
-      return {
-        success: false,
-        message: "Channel installation not found",
-      };
-    }
-
-    return {
-      success: true,
-      message: "Channel installation deleted successfully",
-    };
-  } catch (error) {
-    console.error("Failed to delete channel installation:", error);
-    return {
-      success: false,
-      message: "Failed to delete channel installation",
-    };
-  }
-}

package/src/controllers/collections.ts

@@ -1,176 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import { CollectionService } from "../services/collection_service";
-import type {
-  Collection,
-  CreateCollectionRequest,
-  UpdateCollectionRequest,
-} from "@axiom-lattice/protocols";
-
-const collectionService = new CollectionService();
-
-function serializeCollection(collection: Collection): any {
-  return {
-    id: collection.id,
-    name: collection.name,
-    label: collection.label,
-    embeddingKey: collection.embeddingKey,
-    schema: collection.schema,
-    entryCount: (collection as any)._entryCount ?? 0,
-    createdAt:
-      collection.createdAt instanceof Date
-        ? collection.createdAt.toISOString()
-        : new Date().toISOString(),
-    updatedAt:
-      collection.updatedAt instanceof Date
-        ? collection.updatedAt.toISOString()
-        : new Date().toISOString(),
-  };
-}
-
-export async function getCollectionList(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<any> {
-  try {
-    const collections = await collectionService.getAllCollections(request);
-    return {
-      success: true,
-      message: "Successfully retrieved collection list",
-      data: {
-        records: collections.map(serializeCollection),
-        total: collections.length,
-      },
-    };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to retrieve collections: ${error.message}`,
-      data: { records: [], total: 0 },
-    });
-  }
-}
-
-export async function getCollection(
-  request: FastifyRequest<{ Params: { name: string } }>,
-  reply: FastifyReply
-): Promise<any> {
-  try {
-    const { name } = request.params;
-    const collection = await collectionService.getCollectionByName(request, name);
-
-    if (!collection) {
-      return reply
-        .status(404)
-        .send({ success: false, message: "Collection not found" });
-    }
-
-    return {
-      success: true,
-      message: "Successfully retrieved collection",
-      data: serializeCollection(collection),
-    };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to retrieve collection: ${error.message}`,
-    });
-  }
-}
-
-export async function createCollection(
-  request: FastifyRequest<{ Body: CreateCollectionRequest }>,
-  reply: FastifyReply
-): Promise<any> {
-  try {
-    const data = request.body;
-    if (!data.name) {
-      return reply
-        .status(400)
-        .send({ success: false, message: "name is required" });
-    }
-    if (!data.label) {
-      return reply
-        .status(400)
-        .send({ success: false, message: "label is required" });
-    }
-    if (!data.embeddingKey) {
-      return reply
-        .status(400)
-        .send({ success: false, message: "embeddingKey is required" });
-    }
-
-    const collection = await collectionService.createCollection(request, data);
-    return reply.status(201).send({
-      success: true,
-      message: "Successfully created collection",
-      data: serializeCollection(collection),
-    });
-  } catch (error: any) {
-    if (error.message?.includes("already exists")) {
-      return reply.status(409).send({ success: false, message: error.message });
-    }
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to create collection: ${error.message}`,
-    });
-  }
-}
-
-export async function updateCollection(
-  request: FastifyRequest<{
-    Params: { name: string };
-    Body: UpdateCollectionRequest;
-  }>,
-  reply: FastifyReply
-): Promise<any> {
-  try {
-    const { name } = request.params;
-    const updates = request.body;
-
-    const collection = await collectionService.updateCollection(
-      request,
-      name,
-      updates
-    );
-
-    if (!collection) {
-      return reply
-        .status(404)
-        .send({ success: false, message: "Collection not found" });
-    }
-
-    return {
-      success: true,
-      message: "Successfully updated collection",
-      data: serializeCollection(collection),
-    };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to update collection: ${error.message}`,
-    });
-  }
-}
-
-export async function deleteCollection(
-  request: FastifyRequest<{ Params: { name: string } }>,
-  reply: FastifyReply
-): Promise<any> {
-  try {
-    const { name } = request.params;
-    const result = await collectionService.deleteCollection(request, name);
-
-    if (!result) {
-      return reply
-        .status(404)
-        .send({ success: false, message: "Collection not found" });
-    }
-
-    return { success: true, message: "Successfully deleted collection" };
-  } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to delete collection: ${error.message}`,
-    });
-  }
-}

package/src/controllers/config.ts

@@ -1,126 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import { configService } from "../config";
-import {
-  setQueueServiceType,
-  QueueServiceType,
-} from "../services/queue_service";
-
-/**
- * Configuration Controller
- * Handles configuration updates from frontend
- */
-
-interface UpdateConfigRequest {
-  Body: {
-    config: Record<string, any>;
-  };
-}
-
-/**
- * Update gateway configuration
- * Accepts JSON config and loads it into environment variables
- */
-export async function updateConfig(
-  request: FastifyRequest<UpdateConfigRequest>,
-  reply: FastifyReply
-) {
-  try {
-    const { config: jsonConfig } = request.body;
-
-    if (!jsonConfig || typeof jsonConfig !== "object") {
-      return reply.status(400).send({
-        success: false,
-        error: "Invalid configuration: config must be an object",
-      });
-    }
-
-    // Update configuration service
-    configService.updateConfig(jsonConfig);
-
-    const warnings: string[] = [];
-    const requiresRestart: string[] = [];
-
-    // Check if port is being changed (requires restart)
-    if (jsonConfig.port !== undefined) {
-      requiresRestart.push("PORT");
-      warnings.push("Port change requires server restart to take effect");
-    }
-
-    // If queue service type is being updated, reconfigure the queue service
-    if (jsonConfig.queueServiceType) {
-      setQueueServiceType(jsonConfig.queueServiceType as QueueServiceType);
-    }
-
-    // If Redis configuration is being updated and queue service is Redis, reconfigure
-    if (
-      (jsonConfig.redisUrl || jsonConfig.redisPassword) &&
-      (process.env.QUEUE_SERVICE_TYPE === "redis" ||
-        jsonConfig.queueServiceType === "redis")
-    ) {
-      // Reconfigure queue service to pick up new Redis settings
-      const currentType =
-        (jsonConfig.queueServiceType as QueueServiceType) ||
-        (process.env.QUEUE_SERVICE_TYPE as QueueServiceType) ||
-        "memory";
-      if (currentType === "redis") {
-        setQueueServiceType("redis");
-      }
-    }
-
-    // Get updated config (without sensitive data)
-    const updatedConfig = configService.getConfig();
-    const safeConfig = {
-      ...updatedConfig,
-      redisPassword: updatedConfig.redisPassword
-        ? "***"
-        : updatedConfig.redisPassword,
-    };
-
-    return reply.send({
-      success: true,
-      message: "Configuration updated successfully",
-      data: safeConfig,
-      warnings: warnings.length > 0 ? warnings : undefined,
-      requiresRestart: requiresRestart.length > 0 ? requiresRestart : undefined,
-    });
-  } catch (error: any) {
-    console.error("Failed to update configuration", {
-      error: error.message,
-      stack: error.stack,
-    });
-    return reply.status(500).send({
-      success: false,
-      error: error.message || "Failed to update configuration",
-    });
-  }
-}
-
-/**
- * Get current gateway configuration
- * Returns current configuration (with sensitive data masked)
- */
-export async function getConfig(request: FastifyRequest, reply: FastifyReply) {
-  try {
-    const currentConfig = configService.getConfig();
-    const safeConfig = {
-      ...currentConfig,
-      redisPassword: currentConfig.redisPassword
-        ? "***"
-        : currentConfig.redisPassword,
-    };
-
-    return reply.send({
-      success: true,
-      data: safeConfig,
-    });
-  } catch (error: any) {
-    console.error("Failed to get configuration", {
-      error: error.message,
-      stack: error.stack,
-    });
-    return reply.status(500).send({
-      success: false,
-      error: error.message || "Failed to get configuration",
-    });
-  }
-}