Skip to content

Commit

Permalink
feat(core): Update QueryService to allow additional filtering
Browse files Browse the repository at this point in the history
  • Loading branch information
@doug-martin
doug-martin committed Aug 31, 2020
1 parent 8d40636 commit 474369b
Show file tree
Hide file tree
Showing 20 changed files with 445 additions and 95 deletions.
138 changes: 129 additions & 9 deletions packages/core/__tests__/services/assembler-query.service.spec.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -80,11 +80,21 @@ describe('AssemblerQueryService', () => {
it('should transform the results', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(mockQueryService.findById(1)).thenResolve({ bar: 'bar' });
when(mockQueryService.findById(1, undefined)).thenResolve({ bar: 'bar' });

return expect(assemblerService.findById(1)).resolves.toEqual({ foo: 'bar' });
});

it('should transform a filter if provided', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(mockQueryService.findById(1, objectContaining({ filter: { bar: { eq: 'bar' } } }))).thenResolve({
bar: 'bar',
});

return expect(assemblerService.findById(1, { filter: { foo: { eq: 'bar' } } })).resolves.toEqual({ foo: 'bar' });
});

it('should not transform the results if undefined', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
Expand Down Expand Up @@ -274,7 +284,7 @@ describe('AssemblerQueryService', () => {
const dto: TestDTO = { foo: 'bar' };
const entity: TestEntity = { bar: 'bar' };
const result: TestDTO = { foo: 'baz' };
when(mockQueryService.findRelation(TestDTO, 'test', deepEqual([entity]))).thenCall(
when(mockQueryService.findRelation(TestDTO, 'test', deepEqual([entity]), undefined)).thenCall(
(relationClass, relation, entities) => {
return Promise.resolve(
new Map<TestEntity, TestDTO>([[entities[0], result]]),
Expand All @@ -291,56 +301,136 @@ describe('AssemblerQueryService', () => {
it('should transform the results for a single entity', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(mockQueryService.addRelations('test', 1, deepEqual([2, 3, 4]))).thenResolve({
when(mockQueryService.addRelations('test', 1, deepEqual([2, 3, 4]), undefined)).thenResolve({
bar: 'baz',
});

return expect(assemblerService.addRelations('test', 1, [2, 3, 4])).resolves.toEqual({ foo: 'baz' });
});

it('should transform the filter and results for a single entity', async () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(
mockQueryService.addRelations(
'test',
1,
deepEqual([2, 3, 4]),
objectContaining({ filter: { bar: { eq: 'bar' } } }),
),
).thenResolve({
bar: 'baz',
});
const addResult = await assemblerService.addRelations('test', 1, [2, 3, 4], {
filter: { foo: { eq: 'bar' } },
});
return expect(addResult).toEqual({ foo: 'baz' });
});
});
describe('setRelation', () => {
it('should transform the results for a single entity', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(mockQueryService.setRelation('test', 1, 2)).thenResolve({
when(mockQueryService.setRelation('test', 1, 2, undefined)).thenResolve({
bar: 'baz',
});

return expect(assemblerService.setRelation('test', 1, 2)).resolves.toEqual({ foo: 'baz' });
});
it('should transform the options and results for a single entity', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(
mockQueryService.setRelation('test', 1, 2, objectContaining({ filter: { bar: { eq: 'bar' } } })),
).thenResolve({
bar: 'baz',
});

return expect(
assemblerService.setRelation('test', 1, 2, {
filter: { foo: { eq: 'bar' } },
}),
).resolves.toEqual({ foo: 'baz' });
});
});

describe('removeRelations', () => {
it('should transform the results for a single entity', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(mockQueryService.removeRelations('test', 1, deepEqual([2, 3, 4]))).thenResolve({
when(mockQueryService.removeRelations('test', 1, deepEqual([2, 3, 4]), undefined)).thenResolve({
bar: 'baz',
});

return expect(assemblerService.removeRelations('test', 1, [2, 3, 4])).resolves.toEqual({ foo: 'baz' });
});

it('should transform the options and results for a single entity', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(
mockQueryService.removeRelations(
'test',
1,
deepEqual([2, 3, 4]),
objectContaining({ filter: { bar: { eq: 'bar' } } }),
),
).thenResolve({
bar: 'baz',
});

return expect(
assemblerService.removeRelations('test', 1, [2, 3, 4], {
filter: { foo: { eq: 'bar' } },
}),
).resolves.toEqual({ foo: 'baz' });
});
});
describe('removeRelation', () => {
it('should transform the results for a single entity', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(mockQueryService.removeRelation('test', 1, 2)).thenResolve({
when(mockQueryService.removeRelation('test', 1, 2, undefined)).thenResolve({
bar: 'baz',
});

return expect(assemblerService.removeRelation('test', 1, 2)).resolves.toEqual({ foo: 'baz' });
});
it('should transform the options and results for a single entity', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(
mockQueryService.removeRelation('test', 1, 2, objectContaining({ filter: { bar: { eq: 'bar' } } })),
).thenResolve({
bar: 'baz',
});

return expect(
assemblerService.removeRelation('test', 1, 2, {
filter: { foo: { eq: 'bar' } },
}),
).resolves.toEqual({ foo: 'baz' });
});
});

describe('getById', () => {
it('should transform the results', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(mockQueryService.getById(1)).thenResolve({ bar: 'bar' });
when(mockQueryService.getById(1, undefined)).thenResolve({ bar: 'bar' });

return expect(assemblerService.getById(1)).resolves.toEqual({ foo: 'bar' });
});

it('should transform the filter and results', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(mockQueryService.getById(1, deepEqual({ filter: { bar: { eq: 'bar' } } }))).thenResolve({
bar: 'bar',
});

return expect(assemblerService.getById(1, { filter: { foo: { eq: 'bar' } } })).resolves.toEqual({ foo: 'bar' });
});
});

describe('createOne', () => {
Expand Down Expand Up @@ -369,12 +459,32 @@ describe('AssemblerQueryService', () => {
it('should transform the results for a single entity', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(mockQueryService.updateOne(1, objectContaining({ bar: 'baz' }))).thenResolve({
when(mockQueryService.updateOne(1, objectContaining({ bar: 'baz' }), undefined)).thenResolve({
bar: 'baz',
});

return expect(assemblerService.updateOne(1, { foo: 'baz' })).resolves.toEqual({ foo: 'baz' });
});

it('should transform the filter and results for a single entity', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(
mockQueryService.updateOne(
1,
objectContaining({ bar: 'baz' }),
objectContaining({ filter: { bar: { eq: 'bar' } } }),
),
).thenResolve({
bar: 'baz',
});

return expect(assemblerService.updateOne(1, { foo: 'baz' }, { filter: { foo: { eq: 'bar' } } })).resolves.toEqual(
{
foo: 'baz',
},
);
});
});

describe('updateMany', () => {
Expand All @@ -395,12 +505,22 @@ describe('AssemblerQueryService', () => {
it('should transform the results for a single entity', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(mockQueryService.deleteOne(1)).thenResolve({
when(mockQueryService.deleteOne(1, undefined)).thenResolve({
bar: 'baz',
});

return expect(assemblerService.deleteOne(1)).resolves.toEqual({ foo: 'baz' });
});

it('should transform the filter and results for a single entity', () => {
const mockQueryService = mock<QueryService<TestEntity>>();
const assemblerService = new AssemblerQueryService(new TestAssembler(), instance(mockQueryService));
when(mockQueryService.deleteOne(1, objectContaining({ filter: { bar: { eq: 'bar' } } }))).thenResolve({
bar: 'baz',
});

return expect(assemblerService.deleteOne(1, { filter: { foo: { eq: 'bar' } } })).resolves.toEqual({ foo: 'baz' });
});
});

describe('deleteMany', () => {
Expand Down
20 changes: 10 additions & 10 deletions packages/core/__tests__/services/proxy-query.service.spec.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,7 @@ describe('ProxyQueryService', () => {
const id = 1;
const relationIds = [1, 2, 3];
const result = { foo: 'bar' };
when(mockQueryService.addRelations(relationName, id, relationIds)).thenResolve(result);
when(mockQueryService.addRelations(relationName, id, relationIds, undefined)).thenResolve(result);
return expect(queryService.addRelations(relationName, id, relationIds)).resolves.toBe(result);
});
it('should proxy to the underlying service when calling createMany', () => {
Expand All @@ -38,33 +38,33 @@ describe('ProxyQueryService', () => {
});
it('should proxy to the underlying service when calling deleteOne', () => {
const result = { foo: 'bar' };
when(mockQueryService.deleteOne(1)).thenResolve(result);
when(mockQueryService.deleteOne(1, undefined)).thenResolve(result);
return expect(queryService.deleteOne(1)).resolves.toBe(result);
});
it('should proxy to the underlying service when calling findById', () => {
const result = { foo: 'bar' };
when(mockQueryService.findById(1)).thenResolve(result);
when(mockQueryService.findById(1, undefined)).thenResolve(result);
return expect(queryService.findById(1)).resolves.toBe(result);
});
it('should proxy to the underlying service when calling findRelation with one dto', () => {
const relationName = 'test';
const dto = new TestType();
const result = { foo: 'bar' };
when(mockQueryService.findRelation(TestType, relationName, dto)).thenResolve(result);
when(mockQueryService.findRelation(TestType, relationName, dto, undefined)).thenResolve(result);
return expect(queryService.findRelation(TestType, relationName, dto)).resolves.toBe(result);
});

it('should proxy to the underlying service when calling findRelation with multiple dtos', () => {
const relationName = 'test';
const dtos = [new TestType()];
const result = new Map([[{ foo: 'bar' }, undefined]]);
when(mockQueryService.findRelation(TestType, relationName, dtos)).thenResolve(result);
when(mockQueryService.findRelation(TestType, relationName, dtos, undefined)).thenResolve(result);
return expect(queryService.findRelation(TestType, relationName, dtos)).resolves.toBe(result);
});

it('should proxy to the underlying service when calling getById', () => {
const result = { foo: 'bar' };
when(mockQueryService.getById(1)).thenResolve(result);
when(mockQueryService.getById(1, undefined)).thenResolve(result);
return expect(queryService.getById(1)).resolves.toBe(result);
});
it('should proxy to the underlying service when calling query', () => {
Expand Down Expand Up @@ -150,23 +150,23 @@ describe('ProxyQueryService', () => {
const id = 1;
const relationId = 2;
const result = { foo: 'bar' };
when(mockQueryService.removeRelation(relationName, id, relationId)).thenResolve(result);
when(mockQueryService.removeRelation(relationName, id, relationId, undefined)).thenResolve(result);
return expect(queryService.removeRelation(relationName, id, relationId)).resolves.toBe(result);
});
it('should proxy to the underlying service when calling removeRelations', () => {
const relationName = 'test';
const id = 1;
const relationIds = [2];
const result = { foo: 'bar' };
when(mockQueryService.removeRelations(relationName, id, relationIds)).thenResolve(result);
when(mockQueryService.removeRelations(relationName, id, relationIds, undefined)).thenResolve(result);
return expect(queryService.removeRelations(relationName, id, relationIds)).resolves.toBe(result);
});
it('should proxy to the underlying service when calling setRelation', () => {
const relationName = 'test';
const id = 1;
const relationId = 2;
const result = { foo: 'bar' };
when(mockQueryService.setRelation(relationName, id, relationId)).thenResolve(result);
when(mockQueryService.setRelation(relationName, id, relationId, undefined)).thenResolve(result);
return expect(queryService.setRelation(relationName, id, relationId)).resolves.toBe(result);
});
it('should proxy to the underlying service when calling updateMany', () => {
Expand All @@ -180,7 +180,7 @@ describe('ProxyQueryService', () => {
const id = 1;
const update = { foo: 'bar' };
const result = { foo: 'bar' };
when(mockQueryService.updateOne(id, update)).thenResolve(result);
when(mockQueryService.updateOne(id, update, undefined)).thenResolve(result);
return expect(queryService.updateOne(id, update)).resolves.toBe(result);
});
});
Loading

0 comments on commit 474369b

Please sign in to comment.