diffHistoryObject.js
const omit = require('omit-deep-remove');
const pick = require('lodash.pick');
const empty = require('deep-empty-object');
const { assign } = require('power-assign');
// try to find an id property, otherwise just use the index in the array
const objectHash = (obj, idx) => obj._id || obj.id || `$$index: ${idx}`;
const diffPatcher = require('jsondiffpatch').create({ objectHash });
const historyModelGenerator = require('./diffHistoryModel');
module.exports = class DiffHistory {
constructor(schema, opts = {}) {
this.model = historyModelGenerator(schema, opts);
}
isValidCb = cb => {
return cb && typeof cb === 'function';
};
//https://eslint.org/docs/rules/complexity#when-not-to-use-it
/* eslint-disable complexity */
checkRequired(opts, queryObject, updatedObject) {
if (queryObject && !queryObject.options && !updatedObject) {
return;
}
const { __user: user, __reason: reason } =
(queryObject && queryObject.options) || updatedObject;
if (
opts.required &&
((opts.required.includes('user') && !user) ||
(opts.required.includes('reason') && !reason))
) {
return true;
}
}
saveDiffObject(currentObject, original, updated, opts, queryObject) {
const { __user: user, __reason: reason, __session: session } =
(queryObject && queryObject.options) || currentObject;
let diff = diffPatcher.diff(
JSON.parse(JSON.stringify(original)),
JSON.parse(JSON.stringify(updated))
);
if (opts.omit) {
omit(diff, opts.omit, { cleanEmpty: true });
}
if (opts.pick) {
diff = pick(diff, opts.pick);
}
if (!diff || !Object.keys(diff).length || empty.all(diff)) {
return;
}
const collectionId = currentObject._id;
const collectionName =
currentObject.constructor.modelName || queryObject.model.modelName;
return this.model
.findOne({ collectionId, collectionName })
.sort('-version')
.then(lastHistory => {
const history = new this.model({
collectionId,
collectionName,
diff,
user,
reason,
version: lastHistory ? lastHistory.version + 1 : 0
});
if (session) {
return history.save({ session });
}
return history.save();
});
}
/* eslint-disable complexity */
saveDiffHistory = (queryObject, currentObject, opts) => {
const queryUpdate = queryObject.getUpdate();
const schemaOptions = queryObject.model.schema.options || {};
let keysToBeModified = [];
let mongoUpdateOperations = [];
let plainKeys = [];
for (const key in queryUpdate) {
const value = queryUpdate[key];
if (key.startsWith('$') && typeof value === 'object') {
const innerKeys = Object.keys(value);
keysToBeModified = keysToBeModified.concat(innerKeys);
if (key !== '$setOnInsert') {
mongoUpdateOperations = mongoUpdateOperations.concat(key);
}
} else {
keysToBeModified = keysToBeModified.concat(key);
plainKeys = plainKeys.concat(key);
}
}
const dbObject = pick(currentObject, keysToBeModified);
let updatedObject = assign(
dbObject,
pick(queryUpdate, mongoUpdateOperations),
pick(queryUpdate, plainKeys)
);
let { strict } = queryObject.options || {};
// strict in Query options can override schema option
strict = strict !== undefined ? strict : schemaOptions.strict;
if (strict === true) {
const validPaths = Object.keys(queryObject.model.schema.paths);
updatedObject = pick(updatedObject, validPaths);
}
return this.saveDiffObject(
currentObject,
dbObject,
updatedObject,
opts,
queryObject
);
};
saveDiffs = (queryObject, opts) =>
queryObject
.find(queryObject._conditions)
.cursor()
.eachAsync(result =>
this.saveDiffHistory(queryObject, result, opts)
);
getVersion = (model, id, version, queryOpts, cb) => {
if (typeof queryOpts === 'function') {
cb = queryOpts;
queryOpts = undefined;
}
return model
.findById(id, null, queryOpts)
.then(latest => {
latest = latest || {};
return this.model
.find(
{
collectionName: model.modelName,
collectionId: id,
version: { $gte: parseInt(version, 10) }
},
{ diff: 1, version: 1 },
{ sort: '-version' }
)
.lean()
.cursor()
.eachAsync(history => {
diffPatcher.unpatch(latest, history.diff);
})
.then(() => {
if (this.isValidCb(cb)) return cb(null, latest);
return latest;
});
})
.catch(err => {
if (this.isValidCb(cb)) return cb(err, null);
throw err;
});
};
getDiffs = (modelName, id, opts, cb) => {
opts = opts || {};
if (typeof opts === 'function') {
cb = opts;
opts = {};
}
return this.model
.find({ collectionName: modelName, collectionId: id }, null, opts)
.lean()
.then(histories => {
if (this.isValidCb(cb)) return cb(null, histories);
return histories;
})
.catch(err => {
if (this.isValidCb(cb)) return cb(err, null);
throw err;
});
};
getHistories = (modelName, id, expandableFields, cb) => {
expandableFields = expandableFields || [];
if (typeof expandableFields === 'function') {
cb = expandableFields;
expandableFields = [];
}
const histories = [];
return this.model
.find({ collectionName: modelName, collectionId: id })
.lean()
.cursor()
.eachAsync(history => {
const changedValues = [];
const changedFields = [];
for (const key in history.diff) {
if (history.diff.hasOwnProperty(key)) {
if (expandableFields.indexOf(key) > -1) {
const oldValue = history.diff[key][0];
const newValue = history.diff[key][1];
changedValues.push(
key + ' from ' + oldValue + ' to ' + newValue
);
} else {
changedFields.push(key);
}
}
}
const comment =
'modified ' +
changedFields.concat(changedValues).join(', ');
histories.push({
changedBy: history.user,
changedAt: history.createdAt,
updatedAt: history.updatedAt,
reason: history.reason,
comment: comment
});
})
.then(() => {
if (this.isValidCb(cb)) return cb(null, histories);
return histories;
})
.catch(err => {
if (this.isValidCb(cb)) return cb(err, null);
throw err;
});
};
};