json-fs-query 0.1.0

package/dist/data/utilities/useJoinClause.d.ts

@@ -0,0 +1,6 @@
+export declare const useJoinClause: ({ propertyA, comparator, propertyB }?: {
+    propertyA?: any;
+    comparator?: string;
+    propertyB?: any;
+}, dataSets?: {}, filterJoins?: {}) => Promise<{}>;
+//# sourceMappingURL=useJoinClause.d.ts.map

package/dist/data/utilities/useJoinClause.js

@@ -0,0 +1,51 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.useJoinClause = void 0
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.reduce.js')
+const _readEntity = require('../queries/readEntity')
+const _where = require('../queries/where')
+const _splitEntityProperty = require('./parsers/splitEntityProperty')
+const _siFunciona = _interopRequireDefault(require('si-funciona'))
+function _interopRequireDefault (e) { return e && e.__esModule ? e : { default: e } }
+const useJoinClause = async ({
+  propertyA = null,
+  comparator = '=',
+  propertyB = null
+} = {}, dataSets = {}, filterJoins = {}) => {
+  const {
+    entity: entityA,
+    property: propA
+  } = (0, _splitEntityProperty.splitEntityProperty)(propertyA)
+  const {
+    entity: entityB,
+    property: propB
+  } = (0, _splitEntityProperty.splitEntityProperty)(propertyB)
+  if (!dataSets.hasOwnProperty(entityA)) {
+    dataSets = await (0, _readEntity.readEntity)(entityA, dataSets)
+  }
+  if (!dataSets.hasOwnProperty(entityB)) {
+    dataSets = await (0, _readEntity.readEntity)(entityB, dataSets)
+  }
+  if (!filterJoins.hasOwnProperty(entityA)) {
+    filterJoins[entityA] = _siFunciona.default.cloneObject(dataSets[entityA])
+  }
+  if (!filterJoins.hasOwnProperty(entityB)) {
+    filterJoins[entityB] = _siFunciona.default.cloneObject(dataSets[entityB])
+  }
+  filterJoins[entityA] = filterJoins[entityB].reduce((dataA, dataB) => _siFunciona.default.mergeArrays(dataA, (0, _where.where)(filterJoins[entityA], {
+    property: propA,
+    comparator,
+    value: dataB[propB]
+  })), [])
+  filterJoins[entityB] = filterJoins[entityA].reduce((dataB, dataA) => _siFunciona.default.mergeArrays(dataB, (0, _where.where)(filterJoins[entityB], {
+    property: propB,
+    comparator,
+    value: dataA[propA]
+  })), [])
+  return filterJoins
+}
+exports.useJoinClause = useJoinClause

package/dist/data/utilities/useJoinClause.min.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.useJoinClause=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.reduce.js");var _readEntity=require("../queries/readEntity"),_where=require("../queries/where"),_splitEntityProperty=require("./parsers/splitEntityProperty"),_siFunciona=_interopRequireDefault(require("si-funciona"));function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}const useJoinClause=async({propertyA:e=null,comparator:r="=",propertyB:t=null}={},i={},o={})=>{const{entity:n,property:s}=(0,_splitEntityProperty.splitEntityProperty)(e),{entity:u,property:a}=(0,_splitEntityProperty.splitEntityProperty)(t);return i.hasOwnProperty(n)||(i=await(0,_readEntity.readEntity)(n,i)),i.hasOwnProperty(u)||(i=await(0,_readEntity.readEntity)(u,i)),o.hasOwnProperty(n)||(o[n]=_siFunciona.default.cloneObject(i[n])),o.hasOwnProperty(u)||(o[u]=_siFunciona.default.cloneObject(i[u])),o[n]=o[u].reduce(((e,t)=>_siFunciona.default.mergeArrays(e,(0,_where.where)(o[n],{property:s,comparator:r,value:t[a]}))),[]),o[u]=o[n].reduce(((e,t)=>_siFunciona.default.mergeArrays(e,(0,_where.where)(o[u],{property:a,comparator:r,value:t[s]}))),[]),o};exports.useJoinClause=useJoinClause;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { query } from './data/queries/query';
+export { create, drop, describe } from './data/introspect';
+export { fieldProperties, fieldDefinition, fieldName, keyProperties, keyDefinition, indexType, indexLocation, referenceProperties, reference, recordProperties, recordDefinition, recordPath, entityPath } from './data/introspect';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,35 @@
+'use strict'
+
+require('core-js/modules/esnext.async-iterator.constructor.js')
+require('core-js/modules/esnext.async-iterator.drop.js')
+require('core-js/modules/esnext.iterator.constructor.js')
+require('core-js/modules/esnext.iterator.drop.js')
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+Object.defineProperty(exports, 'create', {
+  enumerable: true,
+  get: function () {
+    return _introspect.create
+  }
+})
+Object.defineProperty(exports, 'describe', {
+  enumerable: true,
+  get: function () {
+    return _introspect.describe
+  }
+})
+Object.defineProperty(exports, 'drop', {
+  enumerable: true,
+  get: function () {
+    return _introspect.drop
+  }
+})
+Object.defineProperty(exports, 'query', {
+  enumerable: true,
+  get: function () {
+    return _query.query
+  }
+})
+var _query = require('./data/queries/query')
+var _introspect = require('./data/introspect')

