Hi. Is it have sense to merge functionality from this repo https://github.com/aarondfrancis/vue-model ?

I think it would be nice to extend the functionality of the orm, or should it be done in the form of a plug-in thanks to the 0.18 version?

Or, if it develop as a plug-in, it will turn into dependency hell

Hi,

I installed and run vuex-orm/vuex-orm-examples-nuxt and I got warnings on terminal for every page refresh:

 WARN  Cannot stringify arbitrary non-POJOs Todo

 WARN  Cannot stringify arbitrary non-POJOs User

I get same warnings in my project, which uses latest Nuxt (v.2.3.2).

Kind Regards,

This doesn't seem possible currently, but is there any plan (or even ability: I'm not a JavaScript guy) to have inheritance mapping similar to Doctrine's single-table inheritance?

I have a case where I have multiple types of tasks, each a subclass of Task. It seems that the polymorphic relationships that are currently implemented are for cases where multiple parent types may own Task objects. I have the opposite problem, where I have several types of tasks and need to have a parent entity own many (potentially differently typed) tasks.

I've seen issues #50 and #192, but they both require a sub-key rather than taking advantage of inheritance. While this will work, it requires the creation of a separate entity when all of the required discriminator information is already present.

It seems to me that it would be possible to have an inheritance mapping and factory method to properly instantiate the correct model type, but I'm not familiar with the code base or the normalizr library. What are your thoughts? I'm happy to help if there's anything I can do.

I think it’s time to consider bumping Vuex ORM version to 1.0.0. The biggest reason is that luckily, I hear many people using Vuex ORM to build their application, and there are already few plugins out there. Hence we should fix the API and make whole application more stable.

But another reason is that Vuex ORM has almost all relationship types supported. We do have other feature requests as well, but I think some of them can be implemented after version 1.0.0.

Here are things I would like to do before bumping to 1.0.0.

• [x] Add Has Many Through relationship.
• [x] #60 Add action methods to the Model class.
• [x] #83 Add more complete lifecycle hooks.
• [x] #90 Add feature to update primary key value with its related records.
• [x] #98 Remove lodash from dependency.
• [x] #104 Make nested relation loading work with same top level relation name.
• [x] #110 Add specific type attributes such as string or number.
• [x] #136 Define lifecycle hook at models.
• [x] #143 Implement action to create a fresh record with default values.
• [x] #150 Add save method to the model.
• [x] #152 Deep relationship loading fails with morph relation.
• [x] #164 0.25.1 forEach of null bug.
• [x] #168 Auto increment the ID value when the value is null.
• [x] #171 Add nullable chain to the attribute definitions.
• [x] #231 Save class instances directly to the store.
• [ ] Fix all issues labeled as bug.
• [x] Refactor the documentation.

I would really love to hear any ideas or request regarding this plan from the community. I didn’t think Vuex ORM would become like it’s today that many people use in their project. I get contacted almost every day about this library.

I’m so thrilled, and I’m willing to make Vuex ORM even more powerful toward the future. Thank you all!

I followed the guide of Defining Relationships in Vuex ORM.

I did everything like the guide, so why I get null value in the category field in Article Model?

codesandbox

This is how I defining my models (category on article is: hasOne/belongTo):

export class Category extends Model {
  static entity = "categories";

  static primaryKey = "_id";

  static fields() {
    return {
      _id: this.attr(null),
      name: this.attr("")
    };
  }
}


export class Article extends Model {
  static entity = "articles";

  static primaryKey = "_id";

  static fields() {
    return {
      _id: this.attr(null),
      name: this.attr(""),
      category: this.hasOne(Category, "_id")
    };
  }

Config Vuex-orm with vuex in main.js:

import VuexORM from "@vuex-orm/core";
import { Article, Category } from "./models";

Vue.use(Vuex);

const database = new VuexORM.Database();

const Articles = {
  namespaced: true,

  actions: {
    test() {
      console.log(this);
    }
  }
};

const Categories = {
  namespaced: true,

  actions: {
    test() {
      console.log(this);
    }
  }
};

database.register(Article, Articles);
database.register(Category, Categories);

const store = new Vuex.Store({
  plugins: [VuexORM.install(database)]
});

Inside app component I have the data that I insert to vuex and get the values like so:

