delete all records then insert new one

[shafiramaki]

if response is true then delete all data and insert new data otherwise ignore it.

[kiaking]

Yap, we need this one!

[mean-cj]

Hello Kiaking

I think we need to support option and method
delete all before create or insert

use option on Model.api

User.api().get(url, {
  deleteAll: true,
})

use deleteAll() on action.

actions: {
   method_name() {
      return this.deleteAll().post()
   }
}

User.insert({
  deleteAll: true,
  data: { id: 1, name: 'John' }
})
User.create({
  deleteAll: true,
  data: { id: 1, name: 'John' }
})

Thank you.

[kiaking]

Yea I hear lots of request regarding this. I think we need it.

[brendon]

Would this be useful in the following case?:

I'm on a password reset page and am fetching the User via a token. When found, the user is loaded into VuexORM, I then fetch the user with first() (this seems slightly dodgy currently as it assumes an empty collection just prior to the fetch).

Also at the moment, navigating back to the password reset page doesn't show a 404 because the User is still in the collection and even though the second fetch returns an empty result, this doesn't clear the User collection.

[cuebit]

I think this issue boils down to the user being able to leverage the persist methods and/or options.

The underlying save() method currently invokes User.insertOrUpdate but in reality, while this should be considered the default behaviour, users should be able to configure persistence to alleviate current limitations.

@mean-cj wrote:

I think we need to support option and method delete all before create or insert

User.api().get(url, {
  deleteAll: true,
})

An option such as deleteAll is useful but, as previously pointed out, this is something User.create handles nicely. However, the current implementation requires user intervention and additional boilerplate code.

---

The { save: boolean } option could be the ideal property to become configurable as it directly relates to persistence. Furthermore, the configuration of this option can work with the save method with a single point of validation.

For instance, the save option can be configured as follows:

save: boolean

save: true invokes Model.insertOrUpdate as per existing implementation.
save: false defers persistence as per existing implementation.

save: string

Where the string value can be any one of the persist methods, falling back to insertOrUpdate:

save: 'create' invokes Model.create
save: 'insert' invokes Model.insert
save: 'insertOrUpdate' invokes the default behaviour

Now, we have the ability to control persistence without additional plugin options.

Refresh entities per request:

User.api().get('url', { save: 'create' })

Refresh entities for all model requests:

static apiConfig = {
  save: 'create'
}

Refresh all entities globally:

VuexORM.use(VuexORMAxios, {
  axios,
  save: 'create'
})

What do you guys think?

[kiaking]

@cuebit Yeah I think that's what we should be doing 👍

[mean-cj]

Hello @cuebit @kiaking

Thank you for your detail.

it ok , but define save option current doesn't work with relation.
i thank we need option for delete model data with relation hasOne, hasMany beforeCreate

or if can define hook method on api option
Example

export default class User extends Model {
  static fields() {
    return {
      id: this.attr(null),
      orders: this.hasMany(OrderItem, 'order_id'),
    }
  }
}

User.api().get('url', { save:'create', beforeCreate:()=>{
 this.model.orders.deleteAll();
 this.model.deleteAll();
}})

Work for me, i use hook for delete all relation

export default class User extends Model {

  static beforeCreate(model) {
    Order.deleteAll()
  }

  static fields() {
    return {
      id: this.attr(null),
      orders: this.hasMany(Order),
    }
  }
}

User.api().get('url', { save:'create'})

[cuebit]

@mean-cj I don't think the plugin will have any intention of handling relations, let alone deleting them, simply because it just bridges axios and Vuex ORM. Until Vuex ORM supports cascade deletes, your solution is about as good as it gets.

[mean-cj]

Hello @cuebit thank you so much.

i'm sorry , i think current PR can be use save option ^^
We are wait @kiaking PR your commit

---

I use entities per request doesn't work

ajax response is ok , last response not exists order_id
but orderModel not deleteAll data before create and not callback beforeCreate method after ajax response.

Order.api().cancleOrder()

export default class Order extends Model {

  static beforeCreate(model) {
    console.log('beforeCreate')
  }

  static apiConfig = {
    cancleOrder(order_id) {
      return this.post(  '/order/cancle', {
          order_id: order_id,
        },
        { save: 'create' }
      )
    },
  }
}

[mean-cj]

Hello @cuebit

deleteAll on beforeCreate doesn't work
because myModel append data before call to beforeCreate method

therefore if use deleteAll in beforeCreate, order relation is empty

  static beforeCreate(model) {
    Order.deleteAll()
  }

[cuebit]

@mean-cj not sure I follow. Assuming you are using save: 'create', this will invoke Model.create() and any corresponding hooks should still fire. If your request also contains relations, those relations will also use the create method on their respective models.

Unless you’re suggesting the create method is working but it’s mutating the relations before the hook is fired on the calling model?

[cuebit]

Resolved by #119