package/dist/index.min.js

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/esnext.async-iterator.constructor.js"),require("core-js/modules/esnext.async-iterator.drop.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.drop.js"),Object.defineProperty(exports,"__esModule",{value:!0}),Object.defineProperty(exports,"create",{enumerable:!0,get:function(){return _introspect.create}}),Object.defineProperty(exports,"describe",{enumerable:!0,get:function(){return _introspect.describe}}),Object.defineProperty(exports,"drop",{enumerable:!0,get:function(){return _introspect.drop}}),Object.defineProperty(exports,"query",{enumerable:!0,get:function(){return _query.query}});var _query=require("./data/queries/query"),_introspect=require("./data/introspect");

package/gulpfile.mjs

@@ -0,0 +1,15 @@
+export {
+  build,
+  dist,
+  defaultCmd as default,
+  bundle,
+  images,
+  partials,
+  readme,
+  sass,
+  testFull,
+  testQuick,
+  typescript,
+  watchFull,
+  watchTest
+} from 'js-build-tools/gulpfile.base.mjs'

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "json-fs-query",
+  "version": "0.1.0",
+  "description": "Use json files to manage and read data.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "gulp build",
+    "dev": "gulp",
+    "docs": "gulp docs",
+    "sass": "gulp sass",
+    "test": "gulp testFull",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test:quick": "gulp testQuick",
+    "watch": "gulp watchFull",
+    "watch:test": "gulp watchTest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jheagle/json-file-db.git"
+  },
+  "keywords": [
+    "database",
+    "filesystem",
+    "json",
+    "data"
+  ],
+  "author": "Joshua Heagle <joshuaheagle@gmail.com>",
+  "license": "GPL-3.0-or-later",
+  "bugs": {
+    "url": "https://github.com/jheagle/json-file-db/issues"
+  },
+  "homepage": "https://github.com/jheagle/json-file-db#readme",
+  "devDependencies": {
+    "gulp": "^5.0.1",
+    "js-build-tools": "^5.3.2",
+    "typedoc": "^0.28.20",
+    "test-filesystem": "^1.3.14"
+  },
+  "dependencies": {
+    "browser-or-node": "^3.0.0",
+    "si-funciona": "^2.3.4"
+  }
+}

package/src/data/introspect/create.test.js

