@vantageos/vantage-crm-mcp 0.1.0

package/dist/convex/users.js

@@ -0,0 +1,217 @@
+"use strict";
+/**
+ * User management functions
+ *
+ * Handles syncing Clerk users to Convex users table
+ * Enhanced with organization/workspace context support
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getByClerkId = exports.updateSettings = exports.getCurrentUser = exports.syncUser = void 0;
+const values_1 = require("convex/values");
+const server_1 = require("./_generated/server");
+const auth_1 = require("./lib/auth");
+/**
+ * Sync current Clerk user to Convex users table
+ *
+ * This should be called from the frontend after Clerk authentication
+ * to ensure the user exists in the Convex users table.
+ * Also syncs organization if user is in one, and ensures default workspace exists.
+ */
+exports.syncUser = (0, server_1.mutation)({
+    args: {},
+    handler: async (ctx) => {
+        const identity = await ctx.auth.getUserIdentity();
+        if (!identity) {
+            throw new Error('Not authenticated');
+        }
+        // Sync user
+        const user = await (0, auth_1.getOrCreateUser)(ctx, identity.subject, // clerkId
+        identity.tokenIdentifier, identity.email || '', identity.name || undefined, identity.pictureUrl || undefined);
+        if (!user) {
+            throw new Error('Failed to sync user');
+        }
+        // Ensure user has a default personal workspace
+        const defaultWorkspace = await ctx.db
+            .query('workspaces')
+            .withIndex('by_owner', (q) => q.eq('ownerId', user._id))
+            .filter((q) => q.and(q.eq(q.field('ownerType'), 'user'), q.eq(q.field('isDefault'), true)))
+            .first();
+        if (!defaultWorkspace) {
+            // Create default personal workspace
+            const workspaceId = await ctx.db.insert('workspaces', {
+                name: 'Personal',
+                ownerType: 'user',
+                ownerId: user._id,
+                isDefault: true,
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            });
+            // Set as active workspace
+            await ctx.db.patch(user._id, { activeWorkspaceId: workspaceId });
+        }
+        // If in organization context, sync org and membership
+        const orgId = identity.org_id;
+        const orgRole = identity.org_role;
+        const orgSlug = identity.org_slug;
+        if (orgId) {
+            // Get org name from claims (Clerk includes it)
+            const orgName = identity.org_name ||
+                orgSlug ||
+                'Organization';
+            // Sync organization
+            const org = await (0, auth_1.getOrCreateOrganization)(ctx, orgId, orgName, orgSlug, identity.org_image_url);
+            // Sync membership
+            if (org) {
+                await (0, auth_1.getOrCreateMembership)(ctx, user._id, org._id, identity.subject, orgId, orgRole || 'org:member');
+            }
+        }
+        return {
+            success: true,
+            userId: user._id,
+            role: user.role,
+        };
+    },
+});
+/**
+ * Get current user info with workspace context
+ * Returns user data + workspace info if authenticated, null otherwise
+ */
+exports.getCurrentUser = (0, server_1.query)({
+    args: {},
+    handler: async (ctx) => {
+        const identity = await ctx.auth.getUserIdentity();
+        if (!identity) {
+            return null;
+        }
+        // Try to find user by Clerk ID first
+        let user = await ctx.db
+            .query('users')
+            .withIndex('by_clerk_id', (q) => q.eq('clerkId', identity.subject))
+            .first();
+        // Fallback to token identifier
+        if (!user) {
+            user = await ctx.db
+                .query('users')
+                .withIndex('by_token', (q) => q.eq('tokenIdentifier', identity.tokenIdentifier))
+                .first();
+        }
+        if (!user) {
+            // User not synced yet
+            return null;
+        }
+        // Get Clerk workspace context (org from token)
+        const clerkWorkspace = await (0, auth_1.getWorkspaceContext)(ctx);
+        // Get active Vantage workspace
+        let activeWorkspace = null;
+        if (user.activeWorkspaceId) {
+            activeWorkspace = await ctx.db.get(user.activeWorkspaceId);
+        }
+        // If no active workspace, get the default one
+        if (!activeWorkspace) {
+            activeWorkspace = await ctx.db
+                .query('workspaces')
+                .withIndex('by_owner', (q) => q.eq('ownerId', user._id))
+                .filter((q) => q.and(q.eq(q.field('ownerType'), 'user'), q.eq(q.field('isDefault'), true)))
+                .first();
+        }
+        // If in org context (from Clerk token), get org details
+        let organization = null;
+        const currentOrgId = clerkWorkspace.orgId;
+        if (currentOrgId) {
+            organization = await ctx.db
+                .query('organizations')
+                .withIndex('by_clerk_id', (q) => q.eq('clerkId', currentOrgId))
+                .first();
+        }
+        return {
+            _id: user._id,
+            clerkId: user.clerkId,
+            email: user.email,
+            name: user.name,
+            firstName: user.firstName,
+            lastName: user.lastName,
+            role: user.role,
+            avatarUrl: user.avatarUrl,
+            settings: user.settings,
+            activeWorkspaceId: user.activeWorkspaceId,
+            createdAt: user.createdAt,
+            updatedAt: user.updatedAt,
+            // Active Vantage workspace
+            activeWorkspace: activeWorkspace
+                ? {
+                    _id: activeWorkspace._id,
+                    name: activeWorkspace.name,
+                    slug: activeWorkspace.slug,
+                    icon: activeWorkspace.icon,
+                    color: activeWorkspace.color,
+                    ownerType: activeWorkspace.ownerType,
+                    isDefault: activeWorkspace.isDefault,
+                }
+                : null,
+            // Clerk context (which org user is viewing)
+            clerkContext: {
+                orgId: clerkWorkspace.orgId,
+                entityId: clerkWorkspace.entityId,
+                isPersonal: clerkWorkspace.isPersonal,
+                organization: organization
+                    ? {
+                        _id: organization._id,
+                        name: organization.name,
+                        slug: organization.slug,
+                        imageUrl: organization.imageUrl,
+                        plan: organization.plan,
+                    }
+                    : null,
+            },
+        };
+    },
+});
+/**
+ * Update user settings
+ */
+exports.updateSettings = (0, server_1.mutation)({
+    args: {
+        theme: values_1.v.optional(values_1.v.string()),
+        defaultModel: values_1.v.optional(values_1.v.string()),
+        notifications: values_1.v.optional(values_1.v.boolean()),
+    },
+    handler: async (ctx, args) => {
+        const identity = await ctx.auth.getUserIdentity();
+        if (!identity)
+            throw new Error('Not authenticated');
+        const user = await ctx.db
+            .query('users')
+            .withIndex('by_clerk_id', (q) => q.eq('clerkId', identity.subject))
+            .first();
+        if (!user)
+            throw new Error('User not found');
+        const currentSettings = user.settings || {};
+        const newSettings = {
+            ...currentSettings,
+            ...(args.theme !== undefined && { theme: args.theme }),
+            ...(args.defaultModel !== undefined && {
+                defaultModel: args.defaultModel,
+            }),
+            ...(args.notifications !== undefined && {
+                notifications: args.notifications,
+            }),
+        };
+        await ctx.db.patch(user._id, {
+            settings: newSettings,
+            updatedAt: Date.now(),
+        });
+        return { success: true };
+    },
+});
+/**
+ * Get user by Clerk ID
+ */
+exports.getByClerkId = (0, server_1.query)({
+    args: { clerkId: values_1.v.string() },
+    handler: async (ctx, { clerkId }) => {
+        return await ctx.db
+            .query('users')
+            .withIndex('by_clerk_id', (q) => q.eq('clerkId', clerkId))
+            .first();
+    },
+});