@devlider001/washlab-backend 1.0.4 → 1.0.5

package/dist/convex/admin.js

@@ -0,0 +1,959 @@
+import { query, mutation } from "./_generated/server";
+import { v } from "convex/values";
+import { paginationOptsValidator } from "convex/server";
+import { getCurrentAdmin, getSuperAdmin, getCurrentAttendant, verifyAttendantBranch } from "./lib/auth";
+import { createAuditLog } from "./lib/audit";
+import { getCurrentTimestamp } from "./lib/utils";
+/**
+ * Admin Functions
+ *
+ * Handles admin operations: branch management, attendant management,
+ * system-wide order viewing, analytics, and customer management.
+ */
+/**
+ * Get current admin profile (from authenticated Clerk session)
+ */
+export const getCurrentUser = query({
+    args: {},
+    handler: async (ctx) => {
+        const admin = await getCurrentAdmin(ctx);
+        return admin;
+    },
+});
+/**
+ * Get all branches - Paginated
+ * Supports usePaginatedQuery for infinite scroll
+ */
+export const getBranches = query({
+    args: {
+        includeInactive: v.optional(v.boolean()),
+        cursor: v.optional(v.string()),
+        numItems: v.optional(v.number()),
+    },
+    handler: async (ctx, args) => {
+        await getCurrentAdmin(ctx);
+        const numItems = args.numItems ?? 20;
+        const result = await ctx.db
+            .query("branches")
+            .filter((q) => q.eq(q.field("isDeleted"), false))
+            .paginate({
+            cursor: args.cursor ?? null,
+            numItems,
+        });
+        let filtered = result.page;
+        if (!args.includeInactive) {
+            filtered = filtered.filter((b) => b.isActive);
+        }
+        return {
+            page: filtered,
+            isDone: result.isDone,
+            continueCursor: result.continueCursor,
+        };
+    },
+});
+/**
+ * Get branch by code
+ */
+export const getBranchByCode = query({
+    args: {
+        code: v.string(),
+    },
+    handler: async (ctx, args) => {
+        // Allow both attendants and admins
+        try {
+            await getCurrentAttendant(ctx);
+        }
+        catch {
+            await getCurrentAdmin(ctx);
+        }
+        const branch = await ctx.db
+            .query("branches")
+            .withIndex("by_code", (q) => q.eq("code", args.code.toUpperCase()))
+            .first();
+        if (!branch || branch.isDeleted) {
+            return null;
+        }
+        return branch;
+    },
+});
+/**
+ * Get single branch by ID
+ */
+export const getBranch = query({
+    args: {
+        branchId: v.id("branches"),
+    },
+    handler: async (ctx, args) => {
+        // Allow both attendants and admins
+        try {
+            const attendant = await getCurrentAttendant(ctx);
+            await verifyAttendantBranch(ctx, attendant._id, args.branchId);
+        }
+        catch {
+            await getCurrentAdmin(ctx);
+        }
+        const branch = await ctx.db.get(args.branchId);
+        if (!branch || branch.isDeleted) {
+            return null;
+        }
+        return branch;
+    },
+});
+/**
+ * Get all attendants - Paginated
+ * Supports usePaginatedQuery for infinite scroll
+ */
+export const getAttendants = query({
+    args: {
+        branchId: v.optional(v.id("branches")),
+        includeInactive: v.optional(v.boolean()),
+        cursor: v.optional(v.string()),
+        numItems: v.optional(v.number()),
+    },
+    handler: async (ctx, args) => {
+        await getCurrentAdmin(ctx);
+        const numItems = args.numItems ?? 20;
+        let query;
+        if (args.branchId) {
+            query = ctx.db
+                .query("attendants")
+                .withIndex("by_branch", (q) => q.eq("branchId", args.branchId));
+        }
+        else {
+            query = ctx.db.query("attendants");
+        }
+        const result = await query
+            .filter((q) => q.eq(q.field("isDeleted"), false))
+            .paginate({
+            cursor: args.cursor ?? null,
+            numItems,
+        });
+        let filtered = result.page;
+        if (!args.includeInactive) {
+            filtered = filtered.filter((a) => a.isActive);
+        }
+        return {
+            page: filtered,
+            isDone: result.isDone,
+            continueCursor: result.continueCursor,
+        };
+    },
+});
+/**
+ * Get all orders (with filters) - Paginated
+ * Supports usePaginatedQuery for infinite scroll
+ */
+export const getOrders = query({
+    args: {
+        branchId: v.optional(v.id("branches")),
+        status: v.optional(v.union(v.literal("pending"), v.literal("in_progress"), v.literal("ready_for_pickup"), v.literal("delivered"), v.literal("completed"), v.literal("cancelled"))),
+        startDate: v.optional(v.number()),
+        endDate: v.optional(v.number()),
+        cursor: v.optional(v.string()),
+        numItems: v.optional(v.number()),
+    },
+    handler: async (ctx, args) => {
+        await getCurrentAdmin(ctx);
+        const numItems = args.numItems ?? 20;
+        // Build base query
+        let query;
+        if (args.branchId) {
+            query = ctx.db
+                .query("orders")
+                .withIndex("by_branch", (q) => q.eq("branchId", args.branchId))
+                .order("desc");
+        }
+        else {
+            query = ctx.db
+                .query("orders")
+                .withIndex("by_created")
+                .order("desc");
+        }
+        // Apply pagination
+        const result = await query
+            .filter((q) => q.eq(q.field("isDeleted"), false))
+            .paginate({
+            cursor: args.cursor ?? null,
+            numItems,
+        });
+        // Apply additional filters
+        let filtered = result.page;
+        if (args.status) {
+            filtered = filtered.filter((o) => o.status === args.status);
+        }
+        if (args.startDate) {
+            filtered = filtered.filter((o) => o.createdAt >= args.startDate);
+        }
+        if (args.endDate) {
+            filtered = filtered.filter((o) => o.createdAt <= args.endDate);
+        }
+        return {
+            page: filtered,
+            isDone: result.isDone,
+            continueCursor: result.continueCursor,
+        };
+    },
+});
+/**
+ * Get analytics dashboard data
+ */
+export const getAnalytics = query({
+    args: {
+        branchId: v.optional(v.id("branches")),
+        startDate: v.optional(v.number()),
+        endDate: v.optional(v.number()),
+    },
+    handler: async (ctx, args) => {
+        await getCurrentAdmin(ctx);
+        // Get all orders in date range
+        let orders;
+        if (args.branchId) {
+            orders = await ctx.db
+                .query("orders")
+                .withIndex("by_branch", (q) => q.eq("branchId", args.branchId))
+                .collect();
+        }
+        else {
+            orders = await ctx.db.query("orders").collect();
+        }
+        let filtered = orders.filter((o) => !o.isDeleted);
+        if (args.startDate) {
+            filtered = filtered.filter((o) => o.createdAt >= args.startDate);
+        }
+        if (args.endDate) {
+            filtered = filtered.filter((o) => o.createdAt <= args.endDate);
+        }
+        // Calculate metrics
+        const totalOrders = filtered.length;
+        const totalRevenue = filtered
+            .filter((o) => o.paymentStatus === "paid")
+            .reduce((sum, o) => sum + o.finalPrice, 0);
+        const ordersByStatus = filtered.reduce((acc, o) => {
+            acc[o.status] = (acc[o.status] || 0) + 1;
+            return acc;
+        }, {});
+        const ordersByDay = filtered.reduce((acc, o) => {
+            const date = new Date(o.createdAt).toISOString().split("T")[0];
+            acc[date] = (acc[date] || 0) + 1;
+            return acc;
+        }, {});
+        // Top customers by order count
+        const customerOrderCounts = filtered.reduce((acc, o) => {
+            acc[o.customerId] = (acc[o.customerId] || 0) + 1;
+            return acc;
+        }, {});
+        const topCustomerIds = Object.entries(customerOrderCounts)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, 10)
+            .map(([id]) => id);
+        const topCustomers = await Promise.all(topCustomerIds.map(async (id) => {
+            const customer = await ctx.db.get(id);
+            return {
+                customerId: id,
+                name: customer?.name || "Unknown",
+                phoneNumber: customer?.phoneNumber || "",
+                orderCount: customerOrderCounts[id],
+            };
+        }));
+        const averageOrderValue = totalOrders > 0 ? totalRevenue / totalOrders : 0;
+        return {
+            totalOrders,
+            totalRevenue,
+            averageOrderValue: Math.round(averageOrderValue * 100) / 100,
+            ordersByStatus,
+            ordersByDay,
+            topCustomers,
+            dateRange: {
+                start: args.startDate,
+                end: args.endDate,
+            },
+        };
+    },
+});
+/**
+ * Get all customers (with filters) - Paginated
+ * Supports usePaginatedQuery for infinite scroll
+ */
+export const getCustomers = query({
+    args: {
+        search: v.optional(v.string()), // Search by name or phone
+        status: v.optional(v.union(v.literal("active"), v.literal("blocked"), v.literal("suspended"), v.literal("restricted"))), // Filter by status
+        isRegistered: v.optional(v.boolean()), // Filter by registered status
+        paginationOpts: paginationOptsValidator, // Pagination options from usePaginatedQuery
+    },
+    handler: async (ctx, args) => {
+        await getCurrentAdmin(ctx);
+        // Get all customers with pagination
+        let result;
+        // Use index if filtering by status
+        if (args.status) {
+            result = await ctx.db
+                .query("users")
+                .withIndex("by_status", (q) => q.eq("status", args.status))
+                .filter((q) => q.eq(q.field("isDeleted"), false))
+                .paginate(args.paginationOpts);
+        }
+        else {
+            result = await ctx.db
+                .query("users")
+                .filter((q) => q.eq(q.field("isDeleted"), false))
+                .paginate(args.paginationOpts);
+        }
+        let filtered = result.page;
+        // Apply search filter
+        if (args.search) {
+            const searchLower = args.search.toLowerCase();
+            filtered = filtered.filter((c) => c.name.toLowerCase().includes(searchLower) ||
+                c.phoneNumber.includes(args.search));
+        }
+        // Apply registered filter
+        if (args.isRegistered !== undefined) {
+            filtered = filtered.filter((c) => c.isRegistered === args.isRegistered);
+        }
+        // Enrich with order stats
+        const customersWithStats = await Promise.all(filtered.map(async (customer) => {
+            const orders = await ctx.db
+                .query("orders")
+                .withIndex("by_customer", (q) => q.eq("customerId", customer._id))
+                .collect();
+            const activeOrders = orders.filter((o) => !o.isDeleted);
+            const completedOrders = activeOrders.filter((o) => o.status === "completed");
+            const totalSpent = activeOrders
+                .filter((o) => o.paymentStatus === "paid")
+                .reduce((sum, o) => sum + o.finalPrice, 0);
+            const lastOrder = activeOrders
+                .sort((a, b) => b.createdAt - a.createdAt)[0];
+            return {
+                ...customer,
+                orderCount: activeOrders.length,
+                completedOrderCount: completedOrders.length,
+                totalSpent: Math.round(totalSpent * 100) / 100,
+                lastOrderDate: lastOrder?.createdAt,
+                lastOrderNumber: lastOrder?.orderNumber,
+            };
+        }));
+        return {
+            page: customersWithStats,
+            isDone: result.isDone,
+            continueCursor: result.continueCursor,
+        };
+    },
+});
+/**
+ * Get customer statistics/aggregations
+ */
+export const getCustomerStats = query({
+    args: {},
+    handler: async (ctx) => {
+        await getCurrentAdmin(ctx);
+        const allCustomers = await ctx.db
+            .query("users")
+            .filter((q) => q.eq(q.field("isDeleted"), false))
+            .collect();
+        const totalCustomers = allCustomers.length;
+        const registeredCustomers = allCustomers.filter((c) => c.isRegistered).length;
+        const walkInCustomers = allCustomers.filter((c) => !c.isRegistered).length;
+        const activeStatusCustomers = allCustomers.filter((c) => c.status === "active").length;
+        const blockedCustomers = allCustomers.filter((c) => c.status === "blocked").length;
+        const suspendedCustomers = allCustomers.filter((c) => c.status === "suspended").length;
+        const restrictedCustomers = allCustomers.filter((c) => c.status === "restricted").length;
+        const verifiedCustomers = allCustomers.filter((c) => c.isVerified).length;
+        // Get customers with orders
+        const customersWithOrders = await Promise.all(allCustomers.map(async (customer) => {
+            const orders = await ctx.db
+                .query("orders")
+                .withIndex("by_customer", (q) => q.eq("customerId", customer._id))
+                .collect();
+            return {
+                customerId: customer._id,
+                hasOrders: orders.filter((o) => !o.isDeleted).length > 0,
+            };
+        }));
+        const customersWithActiveOrders = customersWithOrders.filter((c) => c.hasOrders).length;
+        // Calculate total revenue from all customers
+        let totalRevenue = 0;
+        for (const customer of allCustomers) {
+            const orders = await ctx.db
+                .query("orders")
+                .withIndex("by_customer", (q) => q.eq("customerId", customer._id))
+                .collect();
+            const customerRevenue = orders
+                .filter((o) => !o.isDeleted && o.paymentStatus === "paid")
+                .reduce((sum, o) => sum + o.finalPrice, 0);
+            totalRevenue += customerRevenue;
+        }
+        return {
+            totalCustomers,
+            registeredCustomers,
+            walkInCustomers,
+            activeCustomers: activeStatusCustomers,
+            blockedCustomers,
+            suspendedCustomers,
+            restrictedCustomers,
+            verifiedCustomers,
+            customersWithActiveOrders,
+            totalRevenue: Math.round(totalRevenue * 100) / 100,
+        };
+    },
+});
+/**
+ * Change customer status (with required note)
+ */
+export const changeCustomerStatus = mutation({
+    args: {
+        customerId: v.id("users"),
+        status: v.union(v.literal("active"), v.literal("blocked"), v.literal("suspended"), v.literal("restricted")),
+        note: v.string(), // Required note explaining the status change
+    },
+    handler: async (ctx, args) => {
+        const admin = await getCurrentAdmin(ctx);
+        if (!args.note || args.note.trim().length < 3) {
+            throw new Error("Note is required and must be at least 3 characters");
+        }
+        const customer = await ctx.db.get(args.customerId);
+        if (!customer || customer.isDeleted) {
+            throw new Error("Customer not found");
+        }
+        if (customer.status === args.status) {
+            throw new Error(`Customer is already ${args.status}`);
+        }
+        const now = getCurrentTimestamp();
+        await ctx.db.patch(args.customerId, {
+            status: args.status,
+            statusNote: args.note.trim(),
+            statusChangedBy: admin._id,
+            statusChangedAt: now,
+        });
+        // Get admin name for audit log
+        const adminName = admin.name || admin.email;
+        await createAuditLog({
+            ctx,
+            actorId: admin._id,
+            actorType: "admin",
+            actorRole: admin.role,
+            action: `customer.status_changed`,
+            entityType: "user",
+            entityId: args.customerId,
+            details: JSON.stringify({
+                customerName: customer.name,
+                phoneNumber: customer.phoneNumber,
+                oldStatus: customer.status,
+                newStatus: args.status,
+                note: args.note.trim(),
+                changedBy: adminName,
+            }),
+        });
+        return args.customerId;
+    },
+});
+/**
+ * Delete a customer (soft delete)
+ */
+export const deleteCustomer = mutation({
+    args: {
+        customerId: v.id("users"),
+    },
+    handler: async (ctx, args) => {
+        const admin = await getCurrentAdmin(ctx);
+        const customer = await ctx.db.get(args.customerId);
+        if (!customer || customer.isDeleted) {
+            throw new Error("Customer not found");
+        }
+        // Check for active orders
+        const activeOrders = await ctx.db
+            .query("orders")
+            .withIndex("by_customer", (q) => q.eq("customerId", args.customerId))
+            .filter((q) => q.eq(q.field("isDeleted"), false))
+            .filter((q) => q.neq(q.field("status"), "completed"))
+            .collect();
+        if (activeOrders.length > 0) {
+            throw new Error(`Cannot delete customer with ${activeOrders.length} active order(s). Please complete or cancel orders first.`);
+        }
+        await ctx.db.patch(args.customerId, {
+            isDeleted: true,
+        });
+        await createAuditLog({
+            ctx,
+            actorId: admin._id,
+            actorType: "admin",
+            actorRole: admin.role,
+            action: "customer.deleted",
+            entityType: "user",
+            entityId: args.customerId,
+            details: JSON.stringify({ customerName: customer.name, phoneNumber: customer.phoneNumber }),
+        });
+        return args.customerId;
+    },
+});
+/**
+ * Create new branch
+ */
+export const createBranch = mutation({
+    args: {
+        name: v.string(),
+        code: v.string(), // Unique branch code (e.g., "IND", "BRU")
+        address: v.string(),
+        city: v.string(),
+        country: v.string(),
+        phoneNumber: v.string(),
+        email: v.optional(v.string()),
+        pricingPerKg: v.number(),
+        deliveryFee: v.number(),
+    },
+    handler: async (ctx, args) => {
+        const admin = await getCurrentAdmin(ctx);
+        // Validate and normalize code (uppercase, no spaces)
+        const code = args.code.toUpperCase().trim().replace(/\s+/g, "");
+        if (code.length < 2 || code.length > 10) {
+            throw new Error("Branch code must be between 2 and 10 characters");
+        }
+        // Check if code already exists
+        const existing = await ctx.db
+            .query("branches")
+            .withIndex("by_code", (q) => q.eq("code", code))
+            .first();
+        if (existing && !existing.isDeleted) {
+            throw new Error(`Branch code "${code}" already exists`);
+        }
+        const now = getCurrentTimestamp();
+        const branchId = await ctx.db.insert("branches", {
+            name: args.name,
+            code,
+            address: args.address,
+            city: args.city,
+            country: args.country,
+            phoneNumber: args.phoneNumber,
+            email: args.email,
+            pricingPerKg: args.pricingPerKg,
+            deliveryFee: args.deliveryFee,
+            isActive: true,
+            createdAt: now,
+            createdBy: admin._id,
+            isDeleted: false,
+        });
+        await createAuditLog({
+            ctx,
+            actorId: admin._id,
+            actorType: "admin",
+            actorRole: admin.role,
+            action: "branch.created",
+            entityType: "branch",
+            entityId: branchId,
+            details: JSON.stringify({ ...args, code }),
+        });
+        return branchId;
+    },
+});
+/**
+ * Update branch details
+ */
+export const updateBranch = mutation({
+    args: {
+        branchId: v.id("branches"),
+        name: v.optional(v.string()),
+        code: v.optional(v.string()), // Unique branch code
+        address: v.optional(v.string()),
+        city: v.optional(v.string()),
+        country: v.optional(v.string()),
+        phoneNumber: v.optional(v.string()),
+        email: v.optional(v.string()),
+        pricingPerKg: v.optional(v.number()),
+        deliveryFee: v.optional(v.number()),
+        isActive: v.optional(v.boolean()),
+    },
+    handler: async (ctx, args) => {
+        const admin = await getCurrentAdmin(ctx);
+        const branch = await ctx.db.get(args.branchId);
+        if (!branch || branch.isDeleted) {
+            throw new Error("Branch not found");
+        }
+        const { branchId, code, ...updates } = args;
+        // Prepare update object with proper typing
+        const updateData = { ...updates };
+        // If code is being updated, validate uniqueness
+        if (code !== undefined) {
+            const normalizedCode = code.toUpperCase().trim().replace(/\s+/g, "");
+            if (normalizedCode.length < 2 || normalizedCode.length > 10) {
+                throw new Error("Branch code must be between 2 and 10 characters");
+            }
+            // Check if code already exists (excluding current branch)
+            const existing = await ctx.db
+                .query("branches")
+                .withIndex("by_code", (q) => q.eq("code", normalizedCode))
+                .first();
+            if (existing && existing._id !== args.branchId && !existing.isDeleted) {
+                throw new Error(`Branch code "${normalizedCode}" already exists`);
+            }
+            updateData.code = normalizedCode;
+        }
+        await ctx.db.patch(args.branchId, updateData);
+        await createAuditLog({
+            ctx,
+            actorId: admin._id,
+            actorType: "admin",
+            actorRole: admin.role,
+            action: "branch.updated",
+            entityType: "branch",
+            entityId: args.branchId,
+            oldValue: JSON.stringify(branch),
+            newValue: JSON.stringify({ ...branch, ...updates }),
+        });
+        return args.branchId;
+    },
+});
+/**
+ * Toggle branch active status (enable/disable)
+ */
+export const toggleBranchStatus = mutation({
+    args: {
+        branchId: v.id("branches"),
+    },
+    handler: async (ctx, args) => {
+        const admin = await getCurrentAdmin(ctx);
+        const branch = await ctx.db.get(args.branchId);
+        if (!branch || branch.isDeleted) {
+            throw new Error("Branch not found");
+        }
+        const newStatus = !branch.isActive;
+        await ctx.db.patch(args.branchId, {
+            isActive: newStatus,
+        });
+        await createAuditLog({
+            ctx,
+            actorId: admin._id,
+            actorType: "admin",
+            actorRole: admin.role,
+            action: newStatus ? "branch.enabled" : "branch.disabled",
+            entityType: "branch",
+            entityId: args.branchId,
+            branchId: args.branchId,
+            oldValue: JSON.stringify({ isActive: branch.isActive }),
+            newValue: JSON.stringify({ isActive: newStatus }),
+        });
+        return { branchId: args.branchId, isActive: newStatus };
+    },
+});
+/**
+ * Delete branch (soft delete)
+ */
+export const deleteBranch = mutation({
+    args: {
+        branchId: v.id("branches"),
+    },
+    handler: async (ctx, args) => {
+        const admin = await getCurrentAdmin(ctx);
+        const branch = await ctx.db.get(args.branchId);
+        if (!branch || branch.isDeleted) {
+            throw new Error("Branch not found");
+        }
+        // Check if branch has active orders
+        const activeOrders = await ctx.db
+            .query("orders")
+            .withIndex("by_branch", (q) => q.eq("branchId", args.branchId))
+            .filter((q) => q.and(q.eq(q.field("isDeleted"), false), q.neq(q.field("status"), "completed"), q.neq(q.field("status"), "cancelled")))
+            .first();
+        if (activeOrders) {
+            throw new Error("Cannot delete branch with active orders. Please complete or cancel all orders first.");
+        }
+        await ctx.db.patch(args.branchId, {
+            isDeleted: true,
+            isActive: false, // Also deactivate when deleting
+        });
+        await createAuditLog({
+            ctx,
+            actorId: admin._id,
+            actorType: "admin",
+            actorRole: admin.role,
+            action: "branch.deleted",
+            entityType: "branch",
+            entityId: args.branchId,
+            branchId: args.branchId,
+            oldValue: JSON.stringify(branch),
+        });
+        return args.branchId;
+    },
+});
+/**
+ * Create attendant account
+ * Note: Clerk user must be created separately, then link clerkUserId
+ */
+export const createAttendant = mutation({
+    args: {
+        name: v.string(),
+        email: v.string(),
+        phoneNumber: v.string(),
+        clerkUserId: v.string(), // Clerk user ID (must be created in Clerk first)
+        branchId: v.id("branches"),
+        passcode: v.optional(v.string()),
+    },
+    handler: async (ctx, args) => {
+        const admin = await getCurrentAdmin(ctx);
+        // Verify branch exists
+        const branch = await ctx.db.get(args.branchId);
+        if (!branch || branch.isDeleted) {
+            throw new Error("Branch not found");
+        }
+        // Check if attendant already exists with this email or Clerk ID
+        const existingByEmail = await ctx.db
+            .query("attendants")
+            .withIndex("by_email", (q) => q.eq("email", args.email))
+            .first();
+        if (existingByEmail && !existingByEmail.isDeleted) {
+            throw new Error("Attendant with this email already exists");
+        }
+        const existingByClerk = await ctx.db
+            .query("attendants")
+            .withIndex("by_clerk_user", (q) => q.eq("clerkUserId", args.clerkUserId))
+            .first();
+        if (existingByClerk && !existingByClerk.isDeleted) {
+            throw new Error("Attendant with this Clerk account already exists");
+        }
+        const now = getCurrentTimestamp();
+        const attendantId = await ctx.db.insert("attendants", {
+            name: args.name,
+            email: args.email,
+            phoneNumber: args.phoneNumber,
+            clerkUserId: args.clerkUserId,
+            branchId: args.branchId,
+            passcode: args.passcode,
+            isActive: true,
+            createdAt: now,
+            isDeleted: false,
+        });
+        await createAuditLog({
+            ctx,
+            actorId: admin._id,
+            actorType: "admin",
+            actorRole: admin.role,
+            action: "attendant.created",
+            entityType: "attendant",
+            entityId: attendantId,
+            branchId: args.branchId,
+            details: JSON.stringify({ email: args.email, name: args.name }),
+        });
+        return attendantId;
+    },
+});
+/**
+ * Update attendant details
+ */
+export const updateAttendant = mutation({
+    args: {
+        attendantId: v.id("attendants"),
+        name: v.optional(v.string()),
+        email: v.optional(v.string()),
+        phoneNumber: v.optional(v.string()),
+        branchId: v.optional(v.id("branches")),
+        isActive: v.optional(v.boolean()),
+        passcode: v.optional(v.string()),
+    },
+    handler: async (ctx, args) => {
+        const admin = await getCurrentAdmin(ctx);
+        const attendant = await ctx.db.get(args.attendantId);
+        if (!attendant || attendant.isDeleted) {
+            throw new Error("Attendant not found");
+        }
+        const { attendantId, ...updates } = args;
+        if (args.branchId) {
+            // Verify branch exists
+            const branch = await ctx.db.get(args.branchId);
+            if (!branch || branch.isDeleted) {
+                throw new Error("Branch not found");
+            }
+        }
+        await ctx.db.patch(args.attendantId, updates);
+        await createAuditLog({
+            ctx,
+            actorId: admin._id,
+            actorType: "admin",
+            actorRole: admin.role,
+            action: "attendant.updated",
+            entityType: "attendant",
+            entityId: args.attendantId,
+            branchId: attendant.branchId,
+            oldValue: JSON.stringify(attendant),
+            newValue: JSON.stringify({ ...attendant, ...updates }),
+        });
+        return args.attendantId;
+    },
+});
+/**
+ * Assign attendant to branch
+ */
+export const assignAttendantToBranch = mutation({
+    args: {
+        attendantId: v.id("attendants"),
+        branchId: v.id("branches"),
+    },
+    handler: async (ctx, args) => {
+        const admin = await getCurrentAdmin(ctx);
+        const attendant = await ctx.db.get(args.attendantId);
+        if (!attendant || attendant.isDeleted) {
+            throw new Error("Attendant not found");
+        }
+        const branch = await ctx.db.get(args.branchId);
+        if (!branch || branch.isDeleted) {
+            throw new Error("Branch not found");
+        }
+        await ctx.db.patch(args.attendantId, {
+            branchId: args.branchId,
+        });
+        await createAuditLog({
+            ctx,
+            actorId: admin._id,
+            actorType: "admin",
+            actorRole: admin.role,
+            action: "attendant.assigned_to_branch",
+            entityType: "attendant",
+            entityId: args.attendantId,
+            branchId: args.branchId,
+            details: JSON.stringify({
+                previousBranchId: attendant.branchId,
+                newBranchId: args.branchId,
+            }),
+        });
+        return args.attendantId;
+    },
+});
+/**
+ * Delete attendant (soft delete)
+ */
+export const deleteAttendant = mutation({
+    args: {
+        attendantId: v.id("attendants"),
+    },
+    handler: async (ctx, args) => {
+        const admin = await getCurrentAdmin(ctx);
+        const attendant = await ctx.db.get(args.attendantId);
+        if (!attendant || attendant.isDeleted) {
+            throw new Error("Attendant not found");
+        }
+        // Check if attendant has active orders
+        const activeOrders = await ctx.db
+            .query("orders")
+            .withIndex("by_fulfilled_by", (q) => q.eq("fulfilledBy", args.attendantId))
+            .filter((q) => q.and(q.eq(q.field("isDeleted"), false), q.neq(q.field("status"), "completed"), q.neq(q.field("status"), "cancelled")))
+            .first();
+        if (activeOrders) {
+            throw new Error("Cannot delete attendant with active orders. Please complete or cancel all orders first.");
+        }
+        await ctx.db.patch(args.attendantId, {
+            isDeleted: true,
+            isActive: false, // Also deactivate when deleting
+        });
+        await createAuditLog({
+            ctx,
+            actorId: admin._id,
+            actorType: "admin",
+            actorRole: admin.role,
+            action: "attendant.deleted",
+            entityType: "attendant",
+            entityId: args.attendantId,
+            branchId: attendant.branchId,
+            oldValue: JSON.stringify(attendant),
+        });
+        return args.attendantId;
+    },
+});
+/**
+ * Create admin account
+ * Only super admins can create other admins
+ * Note: Clerk user must be created separately, then link clerkUserId
+ */
+export const createAdmin = mutation({
+    args: {
+        name: v.string(),
+        email: v.string(),
+        clerkUserId: v.string(), // Clerk user ID (must be created in Clerk first)
+        role: v.union(v.literal("admin"), v.literal("super_admin")),
+    },
+    handler: async (ctx, args) => {
+        const superAdmin = await getSuperAdmin(ctx);
+        // Check if admin already exists with this email or Clerk ID
+        const existingByEmail = await ctx.db
+            .query("admins")
+            .withIndex("by_email", (q) => q.eq("email", args.email))
+            .first();
+        if (existingByEmail && !existingByEmail.isDeleted) {
+            throw new Error("Admin with this email already exists");
+        }
+        const existingByClerk = await ctx.db
+            .query("admins")
+            .withIndex("by_clerk_user", (q) => q.eq("clerkUserId", args.clerkUserId))
+            .first();
+        if (existingByClerk && !existingByClerk.isDeleted) {
+            throw new Error("Admin with this Clerk account already exists");
+        }
+        const now = getCurrentTimestamp();
+        const adminId = await ctx.db.insert("admins", {
+            name: args.name,
+            email: args.email,
+            clerkUserId: args.clerkUserId,
+            role: args.role,
+            createdAt: now,
+            lastLoginAt: now,
+            isDeleted: false,
+        });
+        await createAuditLog({
+            ctx,
+            actorId: superAdmin._id,
+            actorType: "admin",
+            actorRole: superAdmin.role,
+            action: "admin.created",
+            entityType: "admin",
+            entityId: adminId,
+            details: JSON.stringify({ email: args.email, name: args.name, role: args.role }),
+        });
+        return adminId;
+    },
+});
+/**
+ * Create the first super admin (one-time setup)
+ * This function can only be used when no super admins exist in the database
+ * After the first super admin is created, use createAdmin instead
+ */
+export const createFirstSuperAdmin = mutation({
+    args: {
+        name: v.string(),
+        email: v.string(),
+        clerkUserId: v.string(), // Clerk user ID (must be created in Clerk first)
+    },
+    handler: async (ctx, args) => {
+        // Check if any super admin already exists
+        const existingSuperAdmin = await ctx.db
+            .query("admins")
+            .filter((q) => q.eq(q.field("role"), "super_admin"))
+            .filter((q) => q.eq(q.field("isDeleted"), false))
+            .first();
+        if (existingSuperAdmin) {
+            throw new Error("Super admin already exists. Use createAdmin mutation instead.");
+        }
+        // Check if admin already exists with this email or Clerk ID
+        const existingByEmail = await ctx.db
+            .query("admins")
+            .withIndex("by_email", (q) => q.eq("email", args.email))
+            .first();
+        if (existingByEmail && !existingByEmail.isDeleted) {
+            throw new Error("Admin with this email already exists");
+        }
+        const existingByClerk = await ctx.db
+            .query("admins")
+            .withIndex("by_clerk_user", (q) => q.eq("clerkUserId", args.clerkUserId))
+            .first();
+        if (existingByClerk && !existingByClerk.isDeleted) {
+            throw new Error("Admin with this Clerk account already exists");
+        }
+        const now = getCurrentTimestamp();
+        const adminId = await ctx.db.insert("admins", {
+            name: args.name,
+            email: args.email,
+            clerkUserId: args.clerkUserId,
+            role: "super_admin",
+            createdAt: now,
+            lastLoginAt: now,
+            isDeleted: false,
+        });
+        return adminId;
+    },
+});
+//# sourceMappingURL=admin.js.map