**New to [Remix](http://remix.run)? Get up to speed by reading my [first look at Remix](https://www.davebitter.com/articles/first-look-at-remix).**
## LoaderFunction
A LoaderFunction is used to fetch and load some data for a (nested) route on the server. Like [Next.js API routes](https://www.davebitter.com/articles/next-js-api-routes), Remix lets you export a special async function that can be used to fetch some data and return an object containing the data. Here is an example of how that may look like when building an overview page for some articles:

```
// app/pages/articles/overview.tsx

import { LoaderFunction } from 'remix';

export const loader: LoaderFunction = async ({ }) => {
    const { articles } = await fetch('https://website.com/api/articles').then(res => res.json())

    return {
        articles: articles
            .splice(0, 5)
            .map(({ title, slug }: ArticleData) => ({ title, slug }))
    };
};
```
Note that by naming the exported function `loader`, Remix picks it up. A great optimization you can do right of the box is just returning the data that your front-end needs. In this case, we just need the first five articles’ `title` and `slug` properties. In general, you want to just return the data you actually need for performance and security reasons. The LoaderFunction is the perfect place to do so.

Next, we want to use this data in the front-end. We export some JSX in the same file where we can access the data form the LoaderFunction by using the `useLoaderData` hook provided by Remix:

```
// app/pages/articles/overview.tsx

import { LoaderFunction, useLoaderData, Link } from 'remix';

type LoaderData = {
    articles?: Partial<ArticleData>[];
};

export const loader: LoaderFunction = async () => {
    const { articles } = await fetch('https://website.com/api/articles').then(res => res.json())

    return {
        articles: articles
            .splice(0, 5)
            .map(({ title, slug }: ArticleData) => ({ title, slug }))
    };
};

const OverviewPage = () => {
    const loaderData = useLoaderData<LoaderData | undefined>();

    return <>
        <h1>Articles</h1>

        <ul>
            {loaderData?.articles?.map(({title, slug}) => {<li key={slug}>
                <Link to={`/aricles/${slug}`} prefetch='intent'>{title}</Link>
            </li>})}
        </ul>
    </>;
}
export default OverviewPage;
```
And that’s it. Whenever this (nested) route gets requested by the user, the LoaderFunction will fetch some data and then render the JSX on the server. Note that for a nested route, the data request is code-split right out of the box. I enjoy how straightforward it is, but incredibly powerful as well!
> The web’s core interactivity consists of links and forms. The rest is secondary.
## ActionFunction
So far, Next.js does things in a similar matter. Where Remix, to me, really shines is the handling of forms. In a framework like Next.js, you’d have to create an API route, probably `preventDefault` on the form submit and post client-side to the API route. Remix, being built on web standards, take a great approach to handling forms. It can actually handle your native form submit right out of the box with ActionFunctions like so:

```
// app/pages/contact.tsx

import { Form, ActionFunction, useActionData, redirect } from 'remix';

type ActionData = {
    fieldErrors?: {
        name: string | undefined;
        question: string | undefined;
    };
    fields?: {
        name: string;
        question: string;
    };
};

export const action: ActionFunction = async ({ request }): Promise<Response | ActionData> => {
    const form = await request.formData();
    const name = form.get('name');
    const question = form.get('question');

    const fieldErrors = {
        name: validateName(name),
        question: validateQuestion(question)
    };

    const fields = { name, question };

    if (Object.values(fieldErrors).some(Boolean)) {
        return { fieldErrors, fields };
    }

    await handleNewContactRequest(fields)

    return redirect(`/contact/thank-you`);
};

const ContactPage = () => {
    const actionData = useActionData<ActionData | undefined>();

    return <>
        <h1>Contact</h1>

        <Form method='post'>
            <label htmlFor='name'>Name</label>
            <input id='name' name='name' defaultValue={actionData?.fields?.name || ''} required></input>
            {actionData?.fieldErrors?.name && <span>{actionData?.fieldErrors?.name}</span>}

            <label htmlFor='question'>Question</label>
            <input id='question' name='question' defaultValue={actionData?.fields?.question || ''} required></input>
            {actionData?.fieldErrors?.question && <span>{actionData?.fieldErrors?.question}</span>}

            <button type='submit'>Send</button>
        </Form>
    </>;
}

export default ContactPage;
```
Quite a lot is happening here. Let’s break it up into smaller pieces:

```
// app/pages/contact.tsx

import { Form } from 'remix';

<Form method='post'>
    <label htmlFor='name'>Name</label>
    <input id='name' name='name' required></input>

    <label htmlFor='question'>Question</label>
    <input id='question' name='question' required></input>

    <button type='submit'>Send</button>
</Form>
```
We use the `Form` component by Remix to have client-side form handling if client-side JavaScript is available. If not, it falls back to a regular HTML `form` element. We make sure to properly add the attribute to our `input` elements with the `name` property as we’re going to need that in the form handling. Remember, Remix is built on web standards. We need to add a form method with the value `post` to make it work.

```
// app/pages/contact.tsx

import { Form, ActionFunction, redirect } from 'remix';

type ActionData = {
    fieldErrors?: {
        name: string | undefined;
        question: string | undefined;
    };
    fields?: {
        name: string;
        question: string;
    };
};

export const action: ActionFunction = async ({ request }): Promise<Response | ActionData> => {
    const form = await request.formData();
    const name = form.get('name');
    const question = form.get('question');

    const fieldErrors = {
        name: validateName(name),
        question: validateQuestion(question)
    };

    const fields = { name, question };

    if (Object.values(fieldErrors).some(Boolean)) {
        return { fieldErrors, fields };
    }

    await handleNewContactRequest(fields)

    return redirect(`/contact/thank-you`);
};
```
Just like the LoaderFunction, we export a special async function called `action` for the ActionFunction. Because we used a form with the method `post` in this file/route, the function will handle the incoming `post` request automatically.

We can then do some basic server-side form validation to ensure we don’t send any bad data to our email service. If there is an error for one of the form fields, we return an object containing the error messages. If all is good, we call our email handling service and redirect the user to a thank you page.

```
// app/pages/contact.tsx

import { Form, useActionData } from 'remix';

type ActionData = {
    fieldErrors?: {
        name: string | undefined;
        question: string | undefined;
    };
    fields?: {
        name: string;
        question: string;
    };
};

const ContactPage = () => {
    const actionData = useActionData<ActionData | undefined>();

    return <>
        <h1>Contact</h1>

        <Form method='post'>
            <label htmlFor='name'>Name</label>
            <input id='name' name='name' defaultValue={actionData?.fields?.name || ''} required></input>
            {actionData?.fieldErrors?.name && <span>{actionData?.fieldErrors?.name}</span>}

            <label htmlFor='question'>Question</label>
            <input id='question' name='question' defaultValue={actionData?.fields?.question || ''} required></input>
            {actionData?.fieldErrors?.question && <span>{actionData?.fieldErrors?.question}</span>}

            <button type='submit'>Send</button>
        </Form>
    </>;
}
```
In case there were errors, our ActionFunction behaves like a LoaderFunction where we can access the data that has been returned. Similarly, we use the `useActionData` hook provided by Remix to access the form field errors and entered values. We can then render the form field errors on the page and make sure to set the `defaultValue` property of the `input` elements with the values the user entered.
> Remix lets you build forms [progressively enhanced](https://www.davebitter.com/articles/custom-inputs-web) without even having to think about it. Writing applications that don’t solely rely on client-side JavaScript has never been easier.
## So all this for a no client-side JavaScript?
Naturally, the visitors of your website will most likely nearly all have client-side JavaScript enabled. There is a common misconception that this is why we want to build websites and web applications without the need of client-side JavaScript. There are a few more major benefits of building with this approach.
### Performance
Firstly, not having to load a large JavaScript bundle on a user’s device and mobile network is a great advantage. As more and more of the web’s functionality is moving to client-side JavaScript, so is the bundle size increasing. Handling all this logic on the server will help greatly with combatting this.
### Reliability
Secondly, having a non-client-side JavaScript “fallback” is great for the reliability and robustness of your web application. What happens when your JavaScript doesn’t load or breaks? In most modern web applications the user won’t be able to complete their task. Having an HTML-only “fallback” available that always works is great to rely on.

Notice how I keep adding quotation marks around “fallback”. This is because it’s not really a fallback with the Progressive Enhancement mindset. Building with the Graceful Degradation mindset would indeed mean that you first build the full functionality in an ideal situation and then make sure that you can fall back on a solution if that doesn’t work.

Progressive Enhancement however flips this around. You first build a working solution with just the basics. In this case, a regular HTML form that will post to a server and be redirected or reloaded after the server is done. Then, when there is client-side JavaScript available, we can handle it on the client and enhance the user experience. The great thing about Remix is that you get most of this right out of the box.
### Reduced complexity (by moving the state to the server)
Finally, a big benefit is moving the state to the server. Notice how I never used any client-side state in this form. This not only reduces the risk of a broken application but makes the code far simpler to read and keep up to date.

Sure, this form will just post the data and be done with it. Imagine you have a form that can create/read/update/delete (CRUD) users. Whenever you modify the user list, you need to make sure that you update all the client-side state that has a copy of the “real” (server-side) state. This can become quite complex and often developers resort to techniques like Redux. This makes an application so much more complex. By doing everything on the server, **Remix will hydrate all the pages every time they load to reflect the latest state of the data**. This is such a powerful shift of responsibility!
## Concluding
Remix makes it incredibly easy to build robust, well-performing and simple web applications by using the “old” web standards with new tricks up its sleeve. I’m a big advocate for how they do this and can’t wait to explore further. For now, thanks for reading and follow me for more of these articles!

Remix LoaderFunction vs ActionFunction

[Remix](https://remix.run) is a full-stack web framework that lets you focus on the user interface and work back through web fundamentals to deliver a fast, slick, and resilient user experience. This is what excited me when I first read about Remix. I'm a big advocate for progressively enhancing web applications and this framework seems to take this approach by simply using web fundamentals.

This is not a step-by-step guide on how to make a web application with Remix, but rather some features I noticed and wanted to highlight. That might come later. If you are looking for that, [Remix.run](http://Remix.run) is an amazing landing page and contains very well written documentation that will take you through all the reasons why they build this framework, what it offers and how it works. Seriously, one of the best landing pages I've seen in the past few years. Please, have a read there and come back for my view as a [Next.js](https://nextjs.org/) fanboy.
## Routing mechanism
Like Next.js, Remix uses a file-based routing system. In `/app` (where your app will live) you can create a folder called `routes`. Every file you add (e.g. `/app/routes/example` will create a route and page under `http://website.com/example`. If you're unfamiliar with this concept, please read my article [A simple, yet detailed introduction to Next.js](https://www.davebitter.com/articles/a-simple-yet-detailled-introduction-to-next-js). Next.js and Remix work nearly the same with some exceptions like creating a dynamic page (`[slug]` vs. `$slug`. If this is not the way you want to work, you can also define your routes in an object for both of these frameworks.
### Nested routes
Remix seems to heavily rely on the usage of nested routes as "partials". Let's say you are building an admin view. You might have multiple routes for several admin pages:
```
- app
    - routes
        - admin.tsx
        - admin
            - new.tsx
            - edit.tsx
                $user.tsx

```
All these admin pages might share a special navigation bar for logged in admins. Naturally, you could load a reusable component in the markup of all these pages, but that sounds more like a partial that you used to use back when building websites with templating languages like Pug or Handlebars. Remix allows you to just load the partial in `app/routes/admin.tsx` and add a Remix component called `<Outlet />` . This component serves as a placeholder where a child route can be rendered. In this case, that would be the new and edit route. I really like this approach of templating out pages.
### Scoped JS and CSS per nested route
These nested routes are not just useful as partials, but will allow Remix to also easily chunck-up your nested routes for JS and CSS bundles. Naturally, it knows what pieces to load as you load them per nested route. This makes these nested routes true small little routes and optimises the loading of resources.

This concept is fundamental to how Remix works. You can read more about nested routes [here](https://remix.run/docs/en/v1/guides/routing) and CSS scoping with `<Links />` [here](https://remix.run/docs/en/v1/guides/styling).
## Server- and client-side code
We've seen great strides by Next.js to make it easy for developers to expose server-side functions right next to client-side code. You can read more about that in my article [Next.js page generation](https://www.davebitter.com/articles/next-js-page-generation). At a first glance, Remix has an evenly convenient, if not better solution. I feel like Remix takes it to the next level by fully focussing on not having to use client-side JS as a standard, but rather an afterthought.
### Loaders
Many web applications need to fetch data. You can use `loader` functions in combination with a `useLoaderData` hook to set this up.
```jsx
import type { LoaderFunction } from "remix";
import type { User } from "@prisma/client";
import { db } from "~/utils/db.server";

type LoaderData = { users: Array<User> };
export let loader: LoaderFunction = async () => {
  const data: LoaderData = {
    users: await db.user.findMany()
  };

  return { data };
};

export default function Users() {
  const data = useLoaderData<LoaderData>();

  return (
    <ul>
      {data.map(user => (
        <li>{user.name}</li>
      ))}
    </ul>
  );
}
```
There is quite some Typescript-specific code here, but in its essence there is an async function exported called `loader`. This function fetches some data and returns an object with data. Note that you can return multiple pieces of data from various sources here. You can now access all this data using the `useLoaderData` hook. An important aspect of this is that no client-side JS is needed here. You just want some data from your server-side function and then use it to render a list on the server to serve to the client.
### Actions
So what about handling things like forms? I need to handle that on the client right? Well, not necessarily. Forms can easily be handled with a `method` attribute on the form element. Sure, you might want to make a fancy multi-step form, but this is where progressive enhancement pops up again. Just make a form with a `method` and let it post using the web standards. You then export an `action` function that will handle the posting of the form. Take a look at this code snippet of the [Jokes app tutorial](https://remix.run/docs/en/v1/tutorials/jokes) I followed in preparation for this article. You can find my full end result in [this repository](https://github.com/DaveBitter/remix-jokes).
```jsx
import type { ActionFunction } from "remix";
import { redirect } from "remix";
import { db } from "~/utils/db.server";

export const action: ActionFunction = async ({
  request
}) => {
  const form = await request.formData();
  const name = form.get("name");
  const content = form.get("content");
  // we do this type check to be extra sure and to make TypeScript happy
  // we'll explore validation next!
  if (
    typeof name !== "string" ||
    typeof content !== "string"
  ) {
    throw new Error(`Form not submitted correctly.`);
  }


  const fields = { name, content };


  const joke = await db.joke.create({ data: fields });
  return redirect(`/jokes/${joke.id}`);
};

export default function NewJokeRoute() {
  return (
    <div>
      <p>Add your own hilarious joke</p>
      <form method="post">
        <div>
          <label>
            Name: <input type="text" name="name" />
          </label>
        </div>
        <div>
          <label>
            Content: <textarea name="content" />
          </label>
        </div>
        <div>
          <button type="submit" className="button">
            Add
          </button>
        </div>
      </form>
    </div>
  );
}
```
There is a basic form (with no client-side JS) that just posts on submit. The `action` function is then called where we can then get the form data and handle it like normal. But what about validation? Naturally, you want to do this on the server, but it's considered good practice to do this on the client as well. The nice thing about having everything in this file is that we can reuse the same validation function in both places. Here's another snippet with just server-side validation implemented.
```jsx
import type { ActionFunction, LoaderFunction } from "remix";
import {
    useActionData,
    redirect,
    Form
} from "remix";
import { JokeDisplay } from "~/components/joke";
import { db } from "~/utils/db.server";
import {
    requireUserId,
    getUserId
} from "~/utils/session.server";

export const loader: LoaderFunction = async ({
    request
}) => {
    const userId = await getUserId(request);
    if (!userId) {
        throw new Response("Unauthorized", { status: 401 });
    }
    return {};
};

function validateJokeContent(content: string) {
    if (content.length < 10) {
        return `That joke is too short`;
    }
}

function validateJokeName(name: string) {
    if (name.length < 2) {
        return `That joke's name is too short`;
    }
}

type ActionData = {
    formError?: string;
    fieldErrors?: {
        name: string | undefined;
        content: string | undefined;
    };
    fields?: {
        name: string;
        content: string;
    };
};

export const action: ActionFunction = async ({
    request
}): Promise<Response | ActionData> => {
    const userId = await requireUserId(request);
    const form = await request.formData();
    const name = form.get("name");
    const content = form.get("content");
    if (
        typeof name !== "string" ||
        typeof content !== "string"
    ) {
        return { formError: `Form not submitted correctly.` };
    }


    const fieldErrors = {
        name: validateJokeName(name),
        content: validateJokeContent(content)
    };
    const fields = { name, content };
    if (Object.values(fieldErrors).some(Boolean)) {
        return { fieldErrors, fields };
    }


    const joke = await db.joke.create({
        data: { ...fields, jokesterId: userId }
    });
    return redirect(`/jokes/${joke.id}`);
};

export default function NewJokeRoute() {
    const actionData = useActionData<
        ActionData | undefined
    >();


    return (
        <div>
            <p>Add your own hilarious joke</p>
            <Form method="post">
                <div>
                    <label>
                        Name:{" "}
                        <input
                            type="text"
                            defaultValue={actionData?.fields?.name}
                            name="name"
                            aria-invalid={
                                Boolean(actionData?.fieldErrors?.name) ||
                                undefined
                            }
                            aria-describedby={
                                actionData?.fieldErrors?.name
                                    ? "name-error"
                                    : undefined
                            }
                        />
                    </label>
                    {actionData?.fieldErrors?.name ? (
                        <p
                            className="form-validation-error"
                            role="alert"
                            id="name-error"
                        >
                            {actionData.fieldErrors.name}
                        </p>
                    ) : null}
                </div>
                <div>
                    <label>
                        Content:{" "}
                        <textarea
                            defaultValue={actionData?.fields?.content}
                            name="content"
                            aria-invalid={
                                Boolean(actionData?.fieldErrors?.content) ||
                                undefined
                            }
                            aria-describedby={
                                actionData?.fieldErrors?.content
                                    ? "content-error"
                                    : undefined
                            }
                        />
                    </label>
                    {actionData?.fieldErrors?.content ? (
                        <p
                            className="form-validation-error"
                            role="alert"
                            id="content-error"
                        >
                            {actionData.fieldErrors.content}
                        </p>
                    ) : null}
                </div>
                <div>
                    <button type="submit" className="button">
                        Add
                    </button>
                </div>
            </Form>
        </div>
    );
}
```
Note that we return the validation messages if there is something wrong and render the page again accessing them with the `useActionData` hook. If the form validates fine, we can redirect to the overview page.
> This is a great example of how easy it can be to create an interactive part of your web application without the need for client-side JS for something that has web standards. Sure you can, but Remix is built in a way where you take this approach first.

## Resource routes
If I would've build the previous form without any client-side JS in Next.js, I would've had to build a Next.js API route. These are incredibly powerful. You can read more about these API routes in my article [Next.js API routes](https://www.davebitter.com/articles/next-js-api-routes). With Remix, you can do exactly the same, but even more. Remix doesn't just offer this for, for instance, JSON responses, but for any kind of response really. You can create a file with a special naming pattern like `/app/routes/jokes[.]rss.tsx`. The `[.]rss` part tells Remix that you will return a `.rss` file. In this code snippet, you can see how something like this could work.
```jsx
import type { LoaderFunction } from "remix";
import { db } from "~/utils/db.server";

export const loader: LoaderFunction = async ({
    request
}) => {
    const jokes = await db.joke.findMany({
        take: 100,
        orderBy: { createdAt: "desc" },
        include: { jokester: { select: { username: true } } }
    });


    const host =
        request.headers.get("X-Forwarded-Host") ??
        request.headers.get("host");
    if (!host) {
        throw new Error("Could not determine domain URL.");
    }
    const protocol = host.includes("localhost")
        ? "http"
        : "https";
    const domain = `${protocol}://${host}`;
    const jokesUrl = `${domain}/jokes`;


    const rssString = `
    <rss xmlns:blogChannel="${jokesUrl}" version="2.0">
      <channel>
        <title>Remix Jokes</title>
        <link>${jokesUrl}</link>
        <description>Some funny jokes</description>
        <language>en-us</language>
        <generator>Kody the Koala</generator>
        <ttl>40</ttl>
        ${jokes
            .map(joke =>
                `
            <item>
              <title>${joke.name}</title>
              <description>A funny joke called ${joke.name}</description>
              <author>${joke.jokester.username}</author>
              <pubDate>${joke.createdAt}</pubDate>
              <link>${jokesUrl}/${joke.id}</link>
              <guid>${jokesUrl}/${joke.id}</guid>
            </item>
          `.trim()
            )
            .join("\n")}
      </channel>
    </rss>
  `.trim();


    return new Response(rssString, {
        headers: {
            "Cache-Control": `public, max-age=${60 * 10
                }, s-maxage=${60 * 60 * 24}`,
            "Content-Type": "application/xml",
            "Content-Length": String(Buffer.byteLength(rssString))
        }
    });
};
```
How cool is that! The routes folder is not just for HTML pages, but you can create routes for any resource you need, hence the name resource routes.
## Nested route utility exports
I found the utility exports that Remix offers on nested routes incredibly nice to use. Previously, I mentioned you could import CSS on nested routes and have it scoped and chuncked to just that nested route. There are a variety of other Remix utilities you can use scoped to a nested route.
### SEO
You probably want to add some meta-tags to your pages. You can do this easily by exporting a `MetaFunction` on (nested) routes. Let's say you have some basic meta-tags on the root of the pages under `app/root.tsx`. You can export that function there like so:
```jsx export const meta: MetaFunction = () => {

  const description = `Learn Remix and laugh at the same time!`;
  return {
    description,
    keywords: "Remix,jokes",
    "twitter:image": "https://remix-jokes.lol/social.png",
    "twitter:card": "summary_large_image",
    "twitter:creator": "@remix_run",
    "twitter:site": "@remix_run",
    "twitter:title": "Remix Jokes",
    "twitter:description": description
  };
};
```
But you might want to update the title or description for a specific nested route. You guessed it, you can export the same function with different values there to extend this base set of meta tags. I think that's pretty sweet.
### Error handling
You can export a `CatchBoundary` and `ErrorBoundary` function for every (nested) route.
```jsx
export function CatchBoundary() {
    const caught = useCatch();


    if (caught.status === 404) {
        return (
            <div className="error-container">
                There are no jokes to display.
            </div>
        );
    }
    throw new Error(
        `Unexpected caught response with status: ${caught.status}`
    );
}

export function ErrorBoundary() {
    return (
        <div className="error-container">
            I did a whoopsies.
        </div>
    );
}
```
This will help you with two things. You can notify the user with some custom message on the page, but more importantly, you can isolate this error to just the nested route. The rest of you're application will run fine. This helps you think about how you want to handle your not so optimal flow.
## Finally, loading some client-side JS for the first time
During the Jokes app tutorial, I didn't even realize that hadn't written any client-side JS yet. I think it's really cool that Remix doesn't load any client-side JS by default. Naturally, you might need some client-side JS so you can load the `<Scripts />` component. This is the first time you will see JS files in your network tab. These optimised and chuncked files will be loaded and "hydrate" your application on the client.
## Verdict.
I'm a big advocate of Progressive Enhancement to make web applications simple, accessible and resilient. You can read some of my articles on this [here](https://www.davebitter.com/tags/progressive-enhancement). I usually put this to practice for just components. Seeing Remix take this approach to the entire application gives me hope for a future of building great web applications using web standards and progressive enhancement.

For the first time in years, I felt like a "web developer" again instead of a JS engineer. It's incredible fun to start thinking about how to leverage these standards smartly. I'm very excited about what Remix will offer and will definitely continue researching Remix and sharing it with all of you. Thanks for reading!

First look at Remix

I am a Developer Advocate & Senior Front-end Developer/Consultant. Here, you can find my resume, a collection of my articles covering a wide range of topics and get in contact.