json-fs-query 0.1.0

package/src/data/utilities/parsers/findMergeJoins.ts

@@ -0,0 +1,27 @@
+import { removeFromQuery } from './removeFromQuery'
+import { ParsedQuery } from './parseQuery'
+
+const mergeJoinMatch: RegExp = /(and)?\s*merge\s+([a-z0-9_-]+\.[a-z0-9_-]+)\s+with\s+([a-z0-9_-]+\.[a-z0-9_-]+)/ig
+
+export type ParsedMergeJoin = {
+  propertyA: string
+  propertyB: string
+}
+
+/**
+ * Extract merge-join clauses from the query.
+ * @param parsed
+ * @param query
+ */
+export const findMergeJoins = (parsed: ParsedQuery, query: string): string => {
+  const mergeJoinsFound: IterableIterator<RegExpMatchArray> = query.matchAll(mergeJoinMatch)
+  // @ts-ignore
+  for (let mergeJoin of mergeJoinsFound) {
+    parsed['mergeJoins'].push({
+      propertyA: mergeJoin[2],
+      propertyB: mergeJoin[3]
+    })
+    query = removeFromQuery(mergeJoin[0].trim(), query)
+  }
+  return query
+}

package/src/data/utilities/parsers/findOffset.ts

@@ -0,0 +1,20 @@
+import { removeFromQuery } from './removeFromQuery'
+import { ParsedQuery } from './parseQuery'
+
+const offsetMatch: RegExp = /offset\s*(\d+)/i
+
+export type ParsedOffset = number
+
+/**
+ * Extract the offset clauses from the query.
+ * @param parsed
+ * @param query
+ */
+export const findOffset = (parsed: ParsedQuery, query: string): string => {
+  const offsetFound: RegExpMatchArray = query.match(offsetMatch)
+  if (offsetFound) {
+    parsed['offset'] = offsetFound ? parseInt(offsetFound[1]) : undefined
+    return removeFromQuery(offsetFound[0], query)
+  }
+  return query
+}

package/src/data/utilities/parsers/findSelects.ts

@@ -0,0 +1,31 @@
+import { removeFromQuery } from './removeFromQuery'
+import { ParsedQuery } from './parseQuery'
+
+const selectClausesMatch: RegExp = /select\s+([a-z0-9=._-]+\s*(as\s+)?([a-z0-9_-]+)?)+\s*(,\s*[a-z0-9=._-]+\s*(as\s*[a-z0-9_-]+)?)*/i
+const selectClauseMatch: RegExp = /(select)?\s*,?\s*([a-z0-9=._-]+)\s*(as\s+)?([a-z0-9_-]+)?/ig
+
+export type ParsedSelect = {
+  property: string
+  alias: string | undefined
+}
+
+/**
+ * Extract select clauses from the query.
+ * @param parsed
+ * @param query
+ */
+export const findSelects = (parsed: ParsedQuery, query: string): string => {
+  const selectsFound: RegExpMatchArray = query.match(selectClausesMatch)
+  if (selectsFound) {
+    const selectClausesFound: IterableIterator<RegExpMatchArray> = selectsFound[0].matchAll(selectClauseMatch)
+    // @ts-ignore
+    for (let selectClause of selectClausesFound) {
+      parsed['selectClauses'].push({
+        property: selectClause[2],
+        alias: selectClause[4],
+      })
+    }
+    return removeFromQuery(selectsFound[0], query)
+  }
+  return query
+}

package/src/data/utilities/parsers/findSortClauses.ts

@@ -0,0 +1,31 @@
+import { removeFromQuery } from './removeFromQuery'
+import { ParsedQuery } from './parseQuery'
+
+const sortMatch: RegExp = /sort\s+([a-z0-9._-]+\s*(asc|desc)?)+\s*(,\s*[a-z0-9._-]+\s*(asc|desc)?)*/i
+const sortRuleMatch: RegExp = /(sort)?\s*,?\s*([a-z0-9._-]+)\s*(asc|desc)?/ig
+
+export type ParsedSortClause = {
+  property: string
+  direction: string | 'asc' | 'desc'
+}
+
+/**
+ * Extract sort clauses from the query.
+ * @param parsed
+ * @param query
+ */
+export const findSortClauses = (parsed: ParsedQuery, query: string): string => {
+  const sortFound: RegExpMatchArray = query.match(sortMatch)
+  if (sortFound) {
+    const sortRulesFound: IterableIterator<RegExpMatchArray> = sortFound[0].matchAll(sortRuleMatch)
+    // @ts-ignore
+    for (let sortClause of sortRulesFound) {
+      parsed['sortClauses'].push({
+        property: sortClause[2],
+        direction: sortClause[3] || 'asc',
+      })
+    }
+    return removeFromQuery(sortFound[0], query)
+  }
+  return query
+}

