@nordsym/apiclaw 1.8.6 → 1.8.7

package/convex/logs.ts

@@ -91,19 +91,16 @@ export const logProviderCall = mutation({
     errorMessage: v.optional(v.string()),
   },
   handler: async (ctx, args) => {
-    // Map provider to workspace email (for providers with workspaces)
-    const providerEmailMap: Record<string, string> = {
-      apilayer: "pratham@apilayer.com",
-    };
-
-    const providerEmail = providerEmailMap[args.provider];
-    let workspace = null;
-
-    if (providerEmail) {
-      workspace = await ctx.db
-        .query("workspaces")
-        .withIndex("by_email", (q) => q.eq("email", providerEmail))
-        .first();
+    // Resolve provider → workspace dynamically (no hardcoded email maps)
+    const providerNameLower = args.provider.toLowerCase();
+    const allProviders = await ctx.db.query("providers").collect();
+    const providerRecord = allProviders.find(
+      (p) => p.name.toLowerCase() === providerNameLower
+    );
+
+    let workspace: any = null;
+    if (providerRecord && (providerRecord as any).workspaceId) {
+      workspace = await ctx.db.get((providerRecord as any).workspaceId);
     }
 
     // Always log to global provider analytics (even without workspace)
@@ -148,8 +145,9 @@ export const getProviderAnalytics = query({
   args: {
     token: v.string(),
     hoursBack: v.optional(v.number()),
+    direction: v.optional(v.string()), // "outbound" = my usage, "inbound" = traffic to my APIs, omit = all
   },
-  handler: async (ctx, { token, hoursBack = 168 }) => {
+  handler: async (ctx, { token, hoursBack = 168, direction }) => {
     const session = await ctx.db
       .query("agentSessions")
       .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
@@ -164,11 +162,18 @@ export const getProviderAnalytics = query({
       .withIndex("by_workspaceId", (q) => q.eq("workspaceId", session.workspaceId))
       .collect();
 
-    const periodLogs = allLogs.filter((l) => l.createdAt >= since);
+    let periodLogs = allLogs.filter((l) => l.createdAt >= since);
+
+    // Filter by direction if specified
+    if (direction === "outbound") {
+      periodLogs = periodLogs.filter((l) => l.direction !== "inbound");
+    } else if (direction === "inbound") {
+      periodLogs = periodLogs.filter((l) => l.direction === "inbound");
+    }
+
     const inboundLogs = periodLogs.filter((l) => l.direction === "inbound");
-    const outboundLogs = periodLogs.filter((l) => l.direction !== "inbound");
 
-    // Daily buckets — separate calls and searches
+    // Daily buckets
     const byDay: Record<string, { calls: number; searches: number }> = {};
     periodLogs.forEach((l) => {
       const day = new Date(l.createdAt).toISOString().split("T")[0];
@@ -180,11 +185,10 @@ export const getProviderAnalytics = query({
       }
     });
 
-    // By action (individual API endpoints, not just provider name)
+    // By action
     const byAction: Record<string, { calls: number; success: number; type: string }> = {};
     periodLogs.forEach((l) => {
       const isDiscovery = l.action.startsWith("discovery:");
-      const key = isDiscovery ? l.action : `${l.provider}:${l.action}`;
       const displayName = isDiscovery ? l.action.replace("discovery:", "Search: ") : l.action;
       if (!byAction[displayName]) byAction[displayName] = { calls: 0, success: 0, type: isDiscovery ? "discovery" : "call" };
       byAction[displayName].calls++;
@@ -194,7 +198,6 @@ export const getProviderAnalytics = query({
     // Unique callers (for inbound)
     const uniqueCallers = new Set(inboundLogs.map((l) => l.callerWorkspaceId).filter(Boolean)).size;
 
-    // Counts
     const callLogs = periodLogs.filter((l) => !l.action.startsWith("discovery:"));
     const discoveryLogs = periodLogs.filter((l) => l.action.startsWith("discovery:"));
 
@@ -202,7 +205,7 @@ export const getProviderAnalytics = query({
       totalCalls: callLogs.length,
       totalDiscoveries: discoveryLogs.length,
       inboundCalls: inboundLogs.filter((l) => !l.action.startsWith("discovery:")).length,
-      outboundCalls: outboundLogs.length,
+      uniqueCallers,
       byDay: Object.entries(byDay)
         .map(([date, data]) => ({ date, calls: data.calls, searches: data.searches }))
         .sort((a, b) => a.date.localeCompare(b.date)),
@@ -668,7 +671,8 @@ export const createProxyLog = mutation({
       subagentId: subagentId || "unknown",
       sessionToken: sessionToken || "proxy",
       status: "success",
-      latencyMs: 0, // Proxy calls don't track latency
+      latencyMs: 0,
+      direction: "outbound",
       createdAt: now,
     });
     

package/convex/migrateProviderWorkspaces.ts

@@ -1,56 +1,175 @@
 import { mutation } from "./_generated/server";
-import { v } from "convex/values";
 
-// Backfill workspaceId on providerAPIs rows that have providerId but no workspaceId
+/**
+ * Workspace Unification Migration (idempotent)
+ *
+ * For every providers record, find the matching workspace by email
+ * and backfill workspaceId on the provider + all related tables.
+ *
+ * Does NOT create new workspaces. If no workspace is found for a
+ * provider email, it is logged in the report for manual handling.
+ *
+ * Safe to run multiple times — skips already-linked records.
+ */
 export const run = mutation({
   args: {},
   handler: async (ctx) => {
-    const results: Record<string, number> = {};
-
-    const pairs = [
-      {
-        providerEmail: "pratham.kumar@apilayer.com",
-        workspaceEmail: "pratham.kumar@apilayer.com",
-        label: "APILayer",
-      },
-      {
-        providerEmail: "marketing@filestack.com",
-        workspaceEmail: "marketing@filestack.com",
-        label: "Filestack",
-      },
-    ];
-
-    for (const pair of pairs) {
-      // Get provider
-      const provider = await ctx.db
-        .query("providers")
-        .withIndex("by_email", (q) => q.eq("email", pair.providerEmail))
-        .first();
-      if (!provider) { results[pair.label] = -1; continue; }
+    const report: {
+      providers: Array<{
+        email: string;
+        name: string;
+        providerId: string;
+        workspaceId: string | null;
+        status: "linked" | "already_linked" | "workspace_not_found";
+        backfilled: {
+          providerAPIs: number;
+          apis: number;
+          apiCalls: number;
+          payouts: number;
+          providerDirectCall: number;
+          usageLog: number;
+        };
+      }>;
+      warnings: string[];
+    } = { providers: [], warnings: [] };
+
+    // 1. Get ALL provider records (no hardcoded list)
+    const allProviders = await ctx.db.query("providers").collect();
+
+    for (const provider of allProviders) {
+      const entry: (typeof report.providers)[number] = {
+        email: provider.email,
+        name: provider.name,
+        providerId: provider._id as string,
+        workspaceId: null,
+        status: "workspace_not_found",
+        backfilled: {
+          providerAPIs: 0,
+          apis: 0,
+          apiCalls: 0,
+          payouts: 0,
+          providerDirectCall: 0,
+          usageLog: 0,
+        },
+      };
 
-      // Get workspace
+      // Already linked?
+      if (provider.workspaceId) {
+        entry.workspaceId = provider.workspaceId as string;
+        entry.status = "already_linked";
+        // Still backfill child tables in case they were missed
+      }
+
+      // 2. Find workspace by email (case-insensitive)
+      const emailLower = provider.email.toLowerCase();
       const workspace = await ctx.db
         .query("workspaces")
-        .withIndex("by_email", (q) => q.eq("email", pair.workspaceEmail))
+        .withIndex("by_email", (q) => q.eq("email", emailLower))
         .first();
-      if (!workspace) { results[pair.label] = -2; continue; }
 
-      // Get all providerAPIs for this provider
-      const apis = await ctx.db
+      if (!workspace) {
+        // Try exact match as fallback (in case stored with different casing)
+        const workspaceExact = await ctx.db
+          .query("workspaces")
+          .withIndex("by_email", (q) => q.eq("email", provider.email))
+          .first();
+
+        if (!workspaceExact) {
+          report.warnings.push(
+            `No workspace found for provider "${provider.name}" (${provider.email})`
+          );
+          report.providers.push(entry);
+          continue;
+        }
+        // Use exact match
+        entry.workspaceId = workspaceExact._id as string;
+      } else {
+        entry.workspaceId = workspace._id as string;
+      }
+
+      const wsId = entry.workspaceId! as any;
+
+      // 3. Link provider → workspace (if not already)
+      if (!provider.workspaceId) {
+        await ctx.db.patch(provider._id, { workspaceId: wsId });
+        entry.status = "linked";
+      }
+
+      // 4. Backfill providerAPIs (skip if workspaceId already set)
+      const providerAPIs = await ctx.db
         .query("providerAPIs")
         .withIndex("by_providerId", (q) => q.eq("providerId", provider._id))
         .collect();
+      for (const api of providerAPIs) {
+        if (!api.workspaceId) {
+          await ctx.db.patch(api._id, { workspaceId: wsId });
+          entry.backfilled.providerAPIs++;
+        }
+      }
 
-      let patched = 0;
+      // 5. Backfill apis
+      const apis = await ctx.db
+        .query("apis")
+        .withIndex("by_providerId", (q) => q.eq("providerId", provider._id))
+        .collect();
       for (const api of apis) {
-        if (!api.workspaceId) {
-          await ctx.db.patch(api._id, { workspaceId: workspace._id });
-          patched++;
+        if (!(api as any).workspaceId) {
+          await ctx.db.patch(api._id, { workspaceId: wsId } as any);
+          entry.backfilled.apis++;
         }
       }
-      results[pair.label] = patched;
+
+      // 6. Backfill apiCalls
+      const apiCalls = await ctx.db
+        .query("apiCalls")
+        .withIndex("by_providerId", (q) => q.eq("providerId", provider._id))
+        .collect();
+      for (const call of apiCalls) {
+        if (!(call as any).workspaceId) {
+          await ctx.db.patch(call._id, { workspaceId: wsId } as any);
+          entry.backfilled.apiCalls++;
+        }
+      }
+
+      // 7. Backfill payouts
+      const payouts = await ctx.db
+        .query("payouts")
+        .withIndex("by_providerId", (q) => q.eq("providerId", provider._id))
+        .collect();
+      for (const payout of payouts) {
+        if (!(payout as any).workspaceId) {
+          await ctx.db.patch(payout._id, { workspaceId: wsId } as any);
+          entry.backfilled.payouts++;
+        }
+      }
+
+      // 8. Backfill providerDirectCall
+      const directCalls = await ctx.db
+        .query("providerDirectCall")
+        .withIndex("by_providerId", (q) => q.eq("providerId", provider._id))
+        .collect();
+      for (const dc of directCalls) {
+        if (!(dc as any).workspaceId) {
+          await ctx.db.patch(dc._id, { workspaceId: wsId } as any);
+          entry.backfilled.providerDirectCall++;
+        }
+      }
+
+      // 9. Backfill usageLog
+      const usageLogs = await ctx.db
+        .query("usageLog")
+        .withIndex("by_providerId", (q) => q.eq("providerId", provider._id))
+        .collect();
+      for (const log of usageLogs) {
+        if (!(log as any).workspaceId) {
+          await ctx.db.patch(log._id, { workspaceId: wsId } as any);
+          entry.backfilled.usageLog++;
+        }
+      }
+
+      report.providers.push(entry);
     }
 
-    return results;
+    return report;
   },
 });