@e22m4u/js-repository 0.1.9 → 0.1.10

package/src/definition/model/properties/empty-values-definer.spec.js

@@ -0,0 +1,96 @@
+import {expect} from 'chai';
+import {DataType} from './data-type.js';
+import {format} from '@e22m4u/js-format';
+import {Schema} from '../../../schema.js';
+import {EmptyValuesDefiner} from './empty-values-definer.js';
+
+const getEmptyValues = (definer, dataType) => {
+  return definer['_emptyValuesMap'].get(dataType);
+};
+
+describe('EmptyValuesDefiner', function () {
+  describe('_emptyValuesMap', function () {
+    it('has default values', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      expect(Array.from(S['_emptyValuesMap'])).to.be.eql([
+        [DataType.ANY, [undefined, null]],
+        [DataType.STRING, [undefined, null, '']],
+        [DataType.NUMBER, [undefined, null, 0]],
+        [DataType.BOOLEAN, [undefined, null]],
+        [DataType.ARRAY, [undefined, null, []]],
+        [DataType.OBJECT, [undefined, null, {}]],
+      ]);
+    });
+  });
+
+  describe('setEmptyValuesOf', function () {
+    it('requires the parameter "dataType" to be a DataType enum', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      const throwable = v => () => S.setEmptyValuesOf(v, []);
+      const error = v =>
+        format(
+          'The argument "dataType" of the EmptyValuesDefiner.setEmptyValuesOf ' +
+            'must be one of data types: %l, but %s given.',
+          Object.values(DataType),
+          v,
+        );
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      expect(throwable({})).to.throw(error('Object'));
+      expect(throwable([])).to.throw(error('Array'));
+      throwable(DataType.ANY)();
+    });
+
+    it('requires the parameter "emptyValues" to be an Array', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      const throwable = v => () => S.setEmptyValuesOf(DataType.ANY, v);
+      const error = v =>
+        format(
+          'The argument "emptyValues" of the EmptyValuesDefiner.setEmptyValuesOf ' +
+            'must be an Array, but %s given.',
+          v,
+        );
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      expect(throwable({})).to.throw(error('Object'));
+      throwable([])();
+      throwable([1, 2, 3])();
+    });
+
+    it('overrides default values of the given data type', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      expect(getEmptyValues(S, DataType.ANY)).eql([undefined, null]);
+      S.setEmptyValuesOf(DataType.ANY, [1, 2, 3]);
+      expect(getEmptyValues(S, DataType.ANY)).eql([1, 2, 3]);
+    });
+  });
+
+  describe('isEmpty', function () {
+    it('returns true if the given value exists in the given type', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      S.setEmptyValuesOf(DataType.ANY, []);
+      expect(S.isEmpty(DataType.ANY, 'foo')).to.be.false;
+      S.setEmptyValuesOf(DataType.ANY, ['bar']);
+      expect(S.isEmpty(DataType.ANY, 'foo')).to.be.false;
+      S.setEmptyValuesOf(DataType.ANY, ['bar', 'foo']);
+      expect(S.isEmpty(DataType.ANY, 'foo')).to.be.true;
+    });
+  });
+});

package/src/definition/model/properties/index.d.ts

@@ -1,5 +1,7 @@
 export * from './data-type.js';
 export * from './property-definition.js';
+export * from './property-uniqueness.js';
+export * from './empty-values-definer.js';
 export * from './property-validator/index.js';
 export * from './property-transformer/index.js';
 export * from './property-uniqueness-validator.js';

package/src/definition/model/properties/index.js

@@ -1,5 +1,7 @@
 export * from './data-type.js';
 export * from './property-definition.js';
+export * from './property-uniqueness.js';
+export * from './empty-values-definer.js';
 export * from './property-validator/index.js';
 export * from './property-transformer/index.js';
 export * from './property-uniqueness-validator.js';

package/src/definition/model/properties/properties-definition-validator.js

@@ -1,6 +1,7 @@
 import {Service} from '@e22m4u/js-service';
 import {DataType as Type} from './data-type.js';
 import {capitalize} from '../../../utils/index.js';
+import {PropertyUniqueness} from './property-uniqueness.js';
 import {InvalidArgumentError} from '../../../errors/index.js';
 import {PropertyValidatorRegistry} from './property-validator/index.js';
 import {PropertyTransformerRegistry} from './property-transformer/index.js';
@@ -297,14 +298,19 @@ export class PropertiesDefinitionValidator extends Service {
         );
       }
     }
