@axiom-lattice/gateway 2.1.53 → 2.1.55

package/src/controllers/skills.ts

@@ -1,55 +1,40 @@
 import { FastifyRequest, FastifyReply } from "fastify";
-import { getStoreLattice } from "@axiom-lattice/core";
-import { validateSkillName } from "@axiom-lattice/core";
-import type {
-  Skill,
-  CreateSkillRequest,
-} from "@axiom-lattice/protocols";
+import { SkillService } from "../services/skill_service";
+import type { Skill, CreateSkillRequest } from "@axiom-lattice/protocols";
 
-/**
- * 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;
-  }
+const skillService = new SkillService();
 
-  // Fallback to request headers for backward compatibility
-  return (request.headers["x-tenant-id"] as string) || "default";
+function serializeSkill(skill: Skill): any {
+  const serialized: any = {
+    id: skill.id,
+    name: skill.name,
+    description: skill.description,
+    license: skill.license,
+    compatibility: skill.compatibility,
+    metadata: skill.metadata || {},
+    content: skill.content,
+    subSkills: skill.subSkills,
+    createdAt: skill.createdAt instanceof Date ? skill.createdAt.toISOString() : new Date().toISOString(),
+    updatedAt: skill.updatedAt instanceof Date ? skill.updatedAt.toISOString() : new Date().toISOString(),
+  };
+  Object.keys(serialized).forEach((key) => {
+    if (serialized[key] === undefined) delete serialized[key];
+  });
+  return serialized;
 }
 
-/**
- * Skills Controller
- * Handles skill-related CRUD operations
- */
-
-/**
- * Skill list response interface
- */
 interface SkillListResponse {
   success: boolean;
   message: string;
-  data: {
-    records: Skill[];
-    total: number;
-  };
+  data: { records: any[]; total: number };
 }
 
-/**
- * Skill response interface
- */
 interface SkillResponse {
   success: boolean;
   message: string;
-  data?: Skill;
+  data?: any;
 }
 
