json-fs-query 0.1.0

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

@@ -0,0 +1,343 @@
+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

@@ -0,0 +1,24 @@
+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
+}

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

@@ -0,0 +1,233 @@
+import { query } from './query'
+import { testHelpers } from 'js-build-tools/testHelpers'
+import { copyDatabase } from '../../../test-data/copyDatabase'
+
+const databasePath = 'query-database/'
+const gulpConfig = testHelpers.gulpConfig
+gulpConfig.set('databasePath', databasePath)
+testHelpers.setDefaults(databasePath)
+
+beforeEach(
+  () => testHelpers.beforeEach()
+    .then(() => copyDatabase(databasePath))
+)
+
+afterEach(testHelpers.afterEach)
+
+describe('query', () => {
+  test('it deletes matching rows, resolved via an indexed condition', async () => {
+    const deleted = await query('delete workouts where date = \'2024-06-05\'')
+    expect(deleted[0]).toHaveLength(3)
+
+    const remaining = await query('read workouts')
+    expect(remaining[0]).toHaveLength(3)
+    expect(remaining[0].every(row => row.date === '2024-06-02')).toBe(true)
+  })
+
+  test('it inserts a new row via a values clause', async () => {
+    const inserted = await query("insert workouts values _id = 99, exercise_id = 1, order = 0, date = '2024-06-10'")
+    expect(inserted[0]).toHaveLength(1)
+    expect(inserted[0][0]).toMatchObject({ _id: '99', exercise_id: '1', order: 0, date: '2024-06-10' })
+
+    const readBack = await query("read workouts where date = '2024-06-10'")
+    expect(readBack[0]).toHaveLength(1)
+  })
+
+  test('it updates matching rows via a set clause, resolved via an indexed condition', async () => {
+    const updated = await query("update workouts set reps = 20 where date = '2024-06-05'")
+    expect(updated[0]).toHaveLength(3)
+    expect(updated[0].every(row => row.reps === 20)).toBe(true)
+
+    const readBack = await query("read workouts where date = '2024-06-05'")
+    expect(readBack[0].every(row => row.reps === 20)).toBe(true)
+  })
+
+  test('it reads with where', async () => {
+    const queryString = 'read workouts where date = \'2024-06-02\''
+    const result = await query(queryString)
+    expect(result).toEqual([
+      [
+        {
+          _id: 1,
+          exercise_id: 1,
+          weight_effort: '115lbs',
+          reps: 10,
+          sets: 3,
+          note: '',
+          order: 0,
+          date: '2024-06-02'
+        },
+        {
+          _id: 2,
+          exercise_id: 2,
+          weight_effort: '155lbs',
+          reps: 10,
+          sets: 3,
+          note: '',
+          order: 1,
+          date: '2024-06-02'
+        },
+        {
+          _id: 3,
+          exercise_id: 3,
+          weight_effort: '155lbs',
+          reps: 10,
+          sets: 3,
+          note: '',
+          order: 2,
+          date: '2024-06-02'
+        }
+      ]
+    ])
+  })
+
+  test('it reads with joins and merges', async () => {
+    const queryString = '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 muscles._id with exercise_muscle.muscle_id'
+      + ' where date = \'2024-06-02\''
+    const result = await query(queryString)
+    expect(result).toEqual([
+      [
+        {
+          _id: 1,
+          exercise_id: 1,
+          weight_effort: '115lbs',
+          reps: 10,
+          sets: 3,
+          note: '',
+          order: 0,
+          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: '',
+          order: 1,
+          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: '',
+          order: 2,
+          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
+            }
+          ]
+        }
+      ]
+    ])
+  })
+
+  test('it can use sort and group by', async () => {
+    const queryString = 'read workouts sort date desc, order asc group by date'
+    const result = await query(queryString)
+    expect(result).toEqual([
+      {
+        '2024-06-02': [
+          {
+            _id: 1,
+            exercise_id: 1,
+            weight_effort: '115lbs',
+            reps: 10,
+            sets: 3,
+            note: '',
+            order: 0,
+            date: '2024-06-02'
+          },
+          {
+            _id: 2,
+            exercise_id: 2,
+            weight_effort: '155lbs',
+            reps: 10,
+            sets: 3,
+            note: '',
+            order: 1,
+            date: '2024-06-02'
+          },
+          {
+            _id: 3,
+            exercise_id: 3,
+            weight_effort: '155lbs',
+            reps: 10,
+            sets: 3,
+            note: '',
+            order: 2,
+            date: '2024-06-02'
+          },
+        ],
+        '2024-06-05': [
+          {
+            _id: 4,
+            exercise_id: 1,
+            weight_effort: '120lbs',
+            reps: 10,
+            sets: 3,
+            note: '',
+            order: 0,
+            date: '2024-06-05'
+          },
+          {
+            _id: 5,
+            exercise_id: 2,
+            weight_effort: '160lbs',
+            reps: 10,
+            sets: 3,
+            note: '',
+            order: 1,
+            date: '2024-06-05'
+          },
+          {
+            _id: 6,
+            exercise_id: 3,
+            weight_effort: '160lbs',
+            reps: 10,
+            sets: 3,
+            note: '',
+            order: 2,
+            date: '2024-06-05'
+          }
+        ]
+      }
+    ])
+  })
+})

