Clarifying revalidatePath behavior when called from Server Actions

[MaxVhanamane]

I’m looking for clarification on the intended semantics of revalidatePath when it’s called from a Server Action, particularly when the action is invoked manually from the client.

Context

1. App Router
2. Server Actions
3. Server Action is called from onSubmit / onClick (not via )
4. Page data is loaded in a Server Component using Supabase (no fetch, no ISR data cache)
5. The route renders dynamic DB data, but the RSC tree appears cached

"use server";

import { revalidatePath } from "next/cache";

export async function createTopic(courseId: string) {
  // DB mutation (Supabase)
  await insertTopic(courseId);

  // Intentionally incorrect path (route does not exist)
  revalidatePath(`/admdfdin/currdfdficulum/${courseId}`);
}

Observed behavior

Calling the Server Action with wrong revalidatePath url:

1. Mutates the database correctly
2. Causes the current page UI to update immediately
3. This happens even though the path passed to revalidatePath does not exist

If revalidatePath is removed entirely:

1. The mutation succeeds
2. The UI does not update until a full browser refresh... this is correct behaviour as I am not revalidating

I don't understand how adding an incorrect URL still revalidates the path correctly.

This is what I was expecting:

1. If you don't revalidate the path after adding an item, you will not see that item on the screen until you refresh the page.
2. If you revalidate the path with the correct URL, it revalidates the UI as expected.
3. If you add the wrong path, it should not revalidate anything, since that path doesn't exist.

[karlhillx]

When you call a Server Action directly from an event handler like onClick or onSubmit (instead of using the native <form action={...}>), you are making an RPC call to the server via Next.js's internal action API.

The intended semantics of revalidatePath in App Router are:

1. It purges the router cache and the Data Cache on the server for the specified path.
2. In the specific response to the Server Action that called it, Next.js attaches instructions for the client router to invalidate its client-side cache and refetch the RSC payload for the current page.

This creates the behavior you are seeing: when a Server Action successfully returns, the client router automatically does a soft refresh of the current page to sync with the server, because it assumes a mutation happened. This happens regardless of whether you passed a correct or incorrect path to revalidatePath().

If you provide a junk path like /admdfdin/currdfdficulum/${courseId}, Next.js purges that non-existent cache on the server, but the client still refreshes the current page's RSC payload because it just completed a Server Action.

How to fix/clarify your implementation:
If your goal is to update the current page after a DB mutation, simply use revalidatePath(page_path) with the correct path. Next.js will wipe the server cache, the client will fetch the fresh RSC payload, and your UI will update.

If you are using Supabase directly in Server Components without fetch(), you are bypassing Next.js's Data Cache entirely. Next.js natively caches fetch() requests, but not raw DB driver calls. However, because revalidatePath forces the client to ask the server for a fresh RSC payload, the server re-runs your component, makes a fresh Supabase call, and sends down the new UI anyway.

TL;DR: The client refreshes the current page's UI automatically after any Server Action, which hides the fact that your revalidatePath targeted the wrong URL.