-/**
- * Skill update request body interface
- */
 interface SkillUpdateBody {
   name?: string;
   description?: string;
@@ -60,438 +45,203 @@ interface SkillUpdateBody {
   subSkills?: string[];
 }
 
-/**
- * Serialize Skill object for JSON response
- * Converts Date objects to ISO strings
- * Explicitly creates a plain object to ensure all fields are serializable
- */
-function serializeSkill(skill: Skill): any {
-  // Explicitly create a plain object with all fields
-  // This ensures Fastify can properly serialize the response
-  const serialized: any = {
-    id: skill.id,
-    name: skill.name,
-    description: skill.description,
-    license: skill.license,
-    compatibility: skill.compatibility,
-    metadata: skill.metadata || {},
-    content: skill.content,
-    subSkills: skill.subSkills,
-    createdAt: skill.createdAt instanceof Date ? skill.createdAt.toISOString() : (skill.createdAt ? new Date(skill.createdAt).toISOString() : new Date().toISOString()),
-    updatedAt: skill.updatedAt instanceof Date ? skill.updatedAt.toISOString() : (skill.updatedAt ? new Date(skill.updatedAt).toISOString() : new Date().toISOString()),
-  };
-
-  // Remove undefined fields to avoid serialization issues
-  Object.keys(serialized).forEach((key) => {
-    if (serialized[key] === undefined) {
-      delete serialized[key];
-    }
-  });
-
-  return serialized;
-}
-
-/**
- * Get list of all skills
- */
-export async function getSkillList(
-  request: FastifyRequest,
-  reply: FastifyReply
-): Promise<SkillListResponse> {
+export async function getSkillList(request: FastifyRequest, reply: FastifyReply): Promise<SkillListResponse> {
   try {
-    const tenantId = getTenantId(request);
-    const storeLattice = getStoreLattice("default", "skill");
-    const skillStore = storeLattice.store;
-    const skills = await skillStore.getAllSkills(tenantId);
-
-    // Serialize skills to convert Date objects to ISO strings
-    const serializedSkills = skills.map(serializeSkill);
-
+    const skills = await skillService.getAllSkills(request);
     return {
       success: true,
       message: "Successfully retrieved skill list",
-      data: {
-        records: serializedSkills,
-        total: serializedSkills.length,
-      },
+      data: { records: skills.map(serializeSkill), total: skills.length },
     };
   } catch (error: any) {
     return reply.status(500).send({
       success: false,
       message: `Failed to retrieve skills: ${error.message}`,
-      data: {
-        records: [],
-        total: 0,
-      },
+      data: { records: [], total: 0 },
     });
   }
 }
 
-/**
- * Get a single skill by ID
- */
 export async function getSkill(
   request: FastifyRequest<{ Params: { id: string } }>,
   reply: FastifyReply
 ): Promise<SkillResponse> {
   try {
-    const tenantId = getTenantId(request);
     const { id } = request.params;
-
-    const storeLattice = getStoreLattice("default", "skill");
-    const skillStore = storeLattice.store;
-    const skill = await skillStore.getSkillById(tenantId, id);
+    const skill = await skillService.getSkillById(request, id);
 
     if (!skill) {
-      return reply.status(404).send({
-        success: false,
-        message: "Skill not found",
-      });
+      return reply.status(404).send({ success: false, message: "Skill not found" });
     }
 
-    return {
-      success: true,
-      message: "Successfully retrieved skill",
-      data: serializeSkill(skill),
-    };
+    return { success: true, message: "Successfully retrieved skill", data: serializeSkill(skill) };
   } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to retrieve skill: ${error.message}`,
-    });
+    return reply.status(500).send({ success: false, message: `Failed to retrieve skill: ${error.message}` });
   }
 }
 
-/**
- * Create a new skill
- */
 export async function createSkill(
   request: FastifyRequest<{ Body: CreateSkillRequest }>,
   reply: FastifyReply
 ): Promise<SkillResponse> {
   try {
     const data = request.body;
-
-    // Validate required fields
     if (!data.name) {
-      return reply.status(400).send({
-        success: false,
-        message: "name is required",
-      });
+      return reply.status(400).send({ success: false, message: "name is required" });
     }
-
     if (!data.description) {
-      return reply.status(400).send({
-        success: false,
-        message: "description is required",
-      });
+      return reply.status(400).send({ success: false, message: "description is required" });
     }
 
-    // Validate name format
-    try {
-      validateSkillName(data.name);
-    } catch (error: any) {
-      return reply.status(400).send({
-        success: false,
-        message: error.message || "Invalid skill name format",
-      });
-    }
-
-    // ID must equal name (name is used for path addressing)
     const id = (request.body as any).id || data.name;
-    
     if (id !== data.name) {
       return reply.status(400).send({
         success: false,
-        message: `id "${id}" must equal name "${data.name}" (name is used for path addressing)`,
+        message: `id "${id}" must equal name "${data.name}"`,
       });
     }
 
-    const tenantId = getTenantId(request);
-    const storeLattice = getStoreLattice("default", "skill");
-    const skillStore = storeLattice.store;
-
-    // Check if skill already exists
-    const exists = await skillStore.hasSkill(tenantId, id);
-    if (exists) {
-      return reply.status(409).send({
-        success: false,
-        message: `Skill with id "${id}" already exists`,
-      });
-    }
-
-    // Create skill
-    const newSkill = await skillStore.createSkill(tenantId, id, data);
-
+    const skill = await skillService.createSkill(request, id, data);
     return reply.status(201).send({
       success: true,
       message: "Successfully created skill",
-      data: serializeSkill(newSkill),
+      data: serializeSkill(skill),
     });
   } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to create skill: ${error.message}`,
-    });
+    if (error.message?.includes("already exists")) {
+      return reply.status(409).send({ success: false, message: error.message });
+    }
+    if (error.message?.includes("must equal name") || error.message?.includes("Invalid skill name")) {
+      return reply.status(400).send({ success: false, message: error.message });
+    }
+    return reply.status(500).send({ success: false, message: `Failed to create skill: ${error.message}` });
   }
 }
 
