feat: Implement comprehensive request tracking and state management

src/lib/edgeFunctionTracking.ts

@@ -0,0 +1,114 @@
+/**
+ * Edge Function Request Tracking Wrapper
+ * 
+ * Wraps Supabase function invocations with request tracking for debugging and monitoring.
+ * Provides correlation IDs for tracing requests across the system.
+ */
+
+import { supabase } from '@/integrations/supabase/client';
+import { trackRequest } from './requestTracking';
+import { getErrorMessage } from './errorHandler';
+
+/**
+ * Invoke a Supabase edge function with request tracking
+ * 
+ * @param functionName - Name of the edge function to invoke
+ * @param payload - Request payload
+ * @param userId - User ID for tracking (optional)
+ * @param parentRequestId - Parent request ID for chaining (optional)
+ * @param traceId - Trace ID for distributed tracing (optional)
+ * @returns Response data with requestId
+ */
+export async function invokeWithTracking<T = any>(
+  functionName: string,
+  payload: Record<string, unknown> = {},
+  userId?: string,
+  parentRequestId?: string,
+  traceId?: string
+): Promise<{ data: T | null; error: any; requestId: string; duration: number }> {
+  try {
+    const { result, requestId, duration } = await trackRequest(
+      {
+        endpoint: `/functions/${functionName}`,
+        method: 'POST',
+        userId,
+        parentRequestId,
+        traceId,
+      },
+      async (context) => {
+        // Include client request ID in payload for correlation
+        const { data, error } = await supabase.functions.invoke<T>(functionName, {
+          body: { ...payload, clientRequestId: context.requestId },
+        });
+
+        if (error) throw error;
+        return data;
+      }
+    );
+
+    return { data: result, error: null, requestId, duration };
+  } catch (error: unknown) {
+    const errorMessage = getErrorMessage(error);
+    // On error, we don't have tracking info, so create basic response
+    return {
+      data: null,
+      error: { message: errorMessage },
+      requestId: 'unknown',
+      duration: 0,
+    };
+  }
+}
+
+/**
+ * Invoke multiple edge functions in parallel with batch tracking
+ * 
+ * Uses a shared trace ID to correlate all operations.
+ * 
+ * @param operations - Array of function invocation configurations
+ * @param userId - User ID for tracking
+ * @returns Array of results with their request IDs
+ */
+export async function invokeBatchWithTracking<T = any>(
+  operations: Array<{
+    functionName: string;
+    payload: Record<string, unknown>;
+  }>,
+  userId?: string
+): Promise<
+  Array<{
+    functionName: string;
+    data: T | null;
+    error: any;
+    requestId: string;
+    duration: number;
+  }>
+> {
+  const traceId = crypto.randomUUID();
+
+  const results = await Promise.allSettled(
+    operations.map(async (op) => {
+      const result = await invokeWithTracking<T>(
+        op.functionName,
+        op.payload,
+        userId,
+        undefined,
+        traceId
+      );
+      return { functionName: op.functionName, ...result };
+    })
+  );
+
+  return results.map((result, index) => {
+    if (result.status === 'fulfilled') {
+      return result.value;
+    } else {
+      return {
+        functionName: operations[index].functionName,
+        data: null,
+        error: { message: result.reason?.message || 'Unknown error' },
+        requestId: 'unknown',
+        duration: 0,
+      };
+    }
+  });
+}