Add new failover history list endpoint (cadence-workflow#1061)

adhityamamallan · web-flow · commit d5ce13c20e22 · 2025-10-31T14:44:59.000+01:00
Add new route handler for a domain, to list failover history using the ListFailoverHistory endpoint.

Signed-off-by: Adhitya Mamallan &lt;adhitya.mamallan@uber.com&gt;
diff --git a/src/app/api/domains/[domain]/[cluster]/failovers/route.ts b/src/app/api/domains/[domain]/[cluster]/failovers/route.ts
@@ -0,0 +1,18 @@
+import { type NextRequest } from 'next/server';
+
+import { listFailoverHistory } from '@/route-handlers/list-failover-history/list-failover-history';
+import { type RouteParams } from '@/route-handlers/list-failover-history/list-failover-history.types';
+import { routeHandlerWithMiddlewares } from '@/utils/route-handlers-middleware';
+import routeHandlersDefaultMiddlewares from '@/utils/route-handlers-middleware/config/route-handlers-default-middlewares.config';
+
+export async function GET(
+  request: NextRequest,
+  options: { params: RouteParams }
+) {
+  return routeHandlerWithMiddlewares(
+    listFailoverHistory,
+    request,
+    options,
+    routeHandlersDefaultMiddlewares
+  );
+}
diff --git a/src/route-handlers/list-failover-history/__tests__/list-failover-history.node.ts b/src/route-handlers/list-failover-history/__tests__/list-failover-history.node.ts
@@ -0,0 +1,159 @@
+import { NextRequest } from 'next/server';
+
+import type { ListFailoverHistoryResponse as OriginalListFailoverHistoryResponse } from '@/__generated__/proto-ts/uber/cadence/api/v1/ListFailoverHistoryResponse';
+import { GRPCError } from '@/utils/grpc/grpc-error';
+import { mockGrpcClusterMethods } from '@/utils/route-handlers-middleware/middlewares/__mocks__/grpc-cluster-methods';
+
+import { listFailoverHistory } from '../list-failover-history';
+import {
+  type Context,
+  type RequestParams,
+} from '../list-failover-history.types';
+
+beforeEach(() => {
+  jest.resetAllMocks();
+});
+
+describe(listFailoverHistory.name, () => {
+  it('calls listFailoverHistory with correct parameters and returns valid response', async () => {
+    const { res, mockListFailoverHistory, mockSuccessResponse } = await setup({
+      domainId: 'test-domain-id',
+    });
+
+    expect(mockListFailoverHistory).toHaveBeenCalledWith({
+      filters: {
+        domainId: 'test-domain-id',
+      },
+      pagination: {
+        nextPageToken: undefined,
+      },
+    });
+    const responseJson = await res.json();
+    expect(responseJson).toEqual(mockSuccessResponse);
+    expect(res.status).toEqual(200);
+  });
+
+  it('calls listFailoverHistory with nextPage token when provided', async () => {
+    const { res, mockListFailoverHistory } = await setup({
+      domainId: 'test-domain-id',
+      nextPage: 'token-123',
+    });
+
+    expect(mockListFailoverHistory).toHaveBeenCalledWith({
+      filters: {
+        domainId: 'test-domain-id',
+      },
+      pagination: {
+        nextPageToken: 'token-123',
+      },
+    });
+    const responseJson = await res.json();
+    expect(responseJson.nextPageToken).toEqual('next-token-456');
+    expect(res.status).toEqual(200);
+  });
+
+  it('returns 400 when query parameters are invalid', async () => {
+    const { res } = await setup({
+      skipDomainId: true,
+    });
+
+    expect(res.status).toEqual(400);
+    const responseJson = await res.json();
+    expect(responseJson).toEqual(
+      expect.objectContaining({
+        message: 'Invalid argument(s) for fetching failover history',
+        validationErrors: expect.arrayContaining([
+          expect.objectContaining({
+            code: 'invalid_type',
+            path: ['domainId'],
+          }),
+        ]),
+      })
+    );
+  });
+
+  it('returns an error when listFailoverHistory errors out with GRPCError', async () => {
+    const { res, mockListFailoverHistory } = await setup({
+      domainId: 'test-domain-id',
+      error: new GRPCError('Failed to fetch failover history'),
+    });
+
+    expect(mockListFailoverHistory).toHaveBeenCalled();
+    expect(res.status).toEqual(500);
+    const responseJson = await res.json();
+    expect(responseJson).toEqual(
+      expect.objectContaining({
+        message: 'Failed to fetch failover history',
+      })
+    );
+  });
+
+  it('returns an error when listFailoverHistory errors out with generic error', async () => {
+    const { res, mockListFailoverHistory } = await setup({
+      domainId: 'test-domain-id',
+      error: new Error('Network error'),
+    });
+
+    expect(mockListFailoverHistory).toHaveBeenCalled();
+    expect(res.status).toEqual(500);
+    const responseJson = await res.json();
+    expect(responseJson).toEqual(
+      expect.objectContaining({
+        message: 'Error fetching failover history',
+      })
+    );
+  });
+});
+
+async function setup({
+  domainId,
+  nextPage,
+  error,
+  skipDomainId,
+}: {
+  domainId?: string;
+  nextPage?: string;
+  error?: Error;
+  skipDomainId?: boolean;
+}) {
+  const mockSuccessResponse: OriginalListFailoverHistoryResponse = {
+    failoverEvents: [],
+    nextPageToken: nextPage ? 'next-token-456' : '',
+  };
+
+  const mockListFailoverHistory = jest
+    .spyOn(mockGrpcClusterMethods, 'listFailoverHistory')
+    .mockImplementationOnce(async () => {
+      if (error) {
+        throw error;
+      }
+      return mockSuccessResponse;
+    });
+
+  const queryParams = new URLSearchParams();
+  if (!skipDomainId && domainId !== undefined) {
+    queryParams.append('domainId', domainId);
+  }
+  if (nextPage !== undefined) {
+    queryParams.append('nextPage', nextPage);
+  }
+
+  const url = `http://localhost/api/clusters/test-cluster/domains/test-domain/failover-history?${queryParams.toString()}`;
+
+  const res = await listFailoverHistory(
+    new NextRequest(url, {
+      method: 'GET',
+    }),
+    {
+      params: {
+        domain: 'test-domain',
+        cluster: 'test-cluster',
+      },
+    } as RequestParams,
+    {
+      grpcClusterMethods: mockGrpcClusterMethods,
+    } as Context
+  );
+
+  return { res, mockListFailoverHistory, mockSuccessResponse };
+}
diff --git a/src/route-handlers/list-failover-history/list-failover-history.ts b/src/route-handlers/list-failover-history/list-failover-history.ts
@@ -0,0 +1,72 @@
+import { type NextRequest, NextResponse } from 'next/server';
+import queryString from 'query-string';
+
+import decodeUrlParams from '@/utils/decode-url-params';
+import { getHTTPStatusCode, GRPCError } from '@/utils/grpc/grpc-error';
+import logger, { type RouteHandlerErrorPayload } from '@/utils/logger';
+
+import type {
+  ListFailoverHistoryResponse,
+  Context,
+  RequestParams,
+  RouteParams,
+} from './list-failover-history.types';
+import listFailoverHistoryQueryParamsSchema from './schemas/list-failover-history-query-params-schema';
+
+export async function listFailoverHistory(
+  request: NextRequest,
+  requestParams: RequestParams,
+  ctx: Context
+) {
+  const decodedParams = decodeUrlParams(requestParams.params) as RouteParams;
+
+  const { data: queryParams, error } =
+    listFailoverHistoryQueryParamsSchema.safeParse(
+      queryString.parse(request.nextUrl.searchParams.toString())
+    );
+
+  if (error) {
+    return NextResponse.json(
+      {
+        message: 'Invalid argument(s) for fetching failover history',
+        validationErrors: error.errors,
+      },
+      {
+        status: 400,
+      }
+    );
+  }
+
+  try {
+    const response: ListFailoverHistoryResponse =
+      await ctx.grpcClusterMethods.listFailoverHistory({
+        filters: {
+          domainId: queryParams.domainId,
+        },
+        pagination: {
+          nextPageToken: queryParams.nextPage,
+        },
+      });
+
+    return NextResponse.json(response);
+  } catch (e) {
+    logger.error<RouteHandlerErrorPayload>(
+      { requestParams: decodedParams, queryParams, error: e },
+      'Error fetching failover history' +
+        (e instanceof GRPCError ? ': ' + e.message : '')
+    );
+
+    return NextResponse.json(
+      {
+        message:
+          e instanceof GRPCError
+            ? e.message
+            : 'Error fetching failover history',
+        cause: e,
+      },
+      {
+        status: getHTTPStatusCode(e),
+      }
+    );
+  }
+}
diff --git a/src/route-handlers/list-failover-history/list-failover-history.types.ts b/src/route-handlers/list-failover-history/list-failover-history.types.ts
@@ -0,0 +1,23 @@
+import { type z } from 'zod';
+
+import { type ListFailoverHistoryResponse as ListFailoverHistoryResponseProto } from '@/__generated__/proto-ts/uber/cadence/api/v1/ListFailoverHistoryResponse';
+import { type DefaultMiddlewaresContext } from '@/utils/route-handlers-middleware';
+
+import type listFailoverHistoryQueryParamsSchema from './schemas/list-failover-history-query-params-schema';
+
+export type RouteParams = {
+  domain: string;
+  cluster: string;
+};
+
+export type RequestParams = {
+  params: RouteParams;
+};
+
+export type ListFailoverHistoryRequestQueryParams = z.input<
+  typeof listFailoverHistoryQueryParamsSchema
+>;
+
+export type ListFailoverHistoryResponse = ListFailoverHistoryResponseProto;
+
+export type Context = DefaultMiddlewaresContext;
diff --git a/src/route-handlers/list-failover-history/schemas/list-failover-history-query-params-schema.ts b/src/route-handlers/list-failover-history/schemas/list-failover-history-query-params-schema.ts
@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+const listFailoverHistoryQueryParamsSchema = z.object({
+  domainId: z.string(),
+  nextPage: z.string().optional(),
+});
+
+export default listFailoverHistoryQueryParamsSchema;
diff --git a/src/utils/grpc/grpc-client.ts b/src/utils/grpc/grpc-client.ts
@@ -18,6 +18,8 @@ import { type ListClosedWorkflowExecutionsRequest__Input } from '@/__generated__
 import { type ListClosedWorkflowExecutionsResponse } from '@/__generated__/proto-ts/uber/cadence/api/v1/ListClosedWorkflowExecutionsResponse';
 import { type ListDomainsRequest__Input } from '@/__generated__/proto-ts/uber/cadence/api/v1/ListDomainsRequest';
 import { type ListDomainsResponse } from '@/__generated__/proto-ts/uber/cadence/api/v1/ListDomainsResponse';
+import { type ListFailoverHistoryRequest__Input } from '@/__generated__/proto-ts/uber/cadence/api/v1/ListFailoverHistoryRequest';
+import { type ListFailoverHistoryResponse } from '@/__generated__/proto-ts/uber/cadence/api/v1/ListFailoverHistoryResponse';
 import { type ListOpenWorkflowExecutionsRequest__Input } from '@/__generated__/proto-ts/uber/cadence/api/v1/ListOpenWorkflowExecutionsRequest';
 import { type ListOpenWorkflowExecutionsResponse } from '@/__generated__/proto-ts/uber/cadence/api/v1/ListOpenWorkflowExecutionsResponse';
 import { type ListTaskListPartitionsRequest__Input } from '@/__generated__/proto-ts/uber/cadence/api/v1/ListTaskListPartitionsRequest';
@@ -122,6 +124,9 @@ export type GRPCClusterMethods = {
   getDiagnosticsWorkflow: (
     payload: DiagnoseWorkflowExecutionRequest__Input
   ) => Promise<DiagnoseWorkflowExecutionResponse>;
+  listFailoverHistory: (
+    payload: ListFailoverHistoryRequest__Input
+  ) => Promise<ListFailoverHistoryResponse>;
 };
 
 // cache services instances
@@ -343,6 +348,13 @@ const getClusterServicesMethods = async (
       method: 'DiagnoseWorkflowExecution',
       metadata: metadata,
     }),
+    listFailoverHistory: domainService.request<
+      ListFailoverHistoryRequest__Input,
+      ListFailoverHistoryResponse
+    >({
+      method: 'ListFailoverHistory',
+      metadata: metadata,
+    }),
   };
 };
 
diff --git a/src/utils/route-handlers-middleware/middlewares/__mocks__/grpc-cluster-methods.ts b/src/utils/route-handlers-middleware/middlewares/__mocks__/grpc-cluster-methods.ts
@@ -13,6 +13,7 @@ export const mockGrpcClusterMethods: GRPCClusterMethods = {
   getDiagnosticsWorkflow: jest.fn(),
   getSearchAttributes: jest.fn(),
   listDomains: jest.fn(),
+  listFailoverHistory: jest.fn(),
   listTaskListPartitions: jest.fn(),
   listWorkflows: jest.fn(),
   openWorkflows: jest.fn(),