 const articleData = [
      {
        _id: "6ce9bae00000000000000000",
        name: "article-1",
        category: "5ce9acd00000000000000000"
      }
    ];
    const categoryData = [
      { _id: "5ce9acd00000000000000000", name: "category-1" }
    ];

    const x = await Article.insertOrUpdate({ data: articleData });
    const y = await Category.insertOrUpdate({ data: categoryData });

    const a = Article.query()
      .with("category")
      .first();

    console.log({ a });
    console.log({ type: a.category });
    console.log("why a.category is null???");

I have been trying to understand this for several days without success. I would much appreciate any help.

Many ORMs provide model methods like .find(), .create() or .save(). With Vuex-ORM we have to use rather long lines like this.$store.dispatch('entities/users/create', { data: { ... } }) or this.$store.getters['entities/users/query']().find().

What do you think about convenience methods like .find(), .first(), .create() and so on on the model class, that dispatch those events against vuex?

I think that would be a more comfortable way to work with vuex-orm :)

Dear @kiaking

I currently have an actual Todo list application that I've been building for over a year now. A very long time ago I had a problem after integrating Vuex that it was difficult to have getters or computed properties saved on a per item basis who's return values are all cached.

Therefore I made my own solution by building one Vue instance per item.

I am currently wondering if Vuex-ORM would be a good replacement or not, and especially in terms of keeping the computed properties per item cached.

This is my solution:

// imports
import ItemComputedProperties from './ItemComputedProperties.js'

window.cachedItems = {};
export default function(id) {
  if (cachedItems[id]) { return cachedItems[id] }
  if (!store.state.nodes[id])
  {
    console.log(`couldn't create new Vue for item ${id} because the node doesn't exist!`);
    return false
  }
  console.log(`creating new Vue for item ${id}!`)
  return cachedItems[id] = new Vue({
    store,
    data: {
      item: store.state.nodes[id],
    },
    computed: ItemComputedProperties,
  });
}

At the bottom you can see the imported ItemComputedProperties. This is basically a list of about 30 computed properties per item. It contains things like: isDue(), hasParentDue(), visibleChildrenIds(), nextItemId(), isProject(), etc.

I would make a call like so: itemGetters(48).isDue() which would let me know if item with id 48 is due or not, and this would be used inside Vue components to show/hide things and classes.

Now I wonder, if I install vuex-orm, which would be more memory intensive. My current solution works fine. I'm wondering the benefits of vuex-orm. Please enlighten me!

Hi,

For nested data with array of object

{
  "phones": [
    {
      "number": "12345678",
      "verified": true
    },
    {
      "number": "123456789",
      "verified": true
    }
  ],
  "emails": [
     {
       "address": "test@test.com",
       "verified": true
     }
  ]
}

In model field declare with hasMany(....) but it gives null array

Can you suggest me proper field declaration for array of object?

Hi, First at all... awesome library!!! But i have a huge problem. How can i insert custom fields in my Many To Many Polimorphic Relation. This is my gist of relationships... https://gist.github.com/jpenaroche/16d289a97c2cedd889d7172ec41a92d4

Issue continuing from https://github.com/vuex-orm/vuex-orm-graphql/issues/39.

Related Issue: #44

Let's see how it goes with the API design!

/cc @phortx @madmike

const post = await Post.dispatch('create', { data: {} });
console.log(post);    // => null

I've expected, that this creates a post with the default attribute values. But it seems I have to pass at least one attribute in the data object.

For me this is a bug. What do you think?

Is your feature request related to a problem? Please describe...

I have some fields where the default value or mutator depends on another value of the data passed in.

Describe the solution you'd like

I'd like to have that the parent record is passed into the functions

Describe alternatives you've considered

I'm not aware of any alternatives except for doing everything manually before creating/inserting the data.

Additional context

As an example, the make function could easily be adapted as such I think:

  make(value: any, _parent: Record, key: string): any {
    value = value !== undefined ? value : this.value

    // Default Value might be a function (taking no parameter).
    let localValue = value

    if (typeof value === 'function') {
      localValue = value(_parent) // Pass in _parent here
    }

    return this.mutate(localValue, key, _parent) // Pass in _parent here
  }

