Adding sub total and sorting capabilities

udmd/api/src/__tests__/device/DeviceDataSource.spec.ts

@@ -19,4 +19,9 @@ describe('DeviceDataSource.getDevice()', () => {
     const result: DevicesResponse = await deviceDS.getDevices(searchOptions);
     await expect(result.totalCount).not.toBe(0);
   });
+
+  test('returns a total filtered count', async () => {
+    const result: DevicesResponse = await deviceDS.getDevices(searchOptions);
+    await expect(result.totalFilteredCount).not.toBe(0);
+  });
 });

udmd/api/src/__tests__/device/MockDeviceDataSource.ts

@@ -13,6 +13,6 @@ export default class MockDeviceDataSource extends GraphQLDataSource<object> {
 
   async getDevices(searchOptions: SearchOptions): Promise<DevicesResponse> {
     const devices: Device[] = createDevices(30);
-    return { devices, totalCount: 30 };
+    return { devices, totalCount: 30, totalFilteredCount: 10 };
   }
 }

udmd/api/src/__tests__/device/__snapshots__/resolve.spec.ts.snap

@@ -337,6 +337,7 @@ Object {
         },
       ],
       "totalCount": 30,
+      "totalFilteredCount": 10,
     },
   },
   "errors": undefined,

udmd/api/src/__tests__/device/dao/mongo/MongoDeviceDAO.spec.ts

@@ -3,11 +3,17 @@ import { MongoDeviceDAO } from '../../../../device/dao/mongodb/MongoDeviceDAO';
 import { Device, SearchOptions, SORT_DIRECTION } from '../../../../device/model';
 import { createDevices } from '../../data';
 
+const mockDevices: Device[] = createDevices(100);
+
+// mongo objects
 let connection: MongoClient;
 let db: Db;
 let deviceCollection: Collection;
+
+// object under test
 let mongoDeviceDAO: MongoDeviceDAO;
-let mockDevices: Device[];
+
+// spies
 let findSpy;
 let sortSpy;
 let limitSpy;
@@ -24,15 +30,12 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  // object under test
   mongoDeviceDAO = new MongoDeviceDAO(db);
 
   // data prep
-  mockDevices = createDevices(100);
   deviceCollection = db.collection('device');
-  deviceCollection.insertMany(mockDevices);
+  await deviceCollection.insertMany(mockDevices);
 
-  // spies
   findSpy = jest.spyOn(Collection.prototype, 'find');
   sortSpy = jest.spyOn(FindCursor.prototype, 'sort');
   limitSpy = jest.spyOn(FindCursor.prototype, 'limit');
@@ -41,6 +44,7 @@ beforeEach(async () => {
 
 afterEach(async () => {
   await db.collection('device').deleteMany({});
+
   jest.resetAllMocks();
   jest.restoreAllMocks();
 });
@@ -150,3 +154,13 @@ describe('MongoDeviceDAO.getDeviceCount', () => {
     expect(count).toBe(mockDevices.length);
   });
 });
+
+describe('MongoDeviceDAO.getFilteredDeviceCount', () => {
+  test('returns the filtered device count in the mongo db', async () => {
+    const searchOptions: SearchOptions = { batchSize: 10 };
+
+    const filterdDeviceCount: number = await mongoDeviceDAO.getFilteredDeviceCount(searchOptions);
+
+    expect(filterdDeviceCount).toBe(mockDevices.length);
+  });
+});

udmd/api/src/__tests__/device/dao/mongo/MongoFilterBuilder.spec.ts

@@ -3,16 +3,16 @@ import { getFilter } from '../../../../device/dao/mongodb/MongoFilterBuilder';
 
 const emptyMongoFilter = {};
 
