@e22m4u/js-repository 0.0.37 → 0.0.39

package/README.md

@@ -2,26 +2,45 @@
 
 Абстракция для работы с базами данных для Node.js
 
-| адаптер | описание                                                                                                                                        |
-|---------|-------------------------------------------------------------------------------------------------------------------------------------------------|
-| memory  | виртуальная база в памяти процесса (для разработки и тестирования)                                                                              |
-| mongodb | MongoDB - система управления NoSQL базами данных (*[требует установки](https://www.npmjs.com/package/@e22m4u/js-repository-mongodb-adapter))* |
-
 ## Установка
 
 ```bash
 npm install @e22m4u/js-repository
 ```
 
-Опционально устанавливаем адаптер, например [mongodb](https://www.npmjs.com/package/@e22m4u/js-repository-mongodb-adapter)
+Опционально устанавливаем адаптер. Например, если используемой базой
+является *MongoDB*, то для подключения потребуется добавить
+[адаптер mongodb](https://www.npmjs.com/package/@e22m4u/js-repository-mongodb-adapter)
+как отдельную зависимость.
 
 ```bash
 npm install @e22m4u/js-repository-mongodb-adapter
 ```
 
-## Пример
+Список доступных адаптеров:
+
+| адаптер   | описание                                                                                                                                        |
+|-----------|-------------------------------------------------------------------------------------------------------------------------------------------------|
+| `memory`  | виртуальная база в памяти процесса (для разработки и тестирования)                                                                              |
+| `mongodb` | MongoDB - система управления NoSQL базами (*[требует установки](https://www.npmjs.com/package/@e22m4u/js-repository-mongodb-adapter))* |
+
+## Концепция
+
+Модуль позволяет спроектировать систему связанных данных, доступ к которым
+осуществляется посредством репозиториев. Каждый репозиторий имеет собственную
+модель, которая описывает структуру определенной коллекции в базе,
+а так же определяет связи к другим коллекциям.
 
-Создаем экземпляр класса `Schema`
+```mermaid
+flowchart LR
+
+A[Datasource]-->B[Model]-->С[Repository];
+```
+
+## Использование
+
+Определения источников и моделей хранятся в экземпляре класса `Schema`,
+и первым шагом будет создание данного экземпляра.
 
 ```js
 import {Schema} from '@e22m4u/js-repository';
@@ -29,7 +48,38 @@ import {Schema} from '@e22m4u/js-repository';
 const schema = new Schema();
 ```
 
-Создаем источник данных `myMemory`
+Интерфейс `Schema` содержит три основных метода:
+
+- `defineDatasource(datasourceDef: object): this` - добавить источник
+- `defineModel(modelDef: object): this` - добавить модель
+- `getRepository(modelName: string): Repository` - получить репозиторий
+
+#### Источник данных
+
+Источник описывает способ подключения к базе и используемый адаптер.
+Если адаптер имеет настройки, то они передаются вместе с объектом
+определения источника методом `defineDatasource`, как это показано
+ниже.
+
+```js
+schema.defineDatasource({
+  name: 'myMongo', // название нового источника
+  adapter: 'mongodb', // название выбранного адаптера
+  // настройки адаптера mongodb
+  host: '127.0.0.1',
+  port: 27017,
+  database: 'data'
+});
+```
+
+Параметры источника:
+
+- `name: string` уникальное название
+- `adapter: string` выбранный адаптер
+
+При желании можно использовать встроенный адаптер `memory`, который хранит
+данные в памяти процесса. У него нет специальных настроек, и он отлично
+подходит для тестов и прототипирования.
 
 ```js
 schema.defineDatasource({
@@ -38,6 +88,127 @@ schema.defineDatasource({
 });
 ```
 
+#### Модель данных
+
+Когда источники определены, можно перейти к описанию моделей данных.
+Модель может определять как структуру какого-либо объекта,
+так и являться отражением реальной коллекции базы.
+
+Представьте себе коллекцию торговых точек, у каждой из которых имеются
+координаты `lat` и `lng`. Мы можем заранее определить модель для
+объекта координат методом `defineModel` и использовать ее в других
+коллекциях.
+
+```js
+schema.defineModel({
+  name: 'latLng', // название новой модели
+  properties: { // поля модели
+    lat: DataType.NUMBER, // поле широты
+    lng: DataType.NUMBER, // поле долготы
+  },
+});
+```
+
+Параметры модели:
+
+- `name: string` уникальное название (обязательно)
+- `datasource: string` выбранный источник данных
+- `properties: object` определения полей модели
+- `relations: object` определения связей модели
+
+Параметр `properties` принимает объект, ключи которого являются именами
+полей, а значением тип поля или объект с дополнительными параметрами.
+
+```js
+schema.defineModel({
+  name: 'latLng',
+  properties: {
+    lat: DataType.NUMBER, // краткое определение поля "lat"
+    lng: { // определение поля "lng" с параметром "required"
+      type: DataType.NUMBER,
+      required: true, // исключает null и undefined
+    },
+  },
+});
+```
+
+Типы данных:
+
+- `DataType.ANY`
+- `DataType.STRING`
+- `DataType.NUMBER`
+- `DataType.BOOLEAN`
+- `DataType.ARRAY`
+- `DataType.OBJECT`
+
+Модель `latLng` всего лишь описывает структуру объекта координат, тогда
+как торговая точка должна иметь реальную таблицу в базе. По аналогии с
+предыдущим примером, добавим модель `place`, но дополнительно укажем
+источник данных в параметре `datasource`
+
+```js
+schema.defineModel({
+  name: 'place',
+  datasource: 'myMemory', // выбранный источник данных
+  properties: {
+    name: DataType.STRING, // поле для названия торговой точки
+    location: { // поле объекта координат
+      type: DataType.OBJECT, // допускать только объекты
+      model: 'latLng', // определение структуры объекта
+    },
+  },
+});
+```
+
+В примере выше мы использовали модель `latLng` как структуру допустимого
+значения поля `location`. Возможный документ данной коллекции может
+выглядеть так:
+
+```json
+{
+  "id": 1,
+  "name": "Burger King at Avenue Mall",
+  "location": {
+    "lat": 32.412891,
+    "lng": 34.7660061
+  }
+}
+```
+
+Стоит обратить внимание, что мы могли бы не объявлять параметр `properties`,
+при этом теряя возможность проверки данных перед записью в базу.
+
+```js
+schema.defineModel({
+  name: 'place',
+  adapter: 'myMemory',
+  // параметр "properties" не указан
+});
+```
+
+Параметры поля:
+
+- `type: string` тип допустимого значения (обязательно)
+- `itemType: string` тип элемента массива (для `type: 'array'`)
+- `model: string` модель объекта (для `type: 'object'`)
+- `primaryKey: boolean` объявить поле первичным ключом
+- `columnName: string` переопределение названия колонки
+- `columnType: string` тип колонки (определяется адаптером)
+- `required: boolean` объявить поле обязательным
+- `default: any` значение по умолчанию
+
+#### Репозиторий
+
+В отличие от `latLng`, модель `place` имеет источник данных с названием
+`myMemory`, который был объявлен ранее. Наличие источника позволяет получить
+репозиторий по названию модели.
+
+```js
+const rep = schema.getRepository('place');
+```
+
+## Пример
+
 Создаем модель `user`
 
 ```js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/js-repository",
-  "version": "0.0.37",
+  "version": "0.0.39",
   "description": "Абстракция для работы с базами данных для Node.js",
   "type": "module",
   "main": "src/index.js",

package/src/adapter/adapter.js

@@ -39,9 +39,9 @@ export class Adapter extends Service {
     this._settings = settings;
     // decorate only extended classes
     if (this.constructor !== Adapter) {
-      this.getService(DataValidationDecorator).decorate(this);
       this.getService(DataSanitizingDecorator).decorate(this);
       this.getService(DefaultValuesDecorator).decorate(this);
+      this.getService(DataValidationDecorator).decorate(this);
       this.getService(FieldsFilteringDecorator).decorate(this);
       this.getService(InclusionDecorator).decorate(this);
     }

package/src/adapter/adapter.spec.js

@@ -33,9 +33,9 @@ describe('Adapter', function () {
 
     it('decorates only extended adapter', function () {
       const schema = new Schema();
-      const dec1 = schema.getService(DataValidationDecorator);
-      const dec2 = schema.getService(DataSanitizingDecorator);
-      const dec3 = schema.getService(DefaultValuesDecorator);
+      const dec1 = schema.getService(DataSanitizingDecorator);
+      const dec2 = schema.getService(DefaultValuesDecorator);
+      const dec3 = schema.getService(DataValidationDecorator);
       const dec4 = schema.getService(FieldsFilteringDecorator);
       const dec5 = schema.getService(InclusionDecorator);
       const order = [];

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

@@ -31,7 +31,7 @@ export class ModelDataValidator extends Service {
     propNames.forEach(propName => {
       const propDef = propDefs[propName];
       if (!propDef) return;
-      this.validatePropertyValue(
+      this._validatePropertyValue(
         modelName,
         propName,
         propDef,
@@ -48,7 +48,7 @@ export class ModelDataValidator extends Service {
    * @param {string|object} propDef
    * @param {*} propValue
    */
-  validatePropertyValue(modelName, propName, propDef, propValue) {
+  _validatePropertyValue(modelName, propName, propDef, propValue) {
     // undefined and null
     if (propValue == null) {
       const isRequired =

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

@@ -1587,6 +1587,61 @@ describe('ModelDataValidator', function () {
               'an Array, but Object given.',
           );
         });
+
+        describe('the "model" option', function () {
+          it('throws an error when the given object element has an invalid model', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'modelA',
+              properties: {
+                foo: DataType.STRING,
+              },
+            });
+            S.defineModel({
+              name: 'modelB',
+              datasource: 'datasource',
+              properties: {
+                bar: {
+                  type: DataType.ARRAY,
+                  itemType: DataType.OBJECT,
+                  model: 'modelA',
+                },
+              },
+            });
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('modelB', {
+                bar: [{foo: 10}],
+              });
+            expect(throwable).to.throw(
+              'The property "foo" of the model "modelA" must have ' +
+                'a String, but Number given.',
+            );
+          });
+
+          it('does not throw an error when the given object element has a valid model', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'modelA',
+              properties: {
+                foo: DataType.STRING,
+              },
+            });
+            S.defineModel({
+              name: 'modelB',
+              datasource: 'datasource',
+              properties: {
+                bar: {
+                  type: DataType.ARRAY,
+                  itemType: DataType.OBJECT,
+                  model: 'modelA',
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('modelB', {
+              bar: [{foo: '10'}],
+            });
+          });
+        });
       });
     });
 
@@ -1883,6 +1938,59 @@ describe('ModelDataValidator', function () {
             foo: {},
           });
         });
+
+        describe('the "model" option', function () {
+          it('throws an error when the given object has an invalid model', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'modelA',
+              properties: {
+                foo: DataType.STRING,
+              },
+            });
+            S.defineModel({
+              name: 'modelB',
+              datasource: 'datasource',
+              properties: {
+                bar: {
+                  type: DataType.OBJECT,
+                  model: 'modelA',
+                },
+              },
+            });
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('modelB', {
+                bar: {foo: 10},
+              });
+            expect(throwable).to.throw(
+              'The property "foo" of the model "modelA" must have ' +
+                'a String, but Number given.',
+            );
+          });
+
+          it('does not throw an error when the given object has a valid model', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'modelA',
+              properties: {
+                foo: DataType.STRING,
+              },
+            });
+            S.defineModel({
+              name: 'modelB',
+              datasource: 'datasource',
+              properties: {
+                bar: {
+                  type: DataType.OBJECT,
+                  model: 'modelA',
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('modelB', {
+              bar: {foo: '10'},
+            });
+          });
+        });
       });
     });
   });

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

@@ -2,4 +2,3 @@ export * from './data-type.js';
 export * from './property-definition.js';
 export * from './properties-definition-validator.js';
 export * from './primary-keys-definition-validator.js';
-export * from './default-values-definition-validator.js';

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

@@ -1,4 +1,3 @@
 export * from './data-type.js';
 export * from './properties-definition-validator.js';
 export * from './primary-keys-definition-validator.js';
-export * from './default-values-definition-validator.js';

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

@@ -1,8 +1,8 @@
 import {Service} from '@e22m4u/js-service';
 import {DataType as Type} from './data-type.js';
+import {capitalize} from '../../../utils/index.js';
 import {InvalidArgumentError} from '../../../errors/index.js';
 import {PrimaryKeysDefinitionValidator} from './primary-keys-definition-validator.js';
-import {DefaultValuesDefinitionValidator} from './default-values-definition-validator.js';
 
 /**
  * Properties definition validator.
@@ -38,10 +38,6 @@ export class PropertiesDefinitionValidator extends Service {
       modelName,
       propDefs,
     );
-    this.getService(DefaultValuesDefinitionValidator).validate(
-      modelName,
-      propDefs,
-    );
   }
 
   /**
@@ -182,13 +178,30 @@ export class PropertiesDefinitionValidator extends Service {
         modelName,
         propDef.type,
       );
-    if (propDef.model && propDef.type !== Type.OBJECT)
-      throw new InvalidArgumentError(
-        'The property %v of the model %v has the non-object type, ' +
-          'so it should not have the option "model" to be provided.',
-        propName,
-        modelName,
-        propDef.type,
-      );
+    if (
+      propDef.model &&
+      propDef.type !== Type.OBJECT &&
+      propDef.itemType !== Type.OBJECT
+    ) {
+      if (propDef.type !== Type.ARRAY) {
+        throw new InvalidArgumentError(
+          'The option "model" is not supported for %s property type, ' +
+            'so the property %v of the model %v should not have ' +
+            'the option "model" to be provided.',
+          capitalize(propDef.type),
+          propName,
+          modelName,
+        );
+      } else {
+        throw new InvalidArgumentError(
+          'The option "model" is not supported for Array property type of %s, ' +
+            'so the property %v of the model %v should not have ' +
+            'the option "model" to be provided.',
+          capitalize(propDef.itemType),
+          propName,
+          modelName,
+        );
+      }
+    }
   }
 }

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

@@ -4,7 +4,6 @@ import {DataType} from './data-type.js';
 import {format} from '@e22m4u/js-format';
 import {PropertiesDefinitionValidator} from './properties-definition-validator.js';
 import {PrimaryKeysDefinitionValidator} from './primary-keys-definition-validator.js';
-import {DefaultValuesDefinitionValidator} from './default-values-definition-validator.js';
 
 const S = new PropertiesDefinitionValidator();
 const sandbox = chai.spy.sandbox();
@@ -333,7 +332,7 @@ describe('PropertiesDefinitionValidator', function () {
       validate(DataType.ARRAY);
     });
 
-    it('expects a non-object property should not have the option "model" to be provided', function () {
+    it('the option "model" requires the "object" property type', function () {
       const validate = v => () => {
         const foo = {
           type: v,
@@ -341,28 +340,46 @@ describe('PropertiesDefinitionValidator', function () {
         };
         S.validate('model', {foo});
       };
-      const error =
-        'The property "foo" of the model "model" has the non-object type, ' +
-        'so it should not have the option "model" to be provided.';
-      expect(validate(DataType.ANY)).to.throw(error);
-      expect(validate(DataType.STRING)).to.throw(error);
-      expect(validate(DataType.NUMBER)).to.throw(error);
-      expect(validate(DataType.BOOLEAN)).to.throw(error);
-      expect(validate(DataType.ARRAY)).to.throw(error);
-      validate(DataType.OBJECT);
+      const error = v =>
+        format(
+          'The option "model" is not supported for %s property type, ' +
+            'so the property "foo" of the model "model" should not have ' +
+            'the option "model" to be provided.',
+          v,
+        );
+      expect(validate(DataType.ANY)).to.throw(error('Any'));
+      expect(validate(DataType.STRING)).to.throw(error('String'));
+      expect(validate(DataType.NUMBER)).to.throw(error('Number'));
+      expect(validate(DataType.BOOLEAN)).to.throw(error('Boolean'));
+      validate(DataType.OBJECT)();
     });
 
-    it('uses PrimaryKeysDefinitionValidator to validate primary keys', function () {
-      const V = S.getService(PrimaryKeysDefinitionValidator);
-      sandbox.on(V, 'validate');
-      const propDefs = {};
-      S.validate('model', propDefs);
-      expect(V.validate).to.have.been.called.once;
-      expect(V.validate).to.have.been.called.with.exactly('model', propDefs);
+    it('the option "model" requires the "object" item type', function () {
+      const validate = v => () => {
+        const foo = {
+          type: DataType.ARRAY,
+          itemType: v,
+          model: 'model',
+        };
+        S.validate('model', {foo});
+      };
+      const error = v =>
+        format(
+          'The option "model" is not supported for Array property type of %s, ' +
+            'so the property "foo" of the model "model" should not have ' +
+            'the option "model" to be provided.',
+          v,
+        );
+      expect(validate(DataType.ANY)).to.throw(error('Any'));
+      expect(validate(DataType.STRING)).to.throw(error('String'));
+      expect(validate(DataType.NUMBER)).to.throw(error('Number'));
+      expect(validate(DataType.BOOLEAN)).to.throw(error('Boolean'));
+      expect(validate(DataType.ARRAY)).to.throw(error('Array'));
+      validate(DataType.OBJECT)();
     });
 
-    it('uses DefaultValuesDefinitionValidator to validate default values', function () {
-      const V = S.getService(DefaultValuesDefinitionValidator);
+    it('uses PrimaryKeysDefinitionValidator to validate primary keys', function () {
+      const V = S.getService(PrimaryKeysDefinitionValidator);
       sandbox.on(V, 'validate');
       const propDefs = {};
       S.validate('model', propDefs);

package/src/filter/filter-clause.d.ts

@@ -237,11 +237,9 @@ export type NormalizedFieldsClause = string[];
  */
 export declare type IncludeClause =
   | string
-  | string[]
   | NestedIncludeClause
-  | NestedIncludeClause[]
   | NormalizedIncludeClause
-  | NormalizedIncludeClause[];
+  | IncludeClause[];
 
 /**
  * Nested include clause.

package/src/definition/model/properties/default-values-definition-validator.d.ts

@@ -1,15 +0,0 @@
-import {Service} from '@e22m4u/js-service';
-import {PropertyDefinitionMap} from '../model-definition.js';
-
-/**
- * Default values definition validator.
- */
-export declare class DefaultValuesDefinitionValidator extends Service {
-  /**
-   * Validate.
-   *
-   * @param modelName
-   * @param propDefs
-   */
-  validate(modelName: string, propDefs: PropertyDefinitionMap): void;
-}

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

@@ -1,53 +0,0 @@
-import {Service} from '@e22m4u/js-service';
-import {ModelDataValidator} from '../model-data-validator.js';
-import {InvalidArgumentError} from '../../../errors/index.js';
-
-/**
- * Default values definition validator.
- */
-export class DefaultValuesDefinitionValidator extends Service {
-  /**
-   * Validate.
-   *
-   * @param {string} modelName
-   * @param {object} propDefs
-   */
-  validate(modelName, propDefs) {
-    if (!modelName || typeof modelName !== 'string')
-      throw new InvalidArgumentError(
-        'The first argument of DefaultValuesDefinitionValidator.validate ' +
-          'should be a non-empty String, but %v given.',
-        modelName,
-      );
-    if (!propDefs || typeof propDefs !== 'object' || Array.isArray(propDefs))
-      throw new InvalidArgumentError(
-        'The provided option "properties" of the model %v ' +
-          'should be an Object, but %v given.',
-        modelName,
-        propDefs,
-      );
-    Object.keys(propDefs).forEach(propName => {
-      const propDef = propDefs[propName];
-      if (typeof propDef === 'string') return;
-      if (!('default' in propDef)) return;
-      const propValue =
-        propDef.default instanceof Function
-          ? propDef.default()
-          : propDef.default;
-      try {
-        this.getService(ModelDataValidator).validatePropertyValue(
-          modelName,
-          propName,
-          propDef,
-          propValue,
-        );
-      } catch (error) {
-        if (error instanceof InvalidArgumentError)
-          throw new InvalidArgumentError(
-            `A default value is invalid. ${error.message}`,
-          );
-        throw error;
-      }
-    });
-  }
-}

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

@@ -1,136 +0,0 @@
-import {expect} from 'chai';
-import {DataType} from './data-type.js';
-import {format} from '@e22m4u/js-format';
-import {DefaultValuesDefinitionValidator} from './default-values-definition-validator.js';
-
-const S = new DefaultValuesDefinitionValidator();
-
-describe('DefaultValuesDefinitionValidator', function () {
-  describe('validate', function () {
-    it('requires a first argument to be a non-empty string', function () {
-      const validate = v => () => S.validate(v, {});
-      const error = v =>
-        format(
-          'The first argument of DefaultValuesDefinitionValidator.validate ' +
-            'should be a non-empty String, but %s given.',
-          v,
-        );
-      expect(validate('')).to.throw(error('""'));
-      expect(validate(10)).to.throw(error('10'));
-      expect(validate(true)).to.throw(error('true'));
-      expect(validate(false)).to.throw(error('false'));
-      expect(validate([])).to.throw(error('Array'));
-      expect(validate({})).to.throw(error('Object'));
-      expect(validate(undefined)).to.throw(error('undefined'));
-      expect(validate(null)).to.throw(error('null'));
-      validate('model')();
-    });
-
-    it('requires a second argument to be an object', function () {
-      const validate = v => () => S.validate('model', v);
-      const error = v =>
-        format(
-          'The provided option "properties" of the model "model" ' +
-            'should be an Object, but %s given.',
-          v,
-        );
-      expect(validate('str')).to.throw(error('"str"'));
-      expect(validate(10)).to.throw(error('10'));
-      expect(validate(true)).to.throw(error('true'));
-      expect(validate(false)).to.throw(error('false'));
-      expect(validate([])).to.throw(error('Array'));
-      expect(validate(undefined)).to.throw(error('undefined'));
-      expect(validate(null)).to.throw(error('null'));
-      validate({})();
-    });
-
-    it('does not throw an error if no properties defined', function () {
-      S.validate('model', {});
-    });
-
-    it('does not throw an error if no default value specified for a required property', function () {
-      S.validate('model', {
-        foo: {
-          type: DataType.STRING,
-          required: true,
-        },
-      });
-    });
-
-    it('does not throw an error if a default value matches a property type', function () {
-      S.validate('model', {
-        foo: {
-          type: DataType.BOOLEAN,
-          default: false,
-        },
-      });
-    });
-
-    it('does not throw an error if a default value from a factory function matches a property type', function () {
-      S.validate('model', {
-        foo: {
-          type: DataType.BOOLEAN,
-          default: () => false,
-        },
-      });
-    });
-
-    it('throws an error if a default value does not match a property type', function () {
-      const throwable = () =>
-        S.validate('model', {
-          foo: {
-            type: DataType.STRING,
-            default: 10,
-          },
-        });
-      expect(throwable).to.throw(
-        'A default value is invalid. The property "foo" of the model ' +
-          '"model" must have a String, but Number given.',
-      );
-    });
-
-    it('throws an error if a default value from a factory function does not match a property type', function () {
-      const throwable = () =>
-        S.validate('model', {
-          foo: {
-            type: DataType.STRING,
-            default: () => 10,
-          },
-        });
-      expect(throwable).to.throw(
-        'A default value is invalid. The property "foo" of the model ' +
-          '"model" must have a String, but Number given.',
-      );
-    });
-
-    it('throws an error if an array element of a default value does not match an item type', function () {
-      const throwable = () =>
-        S.validate('model', {
-          foo: {
-            type: DataType.ARRAY,
-            itemType: DataType.STRING,
-            default: [10],
-          },
-        });
-      expect(throwable).to.throw(
-        'A default value is invalid. The array property "foo" of the model "model" ' +
-          'must have a String element, but Number given.',
-      );
-    });
-
-    it('throws an error if an array element from a default value factory does not match an item type', function () {
-      const throwable = () =>
-        S.validate('model', {
-          foo: {
-            type: DataType.ARRAY,
-            itemType: DataType.STRING,
-            default: () => [10],
-          },
-        });
-      expect(throwable).to.throw(
-        'A default value is invalid. The array property "foo" of the model "model" ' +
-          'must have a String element, but Number given.',
-      );
-    });
-  });
-});