Learn How YOU can build enterprise Vue.js applications with Nuxt
Tags: javascript, tutorial, webdev, showdev
Published: 2019-10-24 20:51:46

---
title: Learn How YOU can build enterprise Vue.js applications with Nuxt
published: true
description: 
tags: javascript, tutorial, webdev, showdev
cover_image: https://thepracticaldev.s3.amazonaws.com/i/pw6wxjmbnb2jtz0vydvh.jpg
---

Follow me on [Twitter](https://twitter.com/chris_noring), happy to take your suggestions on topics or improvements /Chris

> Nuxt is a progressive framework based on Vue.js to create modern web applications. It is based on Vue.js official libraries (vue, vue-router and vuex) and powerful development tools (webpack, Babel and PostCSS). Nuxt goal is to make web development powerful and performant with a great developer experience in mind.

1. Based on Vue-router and Vuex, it also uses Webpack, Babel and PostCSS.

2. Goal, make web development *powerful* and *performant*.

Ok, so a sales pitch, what else?

## The WHAT and WHY

Ok, so we love using Vue.js, it works great to use a router, a store, adding UI and so on, so why should we consider Nuxt? 

> The answer is SSR, Server side rendering 

Why is that such a big deal? Well, search engines, they were made to crawl static pages and most SPA frameworks don't produce static pages but dynamic pages. This causes a problem if you want your app's SEO, to be any good, i.e end up high up on a Google search result. If you have a productivity app you might not care about that so much but if you have an e-commerce store you might be out of business if you haven't got this aspect covered. 

> Is that all Nuxt offer?

There is more. Nuxt makes it easy to bring in things such as *code-splitting*. Code splitting is an important aspect of the user experience. It allows us to only load as much of our app initially that's needed. It works like this, imagine the user visits your site. You only load a tiny portion of the app so the user perceives you got a fast-loading app - everyone's happy. As the user discovers more and more of your app they start navigating to other parts of it. 

At this point, we load in the code needed for that *new* part the user is navigating to. This approach does a lot for the user experience, especially in places where the network connection is not that good. Having this for free in Nuxt is a big deal. 

There is more to Nuxt of course, like *hot module replacement*, being able to load async data before SSR, a great approach to working with Sass, Less and so on. 

### Features

Here's a full list of all features Nuxt is offering:

- **Write** Vue Files (*.vue)
- **Automatic** Code Splitting
- **Server-Side** Rendering
- **Powerful** Routing System with Asynchronous Data
- **Static** File Serving
- **ES2015+** Transpilation
- **Bundling** and minifying of your JS & CSS
- **Managing** `<head>` element (`<title>`, `<meta>`, etc.)
- **Hot module replacement** in Development
- **Pre-processor**: Sass, Less, Stylus, etc.
- **HTTP/2** push headers ready
- **Extending** with Modular architecture

> That's quite the list right?

SSR and code splitting is what really sells it for me though. How about we try to learn it next?

### Schema, lifecycle

Let's try to get ourselves a mile-high view of Nuxt. There are some steps from the incoming request to a rendered page. 

In Nuxt we use a directive called `<nuxt-link>` to navigate between pages. 

![](https://thepracticaldev.s3.amazonaws.com/i/uvl04jgkcebfn5685kh4.png)

1. **nuxtServerInit**, a store is part of your next app. This is an action we can define in the store if we want. It can be used to place data in the store the first thing we do, like a logged-in user. Read more [here](https://nuxtjs.org/guide/vuex-store/#the-nuxtserverinit-action)
2. **middleware**, middleware are custom functions that can run before the rendering of a route. You could, for example, ensure that the user is properly authenticated before being able to see a specific route. Read more [here](https://nuxtjs.org/guide/routing#middleware)
3. **validate**, in this step, we validate that we are dealing with a valid request, for example, we could be validating that an incoming request has the correct route parameters
4. **asyncData() & fetch()**, here we have the chance of fetching data asynchronously that will be part of the SSR rendering, for example, we could be fetching translations or some other data we need to render our page
5. **Render**, here we render the page

### SPA or SSR mode

If for any reason, you prefer not to use server-side rendering or need static hosting for your applications, you can simply use *SPA mode* using `nuxt --spa`. 

In combination with the *generate* feature, it gives you a powerful SPA deployment mechanism without the need to use a Node.js runtime or any special server handling.

read more about available commands here: 

> https://nuxtjs.org/guide/commands

### SSR, Static site generation

The big innovation of Nuxt.js comes with the `nuxt generate` command.

When building your application, it will generate the HTML for every one of your routes and store it in a file.

> How does that work?

```
-| pages/
----| about.vue
----| index.vue
```

turns into

```
-| dist/
----| about/
------| index.html
----| index.html
```

> Great for crawlers :)

### Hosting

Of course, you need to host your app somewhere. Currently, Netlify offers a great and easy way to do so with a simple command:

> https://vueschool.io/lessons/how-to-deploy-nuxtjs-to-netlify?friend=nuxt

## Creating an App

There are two ways to create apps in Nuxt:

1. **Wizard**, Using `create-nuxt-app`, this will trigger a wizard where you are asked to add/opt in to different things
2. **Manually**, A simple NPM install of `nuxt` and you need to define most things yourself. 

### Create an app with `create-nuxt-app`

We can use the command `create-nuxt-app` to get a full-fledged project. The only thing we need to do is choose among different options. 

Let's run the following command:

```
npx create-nuxt-app <project-name>
```

or `yarn`:

```
yarn create nuxt-app <project-name>
```

This triggers a dialog, first choose *Server-side framework*:

### -1- server-side framework

This is what will help us to do things like server side rendering that we use for static site generation. 

- None (Nuxt default server)
- Express
- Koa
- Hapi
- Feathers
- Micro
- Fastify
- Adonis (WIP)

### -2- select `UI library`

Of course you want your app to look good. Below are all the most known UI libraries that will be included in your project.

Then select `UI library`:

- None (feel free to add one later)
- Bootstrap
- Vuetify
- Bulma
- Tailwind
- Element UI
- Ant Design Vue
- Buefy
- iView
- Tachyons

### -3- choose Testing framework

Do you want testing? No? Well, you need it. Jest and AVA are both good options.

- None (feel free to add one later)
- Jest
- AVA

### -4- select mode

This is where we select to have our app server side rendered or not. I'd go with `Universal` myself.


Select `Universal` or `SPA` mode

### -5- http

fetch works of course but it's kind of nice when you can use a battle tested library like `axios`.

Add `axios` module for HTTP requests

### -6- linting

You do lint right? We want our code to look consistent.


Add `ESLint`

### -7- prettier

Add `Prettier`

### -8- launch app

Launch app

```
cd <project-name>
npm run dev
```

the app should now be running on `http://localhost:3000.`

That was simple right? You opted into some tried and testing libraries that are sure to make your app better. 

Below is your project overview, the result of running the creation tool.

![](https://thepracticaldev.s3.amazonaws.com/i/119ftzvmvhg20btb0nrh.png)

### Get started, from scratch

Let's have a look at the second approach, creating our app from scratch. First, we create a directory for our app to live in:

```
mkdir <project-name>
cd <project-name>
```

**Update package.json**

Next, let's add the necessary command to `package.json` so we can start up our app from the terminal:

```json
{
  "name": "my-app",
  "scripts": {
    "dev": "nuxt"
  }
}
```

Now we can type `npm run dev`, to start the app.

**Install nuxt**

Next, let's install the `nuxt` library itself and save a reference to it in `package.json`:

```
npm install --save nuxt
```

**`Pages` directory**

Nuxt has some great conventions, so creating directories with certain names has meaning. That is the case with the directory `pages`. Everything, with file ending `.vue`, that is placed under the `pages` directory, will turn into a route.

```html
<!-- index.vue -->
<template>
  <h1>Hello world!</h1>
</template>
```

Now run

```
npm run dev
```

This will start up our app. Let's go to the browser at `http://localhost:3000` and have a look.

![](https://thepracticaldev.s3.amazonaws.com/i/qrxi76vsd4w58jip18ah.png)

We have an app :)

Now try changing the template in `index.vue`, note how the change is reflected in the browser. This is because Nuxt comes with *hot module reloading*, it responds to changes.

## Demo - SSR

Let's demonstrate the server-side rendering and how that works. As we mentioned before placing files under specific directories have meaning. We will continue to work with our `pages` directory. 

This time, let's do the following:

- **Create** a file `products.vue` under pages
- **Generate** static site

### Create a file

Let's create `products.vue`, under `pages` directory, with the following content:

```html
<!-- products.vue -->
<template>
  <h1>Products</h1>
</template>
```

Our directory `pages` should now look like this:

```
-| pages/
---| index.vue
---| products.vue
```

### Generate static site

Next up, let's generate those static files to make search engines everywhere happy.

We do this with the help of `nuxt generate`. Let's add that command to `package.json` and its `scripts` section  like so:

```json
"generate": "nuxt generate"
```

Next we run `npm run generate`, and we get a `dist` directory created, looking like so:

![](https://thepracticaldev.s3.amazonaws.com/i/8qq5dkamqn0rgxv9ayr5.png)

We can now easily host the content under `dist` using a tool, like for example `http-server`.

It looks like this in the browser:

![](https://thepracticaldev.s3.amazonaws.com/i/wkswi5kwf80yfbu7rp48.png)

As you can see `http://localhost:5000/products/` and `http://localhost:5000/products/index.html` lead to the same place. 

## Working with Assets

Additionally to the `pages` directory, there's another directory that has special meaning. It's called `assets`. In there you can put images as well as stylesheets.

### Working with image assets

Let's give it a try by doing the following

- **Creating** `assets` directory and place a sample image file in there
- **Refer** to sample image file in a Component

**Create assets**

We create our `assets` directory and place a file `budapest.jpeg` in there. Now your directory should look like the following:

```
-| assets/
---| budapest.jpeg
-| pages
--- | products.vue
```


**Refer to asset**

This time we want render our image asset. For this we will update `products.vue` to:

```html
<!-- products.vue -->
<template>
  <div>
    <h1>Products</h1>
    <img src="~/assets/budapest.jpeg" alt="image" />
  </div>
</template>
```

What if we want to set this from code though? Then we extend the component to look like this:

```html
<!-- products.vue -->
<template>
  <div>
    <h1>Products</h1>
    <img :src="img" alt="should work" />
  </div>
</template>
<script>
const url = require('~/assets/budapest.jpeg')

export default {
  data() {
    return {
      img: url
    }
  }
}
</script>
```

as you can see we need to *import* the resource to ensure we get the correct URL to our resource, like so:

```js
const url = require('~/assets/budapest.jpeg')
```

### Working with Style assets

You can use different approaches to styling in Nuxt like Sass, Scss, Less and CSS. For this example let's use `scss`.

To compile `scss`, we need some additional libraries. You need to run the following installation command in the terminal:

```
npm install node-sass sass-loader --save
```

This will give us the needed libraries so Nuxt can do the rest.

There are two ways we could be using `scss` now:

1. **Define** styling in the component directly
2. **Create** an external file and place in the `assets` directory

### Define scss in the component

Let's start with defining the styles in the component directly, like so:

```html
<!-- sample.vue -->
<template>
  <div class="images">
    add some nice images here
  </div>
</template>
<style lang="scss">
  .images {
    margin: 15px;
    padding: 20px;
    display: flex;
    justify-content: center;
    box-shadow: 0 0 10px grey;
  }
</style>
```

Nuxt will compile the above and apply it to any matching CSS classes.

### Define an external file

The other way we can work with styling assets is by creating separate files. 

Let's create the file `page.scss` under `assets/scss` with the following content:

```scss
.page {
  .title {
    font-size: 20px;
  }
}
```

NOTE, we can create the styling file directly under `assets` directory but I just like to separate concerns so I recommend a directory approach like so:

```
-| assets/
---| images/
---| scss/
```

We also need to point this out to Webpack so it finds it, so go and create a file called `nuxt.config.js` in the root and give it the following content:

```js
module.exports = {
  css: [
    '@/assets/scss/page.scss'
  ]
}
```

Now our directory structure for the whole project should look something like so:

```
-| assets/
---| scss/
---| images/
-| pages/
-| nuxt.config.js
-| package.json
```

NOTE, `nuxt.config.js` is a configuration file that Nuxt will read from if it exists. There are a lot more you can do with `nuxt.config.js` and we have reason to come back to it.

## Working with routing

ok, we understand how we can create different pages by simply creating them in the `pages` directory. How to move between pages though?

Simple, use `<nuxt-link>`

We get a lot of routing set up for free. So given the following file structure:

```
pages/
--| user/
-----| index.vue
-----| one.vue
--| index.vue
```

we would get routing set up like so:

```js
router: {
  routes: [
    {
      name: 'index',
      path: '/',
      component: 'pages/index.vue'
    },
    {
      name: 'user',
      path: '/user',
      component: 'pages/user/index.vue'
    },
    {
      name: 'user-one',
      path: '/user/one',
      component: 'pages/user/one.vue'
    }
  ]
}
```

### Dynamic routing

We should understand by now how our file structure affects the routing. There are more aspects of routing we need to understand though namely *dynamic routing*. 

Consider the following file structure:

```
pages/
--| _slug/
-----| comments.vue
-----| index.vue
--| users/
-----| _id.vue
--| index.vue
```

We see the usage of underscore, `_` in both the directory `_slug` and the Vue file `_id.vue`. This is how we create routes with parameters.

Let's look at the resulting routes:

```js
router: {
  routes: [
    {
      name: 'index',
      path: '/',
      component: 'pages/index.vue'
    },
    {
      name: 'users-id',
      path: '/users/:id?',
      component: 'pages/users/_id.vue'
    },
    {
      name: 'slug',
      path: '/:slug',
      component: 'pages/_slug/index.vue'
    },
    {
      name: 'slug-comments',
      path: '/:slug/comments',
      component: 'pages/_slug/comments.vue'
    }
  ]
}
```

our file structure:

```
--| users/
-----| _id.vue
```

resulted in a route looking like this `/users/:id?`. 

NOTE, the `?` means that's it's optional if you want to make it mandatory you need the file structure to look like this:

```
--| users/
-----| _id/
---------| index.vue
```

Also 

```
--| _slug/
```

resulted in `/:slug`

**Validate route params**

Now that we know how to deal with parameters in the routes, how do we validate those parameters?

We can add a `validate()` method for that. If it fails the check it will automatically route you to the 404 page.

```
export default {
  validate ({ params }) {
    // Must be a number
    return /^\d+$/.test(params.id)
  }
}
```

### Nested routes

Sometimes you might have routes within your routes. You might have a `/products` route that in itself might render different pages depending on how the full route looks. 

Let's say if we go to `/products`, it should load a product list but if it goes to `/products/1`, it should load a product detail. If we have this scenario it means we will have the following behavior:

- **a shell**, this page can contain static and dynamic data and will need to contain a `<nuxt-child/>` component tag
- **a specific** file structure

Let's have a look at the file structure:

```
pages/
--| products/
-----| _id.vue
-----| index.vue
--| products.vue
```

The above will treat `products.vue` as the shell page and it will generate the following routes:

```js
router: {
  routes: [
    {
      path: '/products',
      component: 'pages/products.vue',
      children: [
        {
          path: '',
          component: 'pages/products/index.vue',
          name: 'products'
        },
        {
          path: ':id',
          component: 'pages/products/_id.vue',
          name: 'products-id'
        }
      ]
    }
  ]
}
```

To learn more about routing, check here:

> https://nuxtjs.org/guide/routing

## Working with async

When a request comes to a specific route we can bring in data asynchronously and use that to render the page. For that, we can use `asyncData` and fetch our data. Below we have a Vue component where `asyncData` are asking for data. It will block rendering until the data is fetched. We end by returning the data. The data we return ends up being amended to the `data` property of the component. As w can see in our `<template>` we are referring to `article` that was part of the data we returned from `asyncData`.

```html
<template>
  <div v-if="article">
    <h3>
    {{article.title}}
    </h3>
    <div>
      {{article.description}}
    </div>
  </div>
  <div v-else>
    <h3>Sorry</h3>
    No article with that name 
    <strong>{{slug}}</strong>
  </div>
</template>
<script>
function getData(slug) {
  const content = {
    docker: {
      title: 'Docker 101',
      description: 'this is about Docker'
    },
    dotnet: {
      title: '.NET news',
      description: 'this is about .NET'
    }
  };
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(content[slug]);
    }, 5000)
  })
}
export default {
  async asyncData ({ params }) {
    console.log('slug', params.slug);
    const res = await getData(params.slug)
    // called every time before loading the component
    return {
      article: res,
      slug: params.slug
    }
  }
}
</script>
```

## Layout

For the layout we want to cover three cases:

- **default page**, this is the page that constitutes the default rendering of a page unless you explicitly override it.
- **error page**, we can specify a page that will take care of all erroneous responses. 
- **custom layout**, we will cover how to define a custom layout component and show how to use our custom layout

First off, let's create the directory `layouts`, like so:

```
---| layouts
---| pages
```

### Default page

To create a default layout, simply create a component `default.vue`, like so:

```
---| layouts
-------| default.vue
```

Next, give it the following content:

```html
<template>
  <div>
    <div class="header">Hello route demo</div>
    <div class="subheader">
      <div class="item">
        <nuxt-link to="/">Home page</nuxt-link>
      </div>
      <div class="item">
        <nuxt-link to="/products">Products</nuxt-link>
      </div>
    </div>
    <nuxt/>
  </div>
</template>
<style scoped>
</style>
```

In our template we create a *header* section with CSS class `subheader`, in it we have a number of `<div>` elements, each with a `<nuxt-link>` element, that's our navigational link. 

We also render the `<nuxt/>` element, now this is important. This is the element that renders our page content, if you forget this page then it won't work properly.

### Error page

We can create an error page that will allow us to capture all errors. Let's create the component `error.vue`, like so:

```
---| layouts
-------| error.vue
```

Give it the following content:

```html
<template>
  <div class="container">
    <h1 v-if="error.statusCode === 404">Page not found</h1>
    <h1 v-else>An error occurred</h1>
    <nuxt-link to="/">Home page</nuxt-link>
  </div>
</template>
<script>
export default {
  props: ['error']
  // ,layout: 'blog' // you can set a custom layout for the error page
}
</script>
```

Note, how we have a input property `error`, like so `props: ['error']`. Additionally notehoow we can filter on status code and can render different messages depending on what the error is:

```html
<h1 v-if="error.statusCode === 404">Page not found</h1>
```

### Custom layout

Lastly, let's show how to create and apply a custom layout. You can name your custom layout component anything you want. We elect to name our component `blog.vue`, like so:

```
---| layouts
-------| blog.vue
```

Next let's give it some content, like so:

```html
<template>
  <div class="blog">
    <h1>Here's the template for an article</h1>
    <nuxt class="page" />
  </div>
</template>
```

This looks just like `default.vue` in that we have a `<nuxt>` element somewhere to make sure we render the page content.

> How do we use it?

Good question. Let's take a page component and set the `layout` property, like so:

```html
<template>
  <div>
    <h3>Docker 101</h3>
    <div>
      {{content}}
    </div>
  </div>
</template>
<script>
export default {
  layout: 'blog',
  data() {
    return {
      content: 'something...'
    }
  }
}
</script>
```

Note, how we point out the `layout: 'blog'`, thereby we refer to our layout by its name, minus the file extension. 

## Summary

That was quite a lot in one article. Guess what though, there's a lot more to learn. 

Let's recap on our learnings, we learned:

- **The WHAT and WHY of Nuxt**, it's important to understand the reason for wanting to use something. In the case of Nuxt, we learned that it had an opinionated architecture relying on convention. We also learned that it used a lot of great standard libraries for state management and server-side rendering.
- **Static site generation**, we learned how we can address the SEO problem that most SPA apps suffer from.
- **How to create our Nuxt app in two ways**, with a wizard and manually
- **Assets**, we learned how to deal with assets, images as well as styles
- **Routing**, then we covered routing, by convention based on our directory structures but also how to deal with dynamic routing
- **Async**, then we learned how to use a method like `asyncData()` to read asynchronous data before rendering a page.
- **Layout**, we learned how to create different layouts like default, error and a custom layout.

That was a lot but hopefully, you are now so comfortable with Nuxt that you see its value and can find out the rest you need in the docs.