Bumps express from 4.17.1 to 4.18.2.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Bumps qs from 6.5.2 to 6.5.3.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Describe the bug

Pretty sure I’m missing something, would like to understand what.

Getting (checking for existence of) a relationship using the related object’s id returns the wrong parent object, doesn’t load the relationship either.

Steps to reproduce the bug

1. Models

class BoardItem extends Model {
    static entity = "board_item"

    static fields() {
        return {
            id: this.uid(),
            board_id: this.uid(),
            highlight_board_item_id: this.uid(),
            board_item_id: this.attr(null),
            board_item_type: this.attr(null),
            board_item_impl: this.morphTo("board_item_id", "board_item_type"),
            index: this.number(0),
        }
    }
}

class HighlightBoardItem extends Model {
    static entity = "highlight_board_item"

    static fields() {
        return {
            id: this.uid(),
            highlight_board_id: this.uid(),
            board_item: this.hasOne(BoardItem, "highlight_board_item_id"),
            index: this.number(0),
        }
    }
}

2. State of the store

board_item

[
  {
    "$id": "$uid10",
    "id": "$uid10",
    "board_id": "$uid3",
    "highlight_board_item_id": "$uid21",
    "board_item_id": "$uid8",
    "board_item_type": "board_item_value",
    "board_item_impl": [snip],
    "index": 0
  },
  {
    "$id": "$uid14",
    "id": "$uid14",
    "board_id": "$uid3",
    "highlight_board_item_id": "$uid15",
    "board_item_id": "$uid12",
    "board_item_type": "board_item_value",
    "board_item_impl": [snip],
    "index": 1
  }
]

highlight_board_item

[
  {
    "$id": "$uid21",
    "id": "$uid21",
    "highlight_board_id": "$uid7",
    "board_item": {
      "$id": "$uid10",
      "id": "$uid10",
      "board_id": "$uid3",
      "highlight_board_item_id": "$uid21",
      "board_item_id": "$uid8",
      "board_item_type": "board_item_value",
      "board_item_impl": [snip],
      "index": 0
    },
    "index": 0
  }
]

3. Code

Using the ID of a board_item that is not highlighted (i.e. assigned to the 1:1 relationship), but in the database nonetheless.

this.board_item.id: $uid14

this.repoHighlightBoardItem.query().with("board_item", query => {
    query.whereId(this.board_item.id)
}).get()

Ultimately I want the .get() above to be turned into .exists(), which would return True in the above.

4. Outcome

[
  {
    "$id": "$uid21",
    "id": "$uid21",
    "highlight_board_id": "$uid7",
    "board_item": null,
    "index": 0
  }
]

The above object corresponds to the one that is linked to the highlighted item, and does not have its predicate relationship loaded anyway.

The following should be working a priori, but doesn’t:

const repoHighlightBoardItem = this.$store.$db().model("highlight_board_item")
return this.repoHighlightBoardItem.query().with("board_item", query => {
     query.whereId(this.board_item.id)
}).has("board_item").exists()

Horrible workaround:

const repoBoardItem = this.$store.$db().model("board_item")
return repoBoardItem.query().whereId(this.board_item.id).where("highlight_board_item_id", hbii => this.repoHighlightBoardItem.query().whereId(hbii).exists()).exists()

Expected behaviour

I expected the returned array to be empty, as there are no object that satisfy the relationship predicate.

Versions

• Vuex ORM: 0.36.4
• Vuex: 4.1.0
• Vue: 3.2.41

Bumps decode-uri-component from 0.2.0 to 0.2.2.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Is your feature request related to a problem? Please describe...

Currently, I'm trying to store fileHandle (https://developer.mozilla.org/en-US/docs/Web/API/FileSystemFileHandle) in a field of a model. It seems like all fields defined in the static fields will be serialized. As a result, it causes issues when storing fileHandle.

Describe the solution you'd like

Having a way to ignore some fields for serialization would be useful for my case.

Describe alternatives you've considered

I found this #328 but that's not what I actually need. Every record in my table would need to have a field that isn't serialized so I can store fileHandle there.