@axiom-lattice/gateway 2.1.108 → 2.1.110

package/dist/index.mjs

@@ -2945,6 +2945,15 @@ async function completeTask(request, reply) {
   }
 }
 
+// src/controllers/middleware-types.ts
+import { PluginRegistry } from "@axiom-lattice/core";
+function middlewareTypesRoutes(fastify2) {
+  fastify2.get("/api/middleware-types", async (_request, reply) => {
+    const metas = PluginRegistry.listMeta();
+    return reply.send(metas);
+  });
+}
+
 // src/schemas/data-query.ts
 var dataQuerySchema = {
   description: "Execute data query (semantic or SQL)",
@@ -5002,6 +5011,160 @@ function registerMetricsServerConfigRoutes(app2) {
   app2.post("/api/metrics-configs/test-datasources/:datasourceId/meta", testDatasourceMetrics);
 }
 
+// src/controllers/connections.ts
+import { ConnectionRegistry, PluginRegistry as PluginRegistry2 } from "@axiom-lattice/core";
+import { z } from "zod";
+var createBody = z.object({
+  type: z.string().min(1),
+  key: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string().optional(),
+  config: z.record(z.unknown())
+});
+var testOrDiscoverBody = z.object({
+  key: z.string().optional(),
+  config: z.record(z.unknown()).optional()
+});
+function getTenant(request) {
+  return request.headers["x-tenant-id"] || "default";
+}
+function maskSecrets(config) {
+  const sensitive = /* @__PURE__ */ new Set([
+    "password",
+    "secret",
+    "token",
+    "apikey",
+    "api_key",
+    "session",
+    "privatekey",
+    "private_key",
+    "accesskey",
+    "access_key"
+  ]);
+  const out = {};
+  for (const [k, v] of Object.entries(config)) {
+    out[k] = sensitive.has(k.toLowerCase()) ? "********" : v;
+  }
+  return out;
+}
+async function resolveConfig(type, body, tenantId) {
+  if (body.key) {
+    const entry = await ConnectionRegistry.get(type, body.key, tenantId);
+    if (!entry) throw { status: 404, error: `Connection "${body.key}" not found` };
+    return entry.config;
+  }
+  if (body.config) return body.config;
+  throw { status: 400, error: "Either 'key' or 'config' is required" };
+}
+function connectionRoutes(fastify2) {
+  fastify2.get("/api/connections", async (request, reply) => {
+    const { type } = request.query;
+    if (!type) return reply.status(400).send({ error: "query 'type' required" });
+    const entries = await ConnectionRegistry.list(type, getTenant(request));
+    return reply.send({
+      success: true,
+      data: { records: entries.map((e) => ({ ...e, config: maskSecrets(e.config) })), total: entries.length }
+    });
+  });
+  fastify2.post("/api/connections", async (request, reply) => {
+    const parsed = createBody.parse(request.body);
+    const entry = await ConnectionRegistry.create({
+      tenantId: getTenant(request),
+      type: parsed.type,
+      key: parsed.key,
+      name: parsed.name,
+      description: parsed.description,
+      config: parsed.config
+    });
+    return reply.status(201).send({
+      success: true,
+      data: { ...entry, config: maskSecrets(entry.config) }
+    });
+  });
+  fastify2.put("/api/connections/:key", async (request, reply) => {
+    const { type } = request.query;
+    if (!type) return reply.status(400).send({ error: "query 'type' required" });
+    const { key } = request.params;
+    const body = request.body;
+    const tenantId = getTenant(request);
+    const existing = await ConnectionRegistry.get(type, key, tenantId);
+    if (!existing) return reply.status(404).send({ error: "not found" });
+    const updates = {};
+    if (body.name !== void 0) updates.name = body.name;
+    if (body.description !== void 0) updates.description = body.description;
+    if (body.config) {
+      updates.config = { ...existing.config, ...body.config };
+    }
+    const entry = await ConnectionRegistry.update(tenantId, type, key, updates);
+    return reply.send({
+      success: true,
+      data: { ...entry, config: maskSecrets(entry?.config ?? {}) }
+    });
+  });
+  fastify2.delete("/api/connections/:key", async (request, reply) => {
+    const { type } = request.query;
+    if (!type) return reply.status(400).send({ error: "query 'type' required" });
+    const { key } = request.params;
+    const ok = await ConnectionRegistry.delete(getTenant(request), type, key);
+    return reply.send({ success: ok });
+  });
+  fastify2.post("/api/connections/test", async (request, reply) => {
+    const { type } = request.query;
+    if (!type) return reply.status(400).send({ error: "query 'type' required" });
+    const plugin = PluginRegistry2.get(type);
+    if (!plugin?.connection?.test) {
+      return reply.status(400).send({ error: "plugin does not support connection testing" });
+    }
+    try {
+      const body = testOrDiscoverBody.parse(request.body);
+      const targetConfig = await resolveConfig(type, body, getTenant(request));
+      const result = await plugin.connection.test(targetConfig);
+      return reply.send(result);
+    } catch (err) {
+      if (err?.status === 404) {
+        return reply.status(404).send(err);
+      }
+      if (err?.status === 400) {
+        return reply.status(400).send(err);
+      }
+      if (err instanceof z.ZodError) {
+        return reply.status(400).send({ error: err.errors });
+      }
+      return reply.status(500).send({
+        ok: false,
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  });
+  fastify2.post("/api/connections/discover", async (request, reply) => {
+    const { type } = request.query;
+    if (!type) return reply.status(400).send({ error: "query 'type' required" });
+    const plugin = PluginRegistry2.get(type);
+    if (!plugin?.connection?.discover) {
+      return reply.status(400).send({ error: "plugin does not support resource discovery" });
+    }
+    try {
+      const body = testOrDiscoverBody.parse(request.body);
+      const targetConfig = await resolveConfig(type, body, getTenant(request));
+      const resources = await plugin.connection.discover(targetConfig);
+      return reply.send({ resources });
+    } catch (err) {
+      if (err?.status === 404) {
+        return reply.status(404).send(err);
+      }
+      if (err?.status === 400) {
+        return reply.status(400).send(err);
+      }
+      if (err instanceof z.ZodError) {
+        return reply.status(400).send({ error: err.errors });
+      }
+      return reply.status(500).send({
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  });
+}
+
 // src/controllers/eval.ts
 import { getStoreLattice as getStoreLattice11 } from "@axiom-lattice/core";
 import { v4 as uuidv44 } from "uuid";
@@ -6125,7 +6288,7 @@ function registerAuthRoutes(app2, config) {
 }
 
 // src/channels/lark/LarkChannelAdapter.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // src/channels/lark/parser.ts
 function parseLarkMessageEvent(payload) {
@@ -6204,11 +6367,11 @@ function wsEventToInbound(event, installationId, tenantId) {
     }
   };
 }
-var larkConfigSchema = z.object({
-  appId: z.string(),
-  appSecret: z.string(),
-  verificationToken: z.string().optional(),
-  encryptKey: z.string().optional()
+var larkConfigSchema = z2.object({
+  appId: z2.string(),
+  appSecret: z2.string(),
+  verificationToken: z2.string().optional(),
+  encryptKey: z2.string().optional()
 });
 var larkChannelAdapter = {
   channel: "lark",
@@ -7250,6 +7413,8 @@ var registerLatticeRoutes = (app2, channelDeps) => {
   registerWorkspaceRoutes(app2);
   registerDatabaseConfigRoutes(app2);
   registerMetricsServerConfigRoutes(app2);
+  connectionRoutes(app2);
+  middlewareTypesRoutes(app2);
   app2.post(
     "/api/data/query",
     { schema: dataQuerySchema },
@@ -7345,6 +7510,9 @@ var registerLatticeRoutes = (app2, channelDeps) => {
 function registerResourceRoutes(app2, controller) {
   app2.get("/s/:token", controller.resolveResource.bind(controller));
   app2.get("/s/:token/*", controller.resolveResource.bind(controller));
+  app2.post("/s/:token/*", controller.resolveResource.bind(controller));
+  app2.put("/s/:token/*", controller.resolveResource.bind(controller));
+  app2.delete("/s/:token/*", controller.resolveResource.bind(controller));
   app2.post("/s/:token/unlock", controller.unlockShare.bind(controller));
   app2.options("/s/:token", async (_req, reply) => {
     reply.header("Access-Control-Allow-Origin", "*");
@@ -7352,6 +7520,12 @@ function registerResourceRoutes(app2, controller) {
     reply.header("Access-Control-Allow-Headers", "Content-Type");
     return reply.status(204).send();
   });
+  const dirFile = controller.resolveDirectFile.bind(controller);
+  app2.get("/f/:tid/:wid/:pid", dirFile);
+  app2.get("/f/:tid/:wid/:pid/*", dirFile);
+  app2.post("/f/:tid/:wid/:pid/*", dirFile);
+  app2.put("/f/:tid/:wid/:pid/*", dirFile);
+  app2.delete("/f/:tid/:wid/:pid/*", dirFile);
   app2.post("/api/resources/share", controller.createShare.bind(controller));
   app2.get("/api/resources/shares", controller.listShares.bind(controller));
   app2.patch("/api/resources/share/:token", controller.updateShare.bind(controller));
@@ -8196,9 +8370,7 @@ function initializeLogger(config) {
 }
 var app = fastify({
   logger: false,
-  // 禁用内置日志记录器
   bodyLimit: Number(process.env.BODY_LIMIT) || 50 * 1024 * 1024
-  // Default 50MB, configurable via BODY_LIMIT env var
 });
 app.addContentTypeParser("application/json", { parseAs: "string" }, function(request, body, done) {
   if (request.method === "DELETE" || !body || body.length === 0) {
@@ -8232,6 +8404,7 @@ app.addHook("preHandler", async (request, reply) => {
   if (request.url.startsWith("/s/")) return;
   const urlPath = request.url.split("?")[0];
   if (urlPath.includes("/viewfile") || urlPath.includes("/downloadfile") || urlPath.includes("/uploadfile")) return;
+  if (urlPath.startsWith("/f/") || urlPath === "/f") return;
   return reply.status(401).send({
     success: false,
     error: "Unauthorized - Missing or invalid token"
@@ -8415,7 +8588,7 @@ var start = async (config) => {
       logger4.info("Registered sandbox manager from env configuration");
     }
     try {
-      const { ResourceController } = await import("./resources-P4XF764M.mjs");
+      const { ResourceController } = await import("./resources-5POCLGXV.mjs");
       const sharedResourceStore = getStoreLattice16("default", "sharedResource").store;
       const cache = new TokenCache();
       const resourceController = new ResourceController({