package/src/data/utilities/parsers/findUpdateValues.test.js

@@ -0,0 +1,37 @@
+import { findUpdateValues } from './findUpdateValues'
+
+const parse = (query) => {
+  const parsed = {}
+  const remaining = findUpdateValues(parsed, query)
+  return { parsed, remaining }
+}
+
+describe('findUpdateValues', () => {
+  test('extracts a single assignment', () => {
+    const { parsed, remaining } = parse("update workouts set reps = 12")
+    expect(parsed.updateValues).toEqual({ reps: 12 })
+    expect(remaining).toBe('update workouts')
+  })
+
+  test('extracts multiple comma-separated assignments', () => {
+    const { parsed } = parse("set reps = 12, note = 'done'")
+    expect(parsed.updateValues).toEqual({ reps: 12, note: 'done' })
+  })
+
+  test('stops before a following where clause', () => {
+    const { parsed, remaining } = parse("set reps = 12 where date = '2024-06-02'")
+    expect(parsed.updateValues).toEqual({ reps: 12 })
+    expect(remaining).toBe("where date = '2024-06-02'")
+  })
+
+  test('extracts every literal shape', () => {
+    const { parsed } = parse('set active = true, archived = false, note = null, tags = [1,2,3]')
+    expect(parsed.updateValues).toEqual({ active: true, archived: false, note: null, tags: [1, 2, 3] })
+  })
+
+  test('leaves the query untouched, with an empty updateValues, when there is no set clause', () => {
+    const { parsed, remaining } = parse("read workouts where date = '2024-06-02'")
+    expect(parsed.updateValues).toEqual({})
+    expect(remaining).toBe("read workouts where date = '2024-06-02'")
+  })
+})

package/src/data/utilities/parsers/findUpdateValues.ts

@@ -0,0 +1,32 @@
+import { removeFromQuery } from './removeFromQuery'
+import { parseLiteralValue } from './parseLiteralValue'
+import { ParsedQuery } from './parseQuery'
+
+const literal = '(?:["\'][^"\']*[\'"]|[0-9]+|\\[.*?]|null|true|false)'
+const setClauseMatch: RegExp = new RegExp(`(set)\\s+([a-z0-9_-]+\\s*=\\s*${literal}(?:\\s*,\\s*[a-z0-9_-]+\\s*=\\s*${literal})*)`, 'i')
+const assignmentMatch: RegExp = /([a-z0-9_-]+)\s*=\s*(["'](.*?)['"]|([0-9]+)|(\[.*?])|(null)|(true)|(false))/ig
+
+export type ParsedUpdateValues = { [field: string]: any }
+
+/**
+ * Extract an update's "set field = value, field2 = value2" clause from the query. Uses a two-pass
+ * match, unlike the other parsers here: the set clause's own boundary is found first (so it can
+ * be removed from the query as a whole, and so the comma-separated list doesn't get confused with
+ * anything that follows, like a where clause), then each individual assignment is parsed out of
+ * that captured substring.
+ * @param parsed
+ * @param query
+ */
+export const findUpdateValues = (parsed: ParsedQuery, query: string): string => {
+  const clauseFound: RegExpMatchArray = query.match(setClauseMatch)
+  parsed['updateValues'] = {}
+  if (!clauseFound) {
+    return query
+  }
+  const assignmentsFound: IterableIterator<RegExpMatchArray> = clauseFound[2].matchAll(assignmentMatch)
+  // @ts-ignore
+  for (const assignment of assignmentsFound) {
+    parsed['updateValues'][assignment[1]] = parseLiteralValue(assignment, 3)
+  }
+  return removeFromQuery(clauseFound[0], query)
+}

package/src/data/utilities/parsers/isEntityProperty.ts

@@ -0,0 +1 @@
+export const isEntityProperty = (property: string): boolean => /^[a-z0-9_-]+\.([a-z0-9_-]+)$/i.test(property)

package/src/data/utilities/parsers/parseLiteralValue.test.js

