@e22m4u/js-repository 0.8.4 → 0.8.6

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

@@ -2,7 +2,6 @@ import {expect} from 'chai';
 import {DataType} from './data-type.js';
 import {format} from '@e22m4u/js-format';
 import {DatabaseSchema} from '../../../database-schema.js';
-import {BlankValuesService} from '@e22m4u/js-empty-values';
 import {PropertyUniqueness} from './property-uniqueness.js';
 import {PropertyUniquenessValidator} from './property-uniqueness-validator.js';
 import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '../model-definition-utils.js';
@@ -430,11 +429,12 @@ describe('PropertyUniquenessValidator', function () {
           const idValue = 1;
           const modelData = {foo: 'bar'};
           const countMethod = where => {
-            if (invoked === 0)
+            if (invoked === 0) {
               expect(where).to.be.eql({
                 myId: {neq: idValue},
                 foo: 'bar',
               });
+            }
             invoked++;
             return 0;
           };
@@ -838,7 +838,9 @@ describe('PropertyUniquenessValidator', function () {
           let invoked = 0;
           const modelData = {foo: 'val1', bar: 'val2'};
           const countMethod = where => {
-            if (invoked === 0) expect(where).to.be.eql({foo: 'val1'});
+            if (invoked === 0) {
+              expect(where).to.be.eql({foo: 'val1'});
+            }
             invoked++;
             return 0;
           };
@@ -937,11 +939,12 @@ describe('PropertyUniquenessValidator', function () {
           const idValue = 1;
           const modelData = {foo: 'val1', bar: 'val2'};
           const countMethod = where => {
-            if (invoked === 0)
+            if (invoked === 0) {
               expect(where).to.be.eql({
                 [DEF_PK]: {neq: idValue},
                 foo: 'val1',
               });
+            }
             invoked++;
             return 0;
           };
@@ -1000,11 +1003,12 @@ describe('PropertyUniquenessValidator', function () {
           const idValue = 1;
           const modelData = {foo: 'bar'};
           const countMethod = where => {
-            if (invoked === 0)
+            if (invoked === 0) {
               expect(where).to.be.eql({
                 myId: {neq: idValue},
                 foo: 'bar',
               });
+            }
             invoked++;
             return 0;
           };
@@ -1203,11 +1207,12 @@ describe('PropertyUniquenessValidator', function () {
           const idValue = 1;
           const modelData = {foo: 'bar'};
           const countMethod = where => {
-            if (invoked === 0)
+            if (invoked === 0) {
               expect(where).to.be.eql({
                 myId: {neq: idValue},
                 foo: 'bar',
               });
+            }
             invoked++;
             return 0;
           };
@@ -1611,7 +1616,9 @@ describe('PropertyUniquenessValidator', function () {
           let invoked = 0;
           const modelData = {foo: 'val1', bar: 'val2'};
           const countMethod = where => {
-            if (invoked === 0) expect(where).to.be.eql({foo: 'val1'});
+            if (invoked === 0) {
+              expect(where).to.be.eql({foo: 'val1'});
+            }
             invoked++;
             return 0;
           };
@@ -1710,11 +1717,12 @@ describe('PropertyUniquenessValidator', function () {
           const idValue = 1;
           const modelData = {foo: 'val1', bar: 'val2'};
           const countMethod = where => {
-            if (invoked === 0)
+            if (invoked === 0) {
               expect(where).to.be.eql({
                 [DEF_PK]: {neq: idValue},
                 foo: 'val1',
               });
+            }
             invoked++;
             return 0;
           };
@@ -1773,11 +1781,12 @@ describe('PropertyUniquenessValidator', function () {
           const idValue = 1;
           const modelData = {foo: 'bar'};
           const countMethod = where => {
-            if (invoked === 0)
+            if (invoked === 0) {
               expect(where).to.be.eql({
                 myId: {neq: idValue},
                 foo: 'bar',
               });
+            }
             invoked++;
             return 0;
           };
@@ -1854,7 +1863,9 @@ describe('PropertyUniquenessValidator', function () {
           let invoked = 0;
           const modelData = {foo: 'val1', bar: 'val2'};
           const countMethod = where => {
-            if (invoked === 0) expect(where).to.be.eql({foo: 'val1'});
+            if (invoked === 0) {
+              expect(where).to.be.eql({foo: 'val1'});
+            }
             invoked++;
             return 0;
           };
@@ -1862,7 +1873,7 @@ describe('PropertyUniquenessValidator', function () {
           expect(invoked).to.be.eq(1);
         });
 
-        it('skips uniqueness checking for blank values', async function () {
+        it('skips uniqueness checking for an undefined value', async function () {
           const dbs = new DatabaseSchema();
           dbs.defineModel({
             name: 'model',
@@ -1879,12 +1890,98 @@ describe('PropertyUniquenessValidator', function () {
           });
           const puv = dbs.getService(PropertyUniquenessValidator);
           let invoked = 0;
-          dbs
-            .getService(BlankValuesService)
-            .setBlankValuesOf(DataType.STRING, ['val2']);
-          const modelData = {foo: 'val1', bar: 'val2'};
+          const modelData = {foo: 'val1', bar: undefined};
+          const countMethod = where => {
+            if (invoked === 0) {
+              expect(where).to.be.eql({foo: modelData.foo});
+            }
+            invoked++;
+            return 0;
+          };
+          await puv.validate(countMethod, 'create', 'model', modelData);
+          expect(invoked).to.be.eql(1);
+        });
+
+        it('skips uniqueness checking for an empty string', async function () {
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.STRING,
+                unique: PropertyUniqueness.SPARSE,
+              },
+              bar: {
+                type: DataType.STRING,
+                unique: PropertyUniqueness.SPARSE,
+              },
+            },
+          });
+          const puv = dbs.getService(PropertyUniquenessValidator);
+          let invoked = 0;
+          const modelData = {foo: 'val1', bar: ''};
+          const countMethod = where => {
+            if (invoked === 0) {
+              expect(where).to.be.eql({foo: modelData.foo});
+            }
+            invoked++;
+            return 0;
+          };
+          await puv.validate(countMethod, 'create', 'model', modelData);
+          expect(invoked).to.be.eql(1);
+        });
+
+        it('skips uniqueness checking for a zero number', async function () {
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.NUMBER,
+                unique: PropertyUniqueness.SPARSE,
+              },
+              bar: {
+                type: DataType.NUMBER,
+                unique: PropertyUniqueness.SPARSE,
+              },
+            },
+          });
+          const puv = dbs.getService(PropertyUniquenessValidator);
+          let invoked = 0;
+          const modelData = {foo: 10, bar: 0};
+          const countMethod = where => {
+            if (invoked === 0) {
+              expect(where).to.be.eql({foo: modelData.foo});
+            }
+            invoked++;
+            return 0;
+          };
+          await puv.validate(countMethod, 'create', 'model', modelData);
+          expect(invoked).to.be.eql(1);
+        });
+
+        it('skips uniqueness checking for a false value', async function () {
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.BOOLEAN,
+                unique: PropertyUniqueness.SPARSE,
+              },
+              bar: {
+                type: DataType.BOOLEAN,
+                unique: PropertyUniqueness.SPARSE,
+              },
+            },
+          });
+          const puv = dbs.getService(PropertyUniquenessValidator);
+          let invoked = 0;
+          const modelData = {foo: true, bar: false};
           const countMethod = where => {
-            if (invoked === 0) expect(where).to.be.eql({foo: 'val1'});
+            if (invoked === 0) {
+              expect(where).to.be.eql({foo: modelData.foo});
+            }
             invoked++;
             return 0;
           };
@@ -1958,11 +2055,12 @@ describe('PropertyUniquenessValidator', function () {
           const idValue = 1;
           const modelData = {foo: 'val1', bar: 'val2'};
           const countMethod = where => {
-            if (invoked === 0)
+            if (invoked === 0) {
               expect(where).to.be.eql({
                 [DEF_PK]: {neq: idValue},
                 foo: 'val1',
               });
+            }
             invoked++;
             return 0;
           };
@@ -1976,7 +2074,7 @@ describe('PropertyUniquenessValidator', function () {
           expect(invoked).to.be.eq(1);
         });
 
-        it('skips uniqueness checking for blank values', async function () {
+        it('skips uniqueness checking for an undefined value', async function () {
           const dbs = new DatabaseSchema();
           dbs.defineModel({
             name: 'model',
@@ -1993,17 +2091,132 @@ describe('PropertyUniquenessValidator', function () {
           });
           const puv = dbs.getService(PropertyUniquenessValidator);
           let invoked = 0;
-          dbs
-            .getService(BlankValuesService)
-            .setBlankValuesOf(DataType.STRING, ['val2']);
           const idValue = 1;
-          const modelData = {foo: 'val1', bar: 'val2'};
+          const modelData = {foo: 'val1', bar: undefined};
           const countMethod = where => {
-            if (invoked === 0)
+            if (invoked === 0) {
               expect(where).to.be.eql({
                 [DEF_PK]: {neq: idValue},
-                foo: 'val1',
+                foo: modelData.foo,
+              });
+            }
+            invoked++;
+            return 0;
+          };
+          await puv.validate(
+            countMethod,
+            'replaceById',
+            'model',
+            modelData,
+            idValue,
+          );
+          expect(invoked).to.be.eql(1);
+        });
+
+        it('skips uniqueness checking for an empty string', async function () {
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.STRING,
+                unique: PropertyUniqueness.SPARSE,
+              },
+              bar: {
+                type: DataType.STRING,
+                unique: PropertyUniqueness.SPARSE,
+              },
+            },
+          });
+          const puv = dbs.getService(PropertyUniquenessValidator);
+          let invoked = 0;
+          const idValue = 1;
+          const modelData = {foo: 'val1', bar: ''};
+          const countMethod = where => {
+            if (invoked === 0) {
+              expect(where).to.be.eql({
+                [DEF_PK]: {neq: idValue},
+                foo: modelData.foo,
+              });
+            }
+            invoked++;
+            return 0;
+          };
+          await puv.validate(
+            countMethod,
+            'replaceById',
+            'model',
+            modelData,
+            idValue,
+          );
+          expect(invoked).to.be.eql(1);
+        });
+
+        it('skips uniqueness checking for a zero number', async function () {
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.NUMBER,
+                unique: PropertyUniqueness.SPARSE,
+              },
+              bar: {
+                type: DataType.NUMBER,
+                unique: PropertyUniqueness.SPARSE,
+              },
+            },
+          });
+          const puv = dbs.getService(PropertyUniquenessValidator);
+          let invoked = 0;
+          const idValue = 1;
+          const modelData = {foo: 10, bar: 0};
+          const countMethod = where => {
+            if (invoked === 0) {
+              expect(where).to.be.eql({
+                [DEF_PK]: {neq: idValue},
+                foo: modelData.foo,
+              });
+            }
+            invoked++;
+            return 0;
+          };
+          await puv.validate(
+            countMethod,
+            'replaceById',
+            'model',
+            modelData,
+            idValue,
+          );
+          expect(invoked).to.be.eql(1);
+        });
+
+        it('skips uniqueness checking for a false value', async function () {
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.BOOLEAN,
+                unique: PropertyUniqueness.SPARSE,
+              },
+              bar: {
+                type: DataType.BOOLEAN,
+                unique: PropertyUniqueness.SPARSE,
+              },
+            },
+          });
+          const puv = dbs.getService(PropertyUniquenessValidator);
+          let invoked = 0;
+          const idValue = 1;
+          const modelData = {foo: true, bar: false};
+          const countMethod = where => {
+            if (invoked === 0) {
+              expect(where).to.be.eql({
+                [DEF_PK]: {neq: idValue},
+                foo: modelData.foo,
               });
+            }
             invoked++;
             return 0;
           };
@@ -2037,11 +2250,12 @@ describe('PropertyUniquenessValidator', function () {
           const idValue = 1;
           const modelData = {foo: 'bar'};
           const countMethod = where => {
-            if (invoked === 0)
+            if (invoked === 0) {
               expect(where).to.be.eql({
                 myId: {neq: idValue},
                 foo: 'bar',
               });
+            }
             invoked++;
             return 0;
           };
@@ -2116,7 +2330,9 @@ describe('PropertyUniquenessValidator', function () {
           let invoked = 0;
           const modelData = {foo: 'val1', bar: 'val2'};
           const countMethod = where => {
-            if (invoked === 0) expect(where).to.be.eql({foo: 'val1'});
+            if (invoked === 0) {
+              expect(where).to.be.eql({foo: 'val1'});
+            }
             invoked++;
             return 0;
           };
@@ -2241,7 +2457,7 @@ describe('PropertyUniquenessValidator', function () {
               expect(invoked).to.be.eq(3);
             });
 
-            it('skips uniqueness checking for blank values', async function () {
+            it('skips uniqueness checking for an undefined value', async function () {
               const dbs = new DatabaseSchema();
               dbs.defineModel({
                 name: 'model',
@@ -2257,17 +2473,18 @@ describe('PropertyUniquenessValidator', function () {
                 },
               });
               const puv = dbs.getService(PropertyUniquenessValidator);
-              dbs
-                .getService(BlankValuesService)
-                .setBlankValuesOf(DataType.STRING, ['val2']);
               let invoked = 0;
               const idValue = 1;
-              const modelData = {[DEF_PK]: idValue, foo: 'val1', bar: 'val2'};
+              const modelData = {
+                [DEF_PK]: idValue,
+                foo: 'val1',
+                bar: undefined,
+              };
               const countMethod = where => {
                 if (invoked === 0) {
                   expect(where).to.be.eql({[DEF_PK]: idValue});
                 } else if (invoked === 1) {
-                  expect(where).to.be.eql({foo: 'val1'});
+                  expect(where).to.be.eql({foo: modelData.foo});
                 }
                 invoked++;
                 return 0;
@@ -2280,16 +2497,18 @@ describe('PropertyUniquenessValidator', function () {
               );
               expect(invoked).to.be.eql(2);
             });
-          });
 
-          describe('a document of the given identifier already exist', function () {
-            it('uses the default primary key to check existence of the given identifier', async function () {
+            it('skips uniqueness checking for an empty string', async function () {
               const dbs = new DatabaseSchema();
               dbs.defineModel({
                 name: 'model',
                 properties: {
                   foo: {
-                    type: DataType.ANY,
+                    type: DataType.STRING,
+                    unique: PropertyUniqueness.SPARSE,
+                  },
+                  bar: {
+                    type: DataType.STRING,
                     unique: PropertyUniqueness.SPARSE,
                   },
                 },
@@ -2299,22 +2518,17 @@ describe('PropertyUniquenessValidator', function () {
               const idValue = 1;
               const modelData = {
                 [DEF_PK]: idValue,
-                foo: 'bar',
+                foo: 'val1',
+                bar: '',
               };
               const countMethod = where => {
-                invoked++;
-                if (invoked === 1) {
-                  expect(where).to.be.eql({
-                    [DEF_PK]: idValue,
-                  });
-                  return 1;
-                } else if (invoked === 2) {
-                  expect(where).to.be.eql({
-                    [DEF_PK]: {neq: idValue},
-                    foo: 'bar',
-                  });
-                  return 0;
+                if (invoked === 0) {
+                  expect(where).to.be.eql({[DEF_PK]: idValue});
+                } else if (invoked === 1) {
+                  expect(where).to.be.eql({foo: modelData.foo});
                 }
+                invoked++;
+                return 0;
               };
               await puv.validate(
                 countMethod,
@@ -2322,15 +2536,141 @@ describe('PropertyUniquenessValidator', function () {
                 'model',
                 modelData,
               );
-              expect(invoked).to.be.eq(2);
+              expect(invoked).to.be.eql(2);
             });
 
-            it('uses a custom primary key to check existence of the given identifier', async function () {
+            it('skips uniqueness checking for a zero number', async function () {
               const dbs = new DatabaseSchema();
               dbs.defineModel({
                 name: 'model',
                 properties: {
-                  myId: {
+                  foo: {
+                    type: DataType.NUMBER,
+                    unique: PropertyUniqueness.SPARSE,
+                  },
+                  bar: {
+                    type: DataType.NUMBER,
+                    unique: PropertyUniqueness.SPARSE,
+                  },
+                },
+              });
+              const puv = dbs.getService(PropertyUniquenessValidator);
+              let invoked = 0;
+              const idValue = 1;
+              const modelData = {
+                [DEF_PK]: idValue,
+                foo: 10,
+                bar: 0,
+              };
+              const countMethod = where => {
+                if (invoked === 0) {
+                  expect(where).to.be.eql({[DEF_PK]: idValue});
+                } else if (invoked === 1) {
+                  expect(where).to.be.eql({foo: modelData.foo});
+                }
+                invoked++;
+                return 0;
+              };
+              await puv.validate(
+                countMethod,
+                'replaceOrCreate',
+                'model',
+                modelData,
+              );
+              expect(invoked).to.be.eql(2);
+            });
+
+            it('skips uniqueness checking for a false value', async function () {
+              const dbs = new DatabaseSchema();
+              dbs.defineModel({
+                name: 'model',
+                properties: {
+                  foo: {
+                    type: DataType.BOOLEAN,
+                    unique: PropertyUniqueness.SPARSE,
+                  },
+                  bar: {
+                    type: DataType.BOOLEAN,
+                    unique: PropertyUniqueness.SPARSE,
+                  },
+                },
+              });
+              const puv = dbs.getService(PropertyUniquenessValidator);
+              let invoked = 0;
+              const idValue = 1;
+              const modelData = {
+                [DEF_PK]: idValue,
+                foo: true,
+                bar: false,
+              };
+              const countMethod = where => {
+                if (invoked === 0) {
+                  expect(where).to.be.eql({[DEF_PK]: idValue});
+                } else if (invoked === 1) {
+                  expect(where).to.be.eql({foo: modelData.foo});
+                }
+                invoked++;
+                return 0;
+              };
+              await puv.validate(
+                countMethod,
+                'replaceOrCreate',
+                'model',
+                modelData,
+              );
+              expect(invoked).to.be.eql(2);
+            });
+          });
+
+          describe('a document of the given identifier already exist', function () {
+            it('uses the default primary key to check existence of the given identifier', async function () {
+              const dbs = new DatabaseSchema();
+              dbs.defineModel({
+                name: 'model',
+                properties: {
+                  foo: {
+                    type: DataType.ANY,
+                    unique: PropertyUniqueness.SPARSE,
+                  },
+                },
+              });
+              const puv = dbs.getService(PropertyUniquenessValidator);
+              let invoked = 0;
+              const idValue = 1;
+              const modelData = {
+                [DEF_PK]: idValue,
+                foo: 'bar',
+              };
+              const countMethod = where => {
+                invoked++;
+                if (invoked === 1) {
+                  expect(where).to.be.eql({
+                    [DEF_PK]: idValue,
+                  });
+                  return 1;
+                } else if (invoked === 2) {
+                  expect(where).to.be.eql({
+                    [DEF_PK]: {neq: idValue},
+                    foo: 'bar',
+                  });
+                  return 0;
+                }
+              };
+              await puv.validate(
+                countMethod,
+                'replaceOrCreate',
+                'model',
+                modelData,
+              );
+              expect(invoked).to.be.eq(2);
+            });
+
+            it('uses a custom primary key to check existence of the given identifier', async function () {
+              const dbs = new DatabaseSchema();
+              dbs.defineModel({
+                name: 'model',
+                properties: {
+                  myId: {
                     type: DataType.NUMBER,
                     primaryKey: true,
                   },
@@ -2420,7 +2760,7 @@ describe('PropertyUniquenessValidator', function () {
               expect(invoked).to.be.eq(3);
             });
 
-            it('skips uniqueness checking for blank values', async function () {
+            it('skips uniqueness checking for an undefined value', async function () {
               const dbs = new DatabaseSchema();
               dbs.defineModel({
                 name: 'model',
@@ -2436,12 +2776,13 @@ describe('PropertyUniquenessValidator', function () {
                 },
               });
               const puv = dbs.getService(PropertyUniquenessValidator);
-              dbs
-                .getService(BlankValuesService)
-                .setBlankValuesOf(DataType.STRING, ['val2']);
               let invoked = 0;
               const idValue = 1;
-              const modelData = {[DEF_PK]: idValue, foo: 'val1', bar: 'val2'};
+              const modelData = {
+                [DEF_PK]: idValue,
+                foo: 'val1',
+                bar: undefined,
+              };
               const countMethod = where => {
                 invoked++;
                 if (invoked === 1) {
@@ -2450,7 +2791,142 @@ describe('PropertyUniquenessValidator', function () {
                 } else if (invoked === 2) {
                   expect(where).to.be.eql({
                     [DEF_PK]: {neq: idValue},
-                    foo: 'val1',
+                    foo: modelData.foo,
+                  });
+                  return 0;
+                }
+              };
+              await puv.validate(
+                countMethod,
+                'replaceOrCreate',
+                'model',
+                modelData,
+              );
+              expect(invoked).to.be.eql(2);
+            });
+
+            it('skips uniqueness checking for an empty string', async function () {
+              const dbs = new DatabaseSchema();
+              dbs.defineModel({
+                name: 'model',
+                properties: {
+                  foo: {
+                    type: DataType.STRING,
+                    unique: PropertyUniqueness.SPARSE,
+                  },
+                  bar: {
+                    type: DataType.STRING,
+                    unique: PropertyUniqueness.SPARSE,
+                  },
+                },
+              });
+              const puv = dbs.getService(PropertyUniquenessValidator);
+              let invoked = 0;
+              const idValue = 1;
+              const modelData = {
+                [DEF_PK]: idValue,
+                foo: 'val1',
+                bar: '',
+              };
+              const countMethod = where => {
+                invoked++;
+                if (invoked === 1) {
+                  expect(where).to.be.eql({[DEF_PK]: idValue});
+                  return 1;
+                } else if (invoked === 2) {
+                  expect(where).to.be.eql({
+                    [DEF_PK]: {neq: idValue},
+                    foo: modelData.foo,
+                  });
+                  return 0;
+                }
+              };
+              await puv.validate(
+                countMethod,
+                'replaceOrCreate',
+                'model',
+                modelData,
+              );
+              expect(invoked).to.be.eql(2);
+            });
+
+            it('skips uniqueness checking for a zero number', async function () {
+              const dbs = new DatabaseSchema();
+              dbs.defineModel({
+                name: 'model',
+                properties: {
+                  foo: {
+                    type: DataType.NUMBER,
+                    unique: PropertyUniqueness.SPARSE,
+                  },
+                  bar: {
+                    type: DataType.NUMBER,
+                    unique: PropertyUniqueness.SPARSE,
+                  },
+                },
+              });
+              const puv = dbs.getService(PropertyUniquenessValidator);
+              let invoked = 0;
+              const idValue = 1;
+              const modelData = {
+                [DEF_PK]: idValue,
+                foo: 10,
+                bar: 0,
+              };
+              const countMethod = where => {
+                invoked++;
+                if (invoked === 1) {
+                  expect(where).to.be.eql({[DEF_PK]: idValue});
+                  return 1;
+                } else if (invoked === 2) {
+                  expect(where).to.be.eql({
+                    [DEF_PK]: {neq: idValue},
+                    foo: modelData.foo,
+                  });
+                  return 0;
+                }
+              };
+              await puv.validate(
+                countMethod,
+                'replaceOrCreate',
+                'model',
+                modelData,
+              );
+              expect(invoked).to.be.eql(2);
+            });
+
+            it('skips uniqueness checking for a false value', async function () {
+              const dbs = new DatabaseSchema();
+              dbs.defineModel({
+                name: 'model',
+                properties: {
+                  foo: {
+                    type: DataType.BOOLEAN,
+                    unique: PropertyUniqueness.SPARSE,
+                  },
+                  bar: {
+                    type: DataType.BOOLEAN,
+                    unique: PropertyUniqueness.SPARSE,
+                  },
+                },
+              });
+              const puv = dbs.getService(PropertyUniquenessValidator);
+              let invoked = 0;
+              const idValue = 1;
+              const modelData = {
+                [DEF_PK]: idValue,
+                foo: true,
+                bar: false,
+              };
+              const countMethod = where => {
+                invoked++;
+                if (invoked === 1) {
+                  expect(where).to.be.eql({[DEF_PK]: idValue});
+                  return 1;
+                } else if (invoked === 2) {
+                  expect(where).to.be.eql({
+                    [DEF_PK]: {neq: idValue},
+                    foo: modelData.foo,
                   });
                   return 0;
                 }
@@ -2525,7 +3001,9 @@ describe('PropertyUniquenessValidator', function () {
           let invoked = 0;
           const modelData = {foo: 'val1', bar: 'val2'};
           const countMethod = where => {
-            if (invoked === 0) expect(where).to.be.eql({foo: 'val1'});
+            if (invoked === 0) {
+              expect(where).to.be.eql({foo: 'val1'});
+            }
             invoked++;
             return 0;
           };
@@ -2558,7 +3036,7 @@ describe('PropertyUniquenessValidator', function () {
           await expect(promise2).not.to.be.rejected;
         });
 
-        it('skips uniqueness checking for blank values', async function () {
+        it('skips uniqueness checking for an undefined value', async function () {
           const dbs = new DatabaseSchema();
           dbs.defineModel({
             name: 'model',
@@ -2574,13 +3052,99 @@ describe('PropertyUniquenessValidator', function () {
             },
           });
           const puv = dbs.getService(PropertyUniquenessValidator);
-          dbs
-            .getService(BlankValuesService)
-            .setBlankValuesOf(DataType.STRING, ['val2']);
           let invoked = 0;
-          const modelData = {foo: 'val1', bar: 'val2'};
+          const modelData = {foo: 'val1', bar: undefined};
+          const countMethod = where => {
+            if (invoked === 0) {
+              expect(where).to.be.eql({foo: modelData.foo});
+            }
+            invoked++;
+            return 0;
+          };
+          await puv.validate(countMethod, 'patch', 'model', modelData);
+          expect(invoked).to.be.eql(1);
+        });
+
+        it('skips uniqueness checking for an empty string', async function () {
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.STRING,
+                unique: PropertyUniqueness.SPARSE,
+              },
+              bar: {
+                type: DataType.STRING,
+                unique: PropertyUniqueness.SPARSE,
+              },
+            },
+          });
+          const puv = dbs.getService(PropertyUniquenessValidator);
+          let invoked = 0;
+          const modelData = {foo: 'val1', bar: ''};
+          const countMethod = where => {
+            if (invoked === 0) {
+              expect(where).to.be.eql({foo: modelData.foo});
+            }
+            invoked++;
+            return 0;
+          };
+          await puv.validate(countMethod, 'patch', 'model', modelData);
+          expect(invoked).to.be.eql(1);
+        });
+
+        it('skips uniqueness checking for a zero number', async function () {
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.NUMBER,
+                unique: PropertyUniqueness.SPARSE,
+              },
+              bar: {
+                type: DataType.NUMBER,
+                unique: PropertyUniqueness.SPARSE,
+              },
+            },
+          });
+          const puv = dbs.getService(PropertyUniquenessValidator);
+          let invoked = 0;
+          const modelData = {foo: 10, bar: 0};
+          const countMethod = where => {
+            if (invoked === 0) {
+              expect(where).to.be.eql({foo: modelData.foo});
+            }
+            invoked++;
+            return 0;
+          };
+          await puv.validate(countMethod, 'patch', 'model', modelData);
+          expect(invoked).to.be.eql(1);
+        });
+
+        it('skips uniqueness checking for a false value', async function () {
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.BOOLEAN,
+                unique: PropertyUniqueness.SPARSE,
+              },
+              bar: {
+                type: DataType.BOOLEAN,
+                unique: PropertyUniqueness.SPARSE,
+              },
+            },
+          });
+          const puv = dbs.getService(PropertyUniquenessValidator);
+          let invoked = 0;
+          const modelData = {foo: true, bar: false};
           const countMethod = where => {
-            if (invoked === 0) expect(where).to.be.eql({foo: 'val1'});
+            if (invoked === 0) {
+              expect(where).to.be.eql({foo: modelData.foo});
+            }
             invoked++;
             return 0;
           };
@@ -2654,11 +3218,12 @@ describe('PropertyUniquenessValidator', function () {
           const idValue = 1;
           const modelData = {foo: 'val1', bar: 'val2'};
           const countMethod = where => {
-            if (invoked === 0)
+            if (invoked === 0) {
               expect(where).to.be.eql({
                 [DEF_PK]: {neq: idValue},
                 foo: 'val1',
               });
+            }
             invoked++;
             return 0;
           };
@@ -2697,7 +3262,7 @@ describe('PropertyUniquenessValidator', function () {
           await expect(promise2).not.to.be.rejected;
         });
 
-        it('skips uniqueness checking for blank values', async function () {
+        it('skips uniqueness checking for an undefined value', async function () {
           const dbs = new DatabaseSchema();
           dbs.defineModel({
             name: 'model',
@@ -2714,16 +3279,110 @@ describe('PropertyUniquenessValidator', function () {
           });
           const puv = dbs.getService(PropertyUniquenessValidator);
           let invoked = 0;
-          dbs
-            .getService(BlankValuesService)
-            .setBlankValuesOf(DataType.STRING, ['val2']);
-          const modelData = {foo: 'val1', bar: 'val2'};
+          const modelData = {foo: 'val1', bar: undefined};
           const countMethod = where => {
-            if (invoked === 0)
+            if (invoked === 0) {
               expect(where).to.be.eql({
                 [DEF_PK]: {neq: 1},
-                foo: 'val1',
+                foo: modelData.foo,
               });
+            }
+            invoked++;
+            return 0;
+          };
+          await puv.validate(countMethod, 'patchById', 'model', modelData, 1);
+          expect(invoked).to.be.eql(1);
+        });
+
+        it('skips uniqueness checking for an empty string', async function () {
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.STRING,
+                unique: PropertyUniqueness.SPARSE,
+              },
+              bar: {
+                type: DataType.STRING,
+                unique: PropertyUniqueness.SPARSE,
+              },
+            },
+          });
+          const puv = dbs.getService(PropertyUniquenessValidator);
+          let invoked = 0;
+          const modelData = {foo: 'val1', bar: ''};
+          const countMethod = where => {
+            if (invoked === 0) {
+              expect(where).to.be.eql({
+                [DEF_PK]: {neq: 1},
+                foo: modelData.foo,
+              });
+            }
+            invoked++;
+            return 0;
+          };
+          await puv.validate(countMethod, 'patchById', 'model', modelData, 1);
+          expect(invoked).to.be.eql(1);
+        });
+
+        it('skips uniqueness checking for a zero number', async function () {
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.NUMBER,
+                unique: PropertyUniqueness.SPARSE,
+              },
+              bar: {
+                type: DataType.NUMBER,
+                unique: PropertyUniqueness.SPARSE,
+              },
+            },
+          });
+          const puv = dbs.getService(PropertyUniquenessValidator);
+          let invoked = 0;
+          const modelData = {foo: 10, bar: 0};
+          const countMethod = where => {
+            if (invoked === 0) {
+              expect(where).to.be.eql({
+                [DEF_PK]: {neq: 1},
+                foo: modelData.foo,
+              });
+            }
+            invoked++;
+            return 0;
+          };
+          await puv.validate(countMethod, 'patchById', 'model', modelData, 1);
+          expect(invoked).to.be.eql(1);
+        });
+
+        it('skips uniqueness checking for a false value', async function () {
+          const dbs = new DatabaseSchema();
+          dbs.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
+                type: DataType.BOOLEAN,
+                unique: PropertyUniqueness.SPARSE,
+              },
+              bar: {
+                type: DataType.BOOLEAN,
+                unique: PropertyUniqueness.SPARSE,
+              },
+            },
+          });
+          const puv = dbs.getService(PropertyUniquenessValidator);
+          let invoked = 0;
+          const modelData = {foo: true, bar: false};
+          const countMethod = where => {
+            if (invoked === 0) {
+              expect(where).to.be.eql({
+                [DEF_PK]: {neq: 1},
+                foo: modelData.foo,
+              });
+            }
             invoked++;
             return 0;
           };
@@ -2751,11 +3410,12 @@ describe('PropertyUniquenessValidator', function () {
           const idValue = 1;
           const modelData = {foo: 'bar'};
           const countMethod = where => {
-            if (invoked === 0)
+            if (invoked === 0) {
               expect(where).to.be.eql({
                 myId: {neq: idValue},
                 foo: 'bar',
               });
+            }
             invoked++;
             return 0;
           };