@axiom-lattice/gateway 2.1.28 → 2.1.30

package/src/controllers/run.ts

@@ -26,6 +26,8 @@ export const createRun = async (
     } = request.body as CreateRunRequest;
 
     const tenant_id = request.headers["x-tenant-id"] as string;
+    const workspace_id = request.headers["x-workspace-id"] as string;
+    const project_id = request.headers["x-project-id"] as string;
     const x_request_id = (request.headers["x-request-id"] as string) || v4();
 
     // 验证请求数据
@@ -46,6 +48,8 @@ export const createRun = async (
         thread_id: thread_id,
         command,
         tenant_id: tenant_id,
+        workspace_id: workspace_id,
+        project_id: project_id,
         run_id: x_request_id,
       });
 
@@ -77,6 +81,8 @@ export const createRun = async (
         command: command,
         thread_id: thread_id,
         tenant_id: tenant_id,
+        workspace_id: workspace_id,
+        project_id: project_id,
         run_id: x_request_id,
       });
       reply.status(200).send(result);

package/src/controllers/tenants.ts

@@ -0,0 +1,121 @@
+/**
+ * TenantsController
+ *
+ * Controller for tenant management
+ * Handles CRUD operations for tenants (top-level entities)
+ */
+
+import { FastifyInstance, FastifyRequest, FastifyReply } from "fastify";
+import { getStoreLattice } from "@axiom-lattice/core";
+import type {
+  CreateTenantRequest,
+  UpdateTenantRequest,
+} from "@axiom-lattice/protocols";
+import { v4 as uuidv4 } from "uuid";
+
+interface TenantParams {
+  tenantId: string;
+}
+
+export class TenantsController {
+  private tenantStore;
+
+  constructor() {
+    this.tenantStore = getStoreLattice("default", "tenant").store;
+  }
+
+  // ==================== Tenant CRUD ====================
+
+  async listTenants(request: FastifyRequest, reply: FastifyReply) {
+    const tenants = await this.tenantStore.getAllTenants();
+    return { success: true, data: tenants };
+  }
+
+  async createTenant(
+    request: FastifyRequest<{ Body: CreateTenantRequest }>,
+    reply: FastifyReply
+  ) {
+    const data = request.body;
+    const id = uuidv4();
+
+    const tenant = await this.tenantStore.createTenant(id, data);
+    return reply.status(201).send({ success: true, data: tenant });
+  }
+
+  async getTenant(
+    request: FastifyRequest<{ Params: TenantParams }>,
+    reply: FastifyReply
+  ) {
+    const { tenantId } = request.params;
+
+    const tenant = await this.tenantStore.getTenantById(tenantId);
+
+    if (!tenant) {
+      return reply.status(404).send({
+        success: false,
+        error: "Tenant not found",
+      });
+    }
+
+    return { success: true, data: tenant };
+  }
+
+  async updateTenant(
+    request: FastifyRequest<{
+      Params: TenantParams;
+      Body: UpdateTenantRequest;
+    }>,
+    reply: FastifyReply
+  ) {
+    const { tenantId } = request.params;
+    const updates = request.body;
+
+    const tenant = await this.tenantStore.updateTenant(tenantId, updates);
+
+    if (!tenant) {
+      return reply.status(404).send({
+        success: false,
+        error: "Tenant not found",
+      });
+    }
+
+    return { success: true, data: tenant };
+  }
+
+  async deleteTenant(
+    request: FastifyRequest<{ Params: TenantParams }>,
+    reply: FastifyReply
+  ) {
+    const { tenantId } = request.params;
+
+    // Prevent deletion of the default tenant
+    if (tenantId === "default") {
+      return reply.status(403).send({
+        success: false,
+        error: "Cannot delete the default tenant",
+      });
+    }
+
+    const deleted = await this.tenantStore.deleteTenant(tenantId);
+
+    if (!deleted) {
+      return reply.status(404).send({
+        success: false,
+        error: "Tenant not found",
+      });
+    }
+
+    return { success: true };
+  }
+}
+
+export function registerTenantRoutes(app: FastifyInstance) {
+  const controller = new TenantsController();
+
+  // Tenant routes
+  app.get("/api/tenants", controller.listTenants.bind(controller));
+  app.post("/api/tenants", controller.createTenant.bind(controller));
+  app.get("/api/tenants/:tenantId", controller.getTenant.bind(controller));
+  app.patch("/api/tenants/:tenantId", controller.updateTenant.bind(controller));
+  app.delete("/api/tenants/:tenantId", controller.deleteTenant.bind(controller));
+}

package/src/controllers/users.ts

@@ -0,0 +1,135 @@
+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));
+}