Quick Intro to Vuex ORM
Tags: vuex, vue, javascript
Published: 2019-05-15 07:22:06

---
layout: post
title: Quick Intro to Vuex ORM
published: true
description: If you're looking to make a scalable Vue or Nuxt app, you might consider using Vuex ORM. I've recently used it in a project, and in this article, I'll share with you how it works and why I think you'll like it too.
tags: [vuex,vue.js,vue,javascript]
cover_image: https://thepracticaldev.s3.amazonaws.com/i/dst8zi53caev1y7qoz5o.jpg
code: qvo
level: intermediate
ad: ev 
---

If you're looking to make a scalable Vue or Nuxt app, you might consider using Vuex ORM. I've recently used it in a project, and in this article, I'll share with you how it works and why I think you'll like it too.

> Still getting your head around Vuex? Try my article [WTF is Vuex? A Beginner's Guide To Vue's Application Data Store](https://vuejsdevelopers.com/2017/05/15/vue-js-what-is-vuex/).

## What is Vuex ORM

Vuex introduces some powerful concepts for managing your application state including the store, mutations, actions, and so on.

Vuex ORM is an abstraction of Vuex that allows you to think about your application state in terms of models e.g. Posts, Users, Orders, etc, and CRUD operations, e.g. create, update, delete, etc.

> *ORM tools* (object-relational mapping) transform data between incompatible system using objects. ORMs are very popular for databases.

This allows for a signficant simplification of your code. For example, rather than `this.$store.state.commit("UPDATE_USER", { ... })`, you can use `User.update({ ... })`, making your Vue code much easier to reason about.

The other advantages of Vuex ORM are that it reduces boilerplate code by setting up the mutations and getter you'll need automatically, and also makes it easy to work with nested data structures in your application state.

## From Vuex to Vuex ORM

As a way of demonstrating the advantages, let's refactor some raw Vuex code using Vuex ORM.

We'll use a classic to-do list example where we can mark a to-do as "done". Here's the store which will represent that:

*store/index.js*

```js
store: {
  state: { todos: [] },
  mutations: {
    MARK_DONE(state, id) {
      const todo = state.todos.find(todo => todo.id === id);
      todo.done = true;
    }
  }
}
```

Let's say we display our to-do items on the home page of the app. We'll use a computed property `todos` and a `v-for` to link the to-do items to the template.

When a to-do is clicked, we'll mark it as "done" by making a commit to the `MARK_DONE` mutation.

*components/Home.vue*

```html
<template>
  <todo-item 
    v-for="todo in todos"
    :todo="todo"
    @click="markDone(todo.id)"
  />
</template>
<script>
  export default {
    computed: {
      todos() {
        return this.$store.state.todos;
      }
    },
    methods: {
      markDone(id) {
        this.$store.state.commit(MARK_DONE, id);
      }
    }
  }
</script>
```

<content-ad/>

## The Vuex ORM way

As I said, Vuex ORM represents data as *models*. So we'll first create a Todo model and define the fields we'd need like `id`, `title`, and `done`. 

> Unlike most Vue software, Vuex ORM uses ES6 classes for configuration.

*store/models/post.js*

```js
import { Model } from "@vuex-orm/core";

export default class Todo extends Model {
  static entity = "todos";

  static fields () {
    return {
      id: this.string(""),      
      title: this.string(""),
      done: this.boolean(false),
      ...
    };
  }
}
```

Now it's time to register the model to the Vuex ORM "database", which allows you to use the model.

While we're at it, we can register the Vuex ORM plugin with Vuex.

*store/index.js*

```js
import VuexORM from "@vuex-orm/core";
import Todo from "./models/Todo";

const database = new VuexORM.Database();
database.register(Todo, {});

const plugin = VuexORM.install(database);

export default {
  plugins: [plugin]
};
```

With our Vuex ORM store set up, we can start using it in our components. First, import the model into a component file. Now, rather than using the "weird" syntax of Vuex, we can use standard CRUD methods to query our store:

*components/Home.vue*

```js
import Todo from "../store/models/todo";
export default {
  computed: {
    // posts() {
    //   return this.$store.state.todos;
    // }
    todos: () => Todos.all();
  },
  methods: {
    markAsRead(id) {
      // this.$store.state.commit(MARK_DONE, id);
      Todo.update({
        where: id,
        data: { done: true }
      });
    }
  }
}
```

I don't know about you, but I find that much more readable!

## Store config

But hang on, where is the store configuration for the Todo model? Unless you want to customize it, you don't need any! Vuex ORM will automatically create state, mutations, and getters that are aliased to the model API e.g. `read`, `update`, `find`.

## Plugins

Even better, you can add some really handy plugins to Vuex ORM (that's right, a plugin for a plugin for a plugin), include ones to abstract your server communication.

For example, there is an Axios plugin that is almost zero config so long as your model endpoints fit the RESTful pattern.

Let's say when our app loads, it retrieves all the to-do items from the server and pushes them to the store:

```js
created() {
  try {
    let { data } = await this.$http.get("/todos");
    data.forEach(todo => this.$store.state.commit(ADD_TODO, todo));
  } catch (err) {
    // handle error
  }
}
```

The Vuex ORM Axios plugin adds additional model methods like `fetch` which allows you to replace the above code with:

```js
created() {
  Todo.$fetch();
}
```

How easy is that?

## Resources

There's plenty more to know about Vuex ORM so check out the docs:

- [Vuex ORM](https://github.com/vuex-orm/vuex-orm)
- [Vuex ORM Axios plugin](https://github.com/vuex-orm/plugin-axios)

* * *

**Enjoy this article?**

Get more articles like this in your inbox weekly with the *Vue.js Developers Newsletter*.

[Click here to join!](https://vuejsdevelopers.com/newsletter?utm_source=devto&utm_medium=article)

* * *