@axiom-lattice/gateway 2.1.19 → 2.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.19",
+  "version": "2.1.21",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -32,9 +32,9 @@
     "pino-roll": "^3.1.0",
     "redis": "^5.0.1",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "2.1.14",
-    "@axiom-lattice/protocols": "2.1.8",
-    "@axiom-lattice/queue-redis": "1.0.7"
+    "@axiom-lattice/core": "2.1.16",
+    "@axiom-lattice/protocols": "2.1.10",
+    "@axiom-lattice/queue-redis": "1.0.9"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/controllers/skills.ts

@@ -0,0 +1,474 @@
+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";
+
+/**
+ * Skills Controller
+ * Handles skill-related CRUD operations
+ */
+
+/**
+ * Skill list response interface
+ */
+interface SkillListResponse {
+  success: boolean;
+  message: string;
+  data: {
+    records: Skill[];
+    total: number;
+  };
+}
+
+/**
+ * Skill response interface
+ */
+interface SkillResponse {
+  success: boolean;
+  message: string;
+  data?: Skill;
+}
+
+/**
+ * Skill update request body interface
+ */
+interface SkillUpdateBody {
+  name?: string;
+  description?: string;
+  license?: string;
+  compatibility?: string;
+  metadata?: Record<string, string>;
+  content?: string;
+  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> {
+  try {
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.getAllSkills();
+
+    // Serialize skills to convert Date objects to ISO strings
+    const serializedSkills = skills.map(serializeSkill);
+
+    return {
+      success: true,
+      message: "Successfully retrieved skill list",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to retrieve skills: ${error.message}`,
+      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 { id } = request.params;
+
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+    const skill = await skillStore.getSkillById(id);
+
+    if (!skill) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found",
+      });
+    }
+
+    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}`,
+    });
+  }
+}
+
+/**
+ * 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",
+      });
+    }
+
+    if (!data.description) {
+      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)`,
+      });
+    }
+
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+
+    // Check if skill already exists
+    const exists = await skillStore.hasSkill(id);
+    if (exists) {
+      return reply.status(409).send({
+        success: false,
+        message: `Skill with id "${id}" already exists`,
+      });
+    }
+
+    // Create skill
+    const newSkill = await skillStore.createSkill(id, data);
+
+    return reply.status(201).send({
+      success: true,
+      message: "Successfully created skill",
+      data: serializeSkill(newSkill),
+    });
+  } catch (error: any) {
+    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;
+  }>,
+  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 storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+
+    // Check if skill exists
+    const exists = await skillStore.hasSkill(id);
+    if (!exists) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found",
+      });
+    }
+
+    // Update skill
+    const updatedSkill = await skillStore.updateSkill(id, updates);
+
+    if (!updatedSkill) {
+      return reply.status(500).send({
+        success: false,
+        message: "Failed to update skill",
+      });
+    }
+
+    return {
+      success: true,
+      message: "Successfully updated skill",
+      data: serializeSkill(updatedSkill),
+    };
+  } catch (error: any) {
+    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 storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+
+    // Check if skill exists
+    const exists = await skillStore.hasSkill(id);
+    if (!exists) {
+      return reply.status(404).send({
+        success: false,
+        message: "Skill not found",
+      });
+    }
+
+    // Delete the skill
+    const deleted = await skillStore.deleteSkill(id);
+
+    if (!deleted) {
+      return reply.status(500).send({
+        success: false,
+        message: "Failed to delete 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}`,
+    });
+  }
+}
+
+/**
+ * Search skills by metadata
+ */
+export async function searchSkillsByMetadata(
+  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,
+        },
+      });
+    }
+
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.searchByMetadata(key, value);
+
+    // Serialize skills to convert Date objects to ISO strings
+    const serializedSkills = skills.map(serializeSkill);
+
+    return {
+      success: true,
+      message: "Successfully searched skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to search skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}
+
+/**
+ * Filter skills by compatibility
+ */
+export async function filterSkillsByCompatibility(
+  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,
+        },
+      });
+    }
+
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.filterByCompatibility(compatibility);
+
+    // Serialize skills to convert Date objects to ISO strings
+    const serializedSkills = skills.map(serializeSkill);
+
+    return {
+      success: true,
+      message: "Successfully filtered skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to filter skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}
+
+/**
+ * Filter skills by license
+ */
+export async function filterSkillsByLicense(
+  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,
+        },
+      });
+    }
+
+    const storeLattice = getStoreLattice("default", "skill");
+    const skillStore = storeLattice.store;
+    const skills = await skillStore.filterByLicense(license);
+
+    // Serialize skills to convert Date objects to ISO strings
+    const serializedSkills = skills.map(serializeSkill);
+
+    return {
+      success: true,
+      message: "Successfully filtered skills",
+      data: {
+        records: serializedSkills,
+        total: serializedSkills.length,
+      },
+    };
+  } catch (error: any) {
+    return reply.status(500).send({
+      success: false,
+      message: `Failed to filter skills: ${error.message}`,
+      data: {
+        records: [],
+        total: 0,
+      },
+    });
+  }
+}