@@ -0,0 +1,67 @@
+import { create } from './create'
+import { testHelpers } from 'js-build-tools/testHelpers'
+
+const databasePath = 'create-database/'
+const gulpConfig = testHelpers.gulpConfig
+gulpConfig.set('databasePath', databasePath)
+testHelpers.setDefaults(databasePath)
+
+beforeEach(testHelpers.beforeEach)
+
+afterEach(testHelpers.afterEach)
+
+describe('create', () => {
+  test('create a new record', async () => {
+    expect.assertions(3)
+    const recordName = 'foo'
+    const definition = [
+      {
+        name: '_id',
+        type: 'string',
+        optional: false,
+        autoGenerate: true
+      },
+      {
+        name: 'bar',
+        type: 'string',
+        optional: true,
+        autoGenerate: false
+      }
+    ]
+    const keys = [
+      {
+        type: 'primary',
+        fields: [
+          '_id'
+        ],
+        lookup: 'pk__id.json'
+      }
+    ]
+    const result = await create(recordName, definition, keys)
+    expect(result).toEqual({
+      path: recordName,
+      definition: definition,
+      keys: keys,
+      entries: []
+    })
+    expect(testHelpers.fileExists(`${databasePath}${recordName}.json`)).toBeTruthy()
+    expect(testHelpers.fileExists(`${databasePath}${recordName}`)).toBeTruthy()
+  })
+
+  test('registers the new record in __RECORDS', async () => {
+    await create('foo', [], [])
+    const { readFile } = require('fs/promises')
+    const registry = JSON.parse(await readFile(`${databasePath}__RECORDS.json`, 'utf8'))
+    expect(registry.entries).toContain('foo.json')
+  })
+
+  test('creates the database directory itself when it does not already exist', async () => {
+    const { rm } = require('fs/promises')
+    await rm(databasePath, { recursive: true, force: true })
+    expect(testHelpers.fileExists(databasePath)).toBeFalsy()
+
+    await create('foo', [], [])
+
+    expect(testHelpers.fileExists(`${databasePath}foo.json`)).toBeTruthy()
+  })
+})

package/src/data/introspect/create.ts

@@ -0,0 +1,29 @@
+import { fileExists } from 'test-filesystem'
+import { record, recordDefinition } from './definitions/record'
+import { keyProperties } from './definitions/key'
+import { fieldProperties } from './definitions/field'
+import { registerRecord } from '../utilities/registerRecord'
+
+/**
+ * Create a new record.
+ * @param recordName
+ * @param definition
+ * @param keys
+ */
+export const create = async (recordName: string, definition: fieldProperties[] = [], keys: keyProperties[] = []): Promise<recordDefinition | null> => {
+  const gulpConfig = require('js-build-tools/gulp.config')
+  const { writeFile, mkdir } = require('fs/promises')
+  const databasePath = gulpConfig.get('databasePath', 'database/')
+  if (recordName === '__RECORDS') {
+    return null
+  }
+  if (fileExists(`${databasePath}${recordName}.json`)) {
+    return null
+  }
+  await mkdir(databasePath, { recursive: true })
+  const recordContent = record({ path: recordName, definition: definition, keys: keys })
+  await writeFile(`${databasePath}${recordName}.json`, JSON.stringify(recordContent, null, 2))
+  await mkdir(`${databasePath}${recordName}`, { recursive: true })
+  await registerRecord(recordName)
+  return recordContent
+}

package/src/data/introspect/definitions/field.test.js

@@ -0,0 +1,23 @@
+import { field } from './field'
+
+describe('field', () => {
+  test('can create a field with default value', () => {
+    const generatedField = {
+      name: 'quantity',
+      type: 'string',
+      optional: true,
+      autoGenerate: false,
+      default: 0
+    }
+    expect(
+      field({
+        name: generatedField.name,
+        type: generatedField.type,
+        optional: generatedField.optional,
+        autoGenerate: generatedField.autoGenerate,
+        useDefault: true,
+        defaultValue: generatedField.default
+      })
+    ).toEqual(generatedField)
+  })
+})

package/src/data/introspect/definitions/field.ts

