tjmoses/crud-compare

Compare JavaScript Objects, Array of Objects, and/or Array of Primitives to get created, modified, and deleted values.

crud-compare's Issues

Update compare for generic types.

Update the object and array compare functions to have generic types, enabling users to pass their own types for checking.

[Bug] invalid isEqualObject where left side has undefined values

crud-compare/src/index.ts

Line 10 in e3a44f6

function isEqualObject (a, b) {

    const leftSide = {a: undefined};
    const rightSide = {b: "something"};

    console.log("are they equal??", leftSide, rightSide, isEqualObject(leftSide, rightSide));

they have the same amount of "keys", and each value that is present in "leftSide" is strictly equal to a value in the "rightSide".
but still - they are obviously not equal.

feature request: return indexes

add functionality for return indexed

e.g. add option to return keys { extend: true }, and we can get the result

// from 
[{ one: 22, five: 5 }]

// to
[
  {
    value: { one: 22, five: 5 },
    index: 3
  }
]

this is necessary so that later it was not necessary to restart the search function by index if you need to work with reactive data

[improvement] better key finding

you mentioned in an other issue, that you are opting for performance.

there is a big improvement you can do -
instead of declaring originalItemKeys and activeItemKeys as an array of keys, you can declare them as a regular objects (or es6 Set) - then, you don't need to use indexOf for checking if a key is already present. you decrease O(n) to O(1) for those checks.

crud-compare/src/index.ts

Line 64 in 9792a74

if (i === originalItem.length - 1 && originalItemKeys.indexOf(activeItem[j][key]) === -1) {

crud-compare/src/index.ts

Line 71 in 9792a74

if (activeItemKeys.indexOf(outerKeyVal) === -1) {

var originalItemKeys: any = {};
var activeItemKeys: any = {};

for (var i = 0; i < originalItem.length; i++) {
    var outerKeyVal = originalItem[i][key];
    originalItemKeys[outerKeyVal] = true;

    for (var j = 0; j < activeItem.length; j++) {
      if (i === 0) {
        activeItemKeys[activeItem[j][key]] = true;
      }

      if (i === originalItem.length - 1 && !originalItemKeys[activeItem[j][key]]) {
        createdVals.push(activeItem[j]);
      } else if (originalItem[i][key] === activeItem[j][key] && !isEqualObject(originalItem[i], activeItem[j])) {
        updatedVals.push(activeItem[j]);
      }
    }

    if (!activeItemKeys[outerKeyVal]) {
      deletedVals.push(originalItem[i]);
    }
  }

also: you referring a lot to originalItem[i] and [activeItem[j] - you should save them in a local variable.

[Incomplete deps] error when trying to build

simply cloning the repo, and installing dependencies using npm is not sufficient.

compareObjectVals' updatedVals contains all fields, not just the ones that changed

right now when you compare array of objects, the updated array result contains all the fields, even the ones that didn't change. I'd like to know which fields actually changed (field name and value)

[Feature] allow complex key

crud-compare/src/index.ts

Line 34 in af7a0e9

function compareObjectVals (toCompareVals: [Object[], Object[]], key: string) :

currently - the matching of object is based on a "key" property.
this has a limitation for object with complex keys (multiple properties) - or where any other logic should be applied to find the match.

I suggest to extend the "key" parameter, so it allow passing a Matcher function. (but also allow passing a simple string - so you don't create breaking changes)
key: string | (left: any, right: any)=>bool

the library will check if the given key is a string or a function.
if its a string - the library will continue just like always - look for a property with the name of the key.
but if a function is given - the library will apply the function on 2 items to conclude if they "match".

lets say we have a Person object, and the key is based on firstName + lastName - we could write something like:

interface Person
{
   firstName: string;
   lastName: firstName;
   birthDate: Date;
   ...
}
compareObjectVals([arrBefore, arrAfter], (a, b) => a.firstName === b.firstName && a.lastName === b.lastName);

if it's fine by you - I can work on that a create a pull request.