json-fs-query 0.1.0 → 0.1.1

package/src/data/utilities/restrictIndexedList.ts

@@ -1,38 +0,0 @@
-import { splitEntityProperty } from './parsers/splitEntityProperty'
-
-export const restrictIndexedList = (joinClause, filterJoins, indexedClone) => {
-  const { entity: entityA, property: propertyA } = splitEntityProperty(joinClause.propertyA)
-  const { entity: entityB, property: propertyB } = splitEntityProperty(joinClause.propertyB)
-  if (filterJoins.hasOwnProperty(entityA)) {
-    const existingEntities = filterJoins[entityA]
-    if (!indexedClone.hasOwnProperty(entityA)) {
-      indexedClone[entityA] = {}
-    }
-    if (!indexedClone[entityA].hasOwnProperty(propertyA)) {
-      indexedClone[entityA][propertyA] = {}
-    }
-    indexedClone[entityA][propertyA] = [
-      {
-        value: existingEntities[0][propertyA],
-        record: existingEntities
-      }
-    ]
-  }
-  if (filterJoins.hasOwnProperty(entityB)) {
-    const existingEntities = filterJoins[entityB]
-    if (!indexedClone.hasOwnProperty(entityB)) {
-      indexedClone[entityB] = {}
-    }
-    if (!indexedClone[entityB].hasOwnProperty(propertyB)) {
-      indexedClone[entityB][propertyB] = {}
-    }
-    indexedClone[entityB][propertyB] = [
-      {
-        value: existingEntities[0][propertyB],
-        record: existingEntities
-      }
-    ]
-  }
-
-  return indexedClone
-}

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

@@ -1,49 +0,0 @@
-import { retrieveFile } from './retrieveFile'
-import { testHelpers } from 'js-build-tools/testHelpers'
-import fs from 'fs'
-
-const databasePath = 'retrieve-file-database/'
-const gulpConfig = testHelpers.gulpConfig
-gulpConfig.set('databasePath', databasePath)
-testHelpers.setDefaults(databasePath)
-
-beforeEach(testHelpers.beforeEach)
-
-afterEach(testHelpers.afterEach)
-
-describe('retrieveFile', () => {
-  test('should get the file if found', async () => {
-    const recordsContent = {
-      path: '',
-      definition: [
-        {
-          name: 'path',
-          type: 'string',
-          optional: false,
-          keys: []
-        },
-        {
-          name: 'definition',
-          type: 'object',
-          optional: false,
-          keys: []
-        },
-        {
-          name: 'entries',
-          type: 'array',
-          optional: false,
-          keys: []
-        },
-      ],
-      entries: [
-        'exercise_muscle.json',
-        'exercises.json',
-        'muscles.json',
-        'workouts.json',
-      ]
-    }
-    const fileName = '__RECORDS.json'
-    fs.writeFileSync(`${databasePath}${fileName}`, JSON.stringify(recordsContent))
-    expect(await retrieveFile(fileName)).toEqual(recordsContent)
-  })
-})

package/src/data/utilities/retrieveFile.ts

@@ -1,19 +0,0 @@
-import * as jsEnv from 'browser-or-node'
-import * as gulpConfig from 'js-build-tools/gulp.config'
-
-export const retrieveFile = async (path) => {
-  let retrieveFn = url => fetch(url).then(res => res.json())
-  let relativePath = jsEnv.isBrowser ? gulpConfig.get('relativePath', '') : ''
-  if (jsEnv.isNode) {
-    const { readFile } = require('fs/promises')
-    retrieveFn = url => readFile(url).then(res => JSON.parse(res))
-  }
-  const databasePath = gulpConfig.get('databasePath', 'database/')
-  const fetchUrl = `${relativePath}${databasePath}${path}`
-  const recordInfo = await retrieveFn(fetchUrl)
-    .catch(err => console.error(err))
-  if (!recordInfo) {
-    throw new Error(`Could not read ${path}`)
-  }
-  return recordInfo
-}

package/src/data/utilities/retrieveIndexes.ts

