json-fs-query 0.1.0 → 0.1.1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,44 +0,0 @@
-import { registerRecord } from './registerRecord'
-import { testHelpers } from 'js-build-tools/testHelpers'
-
-const { readFile } = require('fs/promises')
-
-const databasePath = 'register-record-database/'
-const gulpConfig = testHelpers.gulpConfig
-gulpConfig.set('databasePath', databasePath)
-testHelpers.setDefaults(databasePath)
-
-beforeEach(testHelpers.beforeEach)
-
-afterEach(testHelpers.afterEach)
-
-describe('registerRecord', () => {
-  test('creates a fresh registry the first time a record is registered', async () => {
-    const result = await registerRecord('foo')
-    expect(result).toEqual({
-      path: '',
-      definition: [
-        { name: 'path', type: 'string', optional: false, autoGenerate: false },
-        { name: 'definition', type: 'object', optional: false, autoGenerate: false },
-        { name: 'keys', type: 'array', optional: false, autoGenerate: false },
-        { name: 'entries', type: 'array', optional: false, autoGenerate: false }
-      ],
-      keys: [],
-      entries: ['foo.json']
-    })
-    const onDisk = JSON.parse(await readFile(`${databasePath}__RECORDS.json`, 'utf8'))
-    expect(onDisk).toEqual(result)
-  })
-
-  test('appends onto an existing registry without disturbing other entries', async () => {
-    await registerRecord('foo')
-    const result = await registerRecord('bar')
-    expect(result.entries).toEqual(['foo.json', 'bar.json'])
-  })
-
-  test('registering the same record twice does not duplicate its entry', async () => {
-    await registerRecord('foo')
-    const result = await registerRecord('foo')
-    expect(result.entries).toEqual(['foo.json'])
-  })
-})

package/src/data/utilities/registerRecord.ts

@@ -1,44 +0,0 @@
-import { recordDefinition } from '../introspect/definitions/record'
-
-const gulpConfig = require('js-build-tools/gulp.config')
-const { readFile, writeFile } = require('fs/promises')
-
-/**
- * __RECORDS is itself an ordinary record - path/definition/keys/entries - whose entries are the
- * filenames of every other record that has been created. This is the schema it's given the first
- * time a record is registered and no __RECORDS.json exists yet, matching what a hand-authored
- * database (see test-data/__RECORDS.json) already expects to find.
- */
-const defaultRegistry = (): recordDefinition => ({
-  path: '',
-  definition: [
-    { name: 'path', type: 'string', optional: false, autoGenerate: false },
-    { name: 'definition', type: 'object', optional: false, autoGenerate: false },
-    { name: 'keys', type: 'array', optional: false, autoGenerate: false },
-    { name: 'entries', type: 'array', optional: false, autoGenerate: false }
-  ],
-  keys: [],
-  entries: []
-})
-
-/**
- * Add a record's filename to the __RECORDS registry, creating the registry file the first time
- * a record is created if it doesn't already exist.
- * @param recordName
- */
-export const registerRecord = async (recordName: string): Promise<recordDefinition> => {
-  const databasePath = gulpConfig.get('databasePath', 'database/')
-  const registryPath = `${databasePath}__RECORDS.json`
-  let registry: recordDefinition
-  try {
-    registry = JSON.parse(await readFile(registryPath, 'utf8'))
-  } catch (err) {
-    registry = defaultRegistry()
-  }
-  const fileName = `${recordName}.json`
-  if (!registry.entries.includes(fileName)) {
-    registry.entries.push(fileName)
-  }
-  await writeFile(registryPath, JSON.stringify(registry, null, 2))
-  return registry
-}

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

@@ -1,44 +0,0 @@
-import { updateIndex } from './updateIndex'
-import { removeFromIndex } from './removeFromIndex'
-import { testHelpers } from 'js-build-tools/testHelpers'
-
-const { readFile } = require('fs/promises')
-
-const databasePath = 'remove-from-index-database/'
-const gulpConfig = testHelpers.gulpConfig
-gulpConfig.set('databasePath', databasePath)
-testHelpers.setDefaults(databasePath)
-
-beforeEach(testHelpers.beforeEach)
-
-afterEach(testHelpers.afterEach)
-
-describe('removeFromIndex', () => {
-  test('does nothing for a key with no lookup', async () => {
-    const result = await removeFromIndex('foo', { type: 'multi', fields: ['a', 'b'], lookup: '' }, 'x', 'x.json')
-    expect(result).toBeNull()
-  })
-
-  test('does nothing when the index file does not exist yet', async () => {
-    const key = { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' }
-    const result = await removeFromIndex('foo', key, 1, '1.json')
-    expect(result).toBeNull()
-  })
-
-  test('removes a file from its value, keeping other files on that value', async () => {
-    const key = { type: 'index', fields: ['date'], lookup: 'index_date.json' }
-    await updateIndex('foo', key, '2024-06-02', '1.json')
-    await updateIndex('foo', key, '2024-06-02', '2.json')
-    const result = await removeFromIndex('foo', key, '2024-06-02', '1.json')
-    expect(result).toEqual([{ value: '2024-06-02', record: ['2.json'] }])
-  })
-
-  test('drops the whole value once its last file is removed', async () => {
-    const key = { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' }
-    await updateIndex('foo', key, 1, '1.json')
-    const result = await removeFromIndex('foo', key, 1, '1.json')
-    expect(result).toEqual([])
-    const onDisk = JSON.parse(await readFile(`${databasePath}__indexes/foo/pk__id.json`, 'utf8'))
-    expect(onDisk).toEqual([])
-  })
-})

package/src/data/utilities/removeFromIndex.ts

@@ -1,34 +0,0 @@
-import { keyDefinition } from '../introspect/definitions/key'
-import { recordPath } from '../introspect/definitions/record'
-import { indexEntry } from './updateIndex'
-
-const gulpConfig = require('js-build-tools/gulp.config')
-const { readFile, writeFile } = require('fs/promises')
-
-/**
- * Remove a single entry file from the index that backs one of a record's keys, dropping a value
- * entirely once its last file is removed. A key with no lookup, or an index file that doesn't
- * exist yet, is left untouched.
- * @param path
- * @param key
- * @param value
- * @param fileName
- */
-export const removeFromIndex = 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 indexPath = `${databasePath}__indexes/${path}/${key.lookup}`
-  let index: indexEntry[] = []
-  try {
-    index = JSON.parse(await readFile(indexPath, 'utf8'))
-  } catch (err) {
-    return null
-  }
-  index = index
-    .map(entry => entry.value == value ? { value: entry.value, record: entry.record.filter(record => record !== fileName) } : entry)
-    .filter(entry => entry.record.length)
-  await writeFile(indexPath, JSON.stringify(index, null, 2))
-  return index
-}