json-fs-query 0.1.0 → 0.1.1

package/src/data/queries/joinEntity.ts

@@ -1,20 +0,0 @@
-import siFunciona from 'si-funciona'
-import { readEntity } from './readEntity'
-import { useJoinClause } from '../utilities/useJoinClause'
-
-export const joinEntity = async (entity, joinEntity, dataSets = {}, joinClauses = []) => {
-  dataSets = await readEntity(entity, dataSets)
-  if (!joinClauses.length) {
-    return dataSets
-  }
-  dataSets = await readEntity(joinEntity, dataSets)
-  for (const anEntity in dataSets[entity]) {
-    let filterJoins = siFunciona.cloneObject(dataSets)
-    filterJoins[entity] = [dataSets[entity][anEntity]]
-    for (let joinClause of joinClauses) {
-      filterJoins = await useJoinClause(joinClause, dataSets, filterJoins)
-    }
-    dataSets[entity][anEntity][joinEntity] = filterJoins[joinEntity]
-  }
-  return dataSets
-}

package/src/data/queries/mergeJoins.test.js

@@ -1,174 +0,0 @@
-import { mergeJoins } from './mergeJoins'
-import { testHelpers } from 'js-build-tools/testHelpers'
-import { copyDatabase } from '../../../test-data/copyDatabase'
-
-const databasePath = 'merge-joins-database/'
-const gulpConfig = testHelpers.gulpConfig
-gulpConfig.set('databasePath', databasePath)
-testHelpers.setDefaults(databasePath)
-
-beforeEach(
-  () => testHelpers.beforeEach()
-    .then(() => copyDatabase(databasePath))
-)
-
-afterEach(testHelpers.afterEach)
-
-describe('mergeJoins', () => {
-  test('can combine several merges', async () => {
-    const results = await mergeJoins(
-      {},
-      [
-        {
-          propertyA: 'workouts.exercise_id',
-          propertyB: 'exercises._id'
-        },
-        {
-          propertyA: 'muscles._id',
-          propertyB: 'exercise_muscle.muscle_id'
-        }
-      ]
-    )
-    expect(results).toEqual({
-      workouts: [
-        {
-          _id: 1,
-          exercise_id: 1,
-          weight_effort: '115lbs',
-          reps: 10,
-          sets: 3,
-          note: '',
-          order: 0,
-          date: '2024-06-02',
-          'exercises.name': 'Bench Press',
-          'exercises.description': ''
-        },
-        {
-          _id: 2,
-          exercise_id: 2,
-          weight_effort: '155lbs',
-          reps: 10,
-          sets: 3,
-          note: '',
-          order: 1,
-          date: '2024-06-02',
-          'exercises.name': 'Deadlift',
-          'exercises.description': ''
-        },
-        {
-          _id: 3,
-          exercise_id: 3,
-          weight_effort: '155lbs',
-          reps: 10,
-          sets: 3,
-          note: '',
-          order: 2,
-          date: '2024-06-02',
-          'exercises.name': 'Squat',
-          'exercises.description': ''
-        },
-        {
-          _id: 4,
-          exercise_id: 1,
-          weight_effort: '120lbs',
-          reps: 10,
-          sets: 3,
-          note: '',
-          order: 0,
-          date: '2024-06-05',
-          'exercises.name': 'Bench Press',
-          'exercises.description': ''
-        },
-        {
-          _id: 5,
-          exercise_id: 2,
-          weight_effort: '160lbs',
-          reps: 10,
-          sets: 3,
-          note: '',
-          order: 1,
-          date: '2024-06-05',
-          'exercises.name': 'Deadlift',
-          'exercises.description': ''
-        },
-        {
-          _id: 6,
-          exercise_id: 3,
-          weight_effort: '160lbs',
-          reps: 10,
-          sets: 3,
-          note: '',
-          order: 2,
-          date: '2024-06-05',
-          'exercises.name': 'Squat',
-          'exercises.description': ''
-        }
-      ],
-      exercises: [
-        { _id: 1, name: 'Bench Press', description: '' },
-        { _id: 2, name: 'Deadlift', description: '' },
-        { _id: 3, name: 'Squat', description: '' }
-      ],
-      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: '' }
-      ],
-      exercise_muscle: [
-        { _id: 1, exercise_id: 1, muscle_id: 11, muscle_rank: 100 },
-        { _id: 2, exercise_id: 2, muscle_id: 8, muscle_rank: 100 },
-        { _id: 3, exercise_id: 3, muscle_id: 12, muscle_rank: 100 }
-      ]
-    })
-  })
-})

package/src/data/queries/mergeJoins.ts

