chore: tests refactoring

src/adapter/adapter-registry.spec.js

@@ -6,9 +6,9 @@ import {MemoryAdapter} from './builtin/memory-adapter.js';
 describe('AdapterRegistry', function () {
   describe('getAdapter', function () {
     it('instantiates a new or returns an existing adapter by a given datasource name', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      const R = S.getService(AdapterRegistry);
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      const R = dbs.getService(AdapterRegistry);
       const adapter = await R.getAdapter('datasource');
       expect(adapter).to.be.instanceof(MemoryAdapter);
       const sameAdapter = await R.getAdapter('datasource');
@@ -24,9 +24,9 @@ describe('AdapterRegistry', function () {
     });
 
     it('throws an error if an adapter is not exists', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'unknown'});
-      const R = S.getService(AdapterRegistry);
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'unknown'});
+      const R = dbs.getService(AdapterRegistry);
       const promise = R.getAdapter('datasource');
       await expect(promise).to.be.rejectedWith(
         'The adapter "unknown" is not found.',

src/adapter/adapter.spec.js

@@ -42,14 +42,14 @@ describe('Adapter', function () {
     });
 
     it('decorates only extended adapter', function () {
-      const schema = new DatabaseSchema();
-      const dec1 = schema.getService(DataSanitizingDecorator);
-      const dec2 = schema.getService(DefaultValuesDecorator);
-      const dec3 = schema.getService(DataTransformationDecorator);
-      const dec4 = schema.getService(DataValidationDecorator);
-      const dec5 = schema.getService(PropertyUniquenessDecorator);
-      const dec6 = schema.getService(FieldsFilteringDecorator);
-      const dec7 = schema.getService(InclusionDecorator);
+      const dbs = new DatabaseSchema();
+      const dec1 = dbs.getService(DataSanitizingDecorator);
+      const dec2 = dbs.getService(DefaultValuesDecorator);
+      const dec3 = dbs.getService(DataTransformationDecorator);
+      const dec4 = dbs.getService(DataValidationDecorator);
+      const dec5 = dbs.getService(PropertyUniquenessDecorator);
+      const dec6 = dbs.getService(FieldsFilteringDecorator);
+      const dec7 = dbs.getService(InclusionDecorator);
       const order = [];
       const decorate = function (ctx) {
         expect(ctx).to.be.instanceof(Adapter);
@@ -62,7 +62,7 @@ describe('Adapter', function () {
       sandbox.on(dec5, 'decorate', decorate);
       sandbox.on(dec6, 'decorate', decorate);
       sandbox.on(dec7, 'decorate', decorate);
-      new Adapter(schema.container);
+      new Adapter(dbs.container);
       expect(order).to.be.empty;
       expect(dec1.decorate).to.be.not.called;
       expect(dec2.decorate).to.be.not.called;
@@ -72,7 +72,7 @@ describe('Adapter', function () {
       expect(dec6.decorate).to.be.not.called;
       expect(dec7.decorate).to.be.not.called;
       class ExtendedAdapter extends Adapter {}
-      new ExtendedAdapter(schema.container);
+      new ExtendedAdapter(dbs.container);
       expect(order[0]).to.be.eql(dec1);
       expect(order[1]).to.be.eql(dec2);
       expect(order[2]).to.be.eql(dec3);

src/adapter/decorator/data-sanitizing-decorator.spec.js

@@ -4,8 +4,8 @@ import {Adapter} from '../adapter.js';
 import {DatabaseSchema} from '../../database-schema.js';
 import {ModelDataSanitizer} from '../../definition/index.js';
 
-const S = new DatabaseSchema();
-S.defineModel({name: 'model'});
+const dbs = new DatabaseSchema();
+dbs.defineModel({name: 'model'});
 
 class TestAdapter extends Adapter {
   // eslint-disable-next-line no-unused-vars
@@ -34,8 +34,8 @@ class TestAdapter extends Adapter {
   }
 }
 
-const A = S.getService(TestAdapter);
-const V = S.getService(ModelDataSanitizer);
+const A = dbs.getService(TestAdapter);
+const V = dbs.getService(ModelDataSanitizer);
 const sandbox = chai.spy.sandbox();
 
 describe('DataSanitizingDecorator', function () {

src/adapter/decorator/data-transformation-decorator.spec.js

@@ -46,10 +46,10 @@ class TestAdapter extends Adapter {
   }
 }
 
-const S = new DatabaseSchema();
-S.defineModel({name: MODEL_NAME});
-const A = S.getService(TestAdapter);
-const T = S.getService(ModelDataTransformer);
+const dbs = new DatabaseSchema();
+dbs.defineModel({name: MODEL_NAME});
+const A = dbs.getService(TestAdapter);
+const T = dbs.getService(ModelDataTransformer);
 const sandbox = chai.spy.sandbox();
 
 describe('DataTransformationDecorator', function () {

src/adapter/decorator/data-validation-decorator.spec.js

@@ -4,8 +4,8 @@ import {Adapter} from '../adapter.js';
 import {DatabaseSchema} from '../../database-schema.js';
 import {ModelDataValidator} from '../../definition/index.js';
 
-const S = new DatabaseSchema();
-S.defineModel({name: 'model'});
+const dbs = new DatabaseSchema();
+dbs.defineModel({name: 'model'});
 
 class TestAdapter extends Adapter {
   // eslint-disable-next-line no-unused-vars
@@ -34,8 +34,8 @@ class TestAdapter extends Adapter {
   }
 }
 
-const A = S.getService(TestAdapter);
-const V = S.getService(ModelDataValidator);
+const A = dbs.getService(TestAdapter);
+const V = dbs.getService(ModelDataValidator);
 const sandbox = chai.spy.sandbox();
 
 describe('DataValidationDecorator', function () {

src/adapter/decorator/default-values-decorator.spec.js

@@ -5,8 +5,8 @@ import {DataType} from '../../definition/index.js';
 import {DatabaseSchema} from '../../database-schema.js';
 import {ModelDefinitionUtils} from '../../definition/index.js';
 
-const S = new DatabaseSchema();
-S.defineModel({
+const dbs = new DatabaseSchema();
+dbs.defineModel({
   name: 'model',
   properties: {
     prop: {
@@ -56,8 +56,8 @@ class TestAdapter extends Adapter {
   }
 }
 
-const A = S.getService(TestAdapter);
-const U = S.getService(ModelDefinitionUtils);
+const A = dbs.getService(TestAdapter);
+const U = dbs.getService(ModelDefinitionUtils);
 const sandbox = chai.spy.sandbox();
 
 describe('DefaultValuesDecorator', function () {

src/adapter/decorator/fields-filtering-decorator.spec.js

@@ -4,9 +4,9 @@ import {Adapter} from '../adapter.js';
 import {FieldsClauseTool} from '../../filter/index.js';
 import {DatabaseSchema} from '../../database-schema.js';
 
-const S = new DatabaseSchema();
+const dbs = new DatabaseSchema();
 const MODEL_NAME = 'model';
-S.defineModel({name: MODEL_NAME});
+dbs.defineModel({name: MODEL_NAME});
 
 const FILTER = {fields: ['foo', 'bar']};
 const MODEL_DATA = {
@@ -53,8 +53,8 @@ class TestAdapter extends Adapter {
   }
 }
 
-const A = S.getService(TestAdapter);
-const T = S.getService(FieldsClauseTool);
+const A = dbs.getService(TestAdapter);
+const T = dbs.getService(FieldsClauseTool);
 const sandbox = chai.spy.sandbox();
 
 describe('FieldsFilteringDecorator', function () {

src/adapter/decorator/inclusion-decorator.spec.js

@@ -4,8 +4,8 @@ import {Adapter} from '../adapter.js';
 import {DatabaseSchema} from '../../database-schema.js';
 import {IncludeClauseTool} from '../../filter/index.js';
 
-const S = new DatabaseSchema();
-S.defineModel({name: 'model'});
+const dbs = new DatabaseSchema();
+dbs.defineModel({name: 'model'});
 const FILTER = {include: 'parent'};
 
 const MODEL_DATA = {
@@ -51,8 +51,8 @@ class TestAdapter extends Adapter {
   }
 }
 
-const A = S.getService(TestAdapter);
-const T = S.getService(IncludeClauseTool);
+const A = dbs.getService(TestAdapter);
+const T = dbs.getService(IncludeClauseTool);
 const sandbox = chai.spy.sandbox();
 
 describe('InclusionDecorator', function () {

src/adapter/decorator/property-uniqueness-decorator.spec.js

@@ -4,8 +4,8 @@ import {Adapter} from '../adapter.js';
 import {DatabaseSchema} from '../../database-schema.js';
 import {PropertyUniquenessValidator} from '../../definition/index.js';
 
-const S = new DatabaseSchema();
-S.defineModel({name: 'model'});
+const dbs = new DatabaseSchema();
+dbs.defineModel({name: 'model'});
 
 class TestAdapter extends Adapter {
   // eslint-disable-next-line no-unused-vars
@@ -34,8 +34,8 @@ class TestAdapter extends Adapter {
   }
 }
 
-const A = S.getService(TestAdapter);
-const V = S.getService(PropertyUniquenessValidator);
+const A = dbs.getService(TestAdapter);
+const V = dbs.getService(PropertyUniquenessValidator);
 const sandbox = chai.spy.sandbox();
 
 describe('PropertyUniquenessDecorator', function () {

src/database-schema.spec.ts

@@ -3,7 +3,7 @@ import {Repository} from './repository/index.js';
 import {DatabaseSchema} from './database-schema.js';
 import {DefinitionRegistry} from './definition/index.js';
 
-describe('Schema', function () {
+describe('DatabaseSchema', function () {
   describe('defineDatasource', function () {
     it('returns this', function () {
       const dbs = new DatabaseSchema();

src/definition/model/model-data-transformer.spec.js

@@ -9,15 +9,15 @@ import {PropertyTransformerRegistry} from './properties/index.js';
 describe('ModelDataTransformer', function () {
   describe('transform', function () {
     it('throws an error if the given model name is not defined', function () {
-      const schema = new DatabaseSchema();
-      const T = schema.getService(ModelDataTransformer);
+      const dbs = new DatabaseSchema();
+      const T = dbs.getService(ModelDataTransformer);
       const throwable = () => T.transform('model', {});
       expect(throwable).to.throw('The model "model" is not defined.');
     });
 
     it('throws an error if the given model data is not a pure object', function () {
-      const schema = new DatabaseSchema();
-      const T = schema.getService(ModelDataTransformer);
+      const dbs = new DatabaseSchema();
+      const T = dbs.getService(ModelDataTransformer);
       const throwable = v => () => T.transform('model', v);
       const error = v =>
         format(
@@ -37,8 +37,8 @@ describe('ModelDataTransformer', function () {
     });
 
     it('does nothing with the given model if no transformers are set', function () {
-      const schema = new DatabaseSchema();
-      schema.defineModel({
+      const dbs = new DatabaseSchema();
+      dbs.defineModel({
         name: 'model',
         properties: {
           foo: DataType.STRING,
@@ -48,7 +48,7 @@ describe('ModelDataTransformer', function () {
           },
         },
       });
-      const T = schema.getService(ModelDataTransformer);
+      const T = dbs.getService(ModelDataTransformer);
       const modelData = {baz: 'qux'};
       const res = T.transform('model', modelData);
       expect(res).to.be.eql(modelData);
@@ -56,12 +56,12 @@ describe('ModelDataTransformer', function () {
 
     describe('the option "transform" with a string value', function () {
       it('transforms the property value by its transformer', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = value => String(value);
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -70,13 +70,13 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res = T.transform('model', {foo: 10});
         expect(res).to.be.eql({foo: '10'});
       });
 
       it('passes specific arguments to the transformer function', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = (value, options, context) => {
           expect(value).to.be.eq('input');
           expect(options).to.be.undefined;
@@ -87,10 +87,10 @@ describe('ModelDataTransformer', function () {
           });
           return 'transformed';
         };
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -99,18 +99,18 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res = T.transform('model', {foo: 'input'});
         expect(res).to.be.eql({foo: 'transformed'});
       });
 
       it('does not transform a property value if it is not provided', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = () => 'transformed';
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -119,18 +119,18 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res = T.transform('model', {});
         expect(res).to.be.eql({});
       });
 
       it('does not transform undefined and null values', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = () => 'transformed';
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -139,7 +139,7 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res1 = T.transform('model', {foo: undefined});
         const res2 = T.transform('model', {foo: null});
         expect(res1).to.be.eql({foo: undefined});
@@ -147,12 +147,12 @@ describe('ModelDataTransformer', function () {
       });
 
       it('the parameter "isPartial" prevents to transform values of not provided properties', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = () => 'transformed';
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -161,13 +161,13 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res = T.transform('model', {}, true);
         expect(res).to.be.eql({});
       });
 
       it('transforms the property value by its asynchronous transformer', async function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer1 = (value, options) => {
           expect(options).to.be.undefined;
           return Promise.resolve(`${value}2`);
@@ -176,11 +176,11 @@ describe('ModelDataTransformer', function () {
           expect(options).to.be.undefined;
           return Promise.resolve(`${value}3`);
         };
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer1', myTransformer1)
           .addTransformer('myTransformer2', myTransformer2);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -193,7 +193,7 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const promise = T.transform('model', {foo: '1', bar: '2'});
         expect(promise).to.be.instanceof(Promise);
         const res = await promise;
@@ -203,12 +203,12 @@ describe('ModelDataTransformer', function () {
 
     describe('the option "transform" with an array value', function () {
       it('transforms given properties by their transformers', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = value => String(value);
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -225,13 +225,13 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res = T.transform('model', {foo: 1, bar: 2, baz: 3});
         expect(res).to.be.eql({foo: '1', bar: '2', baz: '3'});
       });
 
       it('transforms the property value by its transformers in specified order', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const order = [];
         const myTransformer1 = value => {
           order.push('myTransformer1');
@@ -241,11 +241,11 @@ describe('ModelDataTransformer', function () {
           order.push('myTransformer2');
           return value + '2';
         };
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer1', myTransformer1)
           .addTransformer('myTransformer2', myTransformer2);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -254,14 +254,14 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res = T.transform('model', {foo: 'value'});
         expect(res).to.be.eql({foo: 'value12'});
         expect(order).to.be.eql(['myTransformer1', 'myTransformer2']);
       });
 
       it('passes specific arguments to the transformer function', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = (value, options, context) => {
           expect(value).to.be.eq('input');
           expect(options).to.be.undefined;
@@ -272,10 +272,10 @@ describe('ModelDataTransformer', function () {
           });
           return 'transformed';
         };
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -284,18 +284,18 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res = T.transform('model', {foo: 'input'});
         expect(res).to.be.eql({foo: 'transformed'});
       });
 
       it('does not transform a property value if it is not provided', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = () => 'transformed';
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -304,18 +304,18 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res = T.transform('model', {});
         expect(res).to.be.eql({});
       });
 
       it('transforms undefined and null values', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = () => 'transformed';
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -324,7 +324,7 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res1 = T.transform('model', {foo: undefined});
         const res2 = T.transform('model', {foo: null});
         expect(res1).to.be.eql({foo: undefined});
@@ -332,12 +332,12 @@ describe('ModelDataTransformer', function () {
       });
 
       it('the parameter "isPartial" prevents to transform values of not provided properties', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = () => 'transformed';
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -346,13 +346,13 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res = T.transform('model', {}, true);
         expect(res).to.be.eql({});
       });
 
       it('transforms the property value by its asynchronous transformers', async function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer1 = (value, options) => {
           expect(options).to.be.undefined;
           return Promise.resolve(`${value}2`);
@@ -365,12 +365,12 @@ describe('ModelDataTransformer', function () {
           expect(options).to.be.undefined;
           return Promise.resolve(`${value}4`);
         };
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer1', myTransformer1)
           .addTransformer('myTransformer2', myTransformer2)
           .addTransformer('myTransformer3', myTransformer3);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -383,7 +383,7 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const promise = T.transform('model', {foo: '1', bar: '2'});
         expect(promise).to.be.instanceof(Promise);
         const res = await promise;
@@ -393,12 +393,12 @@ describe('ModelDataTransformer', function () {
 
     describe('the option "transform" with an object value', function () {
       it('transforms given properties by their transformers', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = value => String(value);
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -415,13 +415,13 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res = T.transform('model', {foo: 1, bar: 2, baz: 3});
         expect(res).to.be.eql({foo: '1', bar: '2', baz: '3'});
       });
 
       it('transforms the property value by its transformers in specified order', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const order = [];
         const myTransformer1 = value => {
           order.push('myTransformer1');
@@ -431,11 +431,11 @@ describe('ModelDataTransformer', function () {
           order.push('myTransformer2');
           return value + '2';
         };
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer1', myTransformer1)
           .addTransformer('myTransformer2', myTransformer2);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -447,14 +447,14 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res = T.transform('model', {foo: 'value'});
         expect(res).to.be.eql({foo: 'value12'});
         expect(order).to.be.eql(['myTransformer1', 'myTransformer2']);
       });
 
       it('passes specific arguments to the transformer function', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = (value, options, context) => {
           expect(value).to.be.eq('input');
           expect(options).to.be.eql({
@@ -468,10 +468,10 @@ describe('ModelDataTransformer', function () {
           });
           return 'transformed';
         };
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -485,18 +485,18 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res = T.transform('model', {foo: 'input'});
         expect(res).to.be.eql({foo: 'transformed'});
       });
 
       it('does not transform a property value if it is not provided', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = () => 'transformed';
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -507,18 +507,18 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res = T.transform('model', {});
         expect(res).to.be.eql({});
       });
 
       it('transforms undefined and null values', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = () => 'transformed';
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -529,7 +529,7 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res1 = T.transform('model', {foo: undefined});
         const res2 = T.transform('model', {foo: null});
         expect(res1).to.be.eql({foo: undefined});
@@ -537,12 +537,12 @@ describe('ModelDataTransformer', function () {
       });
 
       it('the parameter "isPartial" prevents to transform values of not provided properties', function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer = () => 'transformed';
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer', myTransformer);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -553,13 +553,13 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const res = T.transform('model', {}, true);
         expect(res).to.be.eql({});
       });
 
       it('transforms the property value by its asynchronous transformers', async function () {
-        const schema = new DatabaseSchema();
+        const dbs = new DatabaseSchema();
         const myTransformer1 = (value, options) => {
           expect(options).to.be.eq('foo');
           return Promise.resolve(`${value}2`);
@@ -572,12 +572,12 @@ describe('ModelDataTransformer', function () {
           expect(options).to.be.eq('baz');
           return Promise.resolve(`${value}4`);
         };
-        schema
+        dbs
           .getService(PropertyTransformerRegistry)
           .addTransformer('myTransformer1', myTransformer1)
           .addTransformer('myTransformer2', myTransformer2)
           .addTransformer('myTransformer3', myTransformer3);
-        schema.defineModel({
+        dbs.defineModel({
           name: 'model',
           properties: {
             foo: {
@@ -596,7 +596,7 @@ describe('ModelDataTransformer', function () {
             },
           },
         });
-        const T = schema.getService(ModelDataTransformer);
+        const T = dbs.getService(ModelDataTransformer);
         const promise = T.transform('model', {foo: '1', bar: '2'});
         expect(promise).to.be.instanceof(Promise);
         const res = await promise;
@@ -605,11 +605,11 @@ describe('ModelDataTransformer', function () {
     });
 
     it('the option "transform" requires a non-empty String, an Array or an Object', function () {
-      const schema = new DatabaseSchema();
-      schema
+      const dbs = new DatabaseSchema();
+      dbs
         .getService(PropertyTransformerRegistry)
         .addTransformer('myTransformer', () => 'transformed');
-      schema.defineModel({
+      dbs.defineModel({
         name: 'model',
         properties: {
           foo: {
@@ -618,9 +618,9 @@ describe('ModelDataTransformer', function () {
           },
         },
       });
-      const T = schema.getService(ModelDataTransformer);
+      const T = dbs.getService(ModelDataTransformer);
       const throwable = v => () => {
-        const models = schema.getService(DefinitionRegistry)['_models'];
+        const models = dbs.getService(DefinitionRegistry)['_models'];
         models.model.properties.foo.transform = v;
         T.transform('model', {foo: 'bar'});
       };

src/definition/model/properties/property-transformer/property-transformer-registry.spec.js

@@ -9,8 +9,8 @@ import {PropertyTransformerRegistry} from './property-transformer-registry.js';
 describe('PropertyTransformerRegistry', function () {
   describe('addTransformer', function () {
     it('has builtin transformers', function () {
-      const S = new PropertyTransformerRegistry();
-      expect(S['_transformers']).to.be.eql({
+      const ptr = new PropertyTransformerRegistry();
+      expect(ptr['_transformers']).to.be.eql({
         trim: trimTransformer,
         toUpperCase: toUpperCaseTransformer,
         toLowerCase: toLowerCaseTransformer,
@@ -19,16 +19,16 @@ describe('PropertyTransformerRegistry', function () {
     });
 
     it('adds a given transformer with the name', function () {
-      const S = new PropertyTransformerRegistry();
+      const ptr = new PropertyTransformerRegistry();
       const myTransformer = () => undefined;
-      const res = S.addTransformer('myTransformer', myTransformer);
-      expect(res).to.be.eq(S);
-      expect(S['_transformers']['myTransformer']).to.be.eq(myTransformer);
+      const res = ptr.addTransformer('myTransformer', myTransformer);
+      expect(res).to.be.eq(ptr);
+      expect(ptr['_transformers']['myTransformer']).to.be.eq(myTransformer);
     });
 
     it('requires the given name to be a non-empty string', function () {
-      const S = new PropertyTransformerRegistry();
-      const throwable = v => () => S.addTransformer(v, () => undefined);
+      const ptr = new PropertyTransformerRegistry();
+      const throwable = v => () => ptr.addTransformer(v, () => undefined);
       const error = v =>
         format(
           'A name of the property transformer must ' +
@@ -48,17 +48,17 @@ describe('PropertyTransformerRegistry', function () {
     });
 
     it('throws an error if the given name already exists', function () {
-      const S = new PropertyTransformerRegistry();
-      S.addTransformer('test', () => undefined);
-      const throwable = () => S.addTransformer('test', () => undefined);
+      const ptr = new PropertyTransformerRegistry();
+      ptr.addTransformer('test', () => undefined);
+      const throwable = () => ptr.addTransformer('test', () => undefined);
       expect(throwable).to.throw(
         'The property transformer "test" is already defined.',
       );
     });
 
     it('requires the given transformer to be a function', function () {
-      const S = new PropertyTransformerRegistry();
-      const throwable = v => () => S.addTransformer('test', v);
+      const ptr = new PropertyTransformerRegistry();
+      const throwable = v => () => ptr.addTransformer('test', v);
       const error = v =>
         format(
           'The property transformer "test" must be a Function, but %s given.',
@@ -79,44 +79,44 @@ describe('PropertyTransformerRegistry', function () {
 
   describe('hasTransformer', function () {
     it('returns false for a not existing name', function () {
-      const S = new PropertyTransformerRegistry();
-      expect(S.hasTransformer('str')).to.be.false;
-      expect(S.hasTransformer('')).to.be.false;
-      expect(S.hasTransformer(10)).to.be.false;
-      expect(S.hasTransformer(0)).to.be.false;
-      expect(S.hasTransformer(true)).to.be.false;
-      expect(S.hasTransformer(false)).to.be.false;
-      expect(S.hasTransformer(null)).to.be.false;
-      expect(S.hasTransformer(undefined)).to.be.false;
-      expect(S.hasTransformer({})).to.be.false;
-      expect(S.hasTransformer([])).to.be.false;
-      expect(S.hasTransformer(() => undefined)).to.be.false;
+      const ptr = new PropertyTransformerRegistry();
+      expect(ptr.hasTransformer('str')).to.be.false;
+      expect(ptr.hasTransformer('')).to.be.false;
+      expect(ptr.hasTransformer(10)).to.be.false;
+      expect(ptr.hasTransformer(0)).to.be.false;
+      expect(ptr.hasTransformer(true)).to.be.false;
+      expect(ptr.hasTransformer(false)).to.be.false;
+      expect(ptr.hasTransformer(null)).to.be.false;
+      expect(ptr.hasTransformer(undefined)).to.be.false;
+      expect(ptr.hasTransformer({})).to.be.false;
+      expect(ptr.hasTransformer([])).to.be.false;
+      expect(ptr.hasTransformer(() => undefined)).to.be.false;
     });
 
     it('returns true for an existing name', function () {
-      const S = new PropertyTransformerRegistry();
-      expect(S.hasTransformer('test')).to.be.false;
-      S.addTransformer('test', () => undefined);
-      expect(S.hasTransformer('test')).to.be.true;
+      const ptr = new PropertyTransformerRegistry();
+      expect(ptr.hasTransformer('test')).to.be.false;
+      ptr.addTransformer('test', () => undefined);
+      expect(ptr.hasTransformer('test')).to.be.true;
     });
   });
 
   describe('getTransformer', function () {
     it('returns transformer by its name', function () {
-      const S = new PropertyTransformerRegistry();
+      const ptr = new PropertyTransformerRegistry();
       const myTransformer1 = () => undefined;
       const myTransformer2 = () => undefined;
-      S.addTransformer('foo', myTransformer1);
-      S.addTransformer('bar', myTransformer2);
-      const res1 = S.getTransformer('foo');
-      const res2 = S.getTransformer('bar');
+      ptr.addTransformer('foo', myTransformer1);
+      ptr.addTransformer('bar', myTransformer2);
+      const res1 = ptr.getTransformer('foo');
+      const res2 = ptr.getTransformer('bar');
       expect(res1).to.be.eq(myTransformer1);
       expect(res2).to.be.eq(myTransformer2);
     });
 
     it('throws an error for a not existed name', function () {
-      const S = new PropertyTransformerRegistry();
-      const throwable = v => () => S.getTransformer(v);
+      const ptr = new PropertyTransformerRegistry();
+      const throwable = v => () => ptr.getTransformer(v);
       const error = v =>
         format('The property transformer %s is not defined.', v);
       expect(throwable('str')).to.throw(error('"str"'));

src/definition/model/properties/property-validator/property-validator-registry.spec.js

@@ -7,8 +7,8 @@ import {PropertyValidatorRegistry} from './property-validator-registry.js';
 
 describe('PropertyValidatorRegistry', function () {
   it('has builtin validators', function () {
-    const S = new PropertyValidatorRegistry();
-    expect(S['_validators']).to.be.eql({
+    const pvr = new PropertyValidatorRegistry();
+    expect(pvr['_validators']).to.be.eql({
       maxLength: maxLengthValidator,
       minLength: minLengthValidator,
       regexp: regexpValidator,
@@ -17,16 +17,16 @@ describe('PropertyValidatorRegistry', function () {
 
   describe('addValidator', function () {
     it('adds a given validator with the name', function () {
-      const S = new PropertyValidatorRegistry();
+      const pvr = new PropertyValidatorRegistry();
       const myValidator = () => undefined;
-      const res = S.addValidator('myValidator', myValidator);
-      expect(res).to.be.eq(S);
-      expect(S['_validators']['myValidator']).to.be.eq(myValidator);
+      const res = pvr.addValidator('myValidator', myValidator);
+      expect(res).to.be.eq(pvr);
+      expect(pvr['_validators']['myValidator']).to.be.eq(myValidator);
     });
 
     it('requires the given name to be a non-empty string', function () {
-      const S = new PropertyValidatorRegistry();
-      const throwable = v => () => S.addValidator(v, () => undefined);
+      const pvr = new PropertyValidatorRegistry();
+      const throwable = v => () => pvr.addValidator(v, () => undefined);
       const error = v =>
         format(
           'A name of the property validator must ' +
@@ -46,17 +46,17 @@ describe('PropertyValidatorRegistry', function () {
     });
 
     it('throws an error if the given name already exists', function () {
-      const S = new PropertyValidatorRegistry();
-      S.addValidator('test', () => undefined);
-      const throwable = () => S.addValidator('test', () => undefined);
+      const pvr = new PropertyValidatorRegistry();
+      pvr.addValidator('test', () => undefined);
+      const throwable = () => pvr.addValidator('test', () => undefined);
       expect(throwable).to.throw(
         'The property validator "test" is already defined.',
       );
     });
 
     it('requires the given validator to be a function', function () {
-      const S = new PropertyValidatorRegistry();
-      const throwable = v => () => S.addValidator('test', v);
+      const pvr = new PropertyValidatorRegistry();
+      const throwable = v => () => pvr.addValidator('test', v);
       const error = v =>
         format(
           'The property validator "test" must be a Function, but %s given.',
@@ -77,44 +77,44 @@ describe('PropertyValidatorRegistry', function () {
 
   describe('hasValidator', function () {
     it('returns false for a not existing name', function () {
-      const S = new PropertyValidatorRegistry();
-      expect(S.hasValidator('str')).to.be.false;
-      expect(S.hasValidator('')).to.be.false;
-      expect(S.hasValidator(10)).to.be.false;
-      expect(S.hasValidator(0)).to.be.false;
-      expect(S.hasValidator(true)).to.be.false;
-      expect(S.hasValidator(false)).to.be.false;
-      expect(S.hasValidator(null)).to.be.false;
-      expect(S.hasValidator(undefined)).to.be.false;
-      expect(S.hasValidator({})).to.be.false;
-      expect(S.hasValidator([])).to.be.false;
-      expect(S.hasValidator(() => undefined)).to.be.false;
+      const pvr = new PropertyValidatorRegistry();
+      expect(pvr.hasValidator('str')).to.be.false;
+      expect(pvr.hasValidator('')).to.be.false;
+      expect(pvr.hasValidator(10)).to.be.false;
+      expect(pvr.hasValidator(0)).to.be.false;
+      expect(pvr.hasValidator(true)).to.be.false;
+      expect(pvr.hasValidator(false)).to.be.false;
+      expect(pvr.hasValidator(null)).to.be.false;
+      expect(pvr.hasValidator(undefined)).to.be.false;
+      expect(pvr.hasValidator({})).to.be.false;
+      expect(pvr.hasValidator([])).to.be.false;
+      expect(pvr.hasValidator(() => undefined)).to.be.false;
     });
 
     it('returns true for an existing name', function () {
-      const S = new PropertyValidatorRegistry();
-      expect(S.hasValidator('test')).to.be.false;
-      S.addValidator('test', () => undefined);
-      expect(S.hasValidator('test')).to.be.true;
+      const pvr = new PropertyValidatorRegistry();
+      expect(pvr.hasValidator('test')).to.be.false;
+      pvr.addValidator('test', () => undefined);
+      expect(pvr.hasValidator('test')).to.be.true;
     });
   });
 
   describe('getValidator', function () {
     it('returns validator by its name', function () {
-      const S = new PropertyValidatorRegistry();
+      const pvr = new PropertyValidatorRegistry();
       const myValidator1 = () => undefined;
       const myValidator2 = () => undefined;
-      S.addValidator('foo', myValidator1);
-      S.addValidator('bar', myValidator2);
-      const res1 = S.getValidator('foo');
-      const res2 = S.getValidator('bar');
+      pvr.addValidator('foo', myValidator1);
+      pvr.addValidator('bar', myValidator2);
+      const res1 = pvr.getValidator('foo');
+      const res2 = pvr.getValidator('bar');
       expect(res1).to.be.eq(myValidator1);
       expect(res2).to.be.eq(myValidator2);
     });
 
     it('throws an error for a not existed name', function () {
-      const S = new PropertyValidatorRegistry();
-      const throwable = v => () => S.getValidator(v);
+      const pvr = new PropertyValidatorRegistry();
+      const throwable = v => () => pvr.getValidator(v);
       const error = v => format('The property validator %s is not defined.', v);
       expect(throwable('str')).to.throw(error('"str"'));
       expect(throwable('')).to.throw(error('""'));

src/filter/fields-clause-tool.spec.js

@@ -4,10 +4,10 @@ import {DatabaseSchema} from '../database-schema.js';
 import {FieldsClauseTool} from './fields-clause-tool.js';
 import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '../definition/index.js';
 
-const S = new DatabaseSchema();
+const dbs = new DatabaseSchema();
 const MODEL_NAME = 'model';
-S.defineModel({name: MODEL_NAME});
-const T = S.getService(FieldsClauseTool);
+dbs.defineModel({name: MODEL_NAME});
+const T = dbs.getService(FieldsClauseTool);
 
 describe('FieldsClauseTool', function () {
   describe('filter', function () {

src/relations/belongs-to-resolver.spec.js

@@ -9,8 +9,8 @@ import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '../definition/index.j
 describe('BelongsToResolver', function () {
   describe('includeTo', function () {
     it('requires the "entities" parameter to be an array', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(BelongsToResolver);
       const error = v =>
         format(
           'The parameter "entities" of BelongsToResolver.includeTo requires ' +
@@ -30,8 +30,8 @@ describe('BelongsToResolver', function () {
     });
 
     it('requires elements of the "entities" parameter to be an Object', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(BelongsToResolver);
       const error = v =>
         format(
           'The parameter "entities" of BelongsToResolver.includeTo requires ' +
@@ -51,8 +51,8 @@ describe('BelongsToResolver', function () {
     });
 
     it('requires the "sourceName" parameter to be a non-empty string', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(BelongsToResolver);
       const error = v =>
         format(
           'The parameter "sourceName" of BelongsToResolver.includeTo requires ' +
@@ -71,8 +71,8 @@ describe('BelongsToResolver', function () {
     });
 
     it('requires the "targetName" parameter to be a non-empty string', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(BelongsToResolver);
       const error = v =>
         format(
           'The parameter "targetName" of BelongsToResolver.includeTo requires ' +
@@ -91,8 +91,8 @@ describe('BelongsToResolver', function () {
     });
 
     it('requires the "relationName" parameter to be a non-empty string', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(BelongsToResolver);
       const error = v =>
         format(
           'The parameter "relationName" of BelongsToResolver.includeTo requires ' +
@@ -111,8 +111,8 @@ describe('BelongsToResolver', function () {
     });
 
     it('requires the provided parameter "foreignKey" to be a string', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(BelongsToResolver);
       const error = v =>
         format(
           'The provided parameter "foreignKey" of BelongsToResolver.includeTo ' +
@@ -128,8 +128,8 @@ describe('BelongsToResolver', function () {
     });
 
     it('requires the provided parameter "scope" to be an object', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(BelongsToResolver);
       const error = v =>
         format(
           'The provided parameter "scope" of BelongsToResolver.includeTo ' +
@@ -152,9 +152,9 @@ describe('BelongsToResolver', function () {
     });
 
     it('throws an error if the given target model is not found', async function () {
-      const S = new DatabaseSchema();
-      S.defineModel({name: 'source'});
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      dbs.defineModel({name: 'source'});
+      const R = dbs.getService(BelongsToResolver);
       const promise = R.includeTo([], 'source', 'target', 'relation');
       await expect(promise).to.be.rejectedWith(
         'The model "target" is not defined',
@@ -162,9 +162,9 @@ describe('BelongsToResolver', function () {
     });
 
     it('throws an error if the given target model does not have a datasource', async function () {
-      const S = new DatabaseSchema();
-      S.defineModel({name: 'target'});
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      dbs.defineModel({name: 'target'});
+      const R = dbs.getService(BelongsToResolver);
       const promise = R.includeTo([], 'source', 'target', 'relation');
       await expect(promise).to.be.rejectedWith(
         'The model "target" does not have a specified datasource.',
@@ -172,13 +172,13 @@ describe('BelongsToResolver', function () {
     });
 
     it('does not throw an error if a relation target is not found', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRel = S.getRepository('source');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRel = dbs.getRepository('source');
       const source = await sourceRel.create({parentId: 10});
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includeTo([source], 'source', 'target', 'parent');
       expect(source).to.be.eql({
         [DEF_PK]: source[DEF_PK],
@@ -187,12 +187,12 @@ describe('BelongsToResolver', function () {
     });
 
     it('includes if a primary key is not defined in the target model', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target = await targetRep.create({});
       expect(target).to.be.eql({[DEF_PK]: target[DEF_PK]});
       const source = await sourceRep.create({parentId: target[DEF_PK]});
@@ -200,7 +200,7 @@ describe('BelongsToResolver', function () {
         [DEF_PK]: source[DEF_PK],
         parentId: target[DEF_PK],
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includeTo([source], 'source', 'target', 'parent');
       expect(source).to.be.eql({
         [DEF_PK]: source[DEF_PK],
@@ -210,10 +210,10 @@ describe('BelongsToResolver', function () {
     });
 
     it('includes if the target model has a custom primary key', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({
         name: 'target',
         datasource: 'datasource',
         properties: {
@@ -223,8 +223,8 @@ describe('BelongsToResolver', function () {
           },
         },
       });
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target = await targetRep.create({});
       expect(target).to.be.eql({myId: target.myId});
       const source = await sourceRep.create({parentId: target.myId});
@@ -232,7 +232,7 @@ describe('BelongsToResolver', function () {
         [DEF_PK]: source[DEF_PK],
         parentId: target.myId,
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includeTo([source], 'source', 'target', 'parent');
       expect(source).to.be.eql({
         [DEF_PK]: source[DEF_PK],
@@ -242,9 +242,9 @@ describe('BelongsToResolver', function () {
     });
 
     it('includes if the source model has a custom primary key', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({
         name: 'source',
         datasource: 'datasource',
         properties: {
@@ -254,9 +254,9 @@ describe('BelongsToResolver', function () {
           },
         },
       });
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target = await targetRep.create({});
       expect(target).to.be.eql({[DEF_PK]: target[DEF_PK]});
       const source = await sourceRep.create({parentId: target[DEF_PK]});
@@ -264,7 +264,7 @@ describe('BelongsToResolver', function () {
         myId: source.myId,
         parentId: target[DEF_PK],
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includeTo([source], 'source', 'target', 'parent');
       expect(source).to.be.eql({
         myId: source.myId,
@@ -274,12 +274,12 @@ describe('BelongsToResolver', function () {
     });
 
     it('includes if the property "foreignKey" is specified', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target = await targetRep.create({});
       expect(target).to.be.eql({[DEF_PK]: target[DEF_PK]});
       const source = await sourceRep.create({parentId: target[DEF_PK]});
@@ -287,7 +287,7 @@ describe('BelongsToResolver', function () {
         [DEF_PK]: source[DEF_PK],
         parentId: target[DEF_PK],
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includeTo([source], 'source', 'target', 'relation', 'parentId');
       expect(source).to.be.eql({
         [DEF_PK]: source[DEF_PK],
@@ -297,12 +297,12 @@ describe('BelongsToResolver', function () {
     });
 
     it('uses a where clause of the given scope to filter the relation target', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target = await targetRep.create({
         foo: 'fooVal',
         bar: 'barVal',
@@ -319,7 +319,7 @@ describe('BelongsToResolver', function () {
         [DEF_PK]: source[DEF_PK],
         parentId: target[DEF_PK],
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includeTo([source], 'source', 'target', 'parent', undefined, {
         where: {foo: 'barVal'},
       });
@@ -338,12 +338,12 @@ describe('BelongsToResolver', function () {
     });
 
     it('uses a fields clause of the given scope to filter the relation target', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target = await targetRep.create({
         foo: 'fooVal',
         bar: 'barVal',
@@ -360,7 +360,7 @@ describe('BelongsToResolver', function () {
         [DEF_PK]: source[DEF_PK],
         parentId: target[DEF_PK],
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includeTo([source], 'source', 'target', 'parent', undefined, {
         fields: [DEF_PK, 'bar'],
       });
@@ -375,12 +375,12 @@ describe('BelongsToResolver', function () {
     });
 
     it('uses an include clause of the given scope to resolve target relations', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({
         name: 'datasource',
         adapter: 'memory',
       });
-      S.defineModel({
+      dbs.defineModel({
         name: 'modelA',
         datasource: 'datasource',
         properties: {
@@ -394,7 +394,7 @@ describe('BelongsToResolver', function () {
           },
         },
       });
-      S.defineModel({
+      dbs.defineModel({
         name: 'modelB',
         datasource: 'datasource',
         properties: {
@@ -414,7 +414,7 @@ describe('BelongsToResolver', function () {
           },
         },
       });
-      S.defineModel({
+      dbs.defineModel({
         name: 'modelC',
         datasource: 'datasource',
         properties: {
@@ -434,9 +434,9 @@ describe('BelongsToResolver', function () {
           },
         },
       });
-      const aRep = S.getRepository('modelA');
-      const bRep = S.getRepository('modelB');
-      const cRep = S.getRepository('modelC');
+      const aRep = dbs.getRepository('modelA');
+      const bRep = dbs.getRepository('modelB');
+      const cRep = dbs.getRepository('modelC');
       const a = await aRep.create({});
       const b = await bRep.create({parentId: a.id});
       const c = await cRep.create({parentId: b.id});
@@ -454,7 +454,7 @@ describe('BelongsToResolver', function () {
         source: 'modelC',
         parentId: b.id,
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includeTo([c], 'modelC', 'modelB', 'parent', undefined, {
         include: 'parent',
       });
@@ -475,12 +475,12 @@ describe('BelongsToResolver', function () {
     });
 
     it('does not break the "and" operator of the given "where" clause', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target = await targetRep.create({
         foo: 'fooVal',
         bar: 'barVal',
@@ -497,7 +497,7 @@ describe('BelongsToResolver', function () {
         [DEF_PK]: source[DEF_PK],
         parentId: target[DEF_PK],
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includeTo([source], 'source', 'target', 'parent', undefined, {
         where: {and: [{foo: 'barVal'}]},
         fields: [DEF_PK, 'bar'],
@@ -523,8 +523,8 @@ describe('BelongsToResolver', function () {
 
   describe('includePolymorphicTo', function () {
     it('requires the "entities" parameter to be an array', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(BelongsToResolver);
       const error = v =>
         format(
           'The parameter "entities" of BelongsToResolver.includePolymorphicTo requires ' +
@@ -544,8 +544,8 @@ describe('BelongsToResolver', function () {
     });
 
     it('requires elements of the "entities" parameter to be an Object', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(BelongsToResolver);
       const error = v =>
         format(
           'The parameter "entities" of BelongsToResolver.includePolymorphicTo requires ' +
@@ -565,8 +565,8 @@ describe('BelongsToResolver', function () {
     });
 
     it('requires the "sourceName" parameter to be a non-empty string', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(BelongsToResolver);
       const error = v =>
         format(
           'The parameter "sourceName" of BelongsToResolver.includePolymorphicTo requires ' +
@@ -586,8 +586,8 @@ describe('BelongsToResolver', function () {
     });
 
     it('requires the "relationName" parameter to be a non-empty string', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(BelongsToResolver);
       const error = v =>
         format(
           'The parameter "relationName" of BelongsToResolver.includePolymorphicTo requires ' +
@@ -606,8 +606,8 @@ describe('BelongsToResolver', function () {
     });
 
     it('requires the provided parameter "foreignKey" to be a string', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(BelongsToResolver);
       const error = v =>
         format(
           'The provided parameter "foreignKey" of BelongsToResolver.includePolymorphicTo ' +
@@ -623,8 +623,8 @@ describe('BelongsToResolver', function () {
     });
 
     it('requires the provided parameter "discriminator" to be a string', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(BelongsToResolver);
       const error = v =>
         format(
           'The provided parameter "discriminator" of BelongsToResolver.includePolymorphicTo ' +
@@ -640,8 +640,8 @@ describe('BelongsToResolver', function () {
     });
 
     it('requires the provided parameter "scope" to be an object', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(BelongsToResolver);
       const error = v =>
         format(
           'The provided parameter "scope" of BelongsToResolver.includePolymorphicTo ' +
@@ -664,35 +664,35 @@ describe('BelongsToResolver', function () {
     });
 
     it('does not throw an error if a target model is not found', async function () {
-      const S = new DatabaseSchema();
-      S.defineModel({name: 'source'});
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      dbs.defineModel({name: 'source'});
+      const R = dbs.getService(BelongsToResolver);
       const entity = {[DEF_PK]: 1, parentId: 1, parentType: 'target'};
       await R.includePolymorphicTo([entity], 'source', 'parent');
       expect(entity).to.be.eql(entity);
     });
 
     it('does not throws an error if a target model does not have datasource', async function () {
-      const S = new DatabaseSchema();
-      S.defineModel({name: 'source'});
-      S.defineModel({name: 'target'});
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      dbs.defineModel({name: 'source'});
+      dbs.defineModel({name: 'target'});
+      const R = dbs.getService(BelongsToResolver);
       const entity = {[DEF_PK]: 1, parentId: 1, parentType: 'target'};
       await R.includePolymorphicTo([entity], 'source', 'parent');
       expect(entity).to.be.eql(entity);
     });
 
     it('does not throw an error if a relation target is not found', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRel = S.getRepository('source');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRel = dbs.getRepository('source');
       const source = await sourceRel.create({
         parentId: 10,
         parentType: 'target',
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includePolymorphicTo([source], 'source', 'parent');
       expect(source).to.be.eql({
         [DEF_PK]: source[DEF_PK],
@@ -702,21 +702,21 @@ describe('BelongsToResolver', function () {
     });
 
     it('does not throw an error if no discriminator value', async function () {
-      const S = new DatabaseSchema();
-      S.defineModel({name: 'source'});
-      const R = S.getService(BelongsToResolver);
+      const dbs = new DatabaseSchema();
+      dbs.defineModel({name: 'source'});
+      const R = dbs.getService(BelongsToResolver);
       const entity = {[DEF_PK]: 1, parentId: 1};
       await R.includePolymorphicTo([entity], 'source', 'parent');
       expect(entity).to.be.eql(entity);
     });
 
     it('includes if a primary key is not defined in the target model', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target = await targetRep.create({});
       expect(target).to.be.eql({[DEF_PK]: target[DEF_PK]});
       const source = await sourceRep.create({
@@ -728,7 +728,7 @@ describe('BelongsToResolver', function () {
         parentId: target[DEF_PK],
         parentType: 'target',
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includePolymorphicTo([source], 'source', 'parent');
       expect(source).to.be.eql({
         [DEF_PK]: source[DEF_PK],
@@ -739,9 +739,9 @@ describe('BelongsToResolver', function () {
     });
 
     it('includes if the source model has a custom primary key', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({
         name: 'source',
         datasource: 'datasource',
         properties: {
@@ -751,9 +751,9 @@ describe('BelongsToResolver', function () {
           },
         },
       });
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target = await targetRep.create({});
       expect(target).to.be.eql({[DEF_PK]: target[DEF_PK]});
       const source = await sourceRep.create({
@@ -765,7 +765,7 @@ describe('BelongsToResolver', function () {
         parentId: target[DEF_PK],
         parentType: 'target',
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includePolymorphicTo([source], 'source', 'parent');
       expect(source).to.be.eql({
         myId: source.myId,
@@ -776,12 +776,12 @@ describe('BelongsToResolver', function () {
     });
 
     it('includes if the property "foreignKey" is specified', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target = await targetRep.create({});
       expect(target).to.be.eql({[DEF_PK]: target[DEF_PK]});
       const source = await sourceRep.create({
@@ -793,7 +793,7 @@ describe('BelongsToResolver', function () {
         parentId: target[DEF_PK],
         relationType: 'target',
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includePolymorphicTo([source], 'source', 'relation', 'parentId');
       expect(source).to.be.eql({
         [DEF_PK]: source[DEF_PK],
@@ -804,12 +804,12 @@ describe('BelongsToResolver', function () {
     });
 
     it('includes if the property "discriminator" is specified', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target = await targetRep.create({});
       expect(target).to.be.eql({[DEF_PK]: target[DEF_PK]});
       const source = await sourceRep.create({
@@ -821,7 +821,7 @@ describe('BelongsToResolver', function () {
         relationId: target[DEF_PK],
         parentType: 'target',
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includePolymorphicTo(
         [source],
         'source',
@@ -838,12 +838,12 @@ describe('BelongsToResolver', function () {
     });
 
     it('uses a where clause of the given scope to filter the relation target', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target = await targetRep.create({
         foo: 'fooVal',
         bar: 'barVal',
@@ -862,7 +862,7 @@ describe('BelongsToResolver', function () {
         parentId: target[DEF_PK],
         parentType: 'target',
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includePolymorphicTo(
         [source],
         'source',
@@ -893,12 +893,12 @@ describe('BelongsToResolver', function () {
     });
 
     it('uses a fields clause of the given scope to filter the relation target', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target = await targetRep.create({
         foo: 'fooVal',
         bar: 'barVal',
@@ -917,7 +917,7 @@ describe('BelongsToResolver', function () {
         parentId: target[DEF_PK],
         parentType: 'target',
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includePolymorphicTo(
         [source],
         'source',
@@ -938,12 +938,12 @@ describe('BelongsToResolver', function () {
     });
 
     it('uses an include clause of the given scope to resolve target relations', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({
         name: 'datasource',
         adapter: 'memory',
       });
-      S.defineModel({
+      dbs.defineModel({
         name: 'modelA',
         datasource: 'datasource',
         properties: {
@@ -957,7 +957,7 @@ describe('BelongsToResolver', function () {
           },
         },
       });
-      S.defineModel({
+      dbs.defineModel({
         name: 'modelB',
         datasource: 'datasource',
         properties: {
@@ -977,7 +977,7 @@ describe('BelongsToResolver', function () {
           },
         },
       });
-      S.defineModel({
+      dbs.defineModel({
         name: 'modelC',
         datasource: 'datasource',
         properties: {
@@ -997,9 +997,9 @@ describe('BelongsToResolver', function () {
           },
         },
       });
-      const aRep = S.getRepository('modelA');
-      const bRep = S.getRepository('modelB');
-      const cRep = S.getRepository('modelC');
+      const aRep = dbs.getRepository('modelA');
+      const bRep = dbs.getRepository('modelB');
+      const cRep = dbs.getRepository('modelC');
       const a = await aRep.create({});
       const b = await bRep.create({parentId: a.id});
       const c = await cRep.create({parentId: b.id, parentType: 'modelB'});
@@ -1018,7 +1018,7 @@ describe('BelongsToResolver', function () {
         parentId: b.id,
         parentType: 'modelB',
       });
-      const R = S.getService(BelongsToResolver);
+      const R = dbs.getService(BelongsToResolver);
       await R.includePolymorphicTo(
         [c],
         'modelC',

src/relations/references-many-resolver.spec.js

@@ -9,8 +9,8 @@ import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '../definition/index.j
 describe('ReferencesManyResolver', function () {
   describe('includeTo', function () {
     it('requires the "entities" parameter to be an array', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(ReferencesManyResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(ReferencesManyResolver);
       const error = v =>
         format(
           'The parameter "entities" of ReferencesManyResolver.includeTo requires ' +
@@ -30,8 +30,8 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('requires elements of the "entities" parameter to be an Object', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(ReferencesManyResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(ReferencesManyResolver);
       const error = v =>
         format(
           'The parameter "entities" of ReferencesManyResolver.includeTo requires ' +
@@ -51,8 +51,8 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('requires the "sourceName" parameter to be a non-empty string', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(ReferencesManyResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(ReferencesManyResolver);
       const error = v =>
         format(
           'The parameter "sourceName" of ReferencesManyResolver.includeTo requires ' +
@@ -71,8 +71,8 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('requires the "targetName" parameter to be a non-empty string', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(ReferencesManyResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(ReferencesManyResolver);
       const error = v =>
         format(
           'The parameter "targetName" of ReferencesManyResolver.includeTo requires ' +
@@ -91,8 +91,8 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('requires the "relationName" parameter to be a non-empty string', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(ReferencesManyResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(ReferencesManyResolver);
       const error = v =>
         format(
           'The parameter "relationName" of ReferencesManyResolver.includeTo requires ' +
@@ -111,8 +111,8 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('requires the provided parameter "foreignKey" to be a string', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(ReferencesManyResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(ReferencesManyResolver);
       const error = v =>
         format(
           'The provided parameter "foreignKey" of ReferencesManyResolver.includeTo ' +
@@ -128,8 +128,8 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('requires the provided parameter "scope" to be an object', async function () {
-      const S = new DatabaseSchema();
-      const R = S.getService(ReferencesManyResolver);
+      const dbs = new DatabaseSchema();
+      const R = dbs.getService(ReferencesManyResolver);
       const error = v =>
         format(
           'The provided parameter "scope" of ReferencesManyResolver.includeTo ' +
@@ -152,9 +152,9 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('throws an error if the given target model is not found', async function () {
-      const S = new DatabaseSchema();
-      S.defineModel({name: 'source'});
-      const R = S.getService(ReferencesManyResolver);
+      const dbs = new DatabaseSchema();
+      dbs.defineModel({name: 'source'});
+      const R = dbs.getService(ReferencesManyResolver);
       const promise = R.includeTo([], 'source', 'target', 'relation');
       await expect(promise).to.be.rejectedWith(
         'The model "target" is not defined',
@@ -162,9 +162,9 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('throws an error if the given target model does not have a datasource', async function () {
-      const S = new DatabaseSchema();
-      S.defineModel({name: 'target'});
-      const R = S.getService(ReferencesManyResolver);
+      const dbs = new DatabaseSchema();
+      dbs.defineModel({name: 'target'});
+      const R = dbs.getService(ReferencesManyResolver);
       const promise = R.includeTo([], 'source', 'target', 'relation');
       await expect(promise).to.be.rejectedWith(
         'The model "target" does not have a specified datasource.',
@@ -172,13 +172,13 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('does not throw an error if a relation target is not found', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRel = S.getRepository('source');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRel = dbs.getRepository('source');
       const source = await sourceRel.create({parentIds: [10, 20]});
-      const R = S.getService(ReferencesManyResolver);
+      const R = dbs.getService(ReferencesManyResolver);
       await R.includeTo([source], 'source', 'target', 'parents');
       expect(source).to.be.eql({
         [DEF_PK]: source[DEF_PK],
@@ -188,12 +188,12 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('includes if a primary key is not defined in the target model', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target1 = await targetRep.create({});
       const target2 = await targetRep.create({});
       const target3 = await targetRep.create({});
@@ -207,7 +207,7 @@ describe('ReferencesManyResolver', function () {
         [DEF_PK]: source[DEF_PK],
         parentIds: [target1[DEF_PK], target2[DEF_PK]],
       });
-      const R = S.getService(ReferencesManyResolver);
+      const R = dbs.getService(ReferencesManyResolver);
       await R.includeTo([source], 'source', 'target', 'parents');
       expect(source).to.be.eql({
         [DEF_PK]: source[DEF_PK],
@@ -217,10 +217,10 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('includes if the target model has a custom primary key', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({
         name: 'target',
         datasource: 'datasource',
         properties: {
@@ -230,8 +230,8 @@ describe('ReferencesManyResolver', function () {
           },
         },
       });
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target1 = await targetRep.create({});
       const target2 = await targetRep.create({});
       const target3 = await targetRep.create({});
@@ -245,7 +245,7 @@ describe('ReferencesManyResolver', function () {
         [DEF_PK]: source[DEF_PK],
         parentIds: [target1.myId, target2.myId],
       });
-      const R = S.getService(ReferencesManyResolver);
+      const R = dbs.getService(ReferencesManyResolver);
       await R.includeTo([source], 'source', 'target', 'parents');
       expect(source).to.be.eql({
         [DEF_PK]: source[DEF_PK],
@@ -255,9 +255,9 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('includes if the source model has a custom primary key', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({
         name: 'source',
         datasource: 'datasource',
         properties: {
@@ -267,9 +267,9 @@ describe('ReferencesManyResolver', function () {
           },
         },
       });
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target1 = await targetRep.create({});
       const target2 = await targetRep.create({});
       const target3 = await targetRep.create({});
@@ -283,7 +283,7 @@ describe('ReferencesManyResolver', function () {
         myId: source.myId,
         parentIds: [target1[DEF_PK], target2[DEF_PK]],
       });
-      const R = S.getService(ReferencesManyResolver);
+      const R = dbs.getService(ReferencesManyResolver);
       await R.includeTo([source], 'source', 'target', 'parents');
       expect(source).to.be.eql({
         myId: source.myId,
@@ -293,12 +293,12 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('includes if the property "foreignKey" is specified', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target1 = await targetRep.create({});
       const target2 = await targetRep.create({});
       const target3 = await targetRep.create({});
@@ -312,7 +312,7 @@ describe('ReferencesManyResolver', function () {
         [DEF_PK]: source[DEF_PK],
         parentIds: [target1[DEF_PK], target2[DEF_PK]],
       });
-      const R = S.getService(ReferencesManyResolver);
+      const R = dbs.getService(ReferencesManyResolver);
       await R.includeTo([source], 'source', 'target', 'relations', 'parentIds');
       expect(source).to.be.eql({
         [DEF_PK]: source[DEF_PK],
@@ -322,12 +322,12 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('uses a where clause of the given scope to filter the relation target', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target1 = await targetRep.create({featured: false});
       const target2 = await targetRep.create({featured: true});
       const target3 = await targetRep.create({featured: true});
@@ -341,7 +341,7 @@ describe('ReferencesManyResolver', function () {
         [DEF_PK]: source[DEF_PK],
         parentIds: [target1[DEF_PK], target2[DEF_PK], target3[DEF_PK]],
       });
-      const R = S.getService(ReferencesManyResolver);
+      const R = dbs.getService(ReferencesManyResolver);
       await R.includeTo([source], 'source', 'target', 'parents', undefined, {
         where: {featured: false},
       });
@@ -362,12 +362,12 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('uses a slice clause of the given scope to filter the relation target', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target1 = await targetRep.create({});
       const target2 = await targetRep.create({});
       const target3 = await targetRep.create({});
@@ -393,7 +393,7 @@ describe('ReferencesManyResolver', function () {
           target4[DEF_PK],
         ],
       });
-      const R = S.getService(ReferencesManyResolver);
+      const R = dbs.getService(ReferencesManyResolver);
       await R.includeTo([source], 'source', 'target', 'parents', undefined, {
         skip: 1,
         limit: 2,
@@ -406,12 +406,12 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('uses a fields clause of the given scope to filter the relation target', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target1 = await targetRep.create({
         foo: 'fooVal1',
         bar: 'barVal1',
@@ -446,7 +446,7 @@ describe('ReferencesManyResolver', function () {
         [DEF_PK]: source[DEF_PK],
         parentIds: [target1[DEF_PK], target2[DEF_PK]],
       });
-      const R = S.getService(ReferencesManyResolver);
+      const R = dbs.getService(ReferencesManyResolver);
       await R.includeTo([source], 'source', 'target', 'parents', undefined, {
         fields: [DEF_PK, 'bar'],
       });
@@ -467,12 +467,12 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('uses an include clause of the given scope to resolve target relations', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({
         name: 'datasource',
         adapter: 'memory',
       });
-      S.defineModel({
+      dbs.defineModel({
         name: 'modelA',
         datasource: 'datasource',
         properties: {
@@ -486,7 +486,7 @@ describe('ReferencesManyResolver', function () {
           },
         },
       });
-      S.defineModel({
+      dbs.defineModel({
         name: 'modelB',
         datasource: 'datasource',
         properties: {
@@ -506,7 +506,7 @@ describe('ReferencesManyResolver', function () {
           },
         },
       });
-      S.defineModel({
+      dbs.defineModel({
         name: 'modelC',
         datasource: 'datasource',
         properties: {
@@ -526,9 +526,9 @@ describe('ReferencesManyResolver', function () {
           },
         },
       });
-      const aRep = S.getRepository('modelA');
-      const bRep = S.getRepository('modelB');
-      const cRep = S.getRepository('modelC');
+      const aRep = dbs.getRepository('modelA');
+      const bRep = dbs.getRepository('modelB');
+      const cRep = dbs.getRepository('modelC');
       const a1 = await aRep.create({});
       const a2 = await aRep.create({});
       const b1 = await bRep.create({parentId: a1.id});
@@ -557,7 +557,7 @@ describe('ReferencesManyResolver', function () {
         source: 'modelC',
         parentIds: [b1.id, b2.id],
       });
-      const R = S.getService(ReferencesManyResolver);
+      const R = dbs.getService(ReferencesManyResolver);
       await R.includeTo([c], 'modelC', 'modelB', 'parents', undefined, {
         include: 'parent',
       });
@@ -589,12 +589,12 @@ describe('ReferencesManyResolver', function () {
     });
 
     it('does not break the "and" operator of the given "where" clause', async function () {
-      const S = new DatabaseSchema();
-      S.defineDatasource({name: 'datasource', adapter: 'memory'});
-      S.defineModel({name: 'source', datasource: 'datasource'});
-      S.defineModel({name: 'target', datasource: 'datasource'});
-      const sourceRep = S.getRepository('source');
-      const targetRep = S.getRepository('target');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'source', datasource: 'datasource'});
+      dbs.defineModel({name: 'target', datasource: 'datasource'});
+      const sourceRep = dbs.getRepository('source');
+      const targetRep = dbs.getRepository('target');
       const target1 = await targetRep.create({featured: false});
       const target2 = await targetRep.create({featured: true});
       const target3 = await targetRep.create({featured: true});
@@ -608,7 +608,7 @@ describe('ReferencesManyResolver', function () {
         [DEF_PK]: source[DEF_PK],
         parentIds: [target1[DEF_PK], target2[DEF_PK], target3[DEF_PK]],
       });
-      const R = S.getService(ReferencesManyResolver);
+      const R = dbs.getService(ReferencesManyResolver);
       await R.includeTo([source], 'source', 'target', 'parents', undefined, {
         where: {and: [{featured: false}]},
       });

src/repository/repository-registry.spec.js

@@ -7,10 +7,10 @@ describe('RepositoryRegistry', function () {
   describe('setRepositoryCtor', function () {
     it('sets a given class as the repository constructor', function () {
       class MyRepository extends Repository {}
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const registry = schema.getService(RepositoryRegistry);
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const registry = dbs.getService(RepositoryRegistry);
       registry.setRepositoryCtor(MyRepository);
       const rep = registry.getRepository('model');
       expect(rep).to.be.instanceof(Repository);
@@ -20,11 +20,11 @@ describe('RepositoryRegistry', function () {
 
   describe('getRepository', function () {
     it('uses a given model name to return an existing repository or create the new', function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'modelA', datasource: 'datasource'});
-      schema.defineModel({name: 'modelB', datasource: 'datasource'});
-      const registry = schema.getService(RepositoryRegistry);
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'modelA', datasource: 'datasource'});
+      dbs.defineModel({name: 'modelB', datasource: 'datasource'});
+      const registry = dbs.getService(RepositoryRegistry);
       const repA1 = registry.getRepository('modelA');
       const repA2 = registry.getRepository('modelA');
       const repB1 = registry.getRepository('modelB');

src/repository/repository.spec.js

@@ -5,11 +5,11 @@ import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '../definition/index.j
 describe('Repository', function () {
   describe('create', function () {
     it('creates a new item from the given data', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
       const data = {foo: 'bar'};
-      const rep = schema.getRepository('model');
+      const rep = dbs.getRepository('model');
       const result = await rep.create(data);
       expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], ...data});
     });
@@ -17,10 +17,10 @@ describe('Repository', function () {
 
   describe('replaceById', function () {
     it('replaces an item by the given id', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       const created = await rep.create({foo: 'bar'});
       const result = await rep.replaceById(created[DEF_PK], {baz: 'qux'});
       expect(result).to.be.eql({[DEF_PK]: created[DEF_PK], baz: 'qux'});
@@ -29,20 +29,20 @@ describe('Repository', function () {
 
   describe('replaceOrCreate', function () {
     it('creates a new item from the given data', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
       const data = {foo: 'bar'};
-      const rep = schema.getRepository('model');
+      const rep = dbs.getRepository('model');
       const result = await rep.replaceOrCreate(data);
       expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], ...data});
     });
 
     it('replaces an existing item', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       const created = await rep.create({foo: 'bar'});
       const replacer = {[DEF_PK]: created[DEF_PK], bar: 'qux'};
       const result = await rep.replaceOrCreate(replacer);
@@ -52,10 +52,10 @@ describe('Repository', function () {
 
   describe('patch', function () {
     it('patches all items', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       await rep.create({foo: 'a1', bar: 'b1'});
       await rep.create({foo: 'a2', bar: 'b2'});
       await rep.create({foo: 'a3', bar: 'b3'});
@@ -64,10 +64,10 @@ describe('Repository', function () {
     });
 
     it('patches found items by the "where" clause', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       await rep.create({foo: 'a', bar: '1'});
       await rep.create({foo: 'b', bar: '2'});
       await rep.create({foo: 'c', bar: '2'});
@@ -78,10 +78,10 @@ describe('Repository', function () {
 
   describe('patchById', function () {
     it('patches an item by the given id', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       const created = await rep.create({foo: 'bar'});
       const result = await rep.patchById(created[DEF_PK], {baz: 'qux'});
       expect(result).to.be.eql({
@@ -94,10 +94,10 @@ describe('Repository', function () {
 
   describe('find', function () {
     it('returns all items', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       const created1 = await rep.create({foo: 'bar'});
       const created2 = await rep.create({baz: 'qux'});
       const result = await rep.find();
@@ -105,10 +105,10 @@ describe('Repository', function () {
     });
 
     it('returns found items by the "where" clause', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       await rep.create({foo: 'bar'});
       const created = await rep.create({baz: 'qux'});
       const result = await rep.find({where: {baz: 'qux'}});
@@ -118,10 +118,10 @@ describe('Repository', function () {
 
   describe('findOne', function () {
     it('returns a first item', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       const created = await rep.create({foo: 'bar'});
       await rep.create({baz: 'qux'});
       const result = await rep.findOne();
@@ -129,10 +129,10 @@ describe('Repository', function () {
     });
 
     it('returns a found item by the "where" clause', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       await rep.create({foo: 'bar'});
       const created = await rep.create({baz: 'qux'});
       const result = await rep.findOne({where: {baz: 'qux'}});
@@ -142,10 +142,10 @@ describe('Repository', function () {
 
   describe('findById', function () {
     it('returns an item by the given id', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       const created = await rep.create({foo: 'bar'});
       const result = await rep.findById(created[DEF_PK]);
       expect(result).to.be.eql(created);
@@ -154,10 +154,10 @@ describe('Repository', function () {
 
   describe('delete', function () {
     it('removes all items', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       await rep.create({foo: 'bar'});
       await rep.create({baz: 'qux'});
       const result = await rep.delete();
@@ -165,10 +165,10 @@ describe('Repository', function () {
     });
 
     it('removes found items by the "where" clause', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       await rep.create({foo: 'bar'});
       await rep.create({foo: 'bar'});
       await rep.create({baz: 'qux'});
@@ -179,10 +179,10 @@ describe('Repository', function () {
 
   describe('deleteById', function () {
     it('removes an item by the given id', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       const created = await rep.create({foo: 'bar'});
       const result = await rep.deleteById(created[DEF_PK]);
       expect(result).to.be.true;
@@ -191,10 +191,10 @@ describe('Repository', function () {
 
   describe('exists', function () {
     it('returns true if the given id exists', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       const created = await rep.create({foo: 'bar'});
       const result = await rep.exists(created[DEF_PK]);
       expect(result).to.be.true;
@@ -203,10 +203,10 @@ describe('Repository', function () {
 
   describe('count', function () {
     it('counts all items', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       await rep.create({foo: 'bar'});
       await rep.create({baz: 'qux'});
       const result = await rep.count();
@@ -214,10 +214,10 @@ describe('Repository', function () {
     });
 
     it('counts found items by the "where" clause', async function () {
-      const schema = new DatabaseSchema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const rep = schema.getRepository('model');
+      const dbs = new DatabaseSchema();
+      dbs.defineDatasource({name: 'datasource', adapter: 'memory'});
+      dbs.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = dbs.getRepository('model');
       await rep.create({foo: 'bar'});
       await rep.create({foo: 'bar'});
       await rep.create({baz: 'qux'});