-/**
- * Update an existing skill by ID
- */
 export async function updateSkill(
-  request: FastifyRequest<{
-    Params: { id: string };
-    Body: SkillUpdateBody;
-  }>,
+  request: FastifyRequest<{ Params: { id: string }; Body: SkillUpdateBody }>,
   reply: FastifyReply
 ): Promise<SkillResponse> {
   try {
     const { id } = request.params;
     const updates = request.body;
 
-    // Validate name format if name is being updated
-    if (updates.name !== undefined) {
-      try {
-        validateSkillName(updates.name);
-      } catch (error: any) {
-        return reply.status(400).send({
-          success: false,
-          message: error.message || "Invalid skill name format",
-        });
-      }
-    }
-
-    const tenantId = getTenantId(request);
-    const storeLattice = getStoreLattice("default", "skill");
-    const skillStore = storeLattice.store;
-
-    // Check if skill exists
-    const exists = await skillStore.hasSkill(tenantId, id);
-    if (!exists) {
-      return reply.status(404).send({
-        success: false,
-        message: "Skill not found",
-      });
-    }
-
-    // Update skill
-    const updatedSkill = await skillStore.updateSkill(tenantId, id, updates);
+    const skill = await skillService.updateSkill(request, id, updates);
 
-    if (!updatedSkill) {
-      return reply.status(500).send({
-        success: false,
-        message: "Failed to update skill",
-      });
+    if (!skill) {
+      return reply.status(404).send({ success: false, message: "Skill not found" });
     }
 
-    return {
-      success: true,
-      message: "Successfully updated skill",
-      data: serializeSkill(updatedSkill),
-    };
+    return { success: true, message: "Successfully updated skill", data: serializeSkill(skill) };
   } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to update skill: ${error.message}`,
-    });
+    if (error.message?.includes("Invalid skill name")) {
+      return reply.status(400).send({ success: false, message: error.message });
+    }
+    return reply.status(500).send({ success: false, message: `Failed to update skill: ${error.message}` });
   }
 }
 
-/**
- * Delete a skill by ID
- */
 export async function deleteSkill(
   request: FastifyRequest<{ Params: { id: string } }>,
   reply: FastifyReply
 ): Promise<{ success: boolean; message: string }> {
   try {
     const { id } = request.params;
+    const result = await skillService.deleteSkill(request, id);
 
-    const tenantId = getTenantId(request);
-    const storeLattice = getStoreLattice("default", "skill");
-    const skillStore = storeLattice.store;
-
-    // Check if skill exists
-    const exists = await skillStore.hasSkill(tenantId, id);
-    if (!exists) {
-      return reply.status(404).send({
-        success: false,
-        message: "Skill not found",
-      });
-    }
-
-    // Delete the skill
-    const deleted = await skillStore.deleteSkill(tenantId, id);
-
-    if (!deleted) {
-      return reply.status(500).send({
-        success: false,
-        message: "Failed to delete skill",
-      });
+    if (!result) {
+      return reply.status(404).send({ success: false, message: "Skill not found" });
     }
 
-    return {
-      success: true,
-      message: "Successfully deleted skill",
-    };
+    return { success: true, message: "Successfully deleted skill" };
   } catch (error: any) {
-    return reply.status(500).send({
-      success: false,
-      message: `Failed to delete skill: ${error.message}`,
-    });
+    return reply.status(500).send({ success: false, message: `Failed to delete skill: ${error.message}` });
   }
 }
 
-/**
- * Search skills by metadata
- */
 export async function searchSkillsByMetadata(
-  request: FastifyRequest<{
-    Querystring: { key: string; value: string };
-  }>,
+  request: FastifyRequest<{ Querystring: { key: string; value: string } }>,
   reply: FastifyReply
 ): Promise<SkillListResponse> {
   try {
     const { key, value } = request.query;
-
     if (!key || !value) {
       return reply.status(400).send({
         success: false,
         message: "key and value query parameters are required",
-        data: {
-          records: [],
-          total: 0,
-        },
+        data: { records: [], total: 0 },
       });
     }
 
-    const tenantId = getTenantId(request);
-    const storeLattice = getStoreLattice("default", "skill");
-    const skillStore = storeLattice.store;
-    const skills = await skillStore.searchByMetadata(tenantId, key, value);
-
-    // Serialize skills to convert Date objects to ISO strings
-    const serializedSkills = skills.map(serializeSkill);
-
+    const skills = await skillService.searchByMetadata(request, key, value);
     return {
       success: true,
       message: "Successfully searched skills",
-      data: {
-        records: serializedSkills,
-        total: serializedSkills.length,
-      },
+      data: { records: skills.map(serializeSkill), total: skills.length },
     };
   } catch (error: any) {
     return reply.status(500).send({
       success: false,
       message: `Failed to search skills: ${error.message}`,
-      data: {
-        records: [],
-        total: 0,
-      },
+      data: { records: [], total: 0 },
     });
   }
 }
 
-/**
- * Filter skills by compatibility
- */
 export async function filterSkillsByCompatibility(
-  request: FastifyRequest<{
-    Querystring: { compatibility: string };
-  }>,
+  request: FastifyRequest<{ Querystring: { compatibility: string } }>,
   reply: FastifyReply
 ): Promise<SkillListResponse> {
   try {
     const { compatibility } = request.query;
-
     if (!compatibility) {
       return reply.status(400).send({
         success: false,
         message: "compatibility query parameter is required",
-        data: {
-          records: [],
-          total: 0,
-        },
+        data: { records: [], total: 0 },
       });
     }
 
-    const tenantId = getTenantId(request);
-    const storeLattice = getStoreLattice("default", "skill");
-    const skillStore = storeLattice.store;
-    const skills = await skillStore.filterByCompatibility(tenantId, compatibility);
-
-    // Serialize skills to convert Date objects to ISO strings
-    const serializedSkills = skills.map(serializeSkill);
-
+    const skills = await skillService.filterByCompatibility(request, compatibility);
     return {
       success: true,
       message: "Successfully filtered skills",
-      data: {
-        records: serializedSkills,
-        total: serializedSkills.length,
-      },
+      data: { records: skills.map(serializeSkill), total: skills.length },
     };
   } catch (error: any) {
     return reply.status(500).send({
       success: false,
       message: `Failed to filter skills: ${error.message}`,
-      data: {
-        records: [],
-        total: 0,
-      },
+      data: { records: [], total: 0 },
     });
   }
 }
 
-/**
- * Filter skills by license
- */
 export async function filterSkillsByLicense(
-  request: FastifyRequest<{
-    Querystring: { license: string };
-  }>,
+  request: FastifyRequest<{ Querystring: { license: string } }>,
   reply: FastifyReply
 ): Promise<SkillListResponse> {
   try {
     const { license } = request.query;
-
     if (!license) {
       return reply.status(400).send({
         success: false,
         message: "license query parameter is required",
-        data: {
-          records: [],
-          total: 0,
-        },
+        data: { records: [], total: 0 },
       });
     }
 
-    const tenantId = getTenantId(request);
-    const storeLattice = getStoreLattice("default", "skill");
-    const skillStore = storeLattice.store;
-    const skills = await skillStore.filterByLicense(tenantId, license);
-
-    // Serialize skills to convert Date objects to ISO strings
-    const serializedSkills = skills.map(serializeSkill);
-
+    const skills = await skillService.filterByLicense(request, license);
     return {
       success: true,
       message: "Successfully filtered skills",
-      data: {
-        records: serializedSkills,
-        total: serializedSkills.length,
-      },
+      data: { records: skills.map(serializeSkill), total: skills.length },
     };
   } catch (error: any) {
     return reply.status(500).send({
       success: false,
       message: `Failed to filter skills: ${error.message}`,
-      data: {
-        records: [],
-        total: 0,
-      },
+      data: { records: [], total: 0 },
     });
   }
 }

package/src/controllers/threads.ts

@@ -58,20 +58,22 @@ interface ThreadUpdateBody {
 export async function getThreadList(
   request: FastifyRequest<{
     Params: { assistantId: string };
-    Querystring: { workspaceId?: string; projectId?: string };
   }>,
   reply: FastifyReply
 ): Promise<ThreadListResponse> {
   const tenantId = getTenantId(request);
   const { assistantId } = request.params;
 
-  // Build metadata filter from query params
+  // Build metadata filter from headers (workspace/project isolation)
   const metadataFilter: Record<string, string> = {};
-  if (request.query.workspaceId) {
-    metadataFilter.workspaceId = request.query.workspaceId;
+  const workspaceId = request.headers["x-workspace-id"] as string | undefined;
+  const projectId = request.headers["x-project-id"] as string | undefined;
+  
+  if (workspaceId) {
+    metadataFilter.workspaceId = workspaceId;
   }
-  if (request.query.projectId) {
-    metadataFilter.projectId = request.query.projectId;
+  if (projectId) {
+    metadataFilter.projectId = projectId;
   }
 
   const storeLattice = getStoreLattice("default", "thread");