@axiom-lattice/gateway 3.0.2 → 3.0.3

package/src/controllers/auth.ts

@@ -1,524 +0,0 @@
-import { FastifyInstance, FastifyRequest, FastifyReply } from "fastify";
-import { getStoreLattice } from "@axiom-lattice/core";
-import { v4 as uuidv4 } from "uuid";
-import type { CreateUserRequest, CreateTenantRequest, UserTenantRole } from "@axiom-lattice/protocols";
-
-interface RegisterRequest {
-  email: string;
-  password: string;
-  name: string;
-}
-
-interface LoginRequest {
-  email: string;
-  password: string;
-}
-
-interface SelectTenantRequest {
-  tenantId: string;
-}
-
-interface ApproveUserRequest {
-  userId: string;
-  approved: boolean;
-}
-
-interface AssignTenantRequest {
-  userId: string;
-  tenantId: string;
-  role?: UserTenantRole;
-}
-
-interface ChangePasswordRequest {
-  currentPassword: string;
-  newPassword: string;
-}
-
-export interface AuthConfig {
-  autoApproveUsers: boolean;
-  allowTenantRegistration: boolean;
-  jwtSecret?: string;
-  tokenExpiration: number;
-}
-
-const defaultAuthConfig: AuthConfig = {
-  autoApproveUsers: true,
-  allowTenantRegistration: true,
-  tokenExpiration: 86400,
-};
-
-export class AuthController {
-  private userStore;
-  private tenantStore;
-  private userTenantLinkStore;
-  private config: AuthConfig;
-
-  constructor(config: Partial<AuthConfig> = {}) {
-    this.userStore = getStoreLattice("default", "user").store;
-    this.tenantStore = getStoreLattice("default", "tenant").store;
-    this.userTenantLinkStore = getStoreLattice("default", "userTenantLink").store;
-    this.config = { ...defaultAuthConfig, ...config };
-  }
-
-  async register(
-    request: FastifyRequest<{ Body: RegisterRequest }>,
-    reply: FastifyReply
-  ) {
-    const { email, password, name } = request.body;
-
-    try {
-      const existingUser = await this.userStore.getUserByEmail(email);
-      if (existingUser) {
-        return reply.status(409).send({
-          success: false,
-          error: "User with this email already exists",
-        });
-      }
-
-      const userId = uuidv4();
-      const userStatus = this.config.autoApproveUsers ? "active" : "pending";
-      
-      const userData: CreateUserRequest = {
-        email,
-        name,
-        status: userStatus,
-        metadata: {
-          passwordHash: await this.hashPassword(password),
-        },
-      };
-
-      const user = await this.userStore.createUser(userId, userData);
-
-      return reply.status(201).send({
-        success: true,
-        message: this.config.autoApproveUsers
-          ? "Registration successful"
-          : "Registration successful. Please wait for admin approval.",
-        data: {
-          user: {
-            id: user.id,
-            email: user.email,
-            name: user.name,
-            status: user.status,
-          },
-        },
-      });
-    } catch (error) {
-      console.error("Registration error:", error);
-      return reply.status(500).send({
-        success: false,
-        error: "Registration failed",
-      });
-    }
-  }
-
-  async login(
-    request: FastifyRequest<{ Body: LoginRequest }>,
-    reply: FastifyReply
-  ) {
-    const { email, password } = request.body;
-
-    try {
-      const user = await this.userStore.getUserByEmail(email);
-      if (!user) {
-        return reply.status(401).send({
-          success: false,
-          error: "Invalid credentials",
-        });
-      }
-
-      if (user.status !== "active") {
-        return reply.status(403).send({
-          success: false,
-          error: `Account is ${user.status}. Please wait for admin approval.`,
-        });
-      }
-
-      const isValidPassword = await this.verifyPassword(
-        password,
-        user.metadata?.passwordHash || ""
-      );
-
-      if (!isValidPassword) {
-        return reply.status(401).send({
-          success: false,
-          error: "Invalid credentials",
-        });
-      }
-
-      const tenantLinks = await this.userTenantLinkStore.getTenantsByUser(user.id);
-      
-      const token = await this.generateToken(user.id);
-
-      return {
-        success: true,
-        data: {
-          user: {
-            id: user.id,
-            email: user.email,
-            name: user.name,
-            status: user.status,
-          },
-          tenants: tenantLinks.map(link => ({
-            id: link.tenantId,
-            role: link.role,
-          })),
-          token,
-          requiresTenantSelection: tenantLinks.length > 1,
-          hasTenants: tenantLinks.length > 0,
-        },
-      };
-    } catch (error) {
-      console.error("Login error:", error);
-      return reply.status(500).send({
-        success: false,
-        error: "Login failed",
-      });
-    }
-  }
-
-  async getUserTenants(
-    request: FastifyRequest,
-    reply: FastifyReply
-  ) {
-    const userId = (request as any).user?.id;
-    
-    if (!userId) {
-      return reply.status(401).send({
-        success: false,
-        error: "Unauthorized",
-      });
-    }
-
-    try {
-      const links = await this.userTenantLinkStore.getTenantsByUser(userId);
-      
-      const tenantsWithDetails = await Promise.all(
-        links.map(async (link) => {
-          const tenant = await this.tenantStore.getTenantById(link.tenantId);
-          return {
-            ...link,
-            tenant: tenant || null,
-          };
-        })
-      );
-
-      return {
-        success: true,
-        data: tenantsWithDetails,
-      };
-    } catch (error) {
-      console.error("Get user tenants error:", error);
-      return reply.status(500).send({
-        success: false,
-        error: "Failed to get user tenants",
-      });
-    }
-  }
-
-  async selectTenant(
-    request: FastifyRequest<{ Body: SelectTenantRequest }>,
-    reply: FastifyReply
-  ) {
-    const userId = (request as any).user?.id;
-    const { tenantId } = request.body;
-
-    if (!userId) {
-      return reply.status(401).send({
-        success: false,
-        error: "Unauthorized",
-      });
-    }
-
-    try {
-      const hasLink = await this.userTenantLinkStore.hasLink(userId, tenantId);
-      
-      if (!hasLink) {
-        return reply.status(403).send({
-          success: false,
-          error: "You do not have access to this tenant",
-        });
-      }
-
-      const tenant = await this.tenantStore.getTenantById(tenantId);
-      
-      if (!tenant) {
-        return reply.status(404).send({
-          success: false,
-          error: "Tenant not found",
-        });
-      }
-
-      const token = await this.generateToken(userId, tenantId);
-
-      // Check for personal assistant in this tenant
-      const link = await this.userTenantLinkStore.getLink(userId, tenantId);
-      const linkMeta = (link?.metadata || {}) as Record<string, unknown>;
-
-      let personalAssistant = null;
-      if (linkMeta.personalAssistantId) {
-        const assistantStore = getStoreLattice("default", "assistant").store;
-        const exists = await assistantStore.hasAssistant(tenantId, linkMeta.personalAssistantId as string);
-        if (exists) {
-          personalAssistant = {
-            assistantId: linkMeta.personalAssistantId as string,
-            projectId: linkMeta.personalProjectId as string || "default",
-            workspaceId: linkMeta.personalWorkspaceId as string || "default",
-          };
-        }
-      }
-
-      return {
-        success: true,
-        data: {
-          tenant,
-          token,
-          personalAssistant,
-        },
-      };
-    } catch (error) {
-      console.error("Select tenant error:", error);
-      return reply.status(500).send({
-        success: false,
-        error: "Failed to select tenant",
-      });
-    }
-  }
-
-  async approveUser(
-    request: FastifyRequest<{ Body: ApproveUserRequest }>,
-    reply: FastifyReply
-  ) {
-    const { userId, approved } = request.body;
-
-    try {
-      const user = await this.userStore.getUserById(userId);
-      if (!user) {
-        return reply.status(404).send({
-          success: false,
-          error: "User not found",
-        });
-      }
-
-      if (user.status !== "pending") {
-        return reply.status(400).send({
-          success: false,
-          error: `User is already ${user.status}`,
-        });
-      }
-
-      const updatedUser = await this.userStore.updateUser(userId, {
-        status: approved ? "active" : "suspended",
-      });
-
-      return {
-        success: true,
-        data: updatedUser,
-      };
-    } catch (error) {
-      console.error("Approval error:", error);
-      return reply.status(500).send({
-        success: false,
-        error: "Approval failed",
-      });
-    }
-  }
-
-  async listPendingUsers(
-    request: FastifyRequest,
-    reply: FastifyReply
-  ) {
-    try {
-      const users = await this.userStore.getAllUsers();
-      const pendingUsers = users.filter((u) => u.status === "pending");
-
-      return {
-        success: true,
-        data: pendingUsers,
-      };
-    } catch (error) {
-      console.error("List pending users error:", error);
-      return reply.status(500).send({
-        success: false,
-        error: "Failed to list pending users",
-      });
-    }
-  }
-
-  async assignTenant(
-    request: FastifyRequest<{ Body: AssignTenantRequest }>,
-    reply: FastifyReply
-  ) {
-    const { userId, tenantId, role = "member" } = request.body;
-
-    try {
-      const user = await this.userStore.getUserById(userId);
-      if (!user) {
-        return reply.status(404).send({
-          success: false,
-          error: "User not found",
-        });
-      }
-
-      const tenant = await this.tenantStore.getTenantById(tenantId);
-      if (!tenant) {
-        return reply.status(404).send({
-          success: false,
-          error: "Tenant not found",
-        });
-      }
-
-      const link = await this.userTenantLinkStore.createLink({
-        userId,
-        tenantId,
-        role,
-      });
-
-      return {
-        success: true,
-        data: link,
-      };
-    } catch (error) {
-      console.error("Assign tenant error:", error);
-      return reply.status(500).send({
-        success: false,
-        error: "Failed to assign tenant",
-      });
-    }
-  }
-
-  private async hashPassword(password: string): Promise<string> {
-    const encoder = new TextEncoder();
-    const data = encoder.encode(password + "salt");
-    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-    const hashArray = Array.from(new Uint8Array(hashBuffer));
-    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-  }
-
-  private async verifyPassword(password: string, hash: string): Promise<boolean> {
-    const hashedPassword = await this.hashPassword(password);
-    return hashedPassword === hash;
-  }
-
-  private async generateToken(userId: string, tenantId?: string): Promise<string> {
-    const payload: any = {
-      userId,
-      exp: Date.now() + this.config.tokenExpiration * 1000,
-    };
-    if (tenantId) {
-      payload.tenantId = tenantId;
-    }
-    return btoa(JSON.stringify(payload));
-  }
-
-  async changePassword(
-    request: FastifyRequest<{ Body: ChangePasswordRequest }>,
-    reply: FastifyReply
-  ) {
-    const userId = (request as any).user?.id;
-    const { currentPassword, newPassword } = request.body;
-
-    if (!userId) {
-      return reply.status(401).send({
-        success: false,
-        error: "Unauthorized",
-      });
-    }
-
-    try {
-      const user = await this.userStore.getUserById(userId);
-      if (!user) {
-        return reply.status(404).send({
-          success: false,
-          error: "User not found",
-        });
-      }
-
-      // Verify current password
-      const isValidPassword = await this.verifyPassword(
-        currentPassword,
-        user.metadata?.passwordHash || ""
-      );
-
-      if (!isValidPassword) {
-        return reply.status(401).send({
-          success: false,
-          error: "Current password is incorrect",
-        });
-      }
-
-      // Validate new password length
-      if (newPassword.length < 6) {
-        return reply.status(400).send({
-          success: false,
-          error: "New password must be at least 6 characters",
-        });
-      }
-
-      // Update password
-      await this.userStore.updateUser(userId, {
-        metadata: {
-          ...user.metadata,
-          passwordHash: await this.hashPassword(newPassword),
-        },
-      });
-
-      return reply.send({
-        success: true,
-        message: "Password changed successfully",
-      });
-    } catch (error) {
-      console.error("Change password error:", error);
-      return reply.status(500).send({
-        success: false,
-        error: "Failed to change password",
-      });
-    }
-  }
-}
-
-export function extractUserFromAuthHeader(
-  authHeader: string | undefined
-): { id: string; tenantId?: string } | undefined {
-  if (!authHeader?.startsWith("Bearer ")) return undefined;
-  const token = authHeader.substring(7);
-  try {
-    const payload = JSON.parse(atob(token));
-    if (payload.exp && payload.exp < Date.now()) return undefined;
-    return {
-      id: payload.userId,
-      tenantId: payload.tenantId,
-    };
-  } catch {
-    return undefined;
-  }
-}
-
-export function registerAuthRoutes(
-  app: FastifyInstance,
-  config?: Partial<AuthConfig>
-) {
-  const controller = new AuthController(config);
-
-  const authHook = async (request: FastifyRequest, reply: FastifyReply) => {
-    const user = extractUserFromAuthHeader(request.headers.authorization);
-    if (!user) {
-      return reply.status(401).send({
-        success: false,
-        error: "Unauthorized",
-      });
-    }
-    (request as any).user = user;
-  };
-
-  app.post("/api/auth/register", controller.register.bind(controller));
-  app.post("/api/auth/login", controller.login.bind(controller));
-  app.get("/api/auth/tenants", { preHandler: authHook }, (req, res) => controller.getUserTenants(req, res));
-  app.post("/api/auth/select-tenant", { preHandler: authHook }, (req, res) => controller.selectTenant(req as any, res));
-  app.post("/api/auth/approve", { preHandler: authHook }, (req, res) => controller.approveUser(req as any, res));
-  app.get("/api/auth/pending", { preHandler: authHook }, (req, res) => controller.listPendingUsers(req, res));
-  app.post("/api/auth/assign-tenant", { preHandler: authHook }, (req, res) => controller.assignTenant(req as any, res));
-  app.post("/api/auth/change-password", { preHandler: authHook }, 
-    (req, res) => controller.changePassword(req as any, res)
-  );
-}

