restructured

Author: stefanwullems

src/CacheObserver/CacheManager.test.ts src/CacheObservable/CacheObservable.test.ts

@@ -1,40 +1,10 @@
-import Store from '@orbit/store'
-import { Dict } from '@orbit/utils'
-import { QueryBuilder, Schema, ModelDefinition } from '@orbit/data'
-
-import { CacheManager } from './CacheManager'
-
-const modelDefenition: Dict<ModelDefinition> = {
-  account: {
-    attributes: {
-      test: { type: 'string' }
-    },
-    relationships: {
-      profile: { type: 'hasOne', inverse: 'account', model: 'profile' },
-      services: { type: 'hasMany', inverse: 'subscribers', model: 'service' }
-    }
-  },
-  profile: {
-    attributes: {
-      test: { type: 'string' }
-    },
-    relationships: {
-      account: { type: 'hasOne', inverse: 'profile', model: 'account' }
-    }
-  },
-  service: {
-    attributes: {
-      test: { type: 'string' }
-    },
-    relationships: {
-      subscribers: { type: 'hasMany', inverse: 'services', model: 'account' }
-    }
-  }
-}
+import { QueryBuilder } from '@orbit/data'
 
-const store = new Store({
-  schema: new Schema({ models: modelDefenition })
-})
+import { CacheManager } from './CacheObservable'
+
+import { TestStore } from '../utils/testing/TestStore'
+
+const store = new TestStore()
 
 let manager: CacheManager
 beforeEach(() => {

src/CacheObserver/CacheManager.ts src/CacheObservable/CacheObservable.ts

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

src/CacheObservable/index.ts

@@ -0,0 +1 @@
+export * from './CacheObservable'

src/CacheObserver/index.ts

@@ -1,43 +1,12 @@
-import Store from '@orbit/store'
-import { Dict } from '@orbit/utils'
-import { QueryBuilder, Schema, ModelDefinition } from '@orbit/data'
+import { QueryBuilder } from '@orbit/data'
 
 import { Subscription } from '../Subscription'
 import { FetchManager } from './FetchManager'
 
+import { TestStore } from '../utils/testing/TestStore'
 import { Expression, Term } from '../utils/types'
 
-const modelDefenition: Dict<ModelDefinition> = {
-  account: {
-    attributes: {
-      test: { type: 'string' }
-    },
-    relationships: {
-      profile: { type: 'hasOne', inverse: 'account', model: 'profile' },
-      services: { type: 'hasMany', inverse: 'subscribers', model: 'service' }
-    }
-  },
-  profile: {
-    attributes: {
-      test: { type: 'string' }
-    },
-    relationships: {
-      account: { type: 'hasOne', inverse: 'profile', model: 'account' }
-    }
-  },
-  service: {
-    attributes: {
-      test: { type: 'string' }
-    },
-    relationships: {
-      subscribers: { type: 'hasMany', inverse: 'services', model: 'account' }
-    }
-  }
-}
-
-const store = new Store({
-  schema: new Schema({ models: modelDefenition })
-})
+const store = new TestStore()
 
 let manager: FetchManager
 beforeEach(() => {

src/FetchObserver/FetchManager.test.ts src/FetchObservable/FetchManager.test.ts

@@ -1,7 +1,7 @@
 import Store from '@orbit/store'
 import { Record } from '@orbit/data'
 
-import { Observable } from '../Observer'
+import { Observable } from '../Observable'
 
 import {
   Query,

src/FetchObserver/FetchManager.ts src/FetchObservable/FetchManager.ts

@@ -1,42 +1,11 @@
-import Store from '@orbit/store'
-import { Dict } from '@orbit/utils'
-import { QueryBuilder, Schema, ModelDefinition } from '@orbit/data'
+import { QueryBuilder } from '@orbit/data'
 
 import { QueryManager } from './QueryManager'
 
 import { Expression } from '../utils/types'
+import { TestStore } from '../utils/testing/TestStore'
 
-const modelDefinition: Dict<ModelDefinition> = {
-  account: {
-    attributes: {
-      test: { type: 'string' }
-    },
-    relationships: {
-      profile: { type: 'hasOne', inverse: 'account', model: 'profile' },
-      services: { type: 'hasMany', inverse: 'subscribers', model: 'service' }
-    }
-  },
-  profile: {
-    attributes: {
-      test: { type: 'string' }
-    },
-    relationships: {
-      account: { type: 'hasOne', inverse: 'profile', model: 'account' }
-    }
-  },
-  service: {
-    attributes: {
-      test: { type: 'string' }
-    },
-    relationships: {
-      subscribers: { type: 'hasMany', inverse: 'services', model: 'account' }
-    }
-  }
-}
-
-const store = new Store({
-  schema: new Schema({ models: modelDefinition })
-})
+const store = new TestStore()
 
 let manager: QueryManager
 beforeEach(() => {

src/FetchObserver/index.ts src/FetchObservable/index.ts

@@ -1,7 +1,7 @@
 import Store from '@orbit/store'
 
-import { CacheManager } from '../CacheObserver'
-import { FetchManager } from '../FetchObserver'
+import { CacheManager } from '../CacheObservable'
+import { FetchManager } from '../FetchObservable'
 
 import { Queries, Query, Options, Data, Listener } from '../utils/types'
 import { getTermsOrExpression, validateOptions, hashQueryIdentifier } from '../utils/parseQuery'

src/Observer/Observable.test.ts src/Observable/Observable.test.ts

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

src/Observer/Observable.ts src/Observable/Observable.ts

@@ -0,0 +1,117 @@
+import { RecordOperation } from '@orbit/data'
+
+import { Expression } from './types'
+import { hasChanged, getUpdatedRecords, identityIsEqual } from './changeManagement'
+
+
+describe('getUpdatedRecords(...)', () => {
+  test('It should put expression.record into the records array', () => {
+    const account = { type: 'account', id: '1' }
+
+    const operation: RecordOperation = { op: 'addRecord', record: account }
+
+    const { records } = getUpdatedRecords([operation])
+
+    expect(records).toMatchObject([account])
+  })
+
+  test('It should put expression.relatedRecord into the relatedRecords array', () => {
+    const account = { type: 'account', id: '1' }
+    const profile = { type: 'profile', id: '1' }
+
+    const operation: RecordOperation = {
+      op: 'replaceRelatedRecord',
+      record: account,
+      relationship: 'profile',
+      relatedRecord: profile
+    }
+
+    const { relatedRecords } = getUpdatedRecords([operation])
+
+    expect(relatedRecords).toMatchObject([profile])
+  })
+
+  test('It should put expression.relatedRecords into the relatedRecords array', () => {
+    const account = { type: 'account', id: '1' }
+    const service1 = { type: 'service', id: '1' }
+    const service2 = { type: 'service', id: '2' }
+
+    const operation: RecordOperation = {
+      op: 'replaceRelatedRecords',
+      record: account,
+      relationship: 'services',
+      relatedRecords: [service1, service2]
+    }
+
+    const { relatedRecords } = getUpdatedRecords([operation])
+
+    expect(relatedRecords).toMatchObject([service1, service2])
+  })
+})
+
+describe('shouldUpdate(...)', () => {
+  test('findRecords: It should return true when a record of the listened to type present in records', () => {
+    const expression: Expression = { op: 'findRecords', type: 'account' }
+    const changedRecord = { type: 'account', id: '1' }
+
+    const shouldUpdateVal = hasChanged(expression, [changedRecord], [])
+
+    expect(shouldUpdateVal).toBe(true)
+  })
+
+  test('findRecords: It should return true  when a record of the listened to type present in relatedRecords', () => {
+    const expression: Expression = { op: 'findRecords', type: 'account' }
+    const changedRelatedRecord = { type: 'account', id: '1' }
+
+    const shouldUpdateVal = hasChanged(expression, [], [changedRelatedRecord])
+
+    expect(shouldUpdateVal).toBe(true)
+  })
+
+  test('It should return true with any other operation if a record matches an expression', () => {
+    const expression: Expression = { op: 'findRecord', record: { type: 'account', id: '1' } }
+    const changedRecord = { type: 'account', id: '1' }
+
+    const shouldUpdateVal = hasChanged(expression, [changedRecord], [])
+
+    expect(shouldUpdateVal).toBe(true)
+  })
+
+  test('It should return true with any other operation if the type of a relatedRecord matches the expression (hasOne)', () => {
+    const expression: Expression = { op: 'findRecord', record: { type: 'account', id: '1' } }
+    const changedRelatedRecord = { type: 'account', id: '1' }
+
+    const shouldUpdateVal = hasChanged(expression, [], [changedRelatedRecord])
+
+    expect(shouldUpdateVal).toBe(true)
+  })
+
+  test('It should return true with any other operation if the type of a relatedRecord matches the expression (hasMany)', () => {
+    const expression: Expression = { op: 'findRecord', record: { type: 'account', id: '1' } }
+    const changedRelatedRecord = { type: 'account', id: '1' }
+
+    const shouldUpdateVal = hasChanged(expression, [], [changedRelatedRecord])
+
+    expect(shouldUpdateVal).toBe(true)
+  })
+})
+
+describe('identityIsEqual(...)', () => {
+  test('should return true when identity is equal', () => {
+    const accountId = { type: 'account', id: '1' }
+
+    const result = identityIsEqual(accountId, accountId)
+
+    expect(result).toBe(true)
+  })
+
+  test('should return false when identity is not equal', () => {
+    const accountId1 = { type: 'account', id: '1' }
+    const accountId2 = { type: 'account', id: '2' }
+
+
+    const result = identityIsEqual(accountId1, accountId2)
+
+    expect(result).toBe(false)
+  })
+})

src/Observer/index.ts src/Observable/index.ts

@@ -1,43 +1,5 @@
-import { RecordOperation, RecordIdentity, QueryBuilder } from '@orbit/data'
-import { Expression, Term, Options, Query, Queries } from './utils/types'
-
-export const getTermsOrExpression = (queryOrQueries: Query | Queries) => {
-  return typeof queryOrQueries === 'function'
-    ? getExpression(queryOrQueries)
-    : getTerms(queryOrQueries)
-}
-
-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 getExpression = (query: Query): Expression => {
-  const queryBuilder = new QueryBuilder()
-
-  return query(queryBuilder).expression as Expression
-}
-
-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.')
-  }
-}
+import { RecordOperation, RecordIdentity } from '@orbit/data'
+import { Expression, Term, Options } from './types'
 
 interface Operation {
   record: RecordIdentity