chore: allow querying status by query param (#889)

* chore: allow querying status by query param

* feat: allow querying transaction status via query param

Author: arcoraven

src/server/index.ts

@@ -18,7 +18,6 @@ import { withOpenApi } from "./middleware/open-api";
 import { withPrometheus } from "./middleware/prometheus";
 import { withRateLimit } from "./middleware/rate-limit";
 import { withSecurityHeaders } from "./middleware/security-headers";
-import { withWebSocket } from "./middleware/websocket";
 import { withRoutes } from "./routes";
 import { writeOpenApiToFile } from "./utils/openapi";
 
@@ -81,7 +80,6 @@ export const initServer = async () => {
   withPrometheus(server);
 
   // Register routes
-  await withWebSocket(server);
   await withAuth(server);
   await withOpenApi(server);
   await withRoutes(server);

src/server/routes/index.ts

@@ -104,7 +104,10 @@ import { getAllTransactions } from "./transaction/get-all";
 import { getAllDeployedContracts } from "./transaction/get-all-deployed-contracts";
 import { retryTransaction } from "./transaction/retry";
 import { retryFailedTransactionRoute } from "./transaction/retry-failed";
-import { checkTxStatus } from "./transaction/status";
+import {
+  getTransactionStatusQueryParamRoute,
+  getTransactionStatusRoute,
+} from "./transaction/status";
 import { syncRetryTransactionRoute } from "./transaction/sync-retry";
 import { createWebhookRoute } from "./webhooks/create";
 import { getWebhooksEventTypes } from "./webhooks/events";
@@ -239,7 +242,8 @@ export async function withRoutes(fastify: FastifyInstance) {
 
   // Transactions
   await fastify.register(getAllTransactions);
-  await fastify.register(checkTxStatus);
+  await fastify.register(getTransactionStatusRoute);
+  await fastify.register(getTransactionStatusQueryParamRoute);
   await fastify.register(getAllDeployedContracts);
   await fastify.register(retryTransaction);
   await fastify.register(syncRetryTransactionRoute);

src/server/routes/transaction/status.ts

@@ -1,23 +1,13 @@
-import type { SocketStream } from "@fastify/websocket";
 import { type Static, Type } from "@sinclair/typebox";
 import type { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
 import { TransactionDB } from "../../../shared/db/transactions/db";
-import { logger } from "../../../shared/utils/logger";
 import { createCustomError } from "../../middleware/error";
 import { standardResponseSchema } from "../../schemas/shared-api-schemas";
 import {
   TransactionSchema,
   toTransactionSchema,
 } from "../../schemas/transaction";
-import {
-  findOrAddWSConnectionInSharedState,
-  formatSocketMessage,
-  getStatusMessageAndConnectionStatus,
-  onClose,
-  onError,
-  onMessage,
-} from "../../utils/websocket";
 
 // INPUT
 const requestSchema = Type.Object({
@@ -62,7 +52,7 @@ responseBodySchema.example = {
   },
 };
 
-export async function checkTxStatus(fastify: FastifyInstance) {
+export async function getTransactionStatusRoute(fastify: FastifyInstance) {
   fastify.route<{
     Params: Static<typeof requestSchema>;
     Reply: Static<typeof responseBodySchema>;
@@ -96,41 +86,51 @@ export async function checkTxStatus(fastify: FastifyInstance) {
         result: toTransactionSchema(transaction),
       });
     },
-    wsHandler: async (connection: SocketStream, request) => {
-      const { queueId } = request.params;
+  });
+}
 
-      findOrAddWSConnectionInSharedState(connection, queueId, request);
+// An alterate route that accepts the queueId as a query param.
+export async function getTransactionStatusQueryParamRoute(
+  fastify: FastifyInstance,
+) {
+  fastify.route<{
+    Querystring: Static<typeof requestSchema>;
+    Reply: Static<typeof responseBodySchema>;
+  }>({
+    method: "GET",
+    url: "/transaction/status",
+    schema: {
+      summary: "Get transaction status",
+      description: "Get the status for a transaction request.",
+      tags: ["Transaction"],
+      operationId: "status",
+      querystring: requestSchema,
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: responseBodySchema,
+      },
+    },
+    handler: async (request, reply) => {
+      const { queueId } = request.query;
+      if (!queueId) {
+        throw createCustomError(
+          "Queue ID is required.",
+          StatusCodes.BAD_REQUEST,
+          "QUEUE_ID_REQUIRED",
+        );
+      }
 
       const transaction = await TransactionDB.get(queueId);
-      const returnData = transaction ? toTransactionSchema(transaction) : null;
-
-      const { message, closeConnection } =
-        await getStatusMessageAndConnectionStatus(returnData);
-
-      connection.socket.send(await formatSocketMessage(returnData, message));
-
-      if (closeConnection) {
-        connection.socket.close();
-        return;
+      if (!transaction) {
+        throw createCustomError(
+          "Transaction not found.",
+          StatusCodes.BAD_REQUEST,
+          "TRANSACTION_NOT_FOUND",
+        );
       }
 
-      connection.socket.on("error", (error) => {
-        logger({
-          service: "websocket",
-          level: "error",
-          message: "Websocket error",
-          error,
-        });
-
-        onError(error, connection, request);
-      });
-
-      connection.socket.on("message", async (_message, _isBinary) => {
-        onMessage(connection, request);
-      });
-
-      connection.socket.on("close", () => {
-        onClose(connection, request);
+      reply.status(StatusCodes.OK).send({
+        result: toTransactionSchema(transaction),
       });
     },
   });