@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/controllers/tools.ts

@@ -1,139 +0,0 @@
-import { FastifyRequest, FastifyReply } from "fastify";
-import { toolLatticeManager } from "@axiom-lattice/core";
-import type {
-  ToolConfig,
-} from "@axiom-lattice/protocols";
-
-/**
- * Tools Controller
- * Handles tool-related operations
- */
-
-/**
- * Tool config meta response interface
- */
-interface ToolConfigMetaResponse {
-  success: boolean;
-  message: string;
-  data: {
-    records: Array<{
-      id: string;
-      name: string;
-      description: string;
-      schema?: any; // Serialized schema
-      returnDirect?: boolean;
-      needUserApprove?: boolean;
-    }>;
-    total: number;
-  };
-}
-
-/**
- * Serialize ZodSchema to JSON-serializable format
- * Attempts to extract schema information for API response
- */
-function serializeSchema(schema: any): any {
-  if (!schema) {
-    return undefined;
-  }
-
-  try {
-    // Try to get JSON schema if available (zod-to-json-schema or similar)
-    if (schema._def) {
-      // For Zod schemas, try to extract basic info
-      const def = schema._def;
-      if (def.typeName === "ZodObject") {
-        // Extract shape information
-        const shape = def.shape();
-        const properties: Record<string, any> = {};
-        const required: string[] = [];
-
-        for (const [key, value] of Object.entries(shape)) {
-          const fieldDef = (value as any)._def;
-          if (fieldDef) {
-            properties[key] = {
-              type: fieldDef.typeName === "ZodString" ? "string" :
-                    fieldDef.typeName === "ZodNumber" ? "number" :
-                    fieldDef.typeName === "ZodBoolean" ? "boolean" :
-                    fieldDef.typeName === "ZodArray" ? "array" :
-                    fieldDef.typeName === "ZodObject" ? "object" : "unknown",
-              description: fieldDef.description,
-            };
-            if (!(value as any).isOptional()) {
-              required.push(key);
-            }
-          }
-        }
-
-        return {
-          type: "object",
-          properties,
-          required: required.length > 0 ? required : undefined,
-        };
-      }
-    }
-
-    // Fallback: return schema description or type name
-    return {
-      type: "object",
-      description: schema.description || "Schema definition",
-    };
-  } catch (error) {
-    // If serialization fails, return a safe fallback
-    return {
-      type: "object",
-      description: "Schema definition",
-    };
-  }
-}
-
-/**
- * Get tool config meta from ToolLatticeManager
- * Exposes tool configuration metadata via /api/tools endpoint
- */
-export async function getToolConfigs(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<ToolConfigMetaResponse> {
-  try {
-    const allLattices = toolLatticeManager.getAllLattices();
-    
-    const toolConfigs = allLattices.map((lattice) => {
-      const config = { ...lattice.config };
-      
-      // Serialize schema if present
-      const serializedSchema = config.schema ? serializeSchema(config.schema) : undefined;
-
-      return {
-        id: lattice.key,
-        name: config.name,
-        description: config.description,
-        schema: serializedSchema,
-        returnDirect: config.returnDirect,
-        needUserApprove: config.needUserApprove,
-      };
-    });
-
-    return reply.send({
-      success: true,
-      message: "Successfully retrieved tool configs",
-      data: {
-        records: toolConfigs,
-        total: toolConfigs.length,
-      },
-    });
-  } catch (error: any) {
-    console.error("Failed to get tool configs", {
-      error: error.message,
-      stack: error.stack,
-    });
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to retrieve tool configs: ${error.message}`,
-      data: {
-        records: [],
-        total: 0,
-      },
-    });
-  }
-}

package/src/controllers/users.ts

@@ -1,135 +0,0 @@
-import { FastifyInstance, FastifyRequest, FastifyReply } from "fastify";
-import { getStoreLattice } from "@axiom-lattice/core";
-import type {
-  CreateUserRequest,
-  UpdateUserRequest,
-} from "@axiom-lattice/protocols";
-import { v4 as uuidv4 } from "uuid";
-
-interface UserParams {
-  userId: string;
-}
-
-interface ListUsersQuery {
-  email?: string;
-}
-
-export class UsersController {
-  private userStore;
-
-  constructor() {
-    this.userStore = getStoreLattice("default", "user").store;
-  }
-
-  async listUsers(
-    request: FastifyRequest<{ Querystring: ListUsersQuery }>,
-    reply: FastifyReply
-  ) {
-    const { email } = request.query;
-
-    if (email) {
-      const user = await this.userStore.getUserByEmail(email);
-      return { success: true, data: user ? [user] : [] };
-    }
-
-    const users = await this.userStore.getAllUsers();
-    return { success: true, data: users };
-  }
-
-  async createUser(
-    request: FastifyRequest<{ Body: CreateUserRequest }>,
-    reply: FastifyReply
-  ) {
-    const data = request.body;
-    const id = uuidv4();
-
-    const existingUser = await this.userStore.getUserByEmail(data.email);
-    if (existingUser) {
-      return reply.status(409).send({
-        success: false,
-        error: `User with email ${data.email} already exists`,
-      });
-    }
-
-    const user = await this.userStore.createUser(id, data);
-    return reply.status(201).send({ success: true, data: user });
-  }
-
-  async getUser(
-    request: FastifyRequest<{ Params: UserParams }>,
-    reply: FastifyReply
-  ) {
-    const { userId } = request.params;
-
-    const user = await this.userStore.getUserById(userId);
-
-    if (!user) {
-      return reply.status(404).send({
-        success: false,
-        error: "User not found",
-      });
-    }
-
-    return { success: true, data: user };
-  }
-
-  async updateUser(
-    request: FastifyRequest<{
-      Params: UserParams;
-      Body: UpdateUserRequest;
-    }>,
-    reply: FastifyReply
-  ) {
-    const { userId } = request.params;
-    const updates = request.body;
-
-    if (updates.email) {
-      const existingUser = await this.userStore.getUserByEmail(updates.email);
-      if (existingUser && existingUser.id !== userId) {
-        return reply.status(409).send({
-          success: false,
-          error: `User with email ${updates.email} already exists`,
-        });
-      }
-    }
-
-    const user = await this.userStore.updateUser(userId, updates);
-
-    if (!user) {
-      return reply.status(404).send({
-        success: false,
-        error: "User not found",
-      });
-    }
-
-    return { success: true, data: user };
-  }
-
-  async deleteUser(
-    request: FastifyRequest<{ Params: UserParams }>,
-    reply: FastifyReply
-  ) {
-    const { userId } = request.params;
-
-    const deleted = await this.userStore.deleteUser(userId);
-
-    if (!deleted) {
-      return reply.status(404).send({
-        success: false,
-        error: "User not found",
-      });
-    }
-
-    return { success: true };
-  }
-}
-
-export function registerUserRoutes(app: FastifyInstance) {
-  const controller = new UsersController();
-
-  app.get("/api/users", controller.listUsers.bind(controller));
-  app.post("/api/users", controller.createUser.bind(controller));
-  app.get("/api/users/:userId", controller.getUser.bind(controller));
-  app.patch("/api/users/:userId", controller.updateUser.bind(controller));
-  app.delete("/api/users/:userId", controller.deleteUser.bind(controller));
-}