-    if (propDef.unique && typeof propDef.unique !== 'boolean')
+    if (
+      propDef.unique &&
+      !Object.values(PropertyUniqueness).includes(propDef.unique)
+    ) {
       throw new InvalidArgumentError(
         'The provided option "unique" of the property %v in the model %v ' +
-          'should be a Boolean, but %v given.',
+          'should be one of values: %l, but %v given.',
         propName,
         modelName,
+        Object.values(PropertyUniqueness),
         propDef.unique,
       );
+    }
     if (propDef.unique && propDef.primaryKey)
       throw new InvalidArgumentError(
         'The property %v of the model %v is a primary key, ' +

package/src/definition/model/properties/properties-definition-validator.spec.js

@@ -2,6 +2,7 @@ import chai from 'chai';
 import {expect} from 'chai';
 import {DataType} from './data-type.js';
 import {format} from '@e22m4u/js-format';
+import {PropertyUniqueness} from './property-uniqueness.js';
 import {PropertyValidatorRegistry} from './property-validator/index.js';
 import {PropertyTransformerRegistry} from './property-transformer/index.js';
 import {PropertiesDefinitionValidator} from './properties-definition-validator.js';
@@ -490,7 +491,7 @@ describe('PropertiesDefinitionValidator', function () {
       validate({myTransformer: true})();
     });
 
-    it('expects provided the option "unique" to be a boolean', function () {
+    it('expects provided the option "unique" to be the PropertyUniqueness', function () {
       const validate = v => {
         const foo = {
           type: DataType.STRING,
@@ -501,18 +502,20 @@ describe('PropertiesDefinitionValidator', function () {
       const error = v =>
         format(
           'The provided option "unique" of the property "foo" in the model "model" ' +
-            'should be a Boolean, but %s given.',
+            'should be one of values: %l, but %s given.',
+          Object.values(PropertyUniqueness),
           v,
         );
       expect(validate('str')).to.throw(error('"str"'));
       expect(validate(10)).to.throw(error('10'));
       expect(validate([])).to.throw(error('Array'));
       expect(validate({})).to.throw(error('Object'));
-      validate(true)();
-      validate(false)();
+      validate(PropertyUniqueness.UNIQUE)();
+      validate(PropertyUniqueness.SPARSE)();
+      validate(PropertyUniqueness.NON_UNIQUE)();
     });
 
-    it('expects the primary key should not have the option "unique" to be true', function () {
+    it('expects the primary key should not have the option "unique"', function () {
       const validate = v => () => {
         const foo = {
           type: DataType.ANY,
@@ -525,7 +528,8 @@ describe('PropertiesDefinitionValidator', function () {
         'The property "foo" of the model "model" is a primary key, ' +
           'so it should not have the option "unique" to be provided.',
       );
-      expect(validate(true)).to.throw(error);
+      expect(validate(PropertyUniqueness.UNIQUE)).to.throw(error);
+      expect(validate(PropertyUniqueness.SPARSE)).to.throw(error);
       validate(false)();
       validate(undefined)();
     });

package/src/definition/model/properties/property-uniqueness-validator.js

@@ -1,5 +1,8 @@
+import {DataType} from './data-type.js';
 import {Service} from '@e22m4u/js-service';
 import {isPureObject} from '../../../utils/index.js';
+import {PropertyUniqueness} from './property-uniqueness.js';
+import {EmptyValuesDefiner} from './empty-values-definer.js';
 import {InvalidArgumentError} from '../../../errors/index.js';
 import {ModelDefinitionUtils} from '../model-definition-utils.js';
 
@@ -67,10 +70,17 @@ export class PropertyUniquenessValidator extends Service {
         propValue,
       );
     let willBeReplaced = undefined;
+    const emptyValuesDefiner = this.getService(EmptyValuesDefiner);
     for (const propName of propNames) {
       const propDef = propDefs[propName];
       if (!propDef || typeof propDef === 'string' || !propDef.unique) continue;
+      // sparse
       const propValue = modelData[propName];
+      if (propDef.unique === PropertyUniqueness.SPARSE) {
+        const propType = propDef.type || DataType.ANY;
+        const isEmpty = emptyValuesDefiner.isEmpty(propType, propValue);
+        if (isEmpty) continue;
+      }
       // create
       if (methodName === 'create') {
         const count = await countMethod({[propName]: propValue});

package/src/definition/model/properties/property-uniqueness-validator.spec.js

@@ -2,6 +2,8 @@ import {expect} from 'chai';
 import {DataType} from './data-type.js';
 import {format} from '@e22m4u/js-format';
 import {Schema} from '../../../schema.js';
+import {PropertyUniqueness} from './property-uniqueness.js';
+import {EmptyValuesDefiner} from './empty-values-definer.js';
 import {PropertyUniquenessValidator} from './property-uniqueness-validator.js';
 import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '../model-definition-utils.js';
 
@@ -185,6 +187,48 @@ describe('PropertyUniquenessValidator', function () {
       );
     });
 
+    it('skips uniqueness checking for an empty value for "sparse" mode', async function () {
+      const schema = new Schema();
+      schema.defineModel({
+        name: 'model',
+        properties: {
+          foo: {
+            type: DataType.STRING,
+            unique: true,
+          },
+          bar: {
+            type: DataType.STRING,
+            unique: PropertyUniqueness.SPARSE,
+          },
+          baz: {
+            type: DataType.STRING,
+            unique: true,
+          },
+        },
+      });
+      const S = schema.getService(PropertyUniquenessValidator);
+      let invoked = 0;
+      schema
+        .getService(EmptyValuesDefiner)
+        .setEmptyValuesOf(DataType.STRING, ['val2']);
+      const modelData = {
+        foo: 'val1',
+        bar: 'val2',
+        baz: 'val3',
+      };
+      const countMethod = where => {
+        invoked++;
+        if (invoked === 1) {
+          expect(where).to.be.eql({foo: 'val1'});
+        } else if (invoked === 2) {
+          expect(where).to.be.eql({baz: 'val3'});
+        }
+        return 0;
+      };
+      await S.validate(countMethod, 'create', 'model', modelData);
+      expect(invoked).to.be.eql(2);
+    });
+
     describe('create', function () {
       it('throws an error if the "countMethod" returns a positive number', async function () {
         const schema = new Schema();

package/src/definition/model/properties/property-uniqueness.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Property uniqueness.
+ */
+export declare type PropertyUniqueness = {
+  UNIQUE: true;
+  SPARSE: 'sparse';
+  NON_UNIQUE: false;
+}

package/src/definition/model/properties/property-uniqueness.js

@@ -0,0 +1,8 @@
+/**
+ * Property uniqueness.
+ */
+export const PropertyUniqueness = {
+  UNIQUE: true,
+  SPARSE: 'sparse',
+  NON_UNIQUE: false,
+};

package/src/utils/index.d.ts

@@ -2,6 +2,7 @@ export * from './is-ctor.js';
 export * from './capitalize.js';
 export * from './clone-deep.js';
 export * from './singularize.js';
+export * from './is-deep-equal.js';
 export * from './get-ctor-name.js';
 export * from './is-pure-object.js';
 export * from './string-to-regexp.js';

package/src/utils/index.js

@@ -2,6 +2,7 @@ export * from './is-ctor.js';
 export * from './capitalize.js';
 export * from './clone-deep.js';
 export * from './singularize.js';
+export * from './is-deep-equal.js';
 export * from './get-ctor-name.js';
 export * from './is-pure-object.js';
 export * from './string-to-regexp.js';

package/src/utils/is-deep-equal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Is deep equal.
+ *
+ * @param firstValue
+ * @param secondValue
+ */
+export declare function isDeepEqual(
+  firstValue: unknown,
+  secondValue: unknown,
+): boolean;

package/src/utils/is-deep-equal.js

@@ -0,0 +1,71 @@
+/**
+ * Is deep equal.
+ * https://github.com/pinglu85/BFEdevSolutions/blob/main/Coding-Problems/69.implement-deep-equal-isEqual.md
+ *
+ * @param {*} firstValue
+ * @param {*} secondValue
+ * @returns {boolean}
+ */
+export function isDeepEqual(firstValue, secondValue) {
+  const cached = new WeakMap();
+  const compare = (a, b) => {
+    // Check if one of the two inputs is primitive by using typeof
+    // operator; since the typeof primitive null is object, check
+    // if one of the inputs is equal to null. If one of the two
+    // inputs is primitive, then I can compare them by reference.
+    if (a === null || b === null) return a === b;
+    if (typeof a !== 'object' || typeof b !== 'object') return a === b;
+    // Check if the data type of the two inputs are the same,
+    // both are arrays or objects. If they are not, return false.
+    const dataTypeA = Array.isArray(a) ? 'array' : 'object';
+    const dataTypeB = Array.isArray(b) ? 'array' : 'object';
+    if (dataTypeA !== dataTypeB) return false;
+    // Use Object.keys and Object.getOwnPropertySymbols to get
+    // all of enumerable and not-inherited properties of the two
+    // inputs. Compare their size respectively, if one of them
+    // is not equal, return false.
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    const symbolsA = Object.getOwnPropertySymbols(a);
+    const symbolsB = Object.getOwnPropertySymbols(b);
+    if (symbolsA.length !== symbolsB.length) return false;
+    // To handle the circular reference, initialize a WeakMap
+    // that is going to keep track of the objects or arrays
+    // that have been seen, in which each key is an object
+    // or an array and each value is a set of objects or arrays,
+    // that have been compared to that object or array.
+    let setForA = cached.get(a);
+    if (setForA == null) {
+      setForA = new Set();
+      cached.set(a, setForA);
+    } else if (setForA.has(b)) {
+      return true;
+    }
+    setForA.add(b);
+    let setForB = cached.get(b);
+    if (setForB == null) {
+      setForB = new Set();
+      cached.set(b, setForB);
+    } else if (setForB.has(a)) {
+      return true;
+    }
+    setForB.add(a);
+    // Compare the property names and the values. Loop through
+    // all the properties of the first input data, check if
+    // the property name also exist in the second input data,
+    // if not, return false; otherwise recursively compare
+    // the property value.
+    const propertyNamesA = [...keysA, ...symbolsA];
+    for (const propertyNameA of propertyNamesA) {
+      if (!b.hasOwnProperty(propertyNameA)) return false;
+      const propertyValueA = a[propertyNameA];
+      const propertyValueB = b[propertyNameA];
+      if (!compare(propertyValueA, propertyValueB)) return false;
+    }
+    // If we get out of the loop without
+    // returning false, return true.
+    return true;
+  };
+  return compare(firstValue, secondValue);
+}

package/src/utils/is-deep-equal.spec.js

@@ -0,0 +1,238 @@
+import {expect} from 'chai';
+import {isDeepEqual} from './is-deep-equal.js';
+
+const check = (a, b, expected) => {
+  expect(isDeepEqual(a, b)).to.be.eq(expected);
+  expect(isDeepEqual(b, a)).to.be.eq(expected);
+};
+
+describe('isDeepEqual', function () {
+  describe('string', function () {
+    it('a non-empty string', function () {
+      check('str', 'str', true);
+      check('str', '', false);
+      check('str', 10, false);
+      check('str', 0, false);
+      check('str', -10, false);
+      check('str', true, false);
+      check('str', false, false);
+      check('str', undefined, false);
+      check('str', null, false);
+      check('str', {foo: 'bar'}, false);
+      check('str', {}, false);
+      check('str', [1, 2, 3], false);
+      check('str', [], false);
+    });
+
+    it('an empty string', function () {
+      check('', 'str', false);
+      check('', '', true);
+      check('', 10, false);
+      check('', 0, false);
+      check('', -10, false);
+      check('', true, false);
+      check('', false, false);
+      check('', undefined, false);
+      check('', null, false);
+      check('', {foo: 'bar'}, false);
+      check('', {}, false);
+      check('', [1, 2, 3], false);
+      check('', [], false);
+    });
+  });
+
+  describe('number', function () {
+    it('a positive number', function () {
+      check(10, 'str', false);
+      check(10, '', false);
+      check(10, 10, true);
+      check(10, 0, false);
+      check(10, -10, false);
+      check(10, true, false);
+      check(10, false, false);
+      check(10, undefined, false);
+      check(10, null, false);
+      check(10, {foo: 'bar'}, false);
+      check(10, {}, false);
+      check(10, [1, 2, 3], false);
+      check(10, [], false);
+    });
+
+    it('zero', function () {
+      check(0, 'str', false);
+      check(0, '', false);
+      check(0, 10, false);
+      check(0, 0, true);
+      check(0, -10, false);
+      check(0, true, false);
+      check(0, false, false);
+      check(0, undefined, false);
+      check(0, null, false);
+      check(0, {foo: 'bar'}, false);
+      check(0, {}, false);
+      check(0, [1, 2, 3], false);
+      check(0, [], false);
+    });
+
+    it('a negative number', function () {
+      check(-10, 'str', false);
+      check(-10, '', false);
+      check(-10, 10, false);
+      check(-10, 0, false);
+      check(-10, -10, true);
+      check(-10, true, false);
+      check(-10, false, false);
+      check(-10, undefined, false);
+      check(-10, null, false);
+      check(-10, {foo: 'bar'}, false);
+      check(-10, {}, false);
+      check(-10, [1, 2, 3], false);
+      check(-10, [], false);
+    });
+  });
+
+  describe('boolean', function () {
+    it('true', function () {
+      check(true, 'str', false);
+      check(true, '', false);
+      check(true, 10, false);
+      check(true, 0, false);
+      check(true, -10, false);
+      check(true, true, true);
+      check(true, false, false);
+      check(true, undefined, false);
+      check(true, null, false);
+      check(true, {foo: 'bar'}, false);
+      check(true, {}, false);
+      check(true, [1, 2, 3], false);
+      check(true, [], false);
+    });
+
+    it('false', function () {
+      check(false, 'str', false);
+      check(false, '', false);
+      check(false, 10, false);
+      check(false, 0, false);
+      check(false, -10, false);
+      check(false, true, false);
+      check(false, false, true);
+      check(false, undefined, false);
+      check(false, null, false);
+      check(false, {foo: 'bar'}, false);
+      check(false, {}, false);
+      check(false, [1, 2, 3], false);
+      check(false, [], false);
+    });
+  });
+
+  describe('array', function () {
+    it('an array of numbers', function () {
+      check([1, 2, 3], 'str', false);
+      check([1, 2, 3], '', false);
+      check([1, 2, 3], 10, false);
+      check([1, 2, 3], 0, false);
+      check([1, 2, 3], -10, false);
+      check([1, 2, 3], true, false);
+      check([1, 2, 3], false, false);
+      check([1, 2, 3], undefined, false);
+      check([1, 2, 3], null, false);
+      check([1, 2, 3], {foo: 'bar'}, false);
+      check([1, 2, 3], {}, false);
+      check([1, 2, 3], [1, 2, 3], true);
+      check([1, 2, 3], [], false);
+    });
+
+    it('an empty array', function () {
+      check([], 'str', false);
+      check([], '', false);
+      check([], 10, false);
+      check([], 0, false);
+      check([], -10, false);
+      check([], true, false);
+      check([], false, false);
+      check([], undefined, false);
+      check([], null, false);
+      check([], {foo: 'bar'}, false);
+      check([], {}, false);
+      check([], [1, 2, 3], false);
+      check([], [], true);
+    });
+  });
+
+  describe('object', function () {
+    it('string key and string value', function () {
+      check({foo: 'bar'}, 'str', false);
+      check({foo: 'bar'}, '', false);
+      check({foo: 'bar'}, 10, false);
+      check({foo: 'bar'}, 0, false);
+      check({foo: 'bar'}, -10, false);
+      check({foo: 'bar'}, true, false);
+      check({foo: 'bar'}, false, false);
+      check({foo: 'bar'}, undefined, false);
+      check({foo: 'bar'}, null, false);
+      check({foo: 'bar'}, {foo: 'bar'}, true);
+      check({foo: 'bar'}, {}, false);
+      check({foo: 'bar'}, [1, 2, 3], false);
+      check({foo: 'bar'}, [], false);
+    });
+
+    it('an empty object', function () {
+      check({}, 'str', false);
+      check({}, '', false);
+      check({}, 10, false);
+      check({}, 0, false);
+      check({}, -10, false);
+      check({}, true, false);
+      check({}, false, false);
+      check({}, undefined, false);
+      check({}, null, false);
+      check({}, {foo: 'bar'}, false);
+      check({}, {}, true);
+      check({}, [1, 2, 3], false);
+      check({}, [], false);
+    });
+
+    it('null', function () {
+      check(null, 'str', false);
+      check(null, '', false);
+      check(null, 10, false);
+      check(null, 0, false);
+      check(null, -10, false);
+      check(null, true, false);
+      check(null, false, false);
+      check(null, undefined, false);
+      check(null, null, true);
+      check(null, {foo: 'bar'}, false);
+      check(null, {}, false);
+      check(null, [1, 2, 3], false);
+      check(null, [], false);
+    });
+
+    it('circular reference to itself', function () {
+      const a = {foo: 'bar'};
+      const b = {baz: 'qux'};
+      const c = {foo: 'bar'};
+      a.itself = a;
+      b.itself = b;
+      c.itself = c;
+      check(a, b, false);
+      check(a, c, true);
+    });
+  });
+
+  it('undefined', function () {
+    check(undefined, 'str', false);
+    check(undefined, '', false);
+    check(undefined, 10, false);
+    check(undefined, 0, false);
+    check(undefined, -10, false);
+    check(undefined, true, false);
+    check(undefined, false, false);
+    check(undefined, undefined, true);
+    check(undefined, null, false);
+    check(undefined, {foo: 'bar'}, false);
+    check(undefined, {}, false);
+    check(undefined, [1, 2, 3], false);
+    check(undefined, [], false);
+  });
+});