@@ -0,0 +1,41 @@
+import { parseLiteralValue } from './parseLiteralValue'
+
+describe('parseLiteralValue', () => {
+  const groupMatch = (regex, str) => str.match(regex)
+
+  test('extracts a quoted string', () => {
+    const regex = /(["'](.*)['"]|([0-9]+)|(\[.*])|(null)|(true)|(false))/
+    const match = groupMatch(regex, "'foo'")
+    expect(parseLiteralValue(match, 2)).toBe('foo')
+  })
+
+  test('extracts a number', () => {
+    const regex = /(["'](.*)['"]|([0-9]+)|(\[.*])|(null)|(true)|(false))/
+    const match = groupMatch(regex, '42')
+    expect(parseLiteralValue(match, 2)).toBe(42)
+  })
+
+  test('extracts an array', () => {
+    const regex = /(["'](.*)['"]|([0-9]+)|(\[.*])|(null)|(true)|(false))/
+    const match = groupMatch(regex, '[1,2,3]')
+    expect(parseLiteralValue(match, 2)).toEqual([1, 2, 3])
+  })
+
+  test('extracts null', () => {
+    const regex = /(["'](.*)['"]|([0-9]+)|(\[.*])|(null)|(true)|(false))/
+    const match = groupMatch(regex, 'null')
+    expect(parseLiteralValue(match, 2)).toBeNull()
+  })
+
+  test('extracts true/false', () => {
+    const regex = /(["'](.*)['"]|([0-9]+)|(\[.*])|(null)|(true)|(false))/
+    expect(parseLiteralValue(groupMatch(regex, 'true'), 2)).toBe(true)
+    expect(parseLiteralValue(groupMatch(regex, 'false'), 2)).toBe(false)
+  })
+
+  test('honors a different baseIndex for a differently-shaped parent regex', () => {
+    const regex = /([a-z]+)\s*=\s*(["'](.*)['"]|([0-9]+)|(\[.*])|(null)|(true)|(false))/
+    const match = groupMatch(regex, 'reps=10')
+    expect(parseLiteralValue(match, 3)).toBe(10)
+  })
+})

package/src/data/utilities/parsers/parseLiteralValue.ts

@@ -0,0 +1,29 @@
+export type LiteralValue = string | number | boolean | null | any[]
+
+/**
+ * Several parsers (findConditions, findInsertValues, findUpdateValues) capture a query-string
+ * literal into one of six consecutive alternation groups depending on its shape - quoted string,
+ * number, array, null, true, false - since a single regex can't otherwise tell them apart. Given
+ * the match and the index of the first of those six groups (which shifts depending on how many
+ * groups come before it in the parent regex), return the literal with its real JS type.
+ * @param match
+ * @param baseIndex
+ */
+export const parseLiteralValue = (match: RegExpMatchArray, baseIndex: number): LiteralValue => {
+  if (typeof match[baseIndex] !== 'undefined') {
+    return match[baseIndex]
+  }
+  if (typeof match[baseIndex + 1] !== 'undefined') {
+    return Number(match[baseIndex + 1])
+  }
+  if (typeof match[baseIndex + 2] !== 'undefined') {
+    return JSON.parse(match[baseIndex + 2])
+  }
+  if (typeof match[baseIndex + 3] !== 'undefined') {
+    return null
+  }
+  if (typeof match[baseIndex + 4] !== 'undefined') {
+    return true
+  }
+  return false
+}

package/src/data/utilities/parsers/parseQuery.ts

