lint fix

Author: Alessandro100

src/app/[locale]/feeds/[feedDataType]/[feedId]/lib/feed-data.ts

@@ -27,7 +27,7 @@ export type FeedData = FeedDataResult;
  *
  * Each user gets their own cached version that persists across page navigations
  * (e.g., /feeds/gtfs/mdb-123 → /feeds/gtfs/mdb-123/map)
- * 
+ *
  * Revalidation is short due to the per-user-per-feed cache, but can be adjusted based on needs.
  */
 export const fetchCompleteFeedData = cache(

src/app/api/revalidate/route.ts

@@ -25,22 +25,21 @@ const defaultRevalidateOptions: RevalidateBody = {
   gbfsFeedIds: [],
 };
 
-function json(status: number, body: Record<string, unknown>) {
-  return NextResponse.json(body, { status });
-}
-
-export async function POST(req: Request) {
+export async function POST(req: Request): Promise<NextResponse> {
   const expectedSecret = process.env.REVALIDATE_SECRET;
-  if (!expectedSecret) {
-    return json(500, {
-      ok: false,
-      error: 'Server misconfigured: REVALIDATE_SECRET missing',
-    });
+  if (expectedSecret == null) {
+    return NextResponse.json(
+      { ok: false, error: 'Server misconfigured: REVALIDATE_SECRET missing' },
+      { status: 500 },
+    );
   }
 
   const providedSecret = req.headers.get('x-revalidate-secret');
-  if (!providedSecret || providedSecret !== expectedSecret) {
-    return json(401, { ok: false, error: 'Unauthorized' });
+  if (providedSecret == null || providedSecret !== expectedSecret) {
+    return NextResponse.json(
+      { ok: false, error: 'Unauthorized' },
+      { status: 401 },
+    );
   }
 
   let payload: RevalidateBody = { ...defaultRevalidateOptions }; // default to full revalidation if body is missing/invalid
@@ -114,15 +113,18 @@ export async function POST(req: Request) {
       });
     }
 
-    return json(200, {
+    return NextResponse.json({
       ok: true,
       message: 'Revalidation triggered successfully',
     });
   } catch (error) {
     console.error('Revalidation failed:', error);
-    return json(500, {
-      ok: false,
-      error: 'Failed to revalidate',
-    });
+    return NextResponse.json(
+      {
+        ok: false,
+        error: 'Failed to revalidate',
+      },
+      { status: 500 },
+    );
   }
 }

src/app/screens/Feed/FeedView.tsx

@@ -123,9 +123,7 @@ export default async function FeedView({
       maxWidth='xl'
     >
       {/* TODO: remove this timestamp after confirming ISR is working in production and providing real value to users (e.g. helps with debugging feed updates) */}
-      <div>
-        Generated at: {new Date().toISOString()}
-      </div>
+      <div>Generated at: {new Date().toISOString()}</div>
       <CssBaseline />
       <Box sx={{ display: 'flex', flexDirection: 'column' }}>
         <Box

src/app/utils/proxy-helpers.spec.ts

@@ -1,36 +1,38 @@
-import type { NextRequest, NextResponse as NextResponseType } from 'next/server';
 import {
   isFeedDetailPage,
-  isAuthenticatedNotGuest,
   rewriteFeedRequest,
   hasLocaleInPathname,
   rewriteWithDefaultLocale,
   DEFAULT_LOCALE,
   AUTHED_PROXY_HEADER,
   STATIC_PROXY_HEADER,
 } from './proxy-helpers';
-import * as sessionJwt from './session-jwt';
 
 // Mock the session-jwt module
 jest.mock('./session-jwt');
 
 // Helper to create mock NextRequest
-function createMockNextRequest(overrides: Partial<any> = {}): any {
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+function createMockNextRequest(
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
   return {
     nextUrl: {
-      clone: jest.fn(function (this: any) {
+      clone: jest.fn(function (this: Record<string, unknown>) {
         const url = new URL('http://localhost');
         url.pathname = '/original';
         return url;
       }),
-    } as any,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    } as Record<string, unknown>,
     headers: new Headers(),
     cookies: {
       get: jest.fn(),
-    } as any,
+    } as Record<string, unknown>,
     ...overrides,
   };
 }
+/* eslint-enable @typescript-eslint/consistent-type-assertions */
 
 // Mock routing module
 jest.mock('../../i18n/routing', () => ({
@@ -41,14 +43,17 @@ jest.mock('../../i18n/routing', () => ({
 }));
 
 // Spy on NextResponse.rewrite
+/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
 let rewriteSpy: jest.SpyInstance;
+/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
 let NextResponse: any;
 
 describe('proxy-helpers', () => {
   beforeAll(async () => {
     // Dynamically import NextResponse to avoid module loading issues
     const nextServer = await import('next/server');
-    NextResponse = nextServer.NextResponse;
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+    NextResponse = nextServer.NextResponse as any;
     rewriteSpy = jest.spyOn(NextResponse, 'rewrite');
   });
 
@@ -135,6 +140,7 @@ describe('proxy-helpers', () => {
   // ============================================================================
 
   describe('rewriteFeedRequest', () => {
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
     let mockRequest: any;
 
     beforeEach(() => {
@@ -278,7 +284,9 @@ describe('proxy-helpers', () => {
     it('should handle paths with multiple segments', () => {
       mockUrl = new URL('http://localhost/feeds/gbfs/test-456/map/details');
       rewriteWithDefaultLocale(mockUrl);
-      expect(mockUrl.pathname).toBe(`/${DEFAULT_LOCALE}/feeds/gbfs/test-456/map/details`);
+      expect(mockUrl.pathname).toBe(
+        `/${DEFAULT_LOCALE}/feeds/gbfs/test-456/map/details`,
+      );
     });
 
     it('should return NextResponse', () => {

src/app/utils/proxy-helpers.ts

@@ -57,7 +57,7 @@ export function isFeedDetailPage(pathname: string): FeedDetailPageInfo {
 export function isAuthenticatedNotGuest(request: NextRequest): boolean {
   const sessionCookie = request.cookies.get('md_session');
   const userData = verifySessionToken(sessionCookie?.value ?? '');
-  const isAuthenticated = userData != null ? !userData.isGuest : false;
+  const isAuthenticated = !(userData?.isGuest === true);
 
   return isAuthenticated;
 }
@@ -91,10 +91,17 @@ export interface RewriteFeedRequestParams {
  */
 export function rewriteFeedRequest(
   request: NextRequest,
-  { locale, feedDataType, feedId, subPath, routeType }: RewriteFeedRequestParams,
+  {
+    locale,
+    feedDataType,
+    feedId,
+    subPath,
+    routeType,
+  }: RewriteFeedRequestParams,
 ): NextResponse {
   const url = request.nextUrl.clone();
-  const headerName = routeType === 'authed' ? AUTHED_PROXY_HEADER : STATIC_PROXY_HEADER;
+  const headerName =
+    routeType === 'authed' ? AUTHED_PROXY_HEADER : STATIC_PROXY_HEADER;
   url.pathname = `/${locale}/feeds/${feedDataType}/${feedId}/${routeType}${subPath}`;
 
   const headers = createRequestWithHeader(request, headerName);
@@ -113,7 +120,8 @@ export function rewriteFeedRequest(
  */
 export function hasLocaleInPathname(pathname: string): boolean {
   return routing.locales.some(
-    (locale: string) => pathname.startsWith(`/${locale}/`) || pathname === `/${locale}`,
+    (locale: string) =>
+      pathname.startsWith(`/${locale}/`) || pathname === `/${locale}`,
   );
 }
 

src/proxy.ts

@@ -59,8 +59,10 @@ export default function proxy(request: NextRequest): NextResponse<unknown> {
   const feedDetailPageInfo = isFeedDetailPage(pathname);
   if (
     feedDetailPageInfo.match &&
-    feedDetailPageInfo.feedDataType &&
-    feedDetailPageInfo.feedId
+    feedDetailPageInfo.feedDataType != null &&
+    feedDetailPageInfo.feedDataType !== '' &&
+    feedDetailPageInfo.feedId != null &&
+    feedDetailPageInfo.feedId !== ''
   ) {
     const isAuthenticated = isAuthenticatedNotGuest(request);
     const locale = feedDetailPageInfo.locale ?? DEFAULT_LOCALE;

src/setupTests.ts

@@ -57,20 +57,33 @@ jest.mock('next-intl/server', () => ({
 
 // Mock next/server for middleware tests
 jest.mock('next/server', () => {
-  const createMockResponse = (data?: any, init?: any) => ({
-    body: data,
-    status: init?.status || 200,
-    json: jest.fn().mockResolvedValue(data),
-    ok: (init?.status || 200) < 400,
-    headers: new Headers(init?.headers),
-  });
+  const createMockResponse = (
+    data?: unknown,
+    init?: Record<string, unknown>,
+  ): Record<string, unknown> => {
+    const status = typeof init?.status === 'number' ? init.status : 200;
+    const statusValue = typeof init?.status === 'number' ? init.status : 200;
+    return {
+      body: data,
+      status,
+      json: jest.fn().mockResolvedValue(data),
+      ok: statusValue < 400,
+      headers: new Headers(
+        typeof init?.headers === 'object'
+          ? (init.headers as HeadersInit)
+          : undefined,
+      ),
+    };
+  };
 
   return {
     NextResponse: {
       next: jest.fn(() => createMockResponse()),
-      rewrite: jest.fn((url, config) => createMockResponse()),
-      redirect: jest.fn((url) => createMockResponse()),
-      json: jest.fn((data, init) => createMockResponse(data, init)),
+      rewrite: jest.fn((url: unknown, config: unknown) => createMockResponse()),
+      redirect: jest.fn((url: unknown) => createMockResponse()),
+      json: jest.fn((data: unknown, init: unknown) =>
+        createMockResponse(data, init as Record<string, unknown>),
+      ),
     },
     NextRequest: jest.fn(),
   };