@@ -0,0 +1,48 @@
+export type fieldName = string;
+
+export type fieldDefinition = {
+  name: fieldName
+  type: string
+  optional: boolean
+  default?: any
+  autoGenerate: boolean
+}
+
+export type fieldProperties = {
+  name?: string
+  type?: string
+  optional?: boolean
+  useDefault?: boolean
+  defaultValue?: any
+  autoGenerate?: boolean
+}
+
+/**
+ * Generate a field for a record.
+ * @param properties
+ * @param properties.name
+ * @param properties.type
+ * @param properties.optional
+ * @param properties.useDefault
+ * @param properties.defaultValue
+ * @param properties.autoGenerate
+ */
+export const field = ({
+  name = '',
+  type = 'string',
+  optional = false,
+  useDefault = false,
+  defaultValue = '',
+  autoGenerate = false
+}: fieldProperties = {}): fieldDefinition => {
+  const returnField = {
+    name: name,
+    type: type,
+    optional: optional,
+    autoGenerate: autoGenerate,
+  }
+  if (useDefault) {
+    returnField['default'] = defaultValue
+  }
+  return returnField
+}

package/src/data/introspect/definitions/key.test.js

@@ -0,0 +1,100 @@
+import { key } from './key'
+
+describe('key', () => {
+  test('can generate a primary key', () => {
+    const primaryKey = {
+      type: 'primary',
+      fields: [
+        '_id'
+      ],
+      lookup: 'pk__id.json'
+    }
+    expect(key(primaryKey)).toEqual(primaryKey)
+  })
+
+  test('can generate an index key', () => {
+    const indexKey = {
+      type: 'index',
+      fields: [
+        'date'
+      ],
+      lookup: 'index_date.json'
+    }
+    expect(key(indexKey)).toEqual(indexKey)
+  })
+
+  test('can generate an unique key', () => {
+    const uniqueKey = {
+      type: 'unique',
+      fields: [
+        'email'
+      ],
+      lookup: 'unique_email.json'
+    }
+    expect(key(uniqueKey)).toEqual(uniqueKey)
+  })
+
+  test('can generate a multi key', () => {
+    const multiKey = {
+      type: 'multi',
+      fields: [
+        'email',
+        'user_id'
+      ],
+      lookup: 'multi_email_user_id.json'
+    }
+    expect(key(multiKey)).toEqual(multiKey)
+  })
+
+  test('can generate a foreign key', () => {
+    const foreignKey = {
+      type: 'foreign',
+      fields: [
+        'user_id'
+      ],
+      lookup: 'fk_user_id.json',
+      references: [
+        {
+          fields: [
+            'users._id'
+          ],
+          lookup: 'users.json'
+        }
+      ]
+    }
+    expect(key(foreignKey)).toEqual(foreignKey)
+  })
+
+  test('will throw Error for invalid multi, insufficient fields', () => {
+    const multiKey = {
+      type: 'multi',
+      fields: [
+        'email'
+      ],
+      lookup: 'multi_email_user_id.json'
+    }
+    expect(() => key(multiKey)).toThrow(Error)
+  })
+
+  test('will throw Error for invalid foreign, insufficient references', () => {
+    const foreignKey = {
+      type: 'foreign',
+      fields: [
+        'user_id'
+      ],
+      lookup: 'fk_user_id.json'
+    }
+    expect(() => key(foreignKey)).toThrow(Error)
+  })
+
+  test('will throw Error for unknown key type', () => {
+    const strangeKey = {
+      type: 'strange',
+      fields: [
+        'blah'
+      ],
+      lookup: 'strange_blah.json'
+    }
+    expect(() => key(strangeKey)).toThrow(Error)
+  })
+})

package/src/data/introspect/definitions/key.ts

@@ -0,0 +1,64 @@
+import { keyReference, reference } from './keyReference'
+import { fieldName } from './field'
+
+export type indexType = string
+
+export type indexLocation = string
+
+export type keyDefinition = {
+  type: indexType
+  fields: Array<fieldName>
+  lookup: indexLocation
+  references?: Array<reference>
+}
+
+export type keyProperties = {
+  type?: indexType
+  fields?: Array<fieldName>
+  lookup?: indexLocation
+  references?: Array<reference>
+}
+
+/**
+ * Create a field key.
+ * @param properties
+ * @param properties.type
+ * @param properties.fields
+ * @param properties.lookup
+ * @param properties.references
+ */
+export const key = ({
+  type = 'index',
+  fields = [],
+  lookup = '',
+  references = []
+}: keyProperties = {}): keyDefinition => {
+  switch (type) {
+    case 'primary':
+    case 'index':
+    case 'unique':
+      references = []
+      break
+    case 'multi':
+      if (fields.length < 2) {
+        throw new Error('Multi key indicated with less than two fields')
+      }
+      break
+    case 'foreign':
+      if (references.length < 1) {
+        throw new Error('Foreign key must have one reference to an external record')
+      }
+      break
+    default:
+      throw new Error('Unrecognized key type; must be index, primary, unique, multi, or foreign')
+  }
+  const keyDefinition = {
+    type: type,
+    fields: fields,
+    lookup: lookup
+  }
+  if (typeof references !== 'undefined' && references.length > 0) {
+    keyDefinition['references'] = references.map(keyReference)
+  }
+  return keyDefinition
+}