@@ -0,0 +1,73 @@
+import siFunciona from 'si-funciona'
+import { findCommand, ParsedCommand, ParsedEntity } from './findCommand'
+import { findInsertValues, ParsedInsertRow } from './findInsertValues'
+import { findUpdateValues, ParsedUpdateValues } from './findUpdateValues'
+import { findJoinEntity, ParsedJoinEntity } from './findJoinEntity'
+import { findSelects, ParsedSelect } from './findSelects'
+import { findConditions, ParsedCondition } from './findConditions'
+import { findJoinClauses, ParsedJoinClause } from './findJoinClauses'
+import { findMergeJoins, ParsedMergeJoin } from './findMergeJoins'
+import { findSortClauses, ParsedSortClause } from './findSortClauses'
+import { findGroupBy, ParsedGroupBy } from './findGroupBy'
+import { findLimit, ParsedLimit } from './findLimit'
+import { findOffset, ParsedOffset } from './findOffset'
+
+export type ParsedQuery = {
+  command: ParsedCommand | undefined
+  entity: ParsedEntity | undefined
+  joinEntity: ParsedJoinEntity | undefined
+  selectClauses: ParsedSelect[]
+  insertValues: ParsedInsertRow[]
+  updateValues: ParsedUpdateValues
+  conditions: ParsedCondition[]
+  joinClauses: ParsedJoinClause[]
+  mergeJoins: ParsedMergeJoin[]
+  sortClauses: ParsedSortClause[]
+  groupBy: ParsedGroupBy | undefined
+  limit: ParsedLimit | undefined
+  offset: ParsedOffset | undefined
+}
+
+/**
+ * Break a query down into its components.
+ * @param query
+ */
+export const parseQuery = (query: string): ParsedQuery => {
+  let parsedQuery: ParsedQuery = {
+    command: undefined,
+    entity: undefined,
+    joinEntity: undefined,
+    selectClauses: [],
+    insertValues: [],
+    updateValues: {},
+    conditions: [],
+    joinClauses: [],
+    mergeJoins: [],
+    sortClauses: [],
+    groupBy: undefined,
+    limit: undefined,
+    offset: undefined,
+  }
+
+  const { curry, pipe } = siFunciona
+
+  query = pipe(
+    curry(findCommand)(parsedQuery),
+    curry(findInsertValues)(parsedQuery),
+    curry(findUpdateValues)(parsedQuery),
+    curry(findJoinEntity)(parsedQuery),
+    curry(findSelects)(parsedQuery),
+    curry(findConditions)(parsedQuery),
+    curry(findJoinClauses)(parsedQuery),
+    curry(findMergeJoins)(parsedQuery),
+    curry(findSortClauses)(parsedQuery),
+    curry(findGroupBy)(parsedQuery),
+    curry(findLimit)(parsedQuery),
+    curry(findOffset)(parsedQuery)
+  )(query)
+
+  if (query) {
+    throw new Error(`Unrecognized query value: ${query}`)
+  }
+  return parsedQuery
+}

package/src/data/utilities/parsers/removeFromQuery.ts

@@ -0,0 +1 @@
+export const removeFromQuery = (substring: string, query: string): string => query.replace(substring, '').trim()

package/src/data/utilities/parsers/splitEntityProperty.test.js

@@ -0,0 +1,8 @@
+import { splitEntityProperty } from './splitEntityProperty'
+
+describe('splitEntityProperty', () => {
+  test('can parse entity property', () => {
+    const result = splitEntityProperty('workouts.exercise_id')
+    expect(result).toEqual({ entity: 'workouts', property: 'exercise_id' })
+  })
+})

package/src/data/utilities/parsers/splitEntityProperty.ts

@@ -0,0 +1,17 @@
+const entityMatch = /^[a-z0-9_-]+/i
+const propertyMatch = /\.([a-z0-9_-]+)$/i
+
+export const splitEntityProperty = entityProp => {
+  const entityFound = entityProp.match(entityMatch)
+  if (!entityFound) {
+    throw new Error(`Unable to use property: ${entityProp}`)
+  }
+  const propFound = entityProp.match(propertyMatch)
+  if (!propFound) {
+    throw new Error(`Unable to use property: ${entityProp}`)
+  }
+  return {
+    entity: entityFound[0],
+    property: propFound[1]
+  }
+}

package/src/data/utilities/parsers/splitQueries.test.js

@@ -0,0 +1,33 @@
+import { splitQueries } from './splitQueries'
+
+const sampleQueries = [
+  'read workouts where date = \'2024-06-02\'',
+  'read workouts.muscles'
+  + ' on workouts.exercise_id = exercises._id'
+  + ' and on exercises._id = exercise_muscle.exercise_id'
+  + ' and on exercise_muscle.muscle_id = muscles._id'
+  + ' where muscles.alias = \'chest\'',
+  'read workouts.muscles'
+  + ' on workouts.exercise_id = exercises._id'
+  + ' and on exercises._id = exercise_muscle.exercise_id'
+  + ' and on exercise_muscle.muscle_id = muscles._id'
+  + ' merge workouts.exercise_id with exercises._id'
+  + ' merge exercise_muscle.muscle_id with muscles._id'
+  + ' where muscles.alias = \'chest\'',
+  'read workouts sort date desc, order',
+  'read workouts group by date',
+  'read workouts.exercises'
+  + ' select exercises.name as exercise, workouts.sets as sets, reps'
+  + ' on workouts.exercise_id = exercises._id'
+  + ' merge workouts.exercise_id with exercises._id'
+  + ' limit 2'
+  + ' offset 1'
+]
+
+describe('splitQueries', () => {
+  test('can identify all queries', () => {
+    const queries = sampleQueries.reduce((concatQueries, query) => concatQueries = `${concatQueries} ${query}`, '')
+    const result = splitQueries(queries)
+    expect(result).toEqual(sampleQueries)
+  })
+})

