@e22m4u/js-repository 0.2.7 → 0.3.1

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

@@ -1,16 +1,16 @@
 import {expect} from 'chai';
-import {Schema} from '../schema.js';
 import {format} from '@e22m4u/js-format';
 import {DataType} from '../definition/index.js';
 import {RelationType} from '../definition/index.js';
+import {DatabaseSchema} from '../database-schema.js';
 import {ReferencesManyResolver} from './references-many-resolver.js';
 import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '../definition/index.js';
 
 describe('ReferencesManyResolver', function () {
   describe('includeTo', function () {
     it('requires the "entities" parameter to be an array', async function () {
-      const S = new Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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}]},
       });

package/src/repository/repository-registry.spec.js

@@ -1,16 +1,16 @@
 import {expect} from 'chai';
-import {Schema} from '../schema.js';
 import {Repository} from './repository.js';
+import {DatabaseSchema} from '../database-schema.js';
 import {RepositoryRegistry} from './repository-registry.js';
 
 describe('RepositoryRegistry', function () {
   describe('setRepositoryCtor', function () {
     it('sets a given class as the repository constructor', function () {
       class MyRepository extends Repository {}
-      const schema = new Schema();
-      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 Schema();
-      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');