Currently, the solution I have discovered is to avoid utilizing:

import { redirect } from 'next/navigation';

Instead, opt for:

import { useRouter } from 'next/navigation'
const router = useRouter()
router.push("/")

If you're facing an issue, don't worry - there's a simple solution. The bug currently resides in the try-catch block related to Next redirect. However, there's no need to make any changes. All you have to do is transfer the try-catch block to a different function. Here's an example of how you can modify your code:

"use server";
import LoginSchema from "@/Schemas/LoginSchema";
import PocketBase from "pocketbase";
import { redirect } from "next/navigation";

const analyze = async (data) => {
  const pb = new PocketBase("http://127.0.0.1:8090");
  try {
    const authData = await pb
      .collection("UserTable")
      .authWithPassword(await data.Email, await data.Password);
    if (authData) {
      return authData;
    }
  } catch (error) {
    error;
  }
};

export async function LoginAction(data) {
  const result = await LoginSchema.isValid(await data);
  if (result === true) {
    const result = await analyze(data);
    if (result) {
      return redirect("/");
    } else {
      return "failed";
    }
  } else {
    return "failed";
  }
}

When utilizing the redirect function within a server component, it is advised to place it inside the finally block for proper execution. Here's an example:

export default async function Page() {
    let redirectPath: string | null = null

    try {
        //Remaining code goes here
        redirectPath = `/dashboard`
    } catch (error) {
        //Remaining code goes here
        redirectPath = `/`
    } finally {
        //Release resources
        if (redirectPath)
            redirect(redirectPath)
    }

    return <>{/*More JSX content*/}</>
}

As stated in the documentation on redirects:

The redirect function internally throws an error, so it should be invoked outside of any try/catch blocks.

For handling redirects in api routes, it is recommended to use NextResponse from next/server. Here's how you can do it:

import { NextRequest, NextResponse } from "next/server";

export function GET(request: NextRequest) {
    try {
        //Code implementation
        return NextResponse.redirect(`<an absolute url>`)
    } catch {
        //Error handling logic
        return NextResponse.redirect(`<an absolute url>`)
    } finally {
        //Release resources
        //Avoid performing redirects here
    }
}

The reason for this is that within its code, redirect() actually throws an Error. For more information, please refer to this GitHub link

To achieve this, just utilize
the following code: NextResponse.redirect(new URL('/home', request.url))

This can be implemented in the server side of your 13+ app directory.

I encountered an error that stated:

Uncaught (in promise) Error: NEXT_REDIRECT

It's uncertain whether this is a bug or not, as the method requires context information only available during "react render time!"

To resolve this issue, it is recommended to create a reference for later use.

import { useRouter } from 'next/navigation'

function reactFunctionComponent() {
  const router = useRouter()
  runWithPromise().then( () => router.push("/") )
  ...
}

For more information

Instead of doing that, try this approach.

import { goTo } from 'next/navigation';

export async function GET(req: Request) {
  try {
    // Other logic
  } catch (error) {
    console.log(error);
    goTo('/');
  }

  goTo('/dashboard');
}

Internally, goTo triggers an action as detailed in the documentation here. Therefore, it is unnecessary to handle or return any errors related to it.

Here we define a function called redirect:

function redirect(url, type) {
    if (type === void 0) type = "replace";
    throw getRedirectError(url, type, false);
}

Also, there is a function called getRedirectError():

function getRedirectError(url, type, permanent) {
    if (permanent === void 0) permanent = false;
    const error = new Error(REDIRECT_ERROR_CODE);
    error.digest = REDIRECT_ERROR_CODE + ";" + type + ";" + url + ";" + permanent;
    const requestStore = _requestasyncstorageexternal.requestAsyncStorage.getStore();
    if (requestStore) {
        error.mutableCookies = requestStore.mutableCookies;
    }
    return error;
}

Lastly, the constant REDIRECT_ERROR_CODE is defined in getRedirectError:

const REDIRECT_ERROR_CODE = "NEXT_REDIRECT";

The purpose of the redirect() function is to throw an error that can be caught by next.js for redirection. It's important to note that placing redirect within a try/catch block will cause the error to be caught. To avoid this, keep redirect outside the try/catch block.

A similar feature exists in sveltekit, where redirection is explicitly thrown. This explicit approach can enhance code comprehension, facilitate debugging, and streamline maintenance. In sveltekit:

export const GET: RequestHandler = () => {
    throw redirect(307,`URL`
}

To implement server actions on the client-side, take a look at this documentation link in the Next.js website.

 async function performAppRedirect(route: string) {
      redirect(route)
    }

    // Example usage with async-await
    await performAppRedirect()

Avoid using the redirect() function within try catch blocks as it may lead to unexpected behavior. You can refer to the official documentation for more information on this topic by checking out the screenshot below: View the nextjs documentation screenshot about redirect()

I encountered a similar issue when utilizing a try...catch block. After refactoring my code to eliminate the need for the try...catch block, the functionality improved significantly. It's important to note that this issue is not exclusive to API route files; it can also occur within a react component if a redirect is triggered from within a try catch statement.

In accordance with @Daniel De León's suggestion, the function must be executed within a react component. One approach to achieving this is by utilizing a redirect call within the return statement. For instance:

function directUser(user) {
  if(user.isAdmin) {
    return redirect('/dashboard');
  } else {
    return redirect('401');
  }
}

export default async function ServerComponent(user){
  await directUser(user);
}

In a scenario where there is no try-catch block present, simply send back the response and perform a redirect in the designated file. This can either be within the client-side or server-side component depending on where the response needs to be directed.

If you encounter this issue, utilize the isRedirectError() function to determine if the error originates from the redirect() method.

import { redirect } from 'next/navigation';

export async function GET(req: Request) {
  try {
    redirect('/dashboard');
  } catch (error) {
    // Take appropriate action if the error is not caused by redirect()
    if (!isRedirectError(error)) {
      console.log(error);
      redirect('/');
    }
  }
}