package/src/data/utilities/parsers/splitQueries.ts

@@ -0,0 +1,4 @@
+const queryMatch = /\s*(?=(?:delete|insert|read|update)\s+[a-z0-9._-]+)\s*/i
+
+export const splitQueries = (queries: string = ''): string[] =>
+  queries.split(queryMatch).filter((query) => query.length > 0)

package/src/data/utilities/reconcileJoin.test.js

@@ -0,0 +1,38 @@
+import { reconcileJoin } from './reconcileJoin'
+
+describe('reconcileJoin', () => {
+  test('will apply found join with changes', () => {
+    const dataSet = {
+      workouts: [
+        {
+          _id: 1,
+          exercise_id: 1,
+          weight_effort: '115lbs',
+          reps: 10,
+          sets: 3,
+          note: '',
+          date: '2024-06-02',
+          muscles: [{ _id: 11, name: 'Pectorals', alias: 'chest', image: '' }]
+        }
+      ],
+      muscles: [
+        {
+          _id: 11,
+          name: 'Pectorals',
+          alias: 'chest',
+          image: '',
+          'exercise_muscle._id': 1,
+          'exercise_muscle.exercise_id': 1,
+          'exercise_muscle.muscle_rank': 100
+        },
+        { _id: 14, name: 'Triceps', alias: '', image: '' }
+      ]
+    }
+    const entity = 'workouts'
+    const index = 0
+    const joinEntity = 'muscles'
+    const joinProperty = '_id'
+    const result = reconcileJoin(dataSet, entity, index, joinEntity, joinProperty)
+    expect(result[entity][index][joinEntity][0]).toEqual(dataSet[joinEntity][0])
+  })
+})

package/src/data/utilities/reconcileJoin.ts

@@ -0,0 +1,23 @@
+import { where } from '../queries/where'
+
+export const reconcileJoin = (dataSet, entityName, entityKey, joinEntity, joinProp) => {
+  const entity = dataSet[entityName][entityKey]
+  if (entity.hasOwnProperty(joinEntity) && Array.isArray(entity[joinEntity])) {
+    entity[joinEntity].forEach(
+      (mergedEntity, k) => {
+        const matchedEntity = where(
+          dataSet[joinEntity],
+          {
+            property: joinProp,
+            comparator: '=',
+            value: mergedEntity[joinProp]
+          }
+        )
+        if (matchedEntity.length) {
+          dataSet[entityName][entityKey][joinEntity][k] = matchedEntity[0]
+        }
+      }
+    )
+  }
+  return dataSet
+}

package/src/data/utilities/reconcileJoins.test.js

