refactor chat delivery to graphql + hatchet services

frontend/server/api/omni/delivery/enqueue.post.ts

@@ -1,60 +1,6 @@
-import { readBody } from "h3";
-import { getAuthContext } from "../../../utils/auth";
-import { prisma } from "../../../utils/prisma";
-import { enqueueOutboundDelivery } from "../../../queues/outboundDelivery";
-
-type EnqueueBody = {
-  omniMessageId?: string;
-  endpoint?: string;
-  method?: "POST" | "PUT" | "PATCH";
-  headers?: Record<string, string>;
-  payload?: unknown;
-  provider?: string;
-  channel?: string;
-  attempts?: number;
-};
-
 export default defineEventHandler(async (event) => {
-  const auth = await getAuthContext(event);
-  const body = await readBody<EnqueueBody>(event);
-
-  const omniMessageId = String(body?.omniMessageId ?? "").trim();
-  const endpoint = String(body?.endpoint ?? "").trim();
-  if (!omniMessageId) {
-    throw createError({ statusCode: 400, statusMessage: "omniMessageId is required" });
-  }
-  if (!endpoint) {
-    throw createError({ statusCode: 400, statusMessage: "endpoint is required" });
-  }
-
-  const msg = await prisma.omniMessage.findFirst({
-    where: { id: omniMessageId, teamId: auth.teamId },
-    select: { id: true },
+  throw createError({
+    statusCode: 410,
+    statusMessage: "Legacy delivery enqueue is disabled. Use backend GraphQL requestTelegramOutbound.",
   });
-  if (!msg) {
-    throw createError({ statusCode: 404, statusMessage: "omni message not found" });
-  }
-
-  const attempts = Math.max(1, Math.min(Number(body?.attempts ?? 12), 50));
-  const job = await enqueueOutboundDelivery(
-    {
-      omniMessageId,
-      endpoint,
-      method: body?.method ?? "POST",
-      headers: body?.headers ?? {},
-      payload: body?.payload ?? {},
-      provider: body?.provider ?? undefined,
-      channel: body?.channel ?? undefined,
-    },
-    {
-      attempts,
-    },
-  );
-
-  return {
-    ok: true,
-    queue: process.env.SENDER_FLOW_QUEUE_NAME || process.env.OUTBOUND_DELIVERY_QUEUE_NAME || "sender.flow",
-    jobId: job.id,
-    omniMessageId,
-  };
 });

frontend/server/api/omni/telegram/send.post.ts

@@ -1,11 +1,79 @@
 import { readBody } from "h3";
 import { getAuthContext } from "../../../utils/auth";
 import { prisma } from "../../../utils/prisma";
-import { enqueueTelegramSend } from "../../../queues/telegramSend";
+
+type BackendGraphqlResponse<T> = {
+  data?: T;
+  errors?: Array<{ message?: string }>;
+};
+
+function asString(value: unknown) {
+  if (typeof value !== "string") return null;
+  const v = value.trim();
+  return v || null;
+}
+
+async function requestTelegramOutbound(input: {
+  omniMessageId: string;
+  chatId: string;
+  text: string;
+  businessConnectionId?: string | null;
+}) {
+  type Out = {
+    requestTelegramOutbound: {
+      ok: boolean;
+      message: string;
+      runId?: string | null;
+    };
+  };
+
+  const url = asString(process.env.BACKEND_GRAPHQL_URL);
+  if (!url) throw new Error("BACKEND_GRAPHQL_URL is required");
+
+  const headers: Record<string, string> = {
+    "content-type": "application/json",
+  };
+  const secret = asString(process.env.BACKEND_GRAPHQL_SHARED_SECRET);
+  if (secret) {
+    headers["x-graphql-secret"] = secret;
+  }
+
+  const query = `mutation RequestTelegramOutbound($input: TelegramOutboundTaskInput!) {
+    requestTelegramOutbound(input: $input) {
+      ok
+      message
+      runId
+    }
+  }`;
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      operationName: "RequestTelegramOutbound",
+      query,
+      variables: { input },
+    }),
+  });
+
+  const payload = (await response.json()) as BackendGraphqlResponse<Out>;
+  if (!response.ok || payload.errors?.length) {
+    const message =
+      payload.errors?.map((error) => error.message).filter(Boolean).join("; ") || `HTTP ${response.status}`;
+    throw new Error(message);
+  }
+
+  const result = payload.data?.requestTelegramOutbound;
+  if (!result?.ok) {
+    throw new Error(result?.message || "requestTelegramOutbound failed");
+  }
+
+  return result;
+}
 
 export default defineEventHandler(async (event) => {
   const auth = await getAuthContext(event);
-  const body = await readBody<{ omniMessageId?: string; attempts?: number }>(event);
+  const body = await readBody<{ omniMessageId?: string }>(event);
 
   const omniMessageId = String(body?.omniMessageId ?? "").trim();
   if (!omniMessageId) {
@@ -14,19 +82,26 @@ export default defineEventHandler(async (event) => {
 
   const msg = await prisma.omniMessage.findFirst({
     where: { id: omniMessageId, teamId: auth.teamId, channel: "TELEGRAM", direction: "OUT" },
-    select: { id: true },
+    select: {
+      id: true,
+      text: true,
+      thread: { select: { externalChatId: true, businessConnectionId: true } },
+    },
   });
   if (!msg) {
     throw createError({ statusCode: 404, statusMessage: "telegram outbound message not found" });
   }
 
-  const attempts = Math.max(1, Math.min(Number(body?.attempts ?? 12), 50));
-  const job = await enqueueTelegramSend({ omniMessageId }, { attempts });
+  const result = await requestTelegramOutbound({
+    omniMessageId: msg.id,
+    chatId: msg.thread.externalChatId,
+    text: msg.text,
+    businessConnectionId: msg.thread.businessConnectionId ?? null,
+  });
 
   return {
     ok: true,
-    queue: process.env.SENDER_FLOW_QUEUE_NAME || process.env.OUTBOUND_DELIVERY_QUEUE_NAME || "sender.flow",
-    jobId: job.id,
+    runId: result.runId ?? null,
     omniMessageId,
   };
 });