openai-webhook-responces recibe peticiones y hace log de las responses

supabase/functions/_shared/utils.ts

@@ -47,3 +47,8 @@ export function sendError(
         },
     );
 }
+
+export interface ResponseMetadata extends Record<string, string | undefined> {
+    tabla?: string;
+    accion?: string;
+}

supabase/functions/openai-webhook-responses/deno.json

@@ -1,5 +1,6 @@
 {
   "imports": {
+    "@supabase/supabase-js": "npm:@supabase/supabase-js@2",
     "@supabase/functions-js/edge-runtime.d.ts": "jsr:@supabase/functions-js@^2/edge-runtime.d.ts",
     "express": "npm:express@5.2.1",
     "openai": "npm:openai@6.16.0"

supabase/functions/openai-webhook-responses/index.ts

@@ -4,45 +4,99 @@
 
 // Setup type definitions for built-in Supabase Runtime APIs
 import "@supabase/functions-js/edge-runtime.d.ts";
-import express from "express";
 import OpenAI from "openai";
+import { ResponseMetadata } from "../_shared/utils.ts";
+import { handlePlanesEstudioResponse } from "./planes_estudio/index.ts";
 
-const app = express();
+console.log("Starting OpenAI webhook responses function");
 const client = new OpenAI({
   webhookSecret: Deno.env.get("OPENAI_WEBHOOK_SECRET"),
 });
 
-app.use(express.text({ type: "application/json" }));
+async function handleCompletedResponse(
+  event: OpenAI.Webhooks.ResponseCompletedWebhookEvent,
+) {
+  const response_id = event.data.id;
+  const response = await client.responses.retrieve(response_id);
+  const metadata = response.metadata as ResponseMetadata | null;
+
+  if (!metadata || !metadata.tabla) {
+    console.warn("No se recibió metadata o tabla en la respuesta");
+    return;
+  }
+
+  switch (metadata.tabla) {
+    case "planes_estudio":
+      handlePlanesEstudioResponse(response);
+      break;
+    default:
+      console.warn("Tabla no reconocida:", metadata.tabla);
+  }
+
+  const output_text = response.output
+    .filter((item: any) => item.type === "message")
+    .flatMap((item: any) => item.content)
+    .filter((contentItem: any) => contentItem.type === "output_text")
+    .map((contentItem: any) => contentItem.text)
+    .join("");
+
+  console.log("Response output:", output_text);
+}
+
+Deno.serve(async (req) => {
+  const url = new URL(req.url);
+  const functionName = url.pathname.split("/").pop();
+  console.log(
+    `[${new Date().toISOString()}][${functionName}]: Request received`,
+  );
+
+  // Opcional: Solo permitir POST
+  if (req.method !== "POST") {
+    return new Response("Method Not Allowed", { status: 405 });
+  }
 
-app.post("/webhook", async (req: express.Request, res: express.Response) => {
   try {
-    const event = await client.webhooks.unwrap(req.body, req.headers);
+    // OpenAI requiere el body como texto crudo (string) para verificar la firma criptográfica
+    const payload = await req.text();
 
-    if (event.type === "response.completed") {
-      const response_id = event.data.id;
-      const response = await client.responses.retrieve(response_id);
-      const output_text = response.output
-        .filter((item) => item.type === "message")
-        .flatMap((item) => item.content)
-        .filter((contentItem) => contentItem.type === "output_text")
-        .map((contentItem) => contentItem.text)
-        .join("");
+    // Validar firma y parsear el evento. Deno maneja req.headers compatiblemente
+    const event = await client.webhooks.unwrap(payload, req.headers);
 
-      console.log("Response output:", output_text);
+    switch (event.type) {
+      case "response.completed": {
+        EdgeRuntime.waitUntil(handleCompletedResponse(event));
+        break;
+      }
+      case "response.cancelled": {
+        console.warn("Response cancelled:", event.data);
+        break;
+      }
+      case "response.failed": {
+        console.error("Response failed:", event.data);
+        break;
+      }
+      case "response.incomplete": {
+        console.warn("Response incomplete:", event.data);
+        break;
+      }
+      default: {
+        throw new Error(`Unhandled event type: ${event.type}`);
+      }
     }
-    res.status(200).send();
+
+    console.log(
+      `[${
+        new Date().toISOString()
+      }][${functionName}]: Request processed successfully`,
+    );
+    return new Response("OK", { status: 200 });
   } catch (error) {
     if (error instanceof OpenAI.InvalidWebhookSignatureError) {
-      console.error("Invalid signature", error);
-      res.status(400).send("Invalid signature");
+      console.error("Invalid signature:", error.message);
+      return new Response("Invalid signature", { status: 400 });
     } else {
-      throw error;
+      console.error("Internal Error:", error);
+      return new Response("Internal Server Error", { status: 500 });
     }
   }
 });
-
-Deno.serve(async (req) => {
-  console.log("Inicio de openai-webhook-responses");
-
-  return await app.handle(req);
-});

supabase/functions/openai-webhook-responses/planes_estudio/crear.ts

@@ -0,0 +1,6 @@
+import type { OpenAI } from "openai";
+import { supabase } from "../supabase.ts";
+import type { TablesUpdate } from "../../_shared/database.types.ts";
+
+export function handleCrearPlanEstudio(response: OpenAI.Responses.Response) {
+}

supabase/functions/openai-webhook-responses/planes_estudio/index.ts

@@ -0,0 +1,26 @@
+import { ResponseMetadata } from "../../_shared/utils.ts";
+import type { OpenAI } from "openai";
+
+export function handlePlanesEstudioResponse(
+  response: OpenAI.Responses.Response,
+) {
+  const metadata = response.metadata as ResponseMetadata | null;
+  if (!metadata || !metadata.accion) {
+    console.warn("No se recibió acción en la metadata");
+    return;
+  }
+
+  switch (metadata.accion) {
+    case "crear":
+      // Lógica para crear un plan de estudio
+      break;
+    case "actualizar":
+      // Lógica para actualizar un plan de estudio
+      break;
+    case "eliminar":
+      // Lógica para eliminar un plan de estudio
+      break;
+    default:
+      console.warn("Acción no reconocida:", metadata.accion);
+  }
+}

supabase/functions/openai-webhook-responses/supabase.ts

@@ -0,0 +1,15 @@
+import { createClient } from "@supabase/supabase-js";
+
+const SUPABASE_URL = Deno.env.get("SUPABASE_URL");
+const SUPABASE_ANON_KEY = Deno.env.get("SUPABASE_ANON_KEY");
+
+if (!SUPABASE_URL || !SUPABASE_ANON_KEY) {
+  console.warn("Missing Supabase environment variables");
+}
+
+const supabase = createClient(
+  SUPABASE_URL as string,
+  SUPABASE_ANON_KEY as string,
+);
+
+export { supabase };