@e22m4u/js-repository 0.2.7 → 0.3.0

package/src/repository/repository.spec.js

@@ -1,15 +1,15 @@
 import {expect} from 'chai';
-import {Schema} from '../schema.js';
+import {DatabaseSchema} from '../database-schema.js';
 import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '../definition/index.js';
 
 describe('Repository', function () {
   describe('create', function () {
     it('creates a new item from the given data', async function () {
-      const schema = new Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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 Schema();
-      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'});

package/src/utils/is-promise.spec.js

@@ -1,8 +1,7 @@
 import {expect} from 'chai';
-import {describe} from 'mocha';
 import {isPromise} from './is-promise.js';
 
-describe('isPromise', () => {
+describe('isPromise', function () {
   it('returns true if the given value has type of PromiseLike', function () {
     expect(isPromise(Promise.resolve())).to.be.true;
     expect(isPromise('string')).to.be.false;

package/src/utils/transform-promise.spec.js

@@ -1,5 +1,4 @@
 import {expect} from 'chai';
-import {describe} from 'mocha';
 import {transformPromise} from './transform-promise.js';
 
 describe('transformPromise', function () {

package/src/schema.spec.ts

@@ -1,86 +0,0 @@
-import {expect} from 'chai';
-import {Schema} from './schema.js';
-import {Repository} from './repository/index.js';
-import {DefinitionRegistry} from './definition/index.js';
-
-describe('Schema', function () {
-  describe('defineDatasource', function () {
-    it('returns this', function () {
-      const schema = new Schema();
-      const res = schema.defineDatasource({
-        name: 'datasource',
-        adapter: 'memory',
-      });
-      expect(res).to.be.eq(schema);
-    });
-
-    it('sets the datasource definition', function () {
-      const schema = new Schema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      const res =
-        schema.getService(DefinitionRegistry).getDatasource('datasource');
-      expect(res).to.be.eql({name: 'datasource', adapter: 'memory'});
-    });
-
-    it('throws an error if the datasource name already defined', function () {
-      const schema = new Schema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      const throwable =
-        () => schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      expect(throwable).to.throw(
-        'The datasource "datasource" is already defined.',
-      );
-    });
-  });
-
-  describe('defineModel', function () {
-    it('returns this', function () {
-      const schema = new Schema();
-      const res = schema.defineModel({name: 'model'});
-      expect(res).to.be.eq(schema);
-    });
-
-    it('sets the model definition', function () {
-      const schema = new Schema();
-      schema.defineModel({name: 'model'});
-      const res = schema.getService(DefinitionRegistry).getModel('model');
-      expect(res).to.be.eql({name: 'model'});
-    });
-
-    it('throws an error if the model name already defined', function () {
-      const schema = new Schema();
-      schema.defineModel({name: 'model'});
-      const throwable = () => schema.defineModel({name: 'model'});
-      expect(throwable).to.throw('The model "model" is already defined.');
-    });
-  });
-
-  describe('getRepository', function () {
-    it('returns a repository by the model name', function () {
-      const schema = new Schema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      const res = schema.getRepository('model');
-      expect(res).to.be.instanceof(Repository);
-    });
-
-    it('throws an error if the model is not defined', function () {
-      const schema = new Schema();
-      const throwable = () => schema.getRepository('model');
-      expect(throwable).to.throw('The model "model" is not defined.');
-    });
-
-    it('uses generic types to define the repository type', function () {
-      const schema = new Schema();
-      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
-      schema.defineModel({name: 'model', datasource: 'datasource'});
-      interface MyModel {
-        myId: number;
-      }
-      const res1: Repository = schema.getRepository('model');
-      const res2: Repository<MyModel, number, 'myId'> =
-        schema.getRepository<MyModel, number, 'myId'>('model');
-      expect(res1).to.be.eq(res2);
-    });
-  });
-});