package/src/data/queries/query.ts

@@ -0,0 +1,12 @@
+import { parser } from './parser'
+import { runQuery } from '../utilities/runQuery'
+
+export const query = async (queryString = '') => {
+  const parsedQueries = parser(queryString)
+  const queryResults = []
+  for (let parsed of parsedQueries) {
+    const dataSet = await runQuery(parsed)
+    queryResults.push(dataSet[parsed.entity])
+  }
+  return queryResults
+}

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

@@ -0,0 +1,85 @@
+import { readEntity } from './readEntity'
+import { testHelpers } from 'js-build-tools/testHelpers'
+import { copyDatabase } from '../../../test-data/copyDatabase'
+
+const databasePath = 'read-entity-database/'
+const gulpConfig = testHelpers.gulpConfig
+gulpConfig.set('databasePath', databasePath)
+testHelpers.setDefaults(databasePath)
+
+beforeEach(
+  () => testHelpers.beforeEach()
+    .then(() => copyDatabase(databasePath))
+)
+
+afterEach(testHelpers.afterEach)
+
+const allWorkouts = [
+  {
+    _id: 1,
+    exercise_id: 1,
+    weight_effort: '115lbs',
+    reps: 10,
+    sets: 3,
+    note: '',
+    order: 0,
+    date: '2024-06-02'
+  },
+  {
+    _id: 2,
+    exercise_id: 2,
+    weight_effort: '155lbs',
+    reps: 10,
+    sets: 3,
+    note: '',
+    order: 1,
+    date: '2024-06-02'
+  },
+  {
+    _id: 3,
+    exercise_id: 3,
+    weight_effort: '155lbs',
+    reps: 10,
+    sets: 3,
+    note: '',
+    order: 2,
+    date: '2024-06-02'
+  },
+  {
+    _id: 4,
+    exercise_id: 1,
+    weight_effort: '120lbs',
+    reps: 10,
+    sets: 3,
+    note: '',
+    order: 0,
+    date: '2024-06-05'
+  },
+  {
+    _id: 5,
+    exercise_id: 2,
+    weight_effort: '160lbs',
+    reps: 10,
+    sets: 3,
+    note: '',
+    order: 1,
+    date: '2024-06-05'
+  },
+  {
+    _id: 6,
+    exercise_id: 3,
+    weight_effort: '160lbs',
+    reps: 10,
+    sets: 3,
+    note: '',
+    order: 2,
+    date: '2024-06-05'
+  }
+]
+
+describe('readEntity', () => {
+  test('it will get all files', async () => {
+    const dataSet = await readEntity('workouts')
+    expect(dataSet['workouts']).toEqual(allWorkouts)
+  }, 30000)
+})

package/src/data/queries/readEntity.ts

@@ -0,0 +1,8 @@
+import { retrieveRecords } from '../utilities/retrieveRecords'
+
+export const readEntity = async (entity = '', dataSet = {}) => {
+  if (!dataSet.hasOwnProperty(entity) || !dataSet[entity].length) {
+    dataSet[entity] = await retrieveRecords(entity)
+  }
+  return dataSet
+}