-const filters = [
+const containfilters = [
   [getContainsFilter('make', 'value'), getExpectedRegex('make', 'value')],
   [getContainsFilter('model', 'value'), getExpectedRegex('model', 'value')],
   [getContainsFilter('operational', 'true'), emptyMongoFilter],
-  [getEqualsFilter('make', 'value'), emptyMongoFilter],
+  [getEqualsFilter('make', 'value'), getExpectedEqualsExpression('make', 'value')],
 ];
 
 describe('MongoFilterBuilder.getFilter', () => {
-  test.each(filters)(
-    'returns a regex filter object when a ~ is the operator',
+  test.each(containfilters)(
+    'returns a regex filter object when ~ is the operator',
     async (filter: Filter, expectedResult) => {
       const jsonFilters: Filter[] = [filter];
       expect(getFilter(jsonFilters)).toEqual(expectedResult);
@@ -28,6 +28,12 @@ function getEqualsFilter(field: string, value: string): Filter {
   return { field, operator: '=', value };
 }
 
+function getExpectedEqualsExpression(field: string, value: string): any {
+  const equalsExpression = {};
+  equalsExpression[field] = value;
+  return equalsExpression;
+}
+
 function getExpectedRegex(field: string, value: string): any {
   const regex = {};
   regex[field] = { $regex: value, $options: 'i' };

udmd/api/src/__tests__/device/dao/static/StaticDeviceDAO.spec.ts

@@ -22,27 +22,6 @@ describe('StaticDeviceDAO.getDevices', () => {
     searchOptions = createSearchOptions(batchSize, offset);
     await expect(deviceDAO.getDevices(searchOptions)).resolves.toEqual(allDevices.slice(offset, offset + batchSize));
   });
-
-  test('that providing an offset greater than the number of devices throws an error', async () => {
-    const batchSize = 20;
-    const offset = 200;
-
-    const searchOptions: SearchOptions = createSearchOptions(batchSize, offset);
-
-    await expect(deviceDAO.getDevices(searchOptions)).rejects.toThrowError(
-      'An invalid offset that is greater than the total number of devices was provided.'
-    );
-  });
-
-  test('that if a batch size of 0 is provided, an error is thrown', async () => {
-    const batchSize = 0;
-
-    const searchOptions: SearchOptions = createSearchOptions(batchSize);
-
-    await expect(deviceDAO.getDevices(searchOptions)).rejects.toThrowError(
-      'A batch size greater than zero must be provided'
-    );
-  });
 });
 
 describe('StaticDeviceDAO.getDeviceCount', () => {

udmd/api/src/__tests__/device/resolve.spec.ts

@@ -13,6 +13,7 @@ const QUERY_DEVICES = gql`
   query {
     devices(searchOptions: { batchSize: 10, offset: 10, sortOptions: { direction: DESC, field: "name" }, filter: "" }) {
       totalCount
+      totalFilteredCount
       devices {
         id
         name

udmd/api/src/device/DeviceDataSource.ts

@@ -14,6 +14,7 @@ export class DeviceDataSource extends GraphQLDataSource {
   async getDevices(searchOptions: SearchOptions): Promise<DevicesResponse> {
     const totalCount = await this.deviceDAO.getDeviceCount();
     const devices: Device[] = await this.deviceDAO.getDevices(searchOptions);
-    return { devices, totalCount };
+    const totalFilteredCount: number = await this.deviceDAO.getFilteredDeviceCount(searchOptions);
+    return { devices, totalCount, totalFilteredCount };
   }
 }

udmd/api/src/device/dao/DeviceDAO.ts

@@ -1,6 +1,7 @@
 import { Device, SearchOptions } from '../model';
 
 export interface DeviceDAO {
+  getFilteredDeviceCount(searchOptions: SearchOptions): Promise<number>;
   getDevices(searchOptions: SearchOptions): Promise<Device[]>;
   getDeviceCount(): Promise<number>;
 }

udmd/api/src/device/dao/mongodb/MongoDeviceDAO.ts

@@ -1,6 +1,6 @@
 import { SearchOptions, Device } from '../../model';
 import { DeviceDAO } from '../DeviceDAO';
-import { Db } from 'mongodb';
+import { Db, Filter, FindCursor } from 'mongodb';
 import { fromString } from '../../../device/FilterParser';
 import { getFilter } from './MongoFilterBuilder';
 import { getSort } from './MongoSortBuilder';
@@ -20,11 +20,15 @@ export class MongoDeviceDAO implements DeviceDAO {
       .toArray();
   }
 
+  async getFilteredDeviceCount(searchOptions: SearchOptions): Promise<number> {
+    return await this.db.collection<Device>('device').countDocuments(this.getFilter(searchOptions));
+  }
+
   async getDeviceCount(): Promise<number> {
     return this.db.collection<Device>('device').countDocuments();
   }
 
-  private getFilter(searchOptions: SearchOptions): any {
+  private getFilter(searchOptions: SearchOptions): Filter<Device> {
     return searchOptions.filter ? getFilter(fromString(searchOptions.filter)) : {};
   }
 

udmd/api/src/device/dao/mongodb/MongoFilterBuilder.ts

@@ -5,11 +5,17 @@ export function getFilter(jsonFilters: Filter[]): any {
   const mongoFilters: any = {};
 
   jsonFilters.forEach((filter) => {
+    if (filter.field === 'operational') {
+      // do nothing for filtering on the operational boolean yet
+      // TODO: resolve in a future PR
+    }
     // '~' is our symbol for 'contains'
-    // the operational field is a boolean so do not try a partial match on this field
-    if (filter.operator === '~' && filter.field !== 'operational') {
+    else if (filter.operator === '~') {
       // this means we need to do a case insensitive regex match for the value of the field
       mongoFilters[filter.field] = { $regex: filter.value, $options: 'i' };
+    } else if (filter.operator === '=') {
+      // this means we need to do an exact match for the value of the field
+      mongoFilters[filter.field] = filter.value;
     }
   });
 

udmd/api/src/device/dao/static/StaticDeviceDAO.ts

@@ -33,15 +33,17 @@ export class StaticDeviceDAO implements DeviceDAO {
     return this.devices.length;
   }
 
-  public async getDevices(searchOptions: SearchOptions): Promise<Device[]> {
-    if (searchOptions.batchSize == 0) {
-      throw new Error('A batch size greater than zero must be provided.');
+  public async getFilteredDeviceCount(searchOptions: SearchOptions): Promise<number> {
+    let filteredDevices = this.devices;
+    if (searchOptions.filter) {
+      const filters: Filter[] = fromString(searchOptions.filter);
+      filteredDevices = filterDevices(filters, filteredDevices);
     }
 
-    if (searchOptions.offset > this.devices.length) {
-      throw new Error('An invalid offset that is greater than the total number of devices was provided.');
-    }
+    return filterDevices.length;
+  }
 
+  public async getDevices(searchOptions: SearchOptions): Promise<Device[]> {
     let filteredDevices = this.devices;
     if (searchOptions.filter) {
       const filters: Filter[] = fromString(searchOptions.filter);

udmd/api/src/device/model.ts

@@ -1,6 +1,7 @@
 export interface DevicesResponse {
   devices: Device[];
   totalCount: number;
+  totalFilteredCount: number;
 }
 
 export interface SearchOptions {

udmd/api/src/device/schema.graphql

@@ -28,6 +28,8 @@ type DevicesResponse {
   devices: [Device!]!
   # the total number of devices in the system
   totalCount: Int!
+  # the total number of devices after the filter in the search options has been applied
+  totalFilteredCount: Int!
 }
 
 type Device {