separated some helpers in parseQuery file

Author: stefanwullems

Diff for: src/CacheObserver/CacheManager.ts

@@ -3,8 +3,9 @@ import { Record, Transform, RecordOperation } from '@orbit/data'
 
 import { Observable } from '../Observer'
 
-import { getTermsOrExpression, getUpdatedRecords, shouldUpdate } from '../helpers'
-import { Data, Listener, Query, Queries, Term, Expression, RecordData } from '../types'
+import { getTermsOrExpression } from '../utils/parseQuery'
+import { getUpdatedRecords, shouldUpdate } from '../helpers'
+import { Data, Listener, Query, Queries, Term, Expression, RecordData } from '../utils/types'
 
 export class CacheManager extends Observable<Data> {
 

Diff for: src/FetchObserver/FetchManager.test.ts

@@ -5,7 +5,7 @@ import { QueryBuilder, Schema, ModelDefinition } from '@orbit/data'
 import { Subscription } from '../Subscription'
 import { FetchManager } from './FetchManager'
 
-import { Expression, Term } from '../types'
+import { Expression, Term } from '../utils/types'
 
 const modelDefenition: Dict<ModelDefinition> = {
   account: {

Diff for: src/FetchObserver/FetchManager.ts

@@ -3,7 +3,6 @@ import { Record } from '@orbit/data'
 
 import { Observable } from '../Observer'
 
-import { getTermsOrExpression, validateOptions, hashQueryIdentifier } from '../helpers'
 import {
   Query,
   Queries,
@@ -18,7 +17,8 @@ import {
   RecordObject,
   Listener,
   Status
-} from '../types'
+} from '../utils/types'
+import { getTermsOrExpression, validateOptions, hashQueryIdentifier } from '../utils/parseQuery'
 
 
 export class FetchManager extends Observable<Data> {

Diff for: src/Observer/Observable.ts

@@ -1,6 +1,6 @@
 import { Subscription } from '../Subscription'
 
-import { Listener } from '../types'
+import { Listener } from '../utils/types'
 
 export class Observable<T> {
   _subscriptions: { [id: string]: Subscription<T> } = {}

Diff for: src/QueryObserver/QueryManager.test.ts

@@ -4,7 +4,7 @@ import { QueryBuilder, Schema, ModelDefinition } from '@orbit/data'
 
 import { QueryManager } from './QueryManager'
 
-import { Expression } from '../types'
+import { Expression } from '../utils/types'
 
 const modelDefinition: Dict<ModelDefinition> = {
   account: {

Diff for: src/QueryObserver/QueryManager.ts

@@ -3,8 +3,8 @@ import Store from '@orbit/store'
 import { CacheManager } from '../CacheObserver'
 import { FetchManager } from '../FetchObserver'
 
-import { Queries, Query, Options, Data, Listener } from '../types'
-import { getTermsOrExpression, hashQueryIdentifier, validateOptions } from '../helpers'
+import { Queries, Query, Options, Data, Listener } from '../utils/types'
+import { getTermsOrExpression, validateOptions, hashQueryIdentifier } from '../utils/parseQuery'
 
 export class QueryManager {
 

Diff for: src/Subscription/Subscription.ts

@@ -1,4 +1,4 @@
-import { Listener } from '../types'
+import { Listener } from '../utils/types'
 
 export class Subscription<T> {
   _listeners: Listener<T>[] = []

Diff for: src/helpers.ts

@@ -1,5 +1,5 @@
 import { RecordOperation, RecordIdentity, QueryBuilder } from '@orbit/data'
-import { Expression, Term, Options, Query, Queries } from './types'
+import { Expression, Term, Options, Query, Queries } from './utils/types'
 
 export const getTermsOrExpression = (queryOrQueries: Query | Queries) => {
   return typeof queryOrQueries === 'function'

Diff for: src/index.ts

@@ -1,2 +1,2 @@
 export * from './QueryObserver/QueryManager'
-export * from './types'
+export * from './utils/types'

Diff for: src/utils/parseQuery.ts

@@ -0,0 +1,41 @@
+import { QueryBuilder } from '@orbit/data'
+
+import { Query, Queries, Term, Expression, Options } from './types'
+
+export const getExpression = (query: Query): Expression => {
+  const queryBuilder = new QueryBuilder()
+
+  return query(queryBuilder).expression as Expression
+}
+
+export const getTerms = (queries: Queries): Term[] => {
+  const queryBuilder = new QueryBuilder()
+
+  return Object.keys(queries).sort().map((key) =>
+    ({ key, expression: queries[key](queryBuilder).expression as Expression })
+  )
+}
+
+export const getTermsOrExpression = (queryOrQueries: Query | Queries) => {
+  return typeof queryOrQueries === 'function'
+    ? getExpression(queryOrQueries)
+    : getTerms(queryOrQueries)
+}
+
+export const hashQueryIdentifier = (termsOrExpression: Term[] | Expression, options?: Options) => {
+  return options
+    ? JSON.stringify({ termsOrExpression, options })
+    : JSON.stringify(termsOrExpression)
+}
+
+export const validateOptions = (termsOrExpression: Term[] | Expression, options?: Options) => {
+  if (!options) return
+  if (Array.isArray(termsOrExpression) && !Array.isArray(options)) {
+    throw new Error(
+      'Options are invalid. When making multiple queries' +
+      'the options must be an array of objects with a "queryKey" property that refers to the query to which the options apply'
+    )
+  } else if (!Array.isArray(termsOrExpression) && Array.isArray(options)) {
+    throw new Error('Options are invalid.')
+  }
+}