Guillermo.Arrieta
5c9fde1a9e
Deploy Function / deploy (push) Successful in 24s
close #6: - Ya se pueden generar asignaturas con IA. Específicamente los datos generales. - Se actualizaron los tipos de supabase - Se arreglaron los imports - TODO: generar contenido temático de la asignatura
424 lines
13 KiB
TypeScript
424 lines
13 KiB
TypeScript
import "@supabase/functions-js/edge-runtime.d.ts";
|
|
import { corsHeaders } from "../_shared/cors.ts";
|
|
import { HttpError, sendError, sendSuccess } from "../_shared/utils.ts";
|
|
import { createClient } from "@supabase/supabase-js";
|
|
import type { Database, Json } from "../_shared/database.types.ts";
|
|
import { z } from "zod";
|
|
import {
|
|
OpenAIService,
|
|
type StructuredResponseOptions,
|
|
} from "../_shared/openai-service.ts";
|
|
|
|
Deno.serve(async (req: Request): Promise<Response> => {
|
|
const url = new URL(req.url);
|
|
const functionName = url.pathname.split("/").pop();
|
|
console.log(
|
|
`[${new Date().toISOString()}][${functionName}]: Request received`,
|
|
);
|
|
|
|
if (req.method === "OPTIONS") {
|
|
return new Response(null, { status: 204, headers: corsHeaders });
|
|
}
|
|
|
|
try {
|
|
const method = req.method;
|
|
if (method !== "POST") {
|
|
console.error(
|
|
`[${
|
|
new Date().toISOString()
|
|
}][${functionName}]: Invalid method: ${method}`,
|
|
);
|
|
throw new HttpError(
|
|
405,
|
|
"Método no permitido.",
|
|
"METHOD_NOT_ALLOWED",
|
|
{ method },
|
|
);
|
|
}
|
|
|
|
const authHeaderRaw = req.headers.get("Authorization") ??
|
|
req.headers.get("authorization");
|
|
if (!authHeaderRaw) {
|
|
console.error(
|
|
`[${
|
|
new Date().toISOString()
|
|
}][${functionName}]: Missing Authorization header`,
|
|
);
|
|
throw new HttpError(
|
|
401,
|
|
"No autorizado.",
|
|
"UNAUTHORIZED",
|
|
{ reason: "missing_authorization_header" },
|
|
);
|
|
}
|
|
|
|
const contentType = (req.headers.get("content-type") || "").toLowerCase();
|
|
if (!contentType.startsWith("multipart/form-data")) {
|
|
console.error(
|
|
`[${
|
|
new Date().toISOString()
|
|
}][${functionName}]: Unsupported content type: ${contentType}`,
|
|
);
|
|
throw new HttpError(
|
|
415,
|
|
"Content-Type no soportado.",
|
|
"UNSUPPORTED_MEDIA_TYPE",
|
|
{ contentType },
|
|
);
|
|
}
|
|
|
|
const SUPABASE_URL = Deno.env.get("SUPABASE_URL");
|
|
const SUPABASE_ANON_KEY = Deno.env.get("SUPABASE_ANON_KEY");
|
|
if (!SUPABASE_URL || !SUPABASE_ANON_KEY) {
|
|
throw new HttpError(
|
|
500,
|
|
"Configuración del servidor incompleta.",
|
|
"MISSING_ENV",
|
|
{
|
|
missing: [
|
|
!SUPABASE_URL ? "SUPABASE_URL" : null,
|
|
!SUPABASE_ANON_KEY ? "SUPABASE_ANON_KEY" : null,
|
|
].filter(Boolean),
|
|
},
|
|
);
|
|
}
|
|
|
|
// If needed for RLS-protected reads, create an anon client with user's JWT
|
|
// Currently not used; kept here for future expansion.
|
|
// const supabaseAnon = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
|
|
// global: {
|
|
// headers: {
|
|
// Authorization: authHeaderRaw,
|
|
// },
|
|
// },
|
|
// });
|
|
|
|
const SERVICE_ROLE_KEY = Deno.env.get("SUPABASE_SERVICE_ROLE_KEY");
|
|
if (!SERVICE_ROLE_KEY) {
|
|
throw new HttpError(
|
|
500,
|
|
"Configuración del servidor incompleta.",
|
|
"MISSING_ENV",
|
|
{ missing: ["SUPABASE_SERVICE_ROLE_KEY"] },
|
|
);
|
|
}
|
|
|
|
const supabaseService = createClient<Database>(
|
|
SUPABASE_URL,
|
|
SERVICE_ROLE_KEY,
|
|
);
|
|
|
|
const formData = await req.formData();
|
|
const validation = parseAndValidate(formData);
|
|
if (!validation.success) {
|
|
console.error(
|
|
`[${new Date().toISOString()}][${functionName}]: Validation errors:`,
|
|
validation.errors,
|
|
);
|
|
const message = validation.errors
|
|
.map((e, i) => `${i + 1}. ${e}`)
|
|
.join("\n");
|
|
throw new HttpError(
|
|
422,
|
|
message,
|
|
"VALIDATION_ERROR",
|
|
{ errors: validation.errors },
|
|
);
|
|
}
|
|
|
|
const payload = validation.data;
|
|
|
|
const { data: estructura, error: estructuraError } = await supabaseService
|
|
.from("estructuras_asignatura")
|
|
.select("id,nombre,definicion,version")
|
|
.eq("id", payload.datosBasicos.estructuraId)
|
|
.single();
|
|
if (estructuraError) {
|
|
const maybeCode = (estructuraError as { code?: string }).code;
|
|
if (maybeCode === "PGRST116") {
|
|
throw new HttpError(
|
|
404,
|
|
"No se encontró la estructura de la asignatura.",
|
|
"NOT_FOUND",
|
|
{
|
|
table: "estructuras_asignatura",
|
|
id: payload.datosBasicos.estructuraId,
|
|
},
|
|
);
|
|
}
|
|
throw new HttpError(
|
|
500,
|
|
"No se pudo obtener la estructura de la asignatura.",
|
|
"SUPABASE_QUERY_FAILED",
|
|
estructuraError,
|
|
);
|
|
}
|
|
|
|
const systemPrompt =
|
|
"Eres un asistente experto en diseño curricular. Responde únicamente con JSON válido que cumpla estrictamente el JSON Schema proporcionado.";
|
|
|
|
const userPrompt =
|
|
`Genera un borrador completo completo de una ASIGNATURA con base en lo siguiente:\n` +
|
|
`- Nombre de la asignatura: ${payload.datosBasicos.nombre}\n` +
|
|
`- Código (clave de la asignatura): ${
|
|
payload.datosBasicos.codigo ?? "(no especificado)"
|
|
}\n` +
|
|
`- Tipo: ${payload.datosBasicos.tipo ?? "(no especificado)"}\n` +
|
|
`- Número de créditos: ${payload.datosBasicos.creditos}\n` +
|
|
`- Horas académicas: ${
|
|
payload.datosBasicos.horasAcademicas ?? "(no especificado)"
|
|
}\n` +
|
|
`- Horas independientes: ${
|
|
payload.datosBasicos.horasIndependientes ?? "(no especificado)"
|
|
}\n` +
|
|
`- Descripción del enfoque académico (sobre el contenido de la respuesta generada): ${
|
|
payload.iaConfig?.descripcionEnfoqueAcademico ?? "(ninguna)"
|
|
}\n` +
|
|
`- Instrucciones adicionales (sobre el formato de la respuesta generada): ${
|
|
payload.iaConfig?.instruccionesAdicionalesIA ?? "(ninguna)"
|
|
}`;
|
|
|
|
const schemaDef: Record<string, unknown> =
|
|
typeof estructura?.definicion === "object" &&
|
|
estructura?.definicion !== null
|
|
? (estructura.definicion as Record<string, unknown>)
|
|
: {};
|
|
|
|
const aiStructuredPayload: StructuredResponseOptions = {
|
|
model: "gpt-5-nano",
|
|
input: [
|
|
{ role: "system", content: systemPrompt },
|
|
{ role: "user", content: userPrompt },
|
|
],
|
|
text: {
|
|
format: {
|
|
type: "json_schema",
|
|
name: "asignatura_contenido_tematico",
|
|
schema: schemaDef,
|
|
strict: true,
|
|
},
|
|
},
|
|
};
|
|
|
|
const svc = OpenAIService.fromEnv();
|
|
if (!(svc instanceof OpenAIService)) {
|
|
throw new HttpError(
|
|
500,
|
|
"Configuración del servidor incompleta.",
|
|
"OPENAI_MISCONFIGURED",
|
|
svc,
|
|
);
|
|
}
|
|
|
|
const aiResult = await svc.createStructuredResponse(
|
|
aiStructuredPayload,
|
|
payload.archivosAdjuntos,
|
|
);
|
|
if (!aiResult.ok) {
|
|
const status = aiResult.code === "MissingEnv" ? 500 : 502;
|
|
throw new HttpError(
|
|
status,
|
|
"No se pudo generar la asignatura con IA.",
|
|
"OPENAI_REQUEST_FAILED",
|
|
aiResult,
|
|
);
|
|
}
|
|
|
|
let aiOutput = aiResult.output ?? null;
|
|
if (aiOutput == null && aiResult.outputText) {
|
|
try {
|
|
aiOutput = JSON.parse(aiResult.outputText);
|
|
} catch {
|
|
throw new HttpError(
|
|
502,
|
|
"La respuesta de la IA no es JSON válido.",
|
|
"OPENAI_INVALID_JSON",
|
|
{ outputText: aiResult.outputText },
|
|
);
|
|
}
|
|
}
|
|
if (!aiOutput) {
|
|
throw new HttpError(
|
|
502,
|
|
"La respuesta de la IA no contiene salida estructurada.",
|
|
"OPENAI_MISSING_STRUCTURED_OUTPUT",
|
|
{ outputText: aiResult.outputText ?? null },
|
|
);
|
|
}
|
|
|
|
const aiOutputJson: Json = aiOutput as unknown as Json;
|
|
|
|
const asignaturaInsert:
|
|
Database["public"]["Tables"]["asignaturas"]["Insert"] = {
|
|
plan_estudio_id: payload.plan_estudio_id,
|
|
estructura_id: payload.datosBasicos.estructuraId,
|
|
nombre: payload.datosBasicos.nombre,
|
|
codigo: payload.datosBasicos.codigo ?? null,
|
|
creditos: payload.datosBasicos.creditos,
|
|
horas_academicas: payload.datosBasicos.horasAcademicas ?? null,
|
|
horas_independientes: payload.datosBasicos.horasIndependientes ?? null,
|
|
tipo: (payload.datosBasicos.tipo ?? undefined) as Database["public"][
|
|
"Tables"
|
|
]["asignaturas"]["Insert"]["tipo"],
|
|
tipo_origen: "IA",
|
|
datos: aiOutputJson,
|
|
meta_origen: {
|
|
generado_por: "ai_generate_subject",
|
|
ai: {
|
|
responseId: aiResult.responseId ?? null,
|
|
conversationId: aiResult.conversationId ?? null,
|
|
model: aiResult.model,
|
|
usage: aiResult.usage ?? null,
|
|
},
|
|
referencias: {
|
|
archivosReferenciaIds: payload.iaConfig?.archivosReferencia ?? null,
|
|
repositoriosReferencia: payload.iaConfig?.repositoriosReferencia ??
|
|
null,
|
|
},
|
|
iaConfig: {
|
|
descripcionEnfoqueAcademico:
|
|
payload.iaConfig?.descripcionEnfoqueAcademico ?? null,
|
|
instruccionesAdicionalesIA:
|
|
payload.iaConfig?.instruccionesAdicionalesIA ?? null,
|
|
},
|
|
} as unknown as Json,
|
|
};
|
|
|
|
const { data: asignatura, error: asignaturaError } = await supabaseService
|
|
.from("asignaturas")
|
|
.insert(asignaturaInsert)
|
|
.select(
|
|
"id,nombre,codigo,tipo,creditos,horas_academicas,horas_independientes,estructura_id,plan_estudio_id,contenido_tematico,meta_origen,creado_en,actualizado_en",
|
|
)
|
|
.single();
|
|
|
|
if (asignaturaError) {
|
|
const maybeCode = (asignaturaError as { code?: string }).code;
|
|
const status = maybeCode ? 409 : 500;
|
|
throw new HttpError(
|
|
status,
|
|
"No se pudo guardar la asignatura.",
|
|
"SUPABASE_INSERT_FAILED",
|
|
{ ...asignaturaError, code: maybeCode },
|
|
);
|
|
}
|
|
|
|
console.log(
|
|
`[${
|
|
new Date().toISOString()
|
|
}][${functionName}]: Request processed successfully`,
|
|
);
|
|
return sendSuccess(asignatura);
|
|
} catch (error) {
|
|
if (error instanceof HttpError) {
|
|
console.error(
|
|
`[${new Date().toISOString()}][${functionName}] ⚠️ Handled Error:`,
|
|
{
|
|
message: error.message,
|
|
code: error.code,
|
|
internalDetails: error.internalDetails || "N/A",
|
|
},
|
|
);
|
|
|
|
return sendError(error.status, error.message, error.code);
|
|
}
|
|
|
|
const unexpectedError = error instanceof Error
|
|
? error
|
|
: new Error(String(error));
|
|
|
|
console.error(
|
|
`[${
|
|
new Date().toISOString()
|
|
}][${functionName}] 💥 CRITICAL UNHANDLED ERROR:`,
|
|
unexpectedError.stack || unexpectedError.message,
|
|
);
|
|
|
|
return sendError(
|
|
500,
|
|
"Ocurrió un error inesperado en el servidor.",
|
|
"INTERNAL_SERVER_ERROR",
|
|
);
|
|
}
|
|
});
|
|
|
|
const jsonFromString = <T extends z.ZodTypeAny>(schema: T) =>
|
|
z.string().transform((str, ctx) => {
|
|
try {
|
|
return JSON.parse(str);
|
|
} catch {
|
|
ctx.addIssue({
|
|
code: z.ZodIssueCode.custom,
|
|
message: "El formato no es un JSON válido",
|
|
});
|
|
return z.NEVER;
|
|
}
|
|
}).pipe(schema);
|
|
|
|
const jsonFromStringOptional = <T extends z.ZodTypeAny>(schema: T) =>
|
|
z.string().optional().default("{}").transform((str, ctx) => {
|
|
try {
|
|
return JSON.parse(str);
|
|
} catch {
|
|
ctx.addIssue({
|
|
code: z.ZodIssueCode.custom,
|
|
message: "El formato no es un JSON válido",
|
|
});
|
|
return z.NEVER;
|
|
}
|
|
}).pipe(schema);
|
|
|
|
const DatosBasicosSchema = z.object({
|
|
nombre: z.string().min(1, "El nombre es requerido"),
|
|
codigo: z.string().min(1).optional().nullable(),
|
|
tipo: z.union([z.string().min(1), z.null()]).optional().transform((v) =>
|
|
v ?? null
|
|
),
|
|
creditos: z.number({ invalid_type_error: "Créditos debe ser numérico" })
|
|
.positive("Créditos debe ser >= 0"),
|
|
horasAcademicas: z.number().int().nonnegative().optional().nullable(),
|
|
horasIndependientes: z.number().int().nonnegative().optional().nullable(),
|
|
estructuraId: z.string().uuid("estructuraId debe ser un UUID"),
|
|
});
|
|
|
|
const IAConfigSchema = z.object({
|
|
descripcionEnfoqueAcademico: z.string().optional(),
|
|
instruccionesAdicionalesIA: z.string().optional(),
|
|
archivosReferencia: z.array(z.string().uuid()).optional(),
|
|
repositoriosReferencia: z.array(z.string().uuid()).optional(),
|
|
}).partial();
|
|
|
|
const SolicitudSchema = z.object({
|
|
plan_estudio_id: z.string().uuid("plan_estudio_id debe ser un UUID"),
|
|
datosBasicos: jsonFromString(DatosBasicosSchema),
|
|
iaConfig: jsonFromStringOptional(IAConfigSchema),
|
|
archivosAdjuntos: z.array(z.instanceof(File)).optional().default([]),
|
|
});
|
|
|
|
type EdgeAIGenerateSubjectInput = z.infer<typeof SolicitudSchema>;
|
|
|
|
function parseAndValidate(
|
|
formData: FormData,
|
|
): { success: true; data: EdgeAIGenerateSubjectInput } | {
|
|
success: false;
|
|
errors: string[];
|
|
} {
|
|
const rawInput = {
|
|
plan_estudio_id: formData.get("plan_estudio_id"),
|
|
datosBasicos: formData.get("datosBasicos"),
|
|
iaConfig: formData.get("iaConfig"),
|
|
archivosAdjuntos: formData.getAll("archivosAdjuntos"),
|
|
};
|
|
|
|
const result = SolicitudSchema.safeParse(rawInput);
|
|
if (!result.success) {
|
|
const errors = result.error.errors.map((issue) => {
|
|
const path = issue.path.length ? `${issue.path.join(".")}: ` : "";
|
|
return `${path}${issue.message}`;
|
|
});
|
|
return { success: false, errors };
|
|
}
|
|
|
|
return { success: true, data: result.data };
|
|
}
|