@@ -1,13 +0,0 @@
-import { mergeJoin } from '../utilities/mergeJoin'
-import { reconcileJoins } from '../utilities/reconcileJoins'
-
-export const mergeJoins = async (dataSet = {}, merges = []) => {
-  if (!merges.length) {
-    return dataSet
-  }
-  for (let merge of merges) {
-    dataSet = await mergeJoin(merge.propertyA, merge.propertyB, dataSet)
-    dataSet = reconcileJoins(merge.propertyA, merge.propertyB, dataSet)
-  }
-  return dataSet
-}

package/src/data/queries/parser.test.js

@@ -1,343 +0,0 @@
-import { parser } from './parser'
-
-describe('parser', () => {
-  test('can parse an update with a set clause and a where clause', () => {
-    const query = "update workouts set reps = 12, note = 'done' where date = '2024-06-02'"
-    const result = parser(query)
-    expect(result).toEqual([
-      {
-        command: 'update',
-        entity: 'workouts',
-        joinEntity: undefined,
-        selectClauses: [],
-        insertValues: [],
-        updateValues: { reps: 12, note: 'done' },
-        conditions: [
-          {
-            property: 'date',
-            comparator: '=',
-            value: '2024-06-02'
-          }
-        ],
-        joinClauses: [],
-        mergeJoins: [],
-        sortClauses: [],
-        groupBy: undefined,
-        limit: undefined,
-        offset: undefined,
-      }
-    ])
-  })
-
-  test('can parse an insert with a values clause', () => {
-    const query = "insert workouts values reps = 12, date = '2024-06-02'"
-    const result = parser(query)
-    expect(result).toEqual([
-      {
-        command: 'insert',
-        entity: 'workouts',
-        joinEntity: undefined,
-        selectClauses: [],
-        insertValues: [{ reps: 12, date: '2024-06-02' }],
-        updateValues: {},
-        conditions: [],
-        joinClauses: [],
-        mergeJoins: [],
-        sortClauses: [],
-        groupBy: undefined,
-        limit: undefined,
-        offset: undefined,
-      }
-    ])
-  })
-
-  test('can parse simple read', () => {
-    const query = 'read workouts'
-      + ' where date = \'2024-06-02\''
-    const result = parser(query)
-    expect(result).toEqual([
-      {
-        command: 'read',
-        entity: 'workouts',
-        joinEntity: undefined,
-        selectClauses: [],
-        insertValues: [],
-        updateValues: {},
-        conditions: [
-          {
-            property: 'date',
-            comparator: '=',
-            value: '2024-06-02'
-          }
-        ],
-        joinClauses: [],
-        mergeJoins: [],
-        sortClauses: [],
-        groupBy: undefined,
-        limit: undefined,
-        offset: undefined,
-      }
-    ])
-  })
-
-  test('can parse read with join', () => {
-    const query = '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\''
-    const result = parser(query)
-    expect(result).toEqual([
-      {
-        command: 'read',
-        entity: 'workouts',
-        joinEntity: 'muscles',
-        selectClauses: [],
-        insertValues: [],
-        updateValues: {},
-        conditions: [
-          {
-            property: 'muscles.alias',
-            comparator: '=',
-            value: 'chest'
-          }
-        ],
-        joinClauses: [
-          {
-            propertyA: 'workouts.exercise_id',
-            comparator: '=',
-            propertyB: 'exercises._id'
-          },
-          {
-            propertyA: 'exercises._id',
-            comparator: '=',
-            propertyB: 'exercise_muscle.exercise_id'
-          },
-          {
-            propertyA: 'exercise_muscle.muscle_id',
-            comparator: '=',
-            propertyB: 'muscles._id'
-          }
-        ],
-        mergeJoins: [],
-        sortClauses: [],
-        groupBy: undefined,
-        limit: undefined,
-        offset: undefined,
-      }
-    ])
-  })
-
-  test('can parse read with join and merge', () => {
-    const query = '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\''
-    const result = parser(query)
-    expect(result).toEqual([
-      {
-        command: 'read',
-        entity: 'workouts',
-        joinEntity: 'muscles',
-        selectClauses: [],
-        insertValues: [],
-        updateValues: {},
-        conditions: [
-          {
-            property: 'muscles.alias',
-            comparator: '=',
-            value: 'chest'
-          }
-        ],
-        joinClauses: [
-          {
-            propertyA: 'workouts.exercise_id',
-            comparator: '=',
-            propertyB: 'exercises._id'
-          },
-          {
-            propertyA: 'exercises._id',
-            comparator: '=',
-            propertyB: 'exercise_muscle.exercise_id'
-          },
-          {
-            propertyA: 'exercise_muscle.muscle_id',
-            comparator: '=',
-            propertyB: 'muscles._id'
-          }
-        ],
-        mergeJoins: [
-          {
-            propertyA: 'workouts.exercise_id',
-            propertyB: 'exercises._id'
-          },
-          {
-            propertyA: 'exercise_muscle.muscle_id',
-            propertyB: 'muscles._id'
-          }
-        ],
-        sortClauses: [],
-        groupBy: undefined,
-        limit: undefined,
-        offset: undefined,
-      }
-    ])
-  })
-
-  test('can parse read with sort clause', () => {
-    const query = 'read workouts'
-      + ' sort date desc, order'
-    const result = parser(query)
-    expect(result).toEqual([
-      {
-        command: 'read',
-        entity: 'workouts',
-        joinEntity: undefined,
-        selectClauses: [],
-        insertValues: [],
-        updateValues: {},
-        conditions: [],
-        joinClauses: [],
-        mergeJoins: [],
-        sortClauses: [
-          { property: 'date', direction: 'desc' },
-          { property: 'order', direction: 'asc' }
-        ],
-        groupBy: undefined,
-        limit: undefined,
-        offset: undefined,
-      }
-    ])
-  })
-
-  test('can parse read with group clause', () => {
-    const query = 'read workouts'
-      + ' group by date'
-    const result = parser(query)
-    expect(result).toEqual([
-      {
-        command: 'read',
-        entity: 'workouts',
-        joinEntity: undefined,
-        selectClauses: [],
-        insertValues: [],
-        updateValues: {},
-        conditions: [],
-        joinClauses: [],
-        mergeJoins: [],
-        sortClauses: [],
-        groupBy: 'date',
-        limit: undefined,
-        offset: undefined,
-      }
-    ])
-  })
-
-  test('can parse select, limit, and offset', () => {
-    const query = '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'
-    const result = parser(query)
-    expect(result).toEqual([
-      {
-        command: 'read',
-        entity: 'workouts',
-        joinEntity: 'exercises',
-        selectClauses: [
-          {
-            property: 'exercises.name',
-            alias: 'exercise',
-          },
-          {
-            property: 'workouts.sets',
-            alias: 'sets',
-          },
-          {
-            property: 'reps',
-            alias: undefined,
-          }
-        ],
-        insertValues: [],
-        updateValues: {},
-        conditions: [],
-        joinClauses: [
-          {
-            propertyA: 'workouts.exercise_id',
-            comparator: '=',
-            propertyB: 'exercises._id'
-          }
-        ],
-        mergeJoins: [
-          {
-            propertyA: 'workouts.exercise_id',
-            propertyB: 'exercises._id'
-          }
-        ],
-        sortClauses: [],
-        groupBy: undefined,
-        limit: 2,
-        offset: 1,
-      }
-    ])
-  })
-
-  test('can use queries containing keyword', () => {
-    const query = 'read workouts.exercises'
-      + ' select exercises.name as exercise, read'
-      + ' on workouts.exercise_id = exercises._id'
-      + ' merge workouts.exercise_id with exercises._id'
-      + ' limit 2'
-      + ' offset 1'
-      + ' delete exercises'
-    const result = parser(query)
-    expect(result).toEqual([
-      {
-        command: 'read',
-        entity: 'workouts',
-        joinEntity: 'exercises',
-        selectClauses: [
-          { property: 'exercises.name', alias: 'exercise' },
-          { property: 'read', alias: undefined }
-        ],
-        insertValues: [],
-        updateValues: {},
-        conditions: [],
-        joinClauses: [
-          {
-            propertyA: 'workouts.exercise_id',
-            comparator: '=',
-            propertyB: 'exercises._id'
-          }
-        ],
-        mergeJoins: [
-          { propertyA: 'workouts.exercise_id', propertyB: 'exercises._id' }
-        ],
-        sortClauses: [],
-        groupBy: undefined,
-        limit: 2,
-        offset: 1
-      },
-      {
-        command: 'delete',
-        entity: 'exercises',
-        joinEntity: undefined,
-        selectClauses: [],
-        insertValues: [],
-        updateValues: {},
-        conditions: [],
-        joinClauses: [],
-        mergeJoins: [],
-        sortClauses: [],
-        groupBy: undefined,
-        limit: undefined,
-        offset: undefined
-      }
-    ])
-  })
-})

package/src/data/queries/parser.ts

@@ -1,24 +0,0 @@
-import { splitQueries } from '../utilities/parsers/splitQueries'
-import { parseQuery } from '../utilities/parsers/parseQuery'
-
-export const parser = (queries: string = '') => {
-  const queryArray: string[] = splitQueries(queries)
-  const parsedQueries = []
-  let mergeQuery = ''
-  for (let query of queryArray) {
-    mergeQuery = mergeQuery ? `${mergeQuery}${query}` : query
-    let parsedQuery = {}
-    try {
-      parsedQuery = parseQuery(mergeQuery)
-      mergeQuery = ''
-    } catch (e) {
-      // attempt to combine queries to fix bad splits
-      continue
-    }
-    parsedQueries.push(parsedQuery)
-  }
-  if (mergeQuery) {
-    throw new Error(`Failed to interpret: ${mergeQuery}`)
-  }
-  return parsedQueries
-}