a query with options gets its own id

Author: stefanwullems

src/QueryManager.ts

@@ -2,7 +2,7 @@ import Store from '@orbit/store'
 import { Transform, RecordOperation, Record } from '@orbit/data'
 
 import { Observable } from './Observable'
-import { getUpdatedRecords, hasChanged } from './helpers'
+import { getUpdatedRecords, hasChanged, shouldUpdate } from './helpers'
 import { Term, Queries, Expression, RecordData, Status, QueryRefs, Query, RecordObject, Options, SingleOptions, MultipleOptions } from './types'
 
 export class QueryManager extends Observable {
@@ -151,11 +151,7 @@ export class QueryManager extends Observable {
     Object.keys(this._subscriptions).forEach(id => {
       const termsOrExpression = JSON.parse(id)
 
-      const shouldUpdate = !Array.isArray(termsOrExpression)
-        ? hasChanged(termsOrExpression as Expression, records, relatedRecords)
-        : termsOrExpression.some(({ expression }) => hasChanged(expression, records, relatedRecords))
-
-      if (shouldUpdate) {
+      if (shouldUpdate(termsOrExpression, records, relatedRecords)) {
         const data = this._queryCache(termsOrExpression)
         super.notify(id, data)
       }

src/__tests__/QueryManager.test.ts

@@ -40,35 +40,59 @@ beforeEach(() => {
   manager = new QueryManager(store.fork())
 })
 
-// test('QueryManager._extractTerms(...) returns an ordered array of terms', () => {
-//   const account = { type: 'account', id: '1' }
+describe('QueryManager.query(...)', () => {
+  test('Makes a new query when no queries are going on', () => {
+    const account = { type: 'account', id: '1' }
+
+    const query = (q: QueryBuilder) => q.findRecord(account)
 
-//   const query = (q: QueryBuilder) => q.findRecord(account)/   const queries = { Cccount: query, Account: query, Bccount: query, }
+    manager.query(query)
+
+    expect(Object.keys(manager._queryRefs).length).toBe(1)
+  })
 
-//   const terms = manager._extractTermsOrExpression(queries)
+  test('No new query will be made when an identical query already exists', () => {
+    const account = { type: 'account', id: '1' }
 
-//   expect(terms).toMatchObject([
-//     { key: 'Account', expression: { op: 'findRecord', record: {Account: account } },
-//     { key: 'Bccount', expression: { op: 'findRecord', record: {Account: account } },
-//     { key: 'Cccount', expression: { op: 'findRecord', record: {Account: account } }
-//   ])
-// })
+    const query = (q: QueryBuilder) => q.findRecord(account)
 
-test('QueryManager.query(...) makes a new query when no queries are going on', () => {
-  const account = { type: 'account', id: '1' }
+    manager.query(query)
 
-  const query = (q: QueryBuilder) => q.findRecord(account)
-  const listener = jest.fn()
+    expect(Object.keys(manager._queryRefs).length).toBe(1)
 
-  manager.subscribe(query, listener)
+    manager.query(query)
 
-  expect(Object.keys(manager._queryRefs).length).toBe(0)
+    expect(Object.keys(manager._queryRefs).length).toBe(1)
+  })
 
-  manager.query(query)
+  test('Able to pass in options to make a unique query', () => {
+    const account = { type: 'account', id: '1' }
 
-  expect(Object.keys(manager._queryRefs).length).toBe(1)
+    const query = (q: QueryBuilder) => q.findRecord(account)
+
+    const listener1 = jest.fn()
+    const listener2 = jest.fn()
+
+    const options = {
+      label: 'Find all contacts',
+      sources: {
+        remote: {
+          include: ['phone-numbers']
+        }
+      }
+    }
+
+    manager.query(query)
+
+    expect(Object.keys(manager._queryRefs).length).toBe(1)
+
+    manager.query(query, options)
+
+    expect(Object.keys(manager._queryRefs).length).toBe(2)
+  })
 })
 
+
 describe('queryCache(...)', () => {
   test('The record object is null if no match is found', () => {
     const account = { type: 'account', id: '1' }

src/helpers.ts

@@ -1,5 +1,5 @@
 import { RecordOperation, RecordIdentity } from '@orbit/data'
-import { Expression } from './types';
+import { Expression, Term, Options } from './types';
 
 export const getUpdatedRecords = (operations: RecordOperation[]) => {
   const records: RecordIdentity[] = []
@@ -24,6 +24,25 @@ export const getUpdatedRecords = (operations: RecordOperation[]) => {
   return { records, relatedRecords }
 }
 
+export const shouldUpdate = (
+  termsOrExpression: Term[] | Expression | { termsOrExpression: Term[] | Expression, options: Options },
+  records: RecordIdentity[],
+  relatedRecords: RecordIdentity[]) => {
+
+  if (Array.isArray(termsOrExpression)) {
+    return termsOrExpression.some(({ expression }) => hasChanged(expression, records, relatedRecords))
+  }
+
+  else if (termsOrExpression['op']) {
+    return hasChanged(termsOrExpression as Expression, records, relatedRecords)
+  }
+
+  else {
+    // @ts-ignore
+    return shouldUpdate(termsOrExpression.termsOrExpression, records, relatedRecords)
+  }
+}
+
 export const hasChanged = (
   expression: Expression,
   records: RecordIdentity[],