package/src/controllers/channel-bindings.ts

@@ -1,135 +0,0 @@
-import type { FastifyRequest, FastifyReply } from "fastify";
-import type { CreateBindingInput } from "@axiom-lattice/protocols";
-import { getBindingRegistry } from "@axiom-lattice/core";
-
-function getTenantId(request: FastifyRequest): string {
-  const userTenantId = (request as any).user?.tenantId;
-  if (userTenantId) return userTenantId;
-  return (request.headers["x-tenant-id"] as string) || "default";
-}
-
-export async function getBindingList(
-  request: FastifyRequest<{
-    Querystring: {
-      channel?: string;
-      agentId?: string;
-      channelInstallationId?: string;
-      limit?: number;
-      offset?: number;
-    };
-  }>,
-  _reply: FastifyReply,
-) {
-  const tenantId = getTenantId(request);
-  const { channel, agentId, channelInstallationId, limit, offset } = request.query;
-  try {
-    const registry = getBindingRegistry();
-    const bindings = await registry.list({ channel, agentId, tenantId, channelInstallationId, limit, offset });
-    return { success: true, message: "Bindings retrieved", data: { records: bindings, total: bindings.length } };
-  } catch (error) {
-    console.error("Failed to get bindings:", error);
-    return { success: false, message: "Failed to retrieve bindings", data: { records: [], total: 0 } };
-  }
-}
-
-export async function getBinding(
-  request: FastifyRequest<{ Params: { id: string } }>,
-  reply: FastifyReply,
-) {
-  const tenantId = getTenantId(request);
-  try {
-    const registry = getBindingRegistry();
-    const bindings = await registry.list({ tenantId });
-    const binding = bindings.find((b) => b.id === request.params.id);
-    if (!binding || binding.tenantId !== tenantId) {
-      reply.status(404);
-      return { success: false, message: "Binding not found" };
-    }
-    return { success: true, message: "Binding retrieved", data: binding };
-  } catch (error) {
-    console.error("Failed to get binding:", error);
-    return { success: false, message: "Failed to retrieve binding" };
-  }
-}
-
-export async function createBinding(
-  request: FastifyRequest<{ Body: CreateBindingInput }>,
-  reply: FastifyReply,
-) {
-  const tenantId = getTenantId(request);
-  try {
-    const registry = getBindingRegistry();
-    const binding = await registry.create({ ...request.body, tenantId });
-    reply.status(201);
-    return { success: true, message: "Binding created", data: binding };
-  } catch (error) {
-    console.error("Failed to create binding:", error);
-    reply.status(500);
-    return { success: false, message: "Failed to create binding" };
-  }
-}
-
-export async function updateBinding(
-  request: FastifyRequest<{ Params: { id: string }; Body: Partial<CreateBindingInput & { enabled: boolean }> }>,
-  reply: FastifyReply,
-) {
-  try {
-    const tenantId = getTenantId(request);
-    const registry = getBindingRegistry();
-    const bindings = await registry.list({ tenantId });
-    const existing = bindings.find((b) => b.id === request.params.id);
-    if (!existing || existing.tenantId !== tenantId) {
-      reply.status(404);
-      return { success: false, message: "Binding not found" };
-    }
-    const binding = await registry.update(request.params.id, request.body);
-    return { success: true, message: "Binding updated", data: binding };
-  } catch (error) {
-    console.error("Failed to update binding:", error);
-    reply.status(500);
-    return { success: false, message: "Failed to update binding" };
-  }
-}
-
-export async function deleteBinding(
-  request: FastifyRequest<{ Params: { id: string } }>,
-  reply: FastifyReply,
-) {
-  try {
-    const tenantId = getTenantId(request);
-    const registry = getBindingRegistry();
-    const bindings = await registry.list({ tenantId });
-    const existing = bindings.find((b) => b.id === request.params.id);
-    if (!existing || existing.tenantId !== tenantId) {
-      reply.status(404);
-      return { success: false, message: "Binding not found" };
-    }
-    await registry.delete(request.params.id);
-    return { success: true, message: "Binding deleted" };
-  } catch (error) {
-    console.error("Failed to delete binding:", error);
-    reply.status(500);
-    return { success: false, message: "Failed to delete binding" };
-  }
-}
-
-export async function resolveBinding(
-  request: FastifyRequest<{
-    Querystring: { channel: string; senderId: string; channelInstallationId: string };
-  }>,
-  _reply: FastifyReply,
-) {
-  const tenantId = getTenantId(request);
-  const { channel, senderId, channelInstallationId } = request.query;
-  try {
-    const registry = getBindingRegistry();
-    const binding = await registry.resolve({ channel, senderId, channelInstallationId, tenantId });
-    if (!binding) {
-      return { success: false, message: "No binding found", data: null };
-    }
-    return { success: true, message: "Binding found", data: binding };
-  } catch (error) {
-    console.error("Failed to resolve binding:", error);
-    return { success: false, message: "Failed to resolve binding", data: null };
-  }
-}