@@ -0,0 +1,160 @@
+import { reconcileJoins } from './reconcileJoins'
+
+describe('reconcileJoins', () => {
+  test('reconciles several joins', () => {
+    const propertyA = 'muscles._id'
+    const propertyB = 'exercise_muscle.muscle_id'
+    const dataSet = {
+      workouts: [
+        {
+          _id: 1,
+          exercise_id: 1,
+          weight_effort: '115lbs',
+          reps: 10,
+          sets: 3,
+          note: '',
+          date: '2024-06-02',
+          muscles: [{ _id: 11, name: 'Pectorals', alias: 'chest', image: '' }]
+        },
+        {
+          _id: 2,
+          exercise_id: 2,
+          weight_effort: '155lbs',
+          reps: 10,
+          sets: 3,
+          note: '',
+          date: '2024-06-02',
+          muscles: [{ _id: 8, name: 'Hamstrings', alias: 'abs', image: '' }]
+        },
+        {
+          _id: 3,
+          exercise_id: 3,
+          weight_effort: '155lbs',
+          reps: 10,
+          sets: 3,
+          note: '',
+          date: '2024-06-02',
+          muscles: [{ _id: 12, name: 'Quadriceps', alias: 'quads', image: '' }]
+        }
+      ],
+      muscles: [
+        {
+          _id: 1,
+          name: 'Abdominal',
+          alias: 'abs',
+          image: '../img/abdominals.jpg'
+        },
+        { _id: 2, name: 'Biceps', alias: '', image: '' },
+        { _id: 3, name: 'Calves', alias: '', image: '' },
+        { _id: 4, name: 'Deltoids', alias: 'shoulders', image: '' },
+        {
+          _id: 5,
+          name: 'Erector Spinae',
+          alias: 'mid back, along spine',
+          image: ''
+        },
+        { _id: 6, name: 'Forearms', alias: 'abs', image: '' },
+        { _id: 7, name: 'Gluteus Maximus', alias: 'abs', image: '' },
+        {
+          _id: 8,
+          name: 'Hamstrings',
+          alias: 'abs',
+          image: '',
+          'exercise_muscle._id': 2,
+          'exercise_muscle.exercise_id': 2,
+          'exercise_muscle.muscle_rank': 100
+        },
+        {
+          _id: 9,
+          name: 'Latissimus Dorsi',
+          alias: 'outer lower back',
+          image: ''
+        },
+        { _id: 10, name: 'Obliques', alias: 'outer abs', image: '' },
+        {
+          _id: 11,
+          name: 'Pectorals',
+          alias: 'chest',
+          image: '',
+          'exercise_muscle._id': 1,
+          'exercise_muscle.exercise_id': 1,
+          'exercise_muscle.muscle_rank': 100
+        },
+        {
+          _id: 12,
+          name: 'Quadriceps',
+          alias: 'quads',
+          image: '',
+          'exercise_muscle._id': 3,
+          'exercise_muscle.exercise_id': 3,
+          'exercise_muscle.muscle_rank': 100
+        },
+        { _id: 13, name: 'Trapezius', alias: 'upper back', image: '' },
+        { _id: 14, name: 'Triceps', alias: '', image: '' }
+      ]
+    }
+    const result = reconcileJoins(propertyA, propertyB, dataSet)
+    expect(result['workouts']).toEqual([
+      {
+        _id: 1,
+        exercise_id: 1,
+        weight_effort: '115lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        date: '2024-06-02',
+        muscles: [
+          {
+            _id: 11,
+            name: 'Pectorals',
+            alias: 'chest',
+            image: '',
+            'exercise_muscle._id': 1,
+            'exercise_muscle.exercise_id': 1,
+            'exercise_muscle.muscle_rank': 100
+          }
+        ]
+      },
+      {
+        _id: 2,
+        exercise_id: 2,
+        weight_effort: '155lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        date: '2024-06-02',
+        muscles: [
+          {
+            _id: 8,
+            name: 'Hamstrings',
+            alias: 'abs',
+            image: '',
+            'exercise_muscle._id': 2,
+            'exercise_muscle.exercise_id': 2,
+            'exercise_muscle.muscle_rank': 100
+          }
+        ]
+      },
+      {
+        _id: 3,
+        exercise_id: 3,
+        weight_effort: '155lbs',
+        reps: 10,
+        sets: 3,
+        note: '',
+        date: '2024-06-02',
+        muscles: [
+          {
+            _id: 12,
+            name: 'Quadriceps',
+            alias: 'quads',
+            image: '',
+            'exercise_muscle._id': 3,
+            'exercise_muscle.exercise_id': 3,
+            'exercise_muscle.muscle_rank': 100
+          }
+        ]
+      }
+    ])
+  })
+})

package/src/data/utilities/reconcileJoins.ts

@@ -0,0 +1,15 @@
+import { splitEntityProperty } from './parsers/splitEntityProperty'
+import { reconcileJoin } from './reconcileJoin'
+
+export const reconcileJoins = (propertyA, propertyB, dataSet) => {
+  const { entity: entityA, property: propA } = splitEntityProperty(propertyA)
+  const { entity: entityB, property: propB } = splitEntityProperty(propertyB)
+  for (let entityName in dataSet) {
+    for (let entityKey in dataSet[entityName]) {
+      const entity = dataSet[entityName][entityKey]
+      dataSet = reconcileJoin(dataSet, entityName, entityKey, entityA, propA)
+      dataSet = reconcileJoin(dataSet, entityName, entityKey, entityB, propB)
+    }
+  }
+  return dataSet
+}