Adding resetAllDirtyFlags action + a way to prevent Dirty Flag to be set on update

Author: tvillaren

README.md

@@ -40,6 +40,16 @@ This flag is _automatically_ set to `true` when:
 -   creating a new instance using the `createNew` method;
 -   updating the entity instance in the store, using the `update` action (`insert` and `create` mutation will not set this flag to `true`).
 
+**Preventing flag setting**
+If you want to prevent the flag to be set to `true` when updating, you can pass `preventDirtyFlag: true` to the `update` and `insertOrUpdate` calls:
+
+```js
+User.update({
+    data: myUserToUpdate,
+    preventDirtyFlag: true
+});
+```
+
 ### \$isNew
 
 This flag is _automatically_ set to `true` when calling the `createNew` method.
@@ -108,6 +118,14 @@ or specifically to a type:
 let results = store.getters['entities/users/allNew']();
 ```
 
+### `resetAllDirtyFlags` action
+
+This action will run through all the entities marked as dirty in your store and set the corresponding flag to `false`:
+
+```js
+store.dispatch['entities/resetAllDirtyFlags']({}, { root: true });
+```
+
 ## Plugin Options
 
 By default, the flags are named `$isDirty` and `$isNew`.  

src/index.js

@@ -5,7 +5,8 @@ const defaultOptions = {
 
 export default {
     install(components, installOptions) {
-        const pluginOptions = { ...defaultOptions,
+        const pluginOptions = {
+            ...defaultOptions,
             ...installOptions
         };
 
@@ -47,10 +48,52 @@ export default {
          * This is the only automatic way which sets this flag
          * to true once it's in the store.
          */
+        let _ignoreIsDirtyFlag = false;
+
         Query.on('beforeUpdate', function (model) {
-            model[pluginOptions.isDirtyFlagName] = true;
+            if (!_ignoreIsDirtyFlag)
+                model[pluginOptions.isDirtyFlagName] = true;
         });
 
+        /**
+         * Providing the resetFlags actions
+         */
+        RootActions.resetAllDirtyFlags = function ({
+            rootGetters
+        }) {
+            debugger
+            const allDirty = rootGetters['entities/allDirty']();
+            _ignoreIsDirtyFlag = true;
+            allDirty.forEach(e =>
+                e.$update({
+                    [pluginOptions.isDirtyFlagName]: false
+                })
+            );
+            _ignoreIsDirtyFlag = false;
+        };
+
+        // Overwriting to add preventDirtyFlag option
+        const _insertOrUpdate = RootMutations.insertOrUpdate;
+        RootMutations.insertOrUpdate = function (state, payload) {
+            if (payload.preventDirtyFlag === true) {
+                _ignoreIsDirtyFlag = true;
+                _insertOrUpdate.call(this, state, payload);
+                _ignoreIsDirtyFlag = false;
+            } else
+                _insertOrUpdate.call(this, state, payload);
+        };
+
+        // Overwriting to add preventDirtyFlag option
+        const _update = RootMutations.update;
+        RootMutations.update = function (state, payload) {
+            if (payload.preventDirtyFlag === true) {
+                _ignoreIsDirtyFlag = true;
+                _update.call(this, state, payload);
+                _ignoreIsDirtyFlag = false;
+            } else
+                _update.call(this, state, payload);
+        };
+
         /**
          * Providing the allDirty getter
          */

test/unit/test-all.js

@@ -6,6 +6,12 @@ import Role from '../dev/common/models/Role';
 import {
     expect
 } from 'chai';
+import {
+    Query
+} from '@vuex-orm/core';
+import {
+    debug
+} from 'util';
 
 describe('Vuex ORM $isDirty/$isNew plugin default installation', function () {
     it('should have both flag set to false when creating new', function () {
@@ -211,4 +217,114 @@ describe('Vuex ORM $isDirty/$isNew plugin default installation', function () {
 
         expect(result[0] instanceof User).to.equal(true);
     });
+
+    it('should provide a way to reset all dirty flags to false', async function () {
+        const store = createStore([{
+            model: User
+        }, {
+            model: Role
+        }]);
+
+        let user = new User({
+            id: 1,
+            roleId: 1
+        });
+        let user2 = new User({
+            id: 2,
+            roleId: 1
+        });
+        let role = new Role({
+            id: 3
+        });
+
+        User.insert({
+            data: [user, user2]
+        });
+        Role.insert({
+            data: role
+        });
+
+        user.name = 'AA';
+        role.name = 'AA';
+
+        User.update({
+            data: user
+        });
+        Role.update({
+            data: role
+        });
+
+
+        let result = store.getters['entities/allDirty']();
+        expect(result.length).to.equal(2);
+        await store.dispatch('entities/resetAllDirtyFlags', {}, {
+            root: true
+        });
+
+        let result2 = store.getters['entities/allDirty']();
+        expect(result2.length).to.equal(0);
+    });
+
+
+    it('should provide a way to ignore dirty flag when updating data', async function () {
+        const store = createStore([{
+            model: User
+        }, {
+            model: Role
+        }]);
+
+        let user = new User({
+            id: 1,
+            roleId: 1
+        });
+
+        User.insert({
+            data: [user]
+        });
+
+        user.name = 'AA';
+
+        User.update({
+            data: user,
+            preventDirtyFlag: true
+        });
+
+        let result = store.getters['entities/allDirty']();
+        expect(result.length).to.equal(0);
+    });
+
+    it('should provide a way to ignore dirty flag when insertingOrUpdating data', async function () {
+        const store = createStore([{
+            model: User
+        }, {
+            model: Role
+        }]);
+
+        let user = new User({
+            id: 1,
+            roleId: 1
+        });
+        let user2 = new User({
+            id: 2,
+            roleId: 1
+        });
+
+        User.insert({
+            data: [user, user2]
+        });
+
+        user.name = 'AA';
+
+        User.insertOrUpdate({
+            data: [user, user2],
+            preventDirtyFlag: true
+        });
+
+        let result = store.getters['entities/allDirty']();
+        expect(result.length).to.equal(0);
+
+        let users = store.getters['entities/users/all']();
+        expect(users.length).to.equal(2);
+
+    });
 });