package/src/index.ts

@@ -2,25 +2,56 @@ import fastify from "fastify";
 import cors from "@fastify/cors";
 import sensible from "@fastify/sensible";
 import { registerLatticeRoutes } from "./routes";
-// 导入自定义 Logger 类
-import { Logger } from "./logger/Logger";
 import { configureSwagger } from "./swagger";
 import {
   setQueueServiceType,
   QueueServiceType,
 } from "./services/queue_service";
 import { AgentTaskConsumer } from "./services/agent_task_consumer";
+import {
+  registerLoggerLattice,
+  getLoggerLattice,
+  loggerLatticeManager,
+} from "@axiom-lattice/core";
+import {
+  LoggerType,
+  LoggerConfig,
+  PinoFileOptions,
+} from "@axiom-lattice/protocols";
 
 process.on("unhandledRejection", (reason, promise) => {
   console.error("未处理的Promise拒绝:", reason);
   // 可以在这里进行日志记录或其他处理
 });
 
-// 创建自定义日志记录器
-const logger = new Logger({
-  serviceName: "lattice-gateway",
-  name: "fastify-server",
-});
+// Default logger configuration
+const DEFAULT_LOGGER_CONFIG: LoggerConfig = {
+  name: "default",
+  description: "Default logger for lattice-gateway service",
+  type: LoggerType.PINO,
+  serviceName: "lattice/gateway",
+  loggerName: "lattice/gateway",
+};
+
+// Initialize logger with default config (can be overridden in start function)
+let loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
+let logger = loggerLattice.client;
+
+/**
+ * Initialize logger lattice with given configuration
+ */
+function initializeLogger(config: LoggerConfig) {
+  // Remove existing logger if it exists
+  if (loggerLatticeManager.hasLattice("default")) {
+    loggerLatticeManager.removeLattice("default");
+  }
+
+  // Register logger with provided config
+  registerLoggerLattice("default", config);
+
+  // Get and return logger lattice instance
+  return getLoggerLattice("default");
+}
 
 // 创建 Fastify 应用
 const app = fastify({
@@ -28,20 +59,45 @@ const app = fastify({
   bodyLimit: Number(process.env.BODY_LIMIT) || 50 * 1024 * 1024, // Default 50MB, configurable via BODY_LIMIT env var
 });
 
-// 添加自定义日志记录
+// Add custom logging hooks
 app.addHook("onRequest", (request, reply, done) => {
+  // Convert headers to strings (Fastify headers can be string | string[])
+  const getHeaderValue = (
+    header: string | string[] | undefined
+  ): string | undefined => {
+    if (Array.isArray(header)) {
+      return header[0];
+    }
+    return header;
+  };
+
   const context = {
-    "x-tenant-id": request.headers["x-tenant-id"],
-    "x-request-id": request.headers["x-request-id"],
+    "x-tenant-id": getHeaderValue(request.headers["x-tenant-id"]),
+    "x-request-id": getHeaderValue(request.headers["x-request-id"]),
   };
+  // Update logger context for this request
+  if (loggerLattice.updateContext) {
+    loggerLattice.updateContext(context);
+  }
   done();
 });
 
 app.addHook("onResponse", (request, reply, done) => {
+  // Convert headers to strings (Fastify headers can be string | string[])
+  const getHeaderValue = (
+    header: string | string[] | undefined
+  ): string | undefined => {
+    if (Array.isArray(header)) {
+      return header[0];
+    }
+    return header;
+  };
+
   const context = {
-    "x-tenant-id": request.headers["x-tenant-id"],
-    "x-request-id": request.headers["x-request-id"],
+    "x-tenant-id": getHeaderValue(request.headers["x-tenant-id"]),
+    "x-request-id": getHeaderValue(request.headers["x-request-id"]),
   };
+  loggerLattice.info(`${request.method} ${request.url} - ${reply.statusCode}`);
   done();
 });
 
@@ -61,11 +117,21 @@ app.register(cors, {
 });
 app.register(sensible);
 
-// 错误处理
+// Error handler
 app.setErrorHandler((error, request, reply) => {
+  // Convert headers to strings (Fastify headers can be string | string[])
+  const getHeaderValue = (
+    header: string | string[] | undefined
+  ): string | undefined => {
+    if (Array.isArray(header)) {
+      return header[0];
+    }
+    return header;
+  };
+
   const context = {
-    "x-tenant-id": request.headers["x-tenant-id"],
-    "x-request-id": request.headers["x-request-id"],
+    "x-tenant-id": getHeaderValue(request.headers["x-tenant-id"]),
+    "x-request-id": getHeaderValue(request.headers["x-request-id"]),
   };
   logger.error(
     `请求错误: ${request.method} ${request.url} error:${error.message}`,
@@ -82,8 +148,20 @@ app.setErrorHandler((error, request, reply) => {
   });
 });
 
-// 将日志记录器添加到应用实例中，以便在路由中使用
-app.decorate("logger", logger);
+// Logger lattice will be decorated in start() function
+
+/**
+ * Logger configuration for gateway
+ */
+export interface GatewayLoggerConfig {
+  name?: string;
+  description?: string;
+  type?: LoggerType;
+  serviceName?: string;
+  loggerName?: string;
+  file?: string | PinoFileOptions;
+  context?: Record<string, any>;
+}
 
 // Gateway configuration interface
 export interface LatticeGatewayConfig {
@@ -92,11 +170,28 @@ export interface LatticeGatewayConfig {
     type: QueueServiceType;
     defaultStartPollingQueue: boolean;
   };
+  loggerConfig?: Partial<GatewayLoggerConfig>; // Optional logger configuration to override defaults
 }
 
 // Start server
 const start = async (config?: LatticeGatewayConfig) => {
   try {
+    // Initialize or update logger configuration if provided
+    if (config?.loggerConfig) {
+      const loggerConfig: LoggerConfig = {
+        ...DEFAULT_LOGGER_CONFIG,
+        ...config.loggerConfig,
+        // Merge file config if provided
+        file: config.loggerConfig.file || DEFAULT_LOGGER_CONFIG.file,
+      };
+      loggerLattice = initializeLogger(loggerConfig);
+      logger = loggerLattice.client;
+    }
+
+    // Decorate app with logger lattice (only once, in start function)
+    // Access via: request.server.loggerLattice or app.loggerLattice
+    app.decorate("loggerLattice", loggerLattice);
+
     const target_port = config?.port || Number(process.env.PORT) || 4001;
 
     await app.listen({ port: target_port, host: "0.0.0.0" });