package/src/data/introspect/definitions/keyReference.test.js

@@ -0,0 +1,8 @@
+import { keyReference } from './keyReference'
+
+describe('keyReference', () => {
+  test('can generate a reference', () => {
+    const reference = { fields: ['exercises._id'], lookup: 'exercises.json' }
+    expect(keyReference(reference)).toEqual(reference)
+  })
+})

package/src/data/introspect/definitions/keyReference.ts

@@ -0,0 +1,23 @@
+import { fieldName } from './field'
+import { recordPath } from './record'
+
+export type reference = {
+  fields: fieldName[];
+  lookup: recordPath;
+}
+
+export type referenceProperties = {
+  fields?: fieldName[];
+  lookup?: recordPath;
+}
+
+/**
+ * Create a reference to a remote (foreign; existing on another record) key.
+ * @param properties
+ * @param properties.fields
+ * @param properties.lookup
+ */
+export const keyReference = ({ fields = [], lookup = '' }: referenceProperties = {}): reference => ({
+  fields: fields,
+  lookup: lookup
+})

package/src/data/introspect/definitions/record.ts

@@ -0,0 +1,42 @@
+import { field, fieldDefinition, fieldProperties } from './field'
+import { key, keyDefinition, keyProperties } from './key'
+
+export type recordPath = string
+
+export type entityPath = string
+
+export type recordDefinition = {
+  path: recordPath
+  definition: fieldDefinition[]
+  keys: keyDefinition[]
+  entries: entityPath[]
+}
+
+export type recordProperties = {
+  path?: recordPath
+  definition?: fieldProperties[]
+  keys?: keyProperties[]
+  entries?: entityPath[]
+}
+
+/**
+ *
+ * @param properties
+ * @param properties.path
+ * @param properties.definition
+ * @param properties.keys
+ * @param properties.entries
+ */
+export const record = ({
+  path = '',
+  definition = [],
+  keys = [],
+  entries = []
+}: recordProperties = {}): recordDefinition => {
+  return {
+    path: path,
+    definition: definition.map(field),
+    keys: keys.map(key),
+    entries: entries
+  }
+}

package/src/data/introspect/describe.test.js

@@ -0,0 +1,36 @@
+import { create } from './create'
+import { describe as describeRecord } from './describe'
+import { testHelpers } from 'js-build-tools/testHelpers'
+
+const databasePath = 'describe-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: true, autoGenerate: false }
+]
+
+const keys = [
+  { type: 'primary', fields: ['_id'], lookup: 'pk__id.json' }
+]
+
+describe('describe', () => {
+  test('describes a record by returning its field definition', async () => {
+    await create('foo', definition, keys)
+    const result = await describeRecord('foo')
+    expect(result).toEqual(definition)
+  })
+
+  test('describes __RECORDS by returning the list of known records', async () => {
+    await create('foo', definition, keys)
+    await create('bar', definition, keys)
+    const result = await describeRecord()
+    expect(result).toEqual(['foo.json', 'bar.json'])
+  })
+})

package/src/data/introspect/describe.ts

@@ -0,0 +1,9 @@
+import { retrieveFile } from '../utilities/retrieveFile'
+
+export const describe = async (record = '__RECORDS') => {
+  const recordFile = await retrieveFile(`${record}.json`)
+  if (record === '__RECORDS') {
+    return recordFile.entries
+  }
+  return recordFile.definition
+}