Throw Response to bail out

[szmarczak]

Body

Summary

Bailing out would eliminate the need to pass the response down the chain to the return statement.

Background & Motivation

Remix:

• https://remix.run/docs/en/main/guides/not-found
• https://remix.run/docs/en/main/utils/redirect
• https://remix.run/docs/en/main/pages/faq

The below taken from: https://docs.astro.build/en/guides/backend/google-firebase/#creating-pages

---
import { app } from "../firebase/server";
import { getAuth } from "firebase-admin/auth";
import Layout from "../layouts/Layout.astro";

/* Check if the user is authenticated */
const auth = getAuth(app);
const sessionCookie = Astro.cookies.get("session").value;
if (sessionCookie) {
  const decodedCookie = await auth.verifySessionCookie(sessionCookie);
  if (decodedCookie) {
    return Astro.redirect("/dashboard");
  }
}
---

If there are many pages that require this check, this gets repetetive. Less code = better code.

Goals

• Less boilerplate

Example

---
import { app } from "../firebase/server";
import { getAuth } from "firebase-admin/auth";
import Layout from "../layouts/Layout.astro";
import { requireNotLoggedIn } from '...';

await requireNotLoggedIn();
---

export const requireNotLoggedIn = async () => {
  /* Check if the user is authenticated */
  const auth = getAuth(app);
  const sessionCookie = Astro.cookies.get("session").value;
  if (sessionCookie) {
    const decodedCookie = await auth.verifySessionCookie(sessionCookie);
    if (decodedCookie) {
      throw Astro.redirect("/dashboard");
    }
  }
};

Another example:

---
await requireRoles([ 'ADMIN' ])
---

Possible middleware implementation:

export async function onRequest(context, next) {
    try {
        return await next();
    } catch (error) {
        if (error instanceof Response) {
            return error;
        }
        
        throw error;
    }
};

[tropperstyle]

I've also implemented this using middleware already, and I think it makes sense for the framework to handle it.

[arty-name]

While this is not added to the core framework yet, I am trying to describe this design pattern in the documentation

[arty-name]

Well, this didn’t go far…

[ematipico]

Personally, I don't like using a Response for bailing from the chain, but that doesn't mean that's the way to go.

However, when I implemented the middleware during the experimental phase, it was possible to bail by NOT calling next. We eventually removed the feature because we thought it wasn't a well-known pattern.

Between throwing a response or not calling next, which one feels more correct?

[arty-name]

In my experience the code which decides to throw or return Response doesn’t have access to next at all. It’s a page or an endpoint or some utility function.

[ematipico]

Yeah good point