@@ -1,17 +0,0 @@
-import { retrieveFile } from './retrieveFile'
-import { retrieveRecord } from './retrieveRecord'
-
-export const retrieveIndexes = async (entity = '', properties = [], recordData = {}) => {
-  if (!recordData.hasOwnProperty(entity)) {
-    recordData[entity] = await retrieveRecord(entity)
-  }
-  const indexSet = {}
-  for (let property of properties) {
-    for (let key of recordData[entity].keys) {
-      if (key.fields.includes(property)) {
-        indexSet[property] = await retrieveFile(`__indexes/${entity}/${key.lookup}`)
-      }
-    }
-  }
-  return indexSet
-}

package/src/data/utilities/retrieveRecord.ts

@@ -1,3 +0,0 @@
-import { retrieveFile } from './retrieveFile'
-
-export const retrieveRecord = async (entity = '') => await retrieveFile(`${entity}.json`)

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

@@ -1,223 +0,0 @@
-import { retrieveRecords } from './retrieveRecords'
-import { testHelpers } from 'js-build-tools/testHelpers'
-import { copyDatabase } from '../../../test-data/copyDatabase'
-
-const databasePath = 'retrieve-records-database/'
-const gulpConfig = testHelpers.gulpConfig
-gulpConfig.set('databasePath', databasePath)
-testHelpers.setDefaults(databasePath)
-
-beforeEach(
-  () => testHelpers.beforeEach()
-    .then(() => copyDatabase(databasePath))
-)
-
-afterEach(testHelpers.afterEach)
-
-describe('retrieveRecords', () => {
-  test('retrieve main RECORDS file', async () => {
-    expect(await retrieveRecords('__RECORDS')).toEqual([
-      {
-        path: 'exercise_muscle',
-        definition: [
-          {
-            name: '_id',
-            type: 'string',
-            optional: false
-          },
-          {
-            name: 'exercise_id',
-            type: 'string',
-            optional: false
-          },
-          {
-            name: 'muscle_id',
-            type: 'string',
-            optional: false
-          },
-          { name: 'muscle_rank', type: 'int', optional: false }
-        ],
-        keys: [
-          { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' },
-          {
-            type: 'foreign', fields: ['exercise_id'], lookup: 'fk_exercise_id.json', references: [
-              {
-                'fields': ['exercises._id'],
-                'lookup': 'exercises.json'
-              }
-            ]
-          },
-          {
-            type: 'foreign', fields: ['muscle_id'], lookup: 'fk_muscle_id.json', references: [
-              {
-                'fields': ['muscles._id'],
-                'lookup': 'muscles.json'
-              }
-            ]
-          }
-        ],
-        entries: [
-          'bench_press_pectorals.json',
-          'deadlift_hamstrings.json',
-          'squat_quadriceps.json'
-        ]
-      },
-      {
-        path: 'exercises',
-        definition: [
-          {
-            name: '_id',
-            type: 'string',
-            optional: false
-          },
-          { name: 'name', type: 'string', optional: false },
-          { name: 'description', type: 'string', optional: true }
-        ],
-        keys: [
-          { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' },
-        ],
-        entries: ['bench_press.json', 'deadlift.json', 'squat.json']
-      },
-      {
-        path: 'muscles',
-        definition: [
-          {
-            name: '_id',
-            type: 'string',
-            optional: false
-          },
-          { name: 'name', type: 'string', optional: false },
-          { name: 'alias', type: 'string', optional: true },
-          { name: 'image', type: 'string', optional: true }
-        ],
-        keys: [
-          { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' },
-        ],
-        entries: [
-          'abdominal.json',
-          'biceps.json',
-          'calves.json',
-          'deltoids.json',
-          'erector_spinae.json',
-          'forearms.json',
-          'gluteus_maximus.json',
-          'hamstrings.json',
-          'latissimus_dorsi.json',
-          'obliques.json',
-          'pectorals.json',
-          'quadriceps.json',
-          'trapezius.json',
-          'triceps.json'
-        ]
-      },
-      {
-        path: 'workouts',
-        definition: [
-          {
-            name: '_id',
-            type: 'string',
-            optional: false
-          },
-          {
-            name: 'exercise_id',
-            type: 'string',
-            optional: false
-          },
-          {
-            name: 'weight_effort',
-            type: 'string',
-            optional: true
-          },
-          { name: 'reps', type: 'int', optional: true },
-          { name: 'sets', type: 'int', optional: true },
-          { name: 'note', type: 'string', optional: true },
-          { name: 'order', type: 'int', optional: false },
-          { name: 'date', type: 'string', optional: false }
-        ],
-        keys: [
-          { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' },
-          { type: 'index', fields: ['date'], lookup: 'index_date.json' },
-          {
-            type: 'foreign',
-            fields: ['exercise_id'],
-            lookup: 'fk_exercise_id.json',
-            references: [{ fields: ['exercises._id'], lookup: 'exercises.json' }]
-          }
-        ],
-        entries: [
-          '2024-06-02-001.json',
-          '2024-06-02-002.json',
-          '2024-06-02-003.json',
-          '2024-06-05-001.json',
-          '2024-06-05-002.json',
-          '2024-06-05-003.json'
-        ]
-      }
-    ])
-  })
-
-  test('retrieve workouts entries', async () => {
-    expect(await retrieveRecords('workouts')).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'
-      },
-      {
-        _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/utilities/retrieveRecords.ts

@@ -1,16 +0,0 @@
-import { retrieveFile } from './retrieveFile'
-import { retrieveRecord } from './retrieveRecord'
-
-export const retrieveRecords = async (entity = '') => {
-  const recordFile = await retrieveRecord(entity)
-  const dataSet = []
-  for (let file of recordFile.entries) {
-    const data = await retrieveFile(`${recordFile.path}/${file}`)
-      .catch(err => console.error(err))
-    if (!data) {
-      throw new Error(`Could not read entity ${file}`)
-    }
-    dataSet.push(data)
-  }
-  return dataSet
-}

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

@@ -1,88 +0,0 @@
-import { create } from '../introspect/create'
-import { insertEntity } from '../queries/insertEntity'
-import { runQuery } from './runQuery'
-import { testHelpers } from 'js-build-tools/testHelpers'
-
-const databasePath = 'run-query-database/'
-const gulpConfig = testHelpers.gulpConfig
-gulpConfig.set('databasePath', databasePath)
-testHelpers.setDefaults(databasePath)
-
-beforeEach(testHelpers.beforeEach)
-
-afterEach(testHelpers.afterEach)
-
-const definition = [
-  { name: '_id', type: 'string', optional: false, autoGenerate: true },
-  { name: 'bar', type: 'string', optional: false, autoGenerate: false }
-]
-
-const keys = [
-  { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' }
-]
-
-const baseParsed = (overrides) => Object.assign({
-  entity: 'foo',
-  joinEntity: undefined,
-  conditions: [],
-  joinClauses: [],
-  mergeJoins: [],
-  sortClauses: [],
-  groupBy: undefined
-}, overrides)
-
-describe('runQuery', () => {
-  describe('delete', () => {
-    test('deletes only the rows matching a non-indexed condition', async () => {
-      await create('foo', definition, keys)
-      await insertEntity('foo', [{ bar: 'keep' }, { bar: 'remove' }, { bar: 'keep' }], {})
-
-      const result = await runQuery(baseParsed({
-        command: 'delete',
-        conditions: [{ property: 'bar', comparator: '=', value: 'remove' }]
-      }))
-
-      expect(result.foo.map(row => row.bar)).toEqual(['remove'])
-      const remaining = await runQuery(baseParsed({ command: 'read' }))
-      expect(remaining.foo.map(row => row.bar).sort()).toEqual(['keep', 'keep'])
-    })
-
-    test('with no conditions, deletes every row', async () => {
-      await create('foo', definition, keys)
-      await insertEntity('foo', [{ bar: 'one' }, { bar: 'two' }], {})
-
-      await runQuery(baseParsed({ command: 'delete' }))
-
-      const remaining = await runQuery(baseParsed({ command: 'read' }))
-      expect(remaining.foo).toEqual([])
-    })
-  })
-
-  describe('update', () => {
-    test('updates only the rows matching a non-indexed condition', async () => {
-      await create('foo', definition, keys)
-      await insertEntity('foo', [{ bar: 'change-me' }, { bar: 'leave-me' }], {})
-
-      const result = await runQuery(baseParsed({
-        command: 'update',
-        conditions: [{ property: 'bar', comparator: '=', value: 'change-me' }],
-        updateValues: { bar: 'changed' }
-      }))
-
-      expect(result.foo).toHaveLength(1)
-      expect(result.foo[0].bar).toBe('changed')
-      const remaining = await runQuery(baseParsed({ command: 'read' }))
-      expect(remaining.foo.map(row => row.bar).sort()).toEqual(['changed', 'leave-me'])
-    })
-
-    test('with no conditions, updates every row', async () => {
-      await create('foo', definition, keys)
-      await insertEntity('foo', [{ bar: 'one' }, { bar: 'two' }], {})
-
-      await runQuery(baseParsed({ command: 'update', updateValues: { bar: 'all-changed' } }))
-
-      const remaining = await runQuery(baseParsed({ command: 'read' }))
-      expect(remaining.foo.map(row => row.bar)).toEqual(['all-changed', 'all-changed'])
-    })
-  })
-})

package/src/data/utilities/runQuery.ts

@@ -1,75 +0,0 @@
-import { deleteEntity } from '../queries/deleteEntity'
-import { insertEntity } from '../queries/insertEntity'
-import { readEntity } from '../queries/readEntity'
-import { updateEntity } from '../queries/updateEntity'
-import { joinEntity } from '../queries/joinEntity'
-import { mergeJoins } from '../queries/mergeJoins'
-import { where } from '../queries/where'
-import { sortBy } from '../queries/sortBy'
-import { groupBy } from '../queries/groupBy'
-import { retrieveRecord } from './retrieveRecord'
-import { getConditionIndexedList } from './getConditionIndexedList'
-import { getJoinIndexedList } from './getJoinIndexedList'
-
-export const runQuery = async (parsed) => {
-  const recordData = {
-    [parsed.entity]: await retrieveRecord(parsed.entity)
-  }
-  if (typeof parsed.joinEntity !== 'undefined') {
-    recordData[parsed.joinEntity] = await retrieveRecord(parsed.joinEntity)
-  }
-
-  let dataSet: any = { [parsed.entity]: [] }
-
-  parsed = await getConditionIndexedList(parsed, recordData, dataSet)
-  parsed = await getJoinIndexedList(parsed, recordData, dataSet)
-
-  // delete/update act on whatever is already in dataSet[entity] - unlike read, which loads
-  // everything and lets the where-reduce below narrow it down afterward, they never get a second
-  // pass. So the matching rows have to be fully resolved (indexed conditions already are, via
-  // getConditionIndexedList above; anything left in parsed.conditions is not) before either runs.
-  if (parsed.command === 'delete' || parsed.command === 'update') {
-    dataSet = await readEntity(parsed.entity, dataSet)
-    dataSet[parsed.entity] = parsed.conditions.reduce(
-      (remainingData, condition) => where(remainingData, condition),
-      dataSet[parsed.entity]
-    )
-  }
-
-  switch (parsed.command) {
-    case 'delete':
-      dataSet = await deleteEntity(parsed.entity, dataSet)
-      break
-    case 'insert':
-      dataSet = await insertEntity(parsed.entity, parsed.insertValues, dataSet)
-      break
-    case 'read':
-      dataSet = await readEntity(parsed.entity, dataSet)
-      break
-    case 'update':
-      dataSet = await updateEntity(parsed.entity, parsed.updateValues, dataSet)
-      break
-    default:
-      throw new Error(`Unknown command: ${parsed.command}`)
-  }
-  dataSet = await joinEntity(parsed.entity, parsed.joinEntity, dataSet, parsed.joinClauses)
-  dataSet = await mergeJoins(dataSet, parsed.mergeJoins)
-
-  // delete/update already had parsed.conditions applied above, before they ran. Re-applying the
-  // same conditions here would be wrong, not just redundant, for update specifically: if the
-  // update just changed the very field a condition filters on, re-checking that condition against
-  // the now-changed data would filter the just-updated rows back out.
-  if (parsed.command !== 'delete' && parsed.command !== 'update') {
-    dataSet[parsed.entity] = parsed.conditions.reduce(
-      (remainingData, condition) => {
-        return where(remainingData, condition)
-      },
-      dataSet[parsed.entity]
-    )
-  }
-
-  dataSet[parsed.entity] = sortBy(dataSet[parsed.entity], parsed.sortClauses)
-  dataSet[parsed.entity] = groupBy(dataSet[parsed.entity], parsed.groupBy)
-
-  return dataSet
-}

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

@@ -1,44 +0,0 @@
-import { updateIndex } from './updateIndex'
-import { testHelpers } from 'js-build-tools/testHelpers'
-
-const databasePath = 'update-index-database/'
-const gulpConfig = testHelpers.gulpConfig
-gulpConfig.set('databasePath', databasePath)
-testHelpers.setDefaults(databasePath)
-
-beforeEach(testHelpers.beforeEach)
-
-afterEach(testHelpers.afterEach)
-
-describe('updateIndex', () => {
-  test('does nothing for a key with no lookup', async () => {
-    const result = await updateIndex('foo', { type: 'multi', fields: ['a', 'b'], lookup: '' }, 'x', 'x.json')
-    expect(result).toBeNull()
-  })
-
-  test('creates a new index file the first time a value is indexed', async () => {
-    const key = { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' }
-    const result = await updateIndex('foo', key, 1, '1.json')
-    expect(result).toEqual([{ value: 1, record: ['1.json'] }])
-    expect(testHelpers.fileExists(`${databasePath}__indexes/foo/pk__id.json`)).toBeTruthy()
-  })
-
-  test('appends a new value onto an existing index file', async () => {
-    const key = { type: 'index', fields: ['date'], lookup: 'index_date.json' }
-    await updateIndex('foo', key, '2024-06-02', '1.json')
-    const result = await updateIndex('foo', key, '2024-06-05', '2.json')
-    expect(result).toEqual([
-      { value: '2024-06-02', record: ['1.json'] },
-      { value: '2024-06-05', record: ['2.json'] }
-    ])
-  })
-
-  test('adds a matching file onto an existing value instead of duplicating the value', async () => {
-    const key = { type: 'index', fields: ['date'], lookup: 'index_date.json' }
-    await updateIndex('foo', key, '2024-06-02', '1.json')
-    const result = await updateIndex('foo', key, '2024-06-02', '2.json')
-    expect(result).toEqual([
-      { value: '2024-06-02', record: ['1.json', '2.json'] }
-    ])
-  })
-})

package/src/data/utilities/updateIndex.ts

@@ -1,45 +0,0 @@
-import { keyDefinition } from '../introspect/definitions/key'
-import { recordPath } from '../introspect/definitions/record'
-
-const gulpConfig = require('js-build-tools/gulp.config')
-const { readFile, writeFile, mkdir } = require('fs/promises')
-
-export type indexEntry = {
-  value: any
-  record: string[]
-}
-
-/**
- * Add a single entry file to the index that backs one of a record's keys, creating the index
- * file (and its __indexes/{record} directory) the first time a value is indexed. Keys with no
- * lookup (multi-field keys are not indexed here) are left untouched.
- * @param path
- * @param key
- * @param value
- * @param fileName
- */
-export const updateIndex = async (path: recordPath = '', key: keyDefinition = null, value: any = undefined, fileName: string = ''): Promise<indexEntry[] | null> => {
-  if (!key || !key.lookup) {
-    return null
-  }
-  const databasePath = gulpConfig.get('databasePath', 'database/')
-  const indexDir = `${databasePath}__indexes/${path}`
-  const indexPath = `${indexDir}/${key.lookup}`
-  let index: indexEntry[] = []
-  try {
-    index = JSON.parse(await readFile(indexPath, 'utf8'))
-  } catch (err) {
-    index = []
-  }
-  const existingEntry = index.find(entry => entry.value == value)
-  if (existingEntry) {
-    if (!existingEntry.record.includes(fileName)) {
-      existingEntry.record.push(fileName)
-    }
-  } else {
-    index.push({ value, record: [fileName] })
-  }
-  await mkdir(indexDir, { recursive: true })
-  await writeFile(indexPath, JSON.stringify(index, null, 2))
-  return index
-}