@nordsym/apiclaw 1.8.6 → 1.8.7

package/convex/providers.js

@@ -1,922 +0,0 @@
-import { mutation, query } from "./_generated/server";
-import { v } from "convex/values";
-// Register a new provider and their first API
-export const registerProvider = mutation({
-    args: {
-        provider: v.object({
-            name: v.string(),
-            email: v.string(),
-            website: v.optional(v.string()),
-        }),
-        api: v.object({
-            name: v.string(),
-            description: v.string(),
-            category: v.string(),
-            openApiUrl: v.optional(v.string()),
-            docsUrl: v.optional(v.string()),
-            pricingModel: v.string(),
-            pricingNotes: v.optional(v.string()),
-        }),
-    },
-    handler: async (ctx, args) => {
-        const now = Date.now();
-        // Check if provider already exists by email
-        const existing = await ctx.db
-            .query("providers")
-            .withIndex("by_email", (q) => q.eq("email", args.provider.email))
-            .first();
-        let providerId;
-        if (existing) {
-            // Use existing provider
-            providerId = existing._id;
-        }
-        else {
-            // Create new provider - auto-approve for now
-            providerId = await ctx.db.insert("providers", {
-                name: args.provider.name,
-                email: args.provider.email,
-                website: args.provider.website,
-                status: "approved", // Auto-approve for MVP
-                createdAt: now,
-                updatedAt: now,
-                approvedAt: now,
-            });
-        }
-        // Create the API listing - auto-approve for now
-        const apiId = await ctx.db.insert("providerAPIs", {
-            providerId,
-            name: args.api.name,
-            description: args.api.description,
-            category: args.api.category,
-            openApiUrl: args.api.openApiUrl,
-            docsUrl: args.api.docsUrl,
-            pricingModel: args.api.pricingModel,
-            pricingNotes: args.api.pricingNotes,
-            status: "approved", // Auto-approve for MVP
-            createdAt: now,
-            approvedAt: now,
-            discoveryCount: 0,
-        });
-        // Create session for auto-login after registration
-        const sessionToken = generateToken();
-        const sessionExpiresAt = now + 30 * 24 * 60 * 60 * 1000; // 30 days
-        await ctx.db.insert("sessions", {
-            providerId,
-            token: sessionToken,
-            expiresAt: sessionExpiresAt,
-            createdAt: now,
-        });
-        return { providerId, apiId, sessionToken };
-    },
-});
-// Get provider by email
-export const getProviderByEmail = query({
-    args: { email: v.string() },
-    handler: async (ctx, args) => {
-        return await ctx.db
-            .query("providers")
-            .withIndex("by_email", (q) => q.eq("email", args.email))
-            .first();
-    },
-});
-// Get all APIs for a provider
-export const getProviderAPIs = query({
-    args: { providerId: v.id("providers") },
-    handler: async (ctx, args) => {
-        return await ctx.db
-            .query("providerAPIs")
-            .withIndex("by_providerId", (q) => q.eq("providerId", args.providerId))
-            .collect();
-    },
-});
-// Get all approved APIs (for the registry)
-export const getApprovedAPIs = query({
-    args: {
-        category: v.optional(v.string()),
-        limit: v.optional(v.number()),
-    },
-    handler: async (ctx, args) => {
-        const query = ctx.db
-            .query("providerAPIs")
-            .withIndex("by_status", (q) => q.eq("status", "approved"));
-        const apis = await query.collect();
-        // Filter by category if provided
-        let filtered = args.category
-            ? apis.filter((api) => api.category === args.category)
-            : apis;
-        // Apply limit
-        if (args.limit) {
-            filtered = filtered.slice(0, args.limit);
-        }
-        return filtered;
-    },
-});
-// Get API categories with counts
-export const getCategories = query({
-    handler: async (ctx) => {
-        const apis = await ctx.db
-            .query("providerAPIs")
-            .withIndex("by_status", (q) => q.eq("status", "approved"))
-            .collect();
-        const categories = {};
-        for (const api of apis) {
-            categories[api.category] = (categories[api.category] || 0) + 1;
-        }
-        return Object.entries(categories)
-            .map(([name, count]) => ({ name, count }))
-            .sort((a, b) => b.count - a.count);
-    },
-});
-// Increment discovery count when an agent finds an API
-export const trackDiscovery = mutation({
-    args: { apiId: v.id("providerAPIs") },
-    handler: async (ctx, args) => {
-        const api = await ctx.db.get(args.apiId);
-        if (!api)
-            return;
-        await ctx.db.patch(args.apiId, {
-            discoveryCount: (api.discoveryCount || 0) + 1,
-            lastDiscoveredAt: Date.now(),
-        });
-    },
-});
-// Unified discovery logging
-// Single source of truth: apiLogs. discoveryCount on My APIs is derived from apiLogs.
-export const logDiscovery = mutation({
-    args: {
-        provider: v.string(),
-        query: v.string(),
-        latencyMs: v.number(),
-        callerWorkspaceId: v.string(),
-    },
-    handler: async (ctx, args) => {
-        const providerEmailMap = {
-            apilayer: "pratham.kumar@apilayer.com",
-            filestack: "marketing@filestack.com",
-        };
-        const email = providerEmailMap[args.provider];
-        if (!email)
-            return { logged: false };
-        const workspace = await ctx.db
-            .query("workspaces")
-            .withIndex("by_email", (q) => q.eq("email", email))
-            .first();
-        if (!workspace)
-            return { logged: false };
-        // 1. Log to apiLogs (source of truth for Analytics)
-        await ctx.db.insert("apiLogs", {
-            workspaceId: workspace._id,
-            sessionToken: "",
-            provider: args.provider,
-            action: `discovery:${args.query}`,
-            status: "success",
-            latencyMs: args.latencyMs,
-            direction: "inbound",
-            callerWorkspaceId: args.callerWorkspaceId,
-            createdAt: Date.now(),
-        });
-        // 2. Increment discoveryCount on MATCHING APIs only
-        const providerRecord = await ctx.db
-            .query("providers")
-            .withIndex("by_email", (q) => q.eq("email", email))
-            .first();
-        if (providerRecord) {
-            const apis = await ctx.db.query("providerAPIs").collect();
-            const providerApis = apis.filter((a) => a.providerId === providerRecord._id);
-            const queryLower = args.query.toLowerCase();
-            const queryWords = queryLower.split(/\s+/).filter((w) => w.length > 2);
-            let matched = 0;
-            for (const api of providerApis) {
-                const apiText = `${api.name} ${api.description || ""}`.toLowerCase();
-                if (queryWords.some((w) => apiText.includes(w))) {
-                    await ctx.db.patch(api._id, {
-                        discoveryCount: (api.discoveryCount || 0) + 1,
-                        lastDiscoveredAt: Date.now(),
-                    });
-                    matched++;
-                }
-            }
-            return { logged: true, matched };
-        }
-        return { logged: true, matched: 0 };
-    },
-});
-// Legacy: Track discovery by provider name (kept for backwards compat)
-export const trackDiscoveryByProvider = mutation({
-    args: { provider: v.string(), query: v.string() },
-    handler: async (ctx, args) => {
-        // Find provider by email mapping
-        const providerEmailMap = {
-            apilayer: "pratham.kumar@apilayer.com",
-            filestack: "marketing@filestack.com",
-        };
-        const email = providerEmailMap[args.provider];
-        if (!email)
-            return { updated: 0, error: "no email mapping" };
-        // Find provider record by email
-        const provider = await ctx.db
-            .query("providers")
-            .withIndex("by_email", (q) => q.eq("email", email))
-            .first();
-        if (!provider)
-            return { updated: 0, error: "provider not found" };
-        // Get all APIs for this provider
-        const apis = await ctx.db.query("providerAPIs").collect();
-        const providerApis = apis.filter((a) => a.providerId === provider._id);
-        // Increment discoveryCount on ALL provider APIs
-        for (const api of providerApis) {
-            await ctx.db.patch(api._id, {
-                discoveryCount: (api.discoveryCount || 0) + 1,
-                lastDiscoveredAt: Date.now(),
-            });
-        }
-        return { updated: providerApis.length };
-    },
-});
-// Admin: List pending providers
-export const getPendingProviders = query({
-    handler: async (ctx) => {
-        return await ctx.db
-            .query("providers")
-            .withIndex("by_status", (q) => q.eq("status", "pending"))
-            .collect();
-    },
-});
-// Admin: Approve provider
-export const approveProvider = mutation({
-    args: { providerId: v.id("providers") },
-    handler: async (ctx, args) => {
-        await ctx.db.patch(args.providerId, {
-            status: "approved",
-            approvedAt: Date.now(),
-            updatedAt: Date.now(),
-        });
-    },
-});
-// Admin: Reject provider
-export const rejectProvider = mutation({
-    args: { providerId: v.id("providers") },
-    handler: async (ctx, args) => {
-        await ctx.db.patch(args.providerId, {
-            status: "rejected",
-            updatedAt: Date.now(),
-        });
-    },
-});
-// Get provider stats
-export const getProviderStats = query({
-    handler: async (ctx) => {
-        const providers = await ctx.db.query("providers").collect();
-        const apis = await ctx.db.query("providerAPIs").collect();
-        return {
-            totalProviders: providers.length,
-            approvedProviders: providers.filter((p) => p.status === "approved").length,
-            pendingProviders: providers.filter((p) => p.status === "pending").length,
-            totalAPIs: apis.length,
-            approvedAPIs: apis.filter((a) => a.status === "approved").length,
-            pendingAPIs: apis.filter((a) => a.status === "pending").length,
-            totalDiscoveries: apis.reduce((sum, a) => sum + (a.discoveryCount || 0), 0),
-        };
-    },
-});
-// ============================================
-// DASHBOARD AUTH & SESSION FUNCTIONS
-// ============================================
-// Create magic link for email auth
-export const createMagicLink = mutation({
-    args: { email: v.string() },
-    handler: async (ctx, { email }) => {
-        const token = generateToken();
-        const expiresAt = Date.now() + 15 * 60 * 1000; // 15 minutes
-        await ctx.db.insert("magicLinks", {
-            email: email.toLowerCase(),
-            token,
-            expiresAt,
-            createdAt: Date.now(),
-        });
-        return { token, expiresAt };
-    },
-});
-// Verify magic link and create session
-export const verifyMagicLink = mutation({
-    args: { token: v.string() },
-    handler: async (ctx, { token }) => {
-        const magicLink = await ctx.db
-            .query("magicLinks")
-            .withIndex("by_token", (q) => q.eq("token", token))
-            .first();
-        if (!magicLink) {
-            return { success: false, error: "Invalid token" };
-        }
-        if (magicLink.expiresAt < Date.now()) {
-            return { success: false, error: "Token expired" };
-        }
-        if (magicLink.usedAt) {
-            return { success: false, error: "Token already used" };
-        }
-        // Mark as used
-        await ctx.db.patch(magicLink._id, { usedAt: Date.now() });
-        // Find or create provider
-        let provider = await ctx.db
-            .query("providers")
-            .withIndex("by_email", (q) => q.eq("email", magicLink.email))
-            .first();
-        if (!provider) {
-            const providerId = await ctx.db.insert("providers", {
-                email: magicLink.email,
-                name: magicLink.email.split("@")[0],
-                status: "approved",
-                createdAt: Date.now(),
-                updatedAt: Date.now(),
-            });
-            provider = await ctx.db.get(providerId);
-        }
-        // Create session
-        const sessionToken = generateToken();
-        const sessionExpiresAt = Date.now() + 30 * 24 * 60 * 60 * 1000; // 30 days
-        await ctx.db.insert("sessions", {
-            providerId: provider._id,
-            token: sessionToken,
-            expiresAt: sessionExpiresAt,
-            createdAt: Date.now(),
-        });
-        return {
-            success: true,
-            sessionToken,
-            provider: {
-                id: provider._id,
-                email: provider.email,
-                name: provider.name,
-            },
-        };
-    },
-});
-// Get current session
-export const getSession = query({
-    args: { token: v.string() },
-    handler: async (ctx, { token }) => {
-        const session = await ctx.db
-            .query("sessions")
-            .withIndex("by_token", (q) => q.eq("token", token))
-            .first();
-        if (!session || session.expiresAt < Date.now()) {
-            return null;
-        }
-        const provider = await ctx.db.get(session.providerId);
-        if (!provider)
-            return null;
-        return {
-            providerId: provider._id,
-            email: provider.email,
-            name: provider.name,
-            stripeOnboardingComplete: provider.stripeOnboardingComplete,
-        };
-    },
-});
-// ============================================
-// DASHBOARD ANALYTICS
-// ============================================
-// Get single API by ID
-export const getApiById = query({
-    args: { apiId: v.string() },
-    handler: async (ctx, args) => {
-        // Try to get by document ID
-        try {
-            const api = await ctx.db.get(args.apiId);
-            if (api) {
-                // Check if it has Direct Call configured
-                const directCall = await ctx.db
-                    .query("providerDirectCall")
-                    .filter((q) => q.eq(q.field("apiId"), args.apiId))
-                    .first();
-                return { ...api, hasDirectCall: !!directCall, directCallStatus: directCall?.status };
-            }
-        }
-        catch {
-            // Not a valid ID format
-        }
-        return null;
-    },
-});
-// Get provider APIs with Direct Call status
-export const getProviderAPIsWithStatus = query({
-    args: { providerId: v.string() },
-    handler: async (ctx, args) => {
-        const apis = await ctx.db
-            .query("providerAPIs")
-            .filter((q) => q.eq(q.field("providerId"), args.providerId))
-            .collect();
-        // Add Direct Call status to each API
-        const apisWithStatus = await Promise.all(apis.map(async (api) => {
-            const directCall = await ctx.db
-                .query("providerDirectCall")
-                .filter((q) => q.eq(q.field("apiId"), api._id))
-                .first();
-            return {
-                ...api,
-                hasDirectCall: !!directCall,
-                directCallStatus: directCall?.status,
-            };
-        }));
-        return apisWithStatus;
-    },
-});
-// DEBUG: Delete API
-export const debugDeleteAPI = mutation({
-    args: { apiId: v.string() },
-    handler: async (ctx, args) => {
-        await ctx.db.delete(args.apiId);
-        return { deleted: true };
-    },
-});
-// Add API for logged-in provider (used by register page)
-export const addAPI = mutation({
-    args: {
-        token: v.string(),
-        api: v.object({
-            name: v.string(),
-            description: v.string(),
-            category: v.string(),
-            openApiUrl: v.optional(v.string()),
-            docsUrl: v.optional(v.string()),
-            pricingModel: v.string(),
-            pricingNotes: v.optional(v.string()),
-        }),
-    },
-    handler: async (ctx, args) => {
-        // Verify session
-        const session = await ctx.db
-            .query("sessions")
-            .withIndex("by_token", (q) => q.eq("token", args.token))
-            .first();
-        if (!session || session.expiresAt < Date.now()) {
-            throw new Error("Invalid or expired session");
-        }
-        const now = Date.now();
-        const apiId = await ctx.db.insert("providerAPIs", {
-            providerId: session.providerId,
-            name: args.api.name,
-            description: args.api.description,
-            category: args.api.category,
-            openApiUrl: args.api.openApiUrl,
-            docsUrl: args.api.docsUrl,
-            pricingModel: args.api.pricingModel,
-            pricingNotes: args.api.pricingNotes,
-            status: "approved",
-            createdAt: now,
-            approvedAt: now,
-            discoveryCount: 0,
-        });
-        return { apiId, success: true };
-    },
-});
-// Delete API for logged-in provider
-export const deleteAPI = mutation({
-    args: {
-        token: v.string(),
-        apiId: v.string(),
-    },
-    handler: async (ctx, args) => {
-        // Verify session
-        const session = await ctx.db
-            .query("sessions")
-            .withIndex("by_token", (q) => q.eq("token", args.token))
-            .first();
-        if (!session || session.expiresAt < Date.now()) {
-            throw new Error("Invalid or expired session");
-        }
-        // Get the API and verify ownership
-        const api = await ctx.db.get(args.apiId);
-        if (!api || api.providerId !== session.providerId) {
-            throw new Error("API not found or unauthorized");
-        }
-        // Delete the API
-        await ctx.db.delete(args.apiId);
-        // Also delete any Direct Call config
-        const directCallConfig = await ctx.db
-            .query("providerDirectCall")
-            .filter((q) => q.eq(q.field("apiId"), args.apiId))
-            .first();
-        if (directCallConfig) {
-            await ctx.db.delete(directCallConfig._id);
-        }
-        return { deleted: true };
-    },
-});
-// DEBUG: Update provider name
-export const debugUpdateProvider = mutation({
-    args: {
-        providerId: v.string(),
-        name: v.optional(v.string()),
-    },
-    handler: async (ctx, args) => {
-        const updates = {};
-        if (args.name)
-            updates.name = args.name;
-        await ctx.db.patch(args.providerId, updates);
-        return { updated: true };
-    },
-});
-// DEBUG: Add API for provider (seeding)
-export const debugAddAPI = mutation({
-    args: {
-        providerId: v.string(),
-        name: v.string(),
-        description: v.string(),
-        category: v.string(),
-        docsUrl: v.optional(v.string()),
-        pricingModel: v.string(),
-        pricingNotes: v.optional(v.string()),
-    },
-    handler: async (ctx, args) => {
-        const now = Date.now();
-        return await ctx.db.insert("providerAPIs", {
-            providerId: args.providerId,
-            name: args.name,
-            description: args.description,
-            category: args.category,
-            docsUrl: args.docsUrl,
-            pricingModel: args.pricingModel,
-            pricingNotes: args.pricingNotes,
-            status: "approved",
-            createdAt: now,
-            approvedAt: now,
-            discoveryCount: 0,
-        });
-    },
-});
-// DEBUG: Delete provider and all related data
-export const debugDeleteProvider = mutation({
-    args: { providerId: v.string() },
-    handler: async (ctx, args) => {
-        const providerId = args.providerId;
-        // Delete sessions
-        const sessions = await ctx.db.query("sessions").filter(q => q.eq(q.field("providerId"), providerId)).collect();
-        for (const s of sessions)
-            await ctx.db.delete(s._id);
-        // Delete APIs
-        const apis = await ctx.db.query("providerAPIs").filter(q => q.eq(q.field("providerId"), providerId)).collect();
-        for (const a of apis)
-            await ctx.db.delete(a._id);
-        // Delete direct call configs
-        const configs = await ctx.db.query("providerDirectCall").filter(q => q.eq(q.field("providerId"), providerId)).collect();
-        for (const c of configs) {
-            // Delete actions for this config
-            const actions = await ctx.db.query("providerActions").filter(q => q.eq(q.field("directCallId"), c._id)).collect();
-            for (const act of actions)
-                await ctx.db.delete(act._id);
-            await ctx.db.delete(c._id);
-        }
-        // Delete provider
-        await ctx.db.delete(providerId);
-        return { deleted: true };
-    },
-});
-// DEBUG: List all sessions
-export const debugListSessions = query({
-    args: {},
-    handler: async (ctx) => {
-        return await ctx.db.query("sessions").collect();
-    },
-});
-// DEBUG: List all providers
-export const debugListProviders = query({
-    args: {},
-    handler: async (ctx) => {
-        return await ctx.db.query("providers").collect();
-    },
-});
-export const getAnalytics = query({
-    args: {
-        token: v.string(),
-        period: v.optional(v.string()), // "week", "month", "all"
-    },
-    handler: async (ctx, { token, period = "month" }) => {
-        const session = await ctx.db
-            .query("sessions")
-            .withIndex("by_token", (q) => q.eq("token", token))
-            .first();
-        if (!session || session.expiresAt < Date.now()) {
-            return null;
-        }
-        const now = Date.now();
-        const periodMs = {
-            week: 7 * 24 * 60 * 60 * 1000,
-            month: 30 * 24 * 60 * 60 * 1000,
-            all: now,
-        }[period] || 30 * 24 * 60 * 60 * 1000;
-        const startTime = now - periodMs;
-        // Get usage logs for this provider (from Direct Call usageLog)
-        const usageLogs = await ctx.db
-            .query("usageLog")
-            .withIndex("by_providerId", (q) => q.eq("providerId", session.providerId))
-            .collect();
-        const periodCalls = usageLogs.filter((c) => c.timestamp >= startTime);
-        // Calculate metrics
-        const totalCalls = periodCalls.length;
-        const uniqueAgents = new Set(periodCalls.map((c) => c.userId)).size;
-        const totalRevenue = periodCalls.reduce((sum, c) => sum + (c.creditsUsed / 100), 0); // cents to dollars
-        const successCount = periodCalls.filter((c) => c.success).length;
-        const successRate = totalCalls > 0 ? (successCount / totalCalls) * 100 : 100;
-        const avgLatency = totalCalls > 0
-            ? periodCalls.reduce((sum, c) => sum + c.latencyMs, 0) / totalCalls
-            : 0;
-        // Calls over time (daily buckets)
-        const callsByDay = {};
-        periodCalls.forEach((call) => {
-            const day = new Date(call.timestamp).toISOString().split("T")[0];
-            if (!callsByDay[day]) {
-                callsByDay[day] = { calls: 0, revenue: 0, success: 0 };
-            }
-            callsByDay[day].calls += 1;
-            callsByDay[day].revenue += call.creditsUsed / 100;
-            if (call.success)
-                callsByDay[day].success += 1;
-        });
-        // Top agents (users)
-        const agentCallCounts = {};
-        periodCalls.forEach((call) => {
-            agentCallCounts[call.userId] = (agentCallCounts[call.userId] || 0) + 1;
-        });
-        const topAgents = Object.entries(agentCallCounts)
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, 10)
-            .map(([agentId, calls]) => ({ agentId, calls }));
-        // Top actions
-        const actionCallCounts = {};
-        periodCalls.forEach((call) => {
-            actionCallCounts[call.actionName] = (actionCallCounts[call.actionName] || 0) + 1;
-        });
-        const topActions = Object.entries(actionCallCounts)
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, 10)
-            .map(([actionName, calls]) => ({ actionName, calls }));
-        // Get provider's APIs
-        const apis = await ctx.db
-            .query("providerAPIs")
-            .withIndex("by_providerId", (q) => q.eq("providerId", session.providerId))
-            .collect();
-        // Get Direct Call configs to map directCallId to apiId
-        const directCallConfigs = await ctx.db
-            .query("providerDirectCall")
-            .withIndex("by_providerId", (q) => q.eq("providerId", session.providerId))
-            .collect();
-        // Calls per API (via directCallId → apiId mapping)
-        const callsByDirectCallId = {};
-        periodCalls.forEach((call) => {
-            const dcId = call.directCallId;
-            callsByDirectCallId[dcId] = (callsByDirectCallId[dcId] || 0) + 1;
-        });
-        // Map to apiId
-        const callsByApiId = {};
-        directCallConfigs.forEach((dc) => {
-            if (dc.apiId) {
-                callsByApiId[dc.apiId] = callsByDirectCallId[dc._id] || 0;
-            }
-        });
-        // Preview data for providers with no usage yet
-        const isPreview = totalCalls === 0;
-        if (isPreview) {
-            // Generate preview data so providers can see what the dashboard looks like
-            const previewDays = [];
-            for (let i = 13; i >= 0; i--) {
-                const date = new Date(now - i * 24 * 60 * 60 * 1000).toISOString().split("T")[0];
-                previewDays.push({
-                    date,
-                    calls: Math.floor(Math.random() * 50) + 10,
-                    revenue: Math.random() * 5,
-                });
-            }
-            return {
-                totalCalls: 847,
-                uniqueAgents: 23,
-                totalRevenue: 42.35,
-                successRate: 98.2,
-                avgLatency: 145,
-                callsByDay: previewDays,
-                topAgents: [
-                    { agentId: "agent_demo_1", calls: 234 },
-                    { agentId: "agent_demo_2", calls: 189 },
-                    { agentId: "agent_demo_3", calls: 156 },
-                    { agentId: "agent_demo_4", calls: 98 },
-                    { agentId: "agent_demo_5", calls: 67 },
-                ],
-                topActions: [
-                    { actionName: "send_message", calls: 412 },
-                    { actionName: "get_status", calls: 289 },
-                    { actionName: "create_invoice", calls: 146 },
-                ],
-                apis: apis.map((api) => ({
-                    id: api._id,
-                    name: api.name,
-                    calls: Math.floor(Math.random() * 200) + 50,
-                    status: api.status,
-                })),
-                isPreview: true,
-            };
-        }
-        return {
-            totalCalls,
-            uniqueAgents,
-            totalRevenue,
-            successRate,
-            avgLatency,
-            callsByDay: Object.entries(callsByDay)
-                .map(([date, data]) => ({
-                date,
-                calls: data.calls,
-                revenue: data.revenue,
-            }))
-                .sort((a, b) => a.date.localeCompare(b.date)),
-            topAgents,
-            topActions,
-            apis: apis.map((api) => ({
-                id: api._id,
-                name: api.name,
-                calls: callsByApiId[api._id] || 0,
-                status: api.status,
-            })),
-            isPreview: false,
-        };
-    },
-});
-// ============================================
-// DASHBOARD EARNINGS
-// ============================================
-export const getEarnings = query({
-    args: { token: v.string() },
-    handler: async (ctx, { token }) => {
-        const session = await ctx.db
-            .query("sessions")
-            .withIndex("by_token", (q) => q.eq("token", token))
-            .first();
-        if (!session || session.expiresAt < Date.now()) {
-            return null;
-        }
-        // Get all payouts
-        const payouts = await ctx.db
-            .query("payouts")
-            .withIndex("by_providerId", (q) => q.eq("providerId", session.providerId))
-            .collect();
-        // Get all API calls to calculate pending
-        const allCalls = await ctx.db
-            .query("apiCalls")
-            .withIndex("by_providerId", (q) => q.eq("providerId", session.providerId))
-            .collect();
-        // Find last completed payout
-        const completedPayouts = payouts
-            .filter((p) => p.status === "completed")
-            .sort((a, b) => b.periodEnd - a.periodEnd);
-        const lastPayoutEnd = completedPayouts[0]?.periodEnd || 0;
-        // Pending = all revenue since last payout
-        const pendingCalls = allCalls.filter((c) => c.timestamp > lastPayoutEnd);
-        const pendingAmount = pendingCalls.reduce((sum, c) => sum + c.costUsd, 0);
-        // Total earned all time
-        const totalEarned = allCalls.reduce((sum, c) => sum + c.costUsd, 0);
-        // Get provider for Stripe status
-        const provider = await ctx.db.get(session.providerId);
-        return {
-            pendingAmount,
-            totalEarned,
-            totalPaidOut: completedPayouts.reduce((sum, p) => sum + p.amountUsd, 0),
-            stripeConnected: !!provider?.stripeConnectId,
-            stripeOnboardingComplete: provider?.stripeOnboardingComplete || false,
-            payouts: payouts
-                .sort((a, b) => b.createdAt - a.createdAt)
-                .slice(0, 20)
-                .map((p) => ({
-                id: p._id,
-                amount: p.amountUsd,
-                status: p.status,
-                periodStart: p.periodStart,
-                periodEnd: p.periodEnd,
-                createdAt: p.createdAt,
-                completedAt: p.completedAt,
-            })),
-        };
-    },
-});
-// ============================================
-// ADMIN QUERIES
-// ============================================
-// Get all providers (admin only)
-export const getAllProviders = query({
-    handler: async (ctx) => {
-        return await ctx.db
-            .query("providers")
-            .order("desc")
-            .collect();
-    },
-});
-// Get all APIs (admin only)
-export const getAllAPIs = query({
-    handler: async (ctx) => {
-        return await ctx.db
-            .query("providerAPIs")
-            .order("desc")
-            .collect();
-    },
-});
-// Helper function
-function generateToken() {
-    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-    let result = "";
-    for (let i = 0; i < 48; i++) {
-        result += chars.charAt(Math.floor(Math.random() * chars.length));
-    }
-    return result;
-}
-// Debug: Update API name/description
-export const debugUpdateAPI = mutation({
-    args: {
-        apiId: v.string(),
-        name: v.optional(v.string()),
-        description: v.optional(v.string()),
-        category: v.optional(v.string()),
-        status: v.optional(v.string()),
-        hasDirectCall: v.optional(v.boolean()),
-    },
-    handler: async (ctx, args) => {
-        const updates = {};
-        if (args.name)
-            updates.name = args.name;
-        if (args.description)
-            updates.description = args.description;
-        if (args.category)
-            updates.category = args.category;
-        if (args.status)
-            updates.status = args.status;
-        if (args.hasDirectCall !== undefined)
-            updates.hasDirectCall = args.hasDirectCall;
-        await ctx.db.patch(args.apiId, updates);
-        return { updated: true };
-    },
-});
-// ─── Workspace-native API management (no provider account needed) ─────────────
-// Get all APIs listed by a workspace
-export const getByWorkspaceId = query({
-    args: { workspaceId: v.id("workspaces") },
-    handler: async (ctx, { workspaceId }) => {
-        return await ctx.db
-            .query("providerAPIs")
-            .withIndex("by_workspaceId", (q) => q.eq("workspaceId", workspaceId))
-            .collect();
-    },
-});
-// List a new API directly from a workspace — no provider registration
-export const createForWorkspace = mutation({
-    args: {
-        workspaceId: v.id("workspaces"),
-        name: v.string(),
-        description: v.string(),
-        category: v.string(),
-        openApiUrl: v.optional(v.string()),
-        docsUrl: v.optional(v.string()),
-        pricingModel: v.string(),
-        pricingNotes: v.optional(v.string()),
-    },
-    handler: async (ctx, args) => {
-        const id = await ctx.db.insert("providerAPIs", {
-            workspaceId: args.workspaceId,
-            name: args.name,
-            description: args.description,
-            category: args.category,
-            openApiUrl: args.openApiUrl,
-            docsUrl: args.docsUrl,
-            pricingModel: args.pricingModel,
-            pricingNotes: args.pricingNotes,
-            status: "active",
-            createdAt: Date.now(),
-            discoveryCount: 0,
-        });
-        return { id };
-    },
-});
-// Delete an API owned by a workspace
-export const deleteForWorkspace = mutation({
-    args: { apiId: v.id("providerAPIs"), workspaceId: v.id("workspaces") },
-    handler: async (ctx, { apiId, workspaceId }) => {
-        const api = await ctx.db.get(apiId);
-        if (!api || api.workspaceId !== workspaceId) {
-            throw new Error("Not found or unauthorized");
-        }
-        await ctx.db.delete(apiId);
-        return { deleted: true };
-    },
-});
-// Reset all discoveryCount to 0 (admin cleanup)
-export const resetDiscoveryCounts = mutation({
-    args: {},
-    handler: async (ctx) => {
-        const apis = await ctx.db.query("providerAPIs").collect();
-        let reset = 0;
-        for (const api of apis) {
-            if (api.discoveryCount > 0) {
-                await ctx.db.patch(api._id, { discoveryCount: 0 });
-                reset++;
-            }
-        }
-        return { reset };
-    },
-});
-//# sourceMappingURL=providers.js.map