@nordsym/apiclaw 1.2.2 → 1.2.3

package/convex/providers.ts

@@ -62,7 +62,18 @@ export const registerProvider = mutation({
       discoveryCount: 0,
     });
 
-    return { providerId, apiId };
+    // 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 };
   },
 });
 
@@ -314,6 +325,238 @@ export const getSession = query({
 // 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 as any);
+      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 as any))
+      .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 as any);
+    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 as any);
+    if (!api || (api as any).providerId !== session.providerId) {
+      throw new Error("API not found or unauthorized");
+    }
+
+    // Delete the API
+    await ctx.db.delete(args.apiId as any);
+
+    // 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: any = {};
+    if (args.name) updates.name = args.name;
+    await ctx.db.patch(args.providerId as any, 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 as any,
+      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 as any;
+    
+    // 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(),
@@ -338,45 +581,56 @@ export const getAnalytics = query({
 
     const startTime = now - periodMs;
 
-    // Get all API calls for this provider
-    const allCalls = await ctx.db
-      .query("apiCalls")
+    // 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 = allCalls.filter((c) => c.timestamp >= startTime);
+    const periodCalls = usageLogs.filter((c) => c.timestamp >= startTime);
 
     // Calculate metrics
     const totalCalls = periodCalls.length;
-    const uniqueAgents = new Set(periodCalls.map((c) => c.agentId)).size;
-    const totalRevenue = periodCalls.reduce((sum, c) => sum + c.costUsd, 0);
+    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: Record<string, number> = {};
-    const revenueByDay: Record<string, number> = {};
+    const callsByDay: Record<string, { calls: number; revenue: number; success: number }> = {};
 
     periodCalls.forEach((call) => {
       const day = new Date(call.timestamp).toISOString().split("T")[0];
-      callsByDay[day] = (callsByDay[day] || 0) + 1;
-      revenueByDay[day] = (revenueByDay[day] || 0) + call.costUsd;
+      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
+    // Top agents (users)
     const agentCallCounts: Record<string, number> = {};
     periodCalls.forEach((call) => {
-      agentCallCounts[call.agentId] = (agentCallCounts[call.agentId] || 0) + 1;
+      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 }));
 
-    // By region
-    const callsByRegion: Record<string, number> = {};
+    // Top actions
+    const actionCallCounts: Record<string, number> = {};
     periodCalls.forEach((call) => {
-      const region = call.region || "Unknown";
-      callsByRegion[region] = (callsByRegion[region] || 0) + 1;
+      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
@@ -384,32 +638,93 @@ export const getAnalytics = query({
       .withIndex("by_providerId", (q) => q.eq("providerId", session.providerId))
       .collect();
 
-    // Calls per API
-    const callsByApi: Record<string, number> = {};
+    // 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: Record<string, number> = {};
     periodCalls.forEach((call) => {
-      const apiIdStr = call.apiId as string;
-      callsByApi[apiIdStr] = (callsByApi[apiIdStr] || 0) + 1;
+      const dcId = call.directCallId as string;
+      callsByDirectCallId[dcId] = (callsByDirectCallId[dcId] || 0) + 1;
+    });
+
+    // Map to apiId
+    const callsByApiId: Record<string, number> = {};
+    directCallConfigs.forEach((dc) => {
+      if (dc.apiId) {
+        callsByApiId[dc.apiId as string] = callsByDirectCallId[dc._id as string] || 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, calls]) => ({
+        .map(([date, data]) => ({
           date,
-          calls,
-          revenue: revenueByDay[date] || 0,
+          calls: data.calls,
+          revenue: data.revenue,
         }))
         .sort((a, b) => a.date.localeCompare(b.date)),
       topAgents,
-      callsByRegion,
+      topActions,
       apis: apis.map((api) => ({
         id: api._id,
         name: api.name,
-        calls: callsByApi[api._id as string] || 0,
+        calls: callsByApiId[api._id as string] || 0,
         status: api.status,
       })),
+      isPreview: false,
     };
   },
 });

package/convex/schema.ts

@@ -217,4 +217,91 @@ export default defineSchema({
   })
     .index("by_type", ["type"])
     .index("by_timestamp", ["timestamp"]),
+
+  // ============================================
+  // SELF-SERVICE DIRECT CALL TABLES
+  // ============================================
+
+  // Provider Direct Call configuration (master key, limits, pricing)
+  providerDirectCall: defineTable({
+    providerId: v.id("providers"),
+    apiId: v.optional(v.id("providerAPIs")),
+    baseUrl: v.string(),
+    authType: v.string(), // "bearer" | "basic" | "api_key" | "none"
+    authHeader: v.string(), // e.g. "Authorization", "X-API-Key"
+    authPrefix: v.string(), // e.g. "Bearer ", "Basic ", ""
+    encryptedMasterKey: v.string(),
+    rateLimitPerUser: v.number(), // requests per minute per user
+    rateLimitPerDay: v.number(), // requests per day per user
+    pricePerRequest: v.number(), // in USD cents
+    status: v.string(), // "draft" | "testing" | "live"
+    // Customer key passthrough settings
+    allowCustomerKeys: v.optional(v.boolean()), // Allow agents to pass their own API key (default: true)
+    requireCustomerKeys: v.optional(v.boolean()), // Require customer key, no master key fallback (default: false)
+    createdAt: v.number(),
+    updatedAt: v.number(),
+    publishedAt: v.optional(v.number()),
+  })
+    .index("by_providerId", ["providerId"])
+    .index("by_apiId", ["apiId"])
+    .index("by_status", ["status"]),
+
+  // Actions defined by providers for their Direct Call APIs
+  providerActions: defineTable({
+    directCallId: v.id("providerDirectCall"),
+    name: v.string(), // machine name, e.g. "send_sms"
+    displayName: v.string(), // human-friendly, e.g. "Send SMS"
+    description: v.string(),
+    method: v.string(), // "GET" | "POST" | "PUT" | "PATCH" | "DELETE"
+    path: v.string(), // e.g. "/v1/messages" or "/users/{userId}"
+    params: v.array(v.object({
+      name: v.string(),
+      type: v.string(), // "string" | "number" | "boolean" | "object"
+      required: v.boolean(),
+      description: v.string(),
+      default: v.optional(v.any()),
+      in: v.string(), // "body" | "query" | "path"
+    })),
+    responseMapping: v.array(v.object({
+      name: v.string(),
+      path: v.string(), // JSON path, e.g. "data.id" or "results[0].name"
+    })),
+    enabled: v.boolean(),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_directCallId", ["directCallId"])
+    .index("by_directCallId_name", ["directCallId", "name"]),
+
+  // Usage logs for Direct Call actions
+  usageLog: defineTable({
+    userId: v.string(),
+    providerId: v.id("providers"),
+    directCallId: v.id("providerDirectCall"),
+    actionName: v.string(),
+    timestamp: v.number(),
+    success: v.boolean(),
+    latencyMs: v.number(),
+    creditsUsed: v.number(), // in USD cents
+    errorMessage: v.optional(v.string()),
+  })
+    .index("by_userId", ["userId"])
+    .index("by_providerId", ["providerId"])
+    .index("by_directCallId", ["directCallId"])
+    .index("by_timestamp", ["timestamp"])
+    .index("by_userId_providerId", ["userId", "providerId"])
+    .index("by_userId_timestamp", ["userId", "timestamp"]),
+
+  // ============================================
+  // WAITLIST (for Direct Call provider leads)
+  // ============================================
+
+  waitlist: defineTable({
+    email: v.string(),
+    type: v.string(), // "provider" | "agent" | "general"
+    source: v.optional(v.string()), // "landing", "docs", etc.
+    createdAt: v.number(),
+  })
+    .index("by_email", ["email"])
+    .index("by_type", ["type"]),
 });