json-fs-query 1.0.5 → 1.0.6

package/dist/data/queries/insertEntity.js

@@ -1,117 +1,117 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.insertEntity = void 0;
-require("core-js/modules/es.json.stringify.js");
-require("core-js/modules/esnext.iterator.constructor.js");
-require("core-js/modules/esnext.iterator.find.js");
-require("core-js/modules/esnext.iterator.map.js");
-var _retrieveRecord = require("../utilities/retrieveRecord");
-var _updateIndex = require("../utilities/updateIndex");
-var _keyGenerate = require("../introspect/policies/keyGenerate");
-var _keyUnique = require("../introspect/policies/keyUnique");
-var _useDefault = require("../introspect/policies/useDefault");
-var _typeCheck = require("../introspect/policies/typeCheck");
-var _foreignKeyExists = require("../introspect/policies/foreignKeyExists");
-var _splitEntityProperty = require("../utilities/parsers/splitEntityProperty");
-var _computeKeyValue = require("../utilities/computeKeyValue");
-var _config = require("../utilities/config");
-const {
-  writeFile
-} = require('fs/promises');
-/**
- * Build one entity's stored values from the raw input values, generating any autoGenerate
- * fields and applying field defaults, then throw if a required field still has no value.
- * @param entity
- * @param record
- * @param rowValues
- */
-const buildEntityValues = async (entity, record, rowValues = {}) => {
-  const entityValues = {};
-  for (const field of record.definition) {
-    let value = rowValues[field.name];
-    if (field.autoGenerate) {
-      value = await (0, _keyGenerate.keyGenerate)(entity, [field.name]);
-    } else if (Object.prototype.hasOwnProperty.call(field, 'default')) {
-      value = (0, _useDefault.useDefault)(field['default'], value);
-    }
-    if (typeof value === 'undefined') {
-      if (!field.optional) {
-        throw new Error(`Missing required field "${field.name}" for ${entity}`);
-      }
-      continue;
-    }
-    entityValues[field.name] = (0, _typeCheck.typeCheck)(field.type, value);
-  }
-  return entityValues;
-};
-/**
- * Reject the insert if it collides with an existing primary or unique key value - a single field,
- * or a composite of several for a multi-field key.
- * @param entity
- * @param record
- * @param entityValues
- */
-const assertUnique = async (entity, record, entityValues) => {
-  for (const key of record.keys) {
-    if (key.type !== 'primary' && key.type !== 'unique') {
-      continue;
-    }
-    const checkKeys = key.fields.map(field => entityValues[field]);
-    const isUnique = await (0, _keyUnique.keyUnique)(entity, key.fields, checkKeys);
-    if (!isUnique) {
-      throw new Error(`Duplicate value for ${key.type} key "${key.fields.join(', ')}" on ${entity}`);
-    }
-  }
-};
-/**
- * Reject the insert if a single-field foreign key's value doesn't exist in the record it
- * references.
- * @param entity
- * @param record
- * @param entityValues
- */
-const assertForeignKeys = async (entity, record, entityValues) => {
-  for (const key of record.keys) {
-    if (key.type !== 'foreign' || key.fields.length !== 1 || !key.references || key.references.length !== 1) {
-      continue;
-    }
-    const field = key.fields[0];
-    if (!Object.prototype.hasOwnProperty.call(entityValues, field)) {
-      continue;
-    }
-    const {
-      entity: refEntity,
-      property: refProperty
-    } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0]);
-    const exists = await (0, _foreignKeyExists.foreignKeyExists)(refEntity, refProperty, entityValues[field]);
-    if (!exists) {
-      throw new Error(`Foreign key "${field}" on ${entity} references a nonexistent ${refEntity}.${refProperty} = ${entityValues[field]}`);
-    }
-  }
-};
-const insertEntity = async (entity = '', values = [], dataSet = {}) => {
-  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
-  const record = await (0, _retrieveRecord.retrieveRecord)(entity);
-  const primaryKey = record.keys.find(key => key.type === 'primary' && key.fields.length === 1);
-  if (!Object.prototype.hasOwnProperty.call(dataSet, entity)) {
-    dataSet[entity] = [];
-  }
-  for (const rowValues of values) {
-    const entityValues = await buildEntityValues(entity, record, rowValues);
-    await assertUnique(entity, record, entityValues);
-    await assertForeignKeys(entity, record, entityValues);
-    const fileName = `${primaryKey ? entityValues[primaryKey.fields[0]] : crypto.randomUUID()}.json`;
-    await writeFile(`${databasePath}${record.path}/${fileName}`, JSON.stringify(entityValues, null, 2));
-    record.entries.push(fileName);
-    await writeFile(`${databasePath}${record.path}.json`, JSON.stringify(record, null, 2));
-    for (const key of record.keys) {
-      await (0, _updateIndex.updateIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, entityValues), fileName);
-    }
-    dataSet[entity].push(entityValues);
-  }
-  return dataSet;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertEntity = void 0;
+require("core-js/modules/es.json.stringify.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.find.js");
+require("core-js/modules/esnext.iterator.map.js");
+var _retrieveRecord = require("../utilities/retrieveRecord");
+var _updateIndex = require("../utilities/updateIndex");
+var _keyGenerate = require("../introspect/policies/keyGenerate");
+var _keyUnique = require("../introspect/policies/keyUnique");
+var _useDefault = require("../introspect/policies/useDefault");
+var _typeCheck = require("../introspect/policies/typeCheck");
+var _foreignKeyExists = require("../introspect/policies/foreignKeyExists");
+var _splitEntityProperty = require("../utilities/parsers/splitEntityProperty");
+var _computeKeyValue = require("../utilities/computeKeyValue");
+var _config = require("../utilities/config");
+const {
+  writeFile
+} = require('fs/promises');
+/**
+ * Build one entity's stored values from the raw input values, generating any autoGenerate
+ * fields and applying field defaults, then throw if a required field still has no value.
+ * @param entity
+ * @param record
+ * @param rowValues
+ */
+const buildEntityValues = async (entity, record, rowValues = {}) => {
+  const entityValues = {};
+  for (const field of record.definition) {
+    let value = rowValues[field.name];
+    if (field.autoGenerate) {
+      value = await (0, _keyGenerate.keyGenerate)(entity, [field.name]);
+    } else if (Object.prototype.hasOwnProperty.call(field, 'default')) {
+      value = (0, _useDefault.useDefault)(field['default'], value);
+    }
+    if (typeof value === 'undefined') {
+      if (!field.optional) {
+        throw new Error(`Missing required field "${field.name}" for ${entity}`);
+      }
+      continue;
+    }
+    entityValues[field.name] = (0, _typeCheck.typeCheck)(field.type, value);
+  }
+  return entityValues;
+};
+/**
+ * Reject the insert if it collides with an existing primary or unique key value - a single field,
+ * or a composite of several for a multi-field key.
+ * @param entity
+ * @param record
+ * @param entityValues
+ */
+const assertUnique = async (entity, record, entityValues) => {
+  for (const key of record.keys) {
+    if (key.type !== 'primary' && key.type !== 'unique') {
+      continue;
+    }
+    const checkKeys = key.fields.map(field => entityValues[field]);
+    const isUnique = await (0, _keyUnique.keyUnique)(entity, key.fields, checkKeys);
+    if (!isUnique) {
+      throw new Error(`Duplicate value for ${key.type} key "${key.fields.join(', ')}" on ${entity}`);
+    }
+  }
+};
+/**
+ * Reject the insert if a single-field foreign key's value doesn't exist in the record it
+ * references.
+ * @param entity
+ * @param record
+ * @param entityValues
+ */
+const assertForeignKeys = async (entity, record, entityValues) => {
+  for (const key of record.keys) {
+    if (key.type !== 'foreign' || key.fields.length !== 1 || !key.references || key.references.length !== 1) {
+      continue;
+    }
+    const field = key.fields[0];
+    if (!Object.prototype.hasOwnProperty.call(entityValues, field)) {
+      continue;
+    }
+    const {
+      entity: refEntity,
+      property: refProperty
+    } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0]);
+    const exists = await (0, _foreignKeyExists.foreignKeyExists)(refEntity, refProperty, entityValues[field]);
+    if (!exists) {
+      throw new Error(`Foreign key "${field}" on ${entity} references a nonexistent ${refEntity}.${refProperty} = ${entityValues[field]}`);
+    }
+  }
+};
+const insertEntity = async (entity = '', values = [], dataSet = {}) => {
+  const databasePath = (0, _config.getSetting)('databasePath', 'database/');
+  const record = await (0, _retrieveRecord.retrieveRecord)(entity);
+  const primaryKey = record.keys.find(key => key.type === 'primary' && key.fields.length === 1);
+  if (!Object.prototype.hasOwnProperty.call(dataSet, entity)) {
+    dataSet[entity] = [];
+  }
+  for (const rowValues of values) {
+    const entityValues = await buildEntityValues(entity, record, rowValues);
+    await assertUnique(entity, record, entityValues);
+    await assertForeignKeys(entity, record, entityValues);
+    const fileName = `${primaryKey ? entityValues[primaryKey.fields[0]] : crypto.randomUUID()}.json`;
+    await writeFile(`${databasePath}${record.path}/${fileName}`, JSON.stringify(entityValues, null, 2));
+    record.entries.push(fileName);
+    await writeFile(`${databasePath}${record.path}.json`, JSON.stringify(record, null, 2));
+    for (const key of record.keys) {
+      await (0, _updateIndex.updateIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, entityValues), fileName);
+    }
+    dataSet[entity].push(entityValues);
+  }
+  return dataSet;
+};
 exports.insertEntity = insertEntity;

package/dist/data/queries/joinEntity.js

@@ -1,32 +1,32 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.joinEntity = void 0;
-var _siFunciona = _interopRequireDefault(require("si-funciona"));
-var _readEntity = require("./readEntity");
-var _useJoinClause = require("../utilities/useJoinClause");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const joinEntity = async (entity, joinEntity, dataSets = {}, joinClauses = [], entityAlreadyResolved = false) => {
-  // Same ambiguity readEntity() always has (can't tell "never loaded" from "loaded, zero rows
-  // matched") - runQuery already resolved entity's rows via an indexed condition in that second
-  // case, so entityAlreadyResolved tells this call not to reload and silently discard that result.
-  if (!entityAlreadyResolved) {
-    dataSets = await (0, _readEntity.readEntity)(entity, dataSets);
-  }
-  if (!joinClauses.length) {
-    return dataSets;
-  }
-  dataSets = await (0, _readEntity.readEntity)(joinEntity, dataSets);
-  for (const anEntity in dataSets[entity]) {
-    let filterJoins = _siFunciona.default.cloneObject(dataSets);
-    filterJoins[entity] = [dataSets[entity][anEntity]];
-    for (const joinClause of joinClauses) {
-      filterJoins = await (0, _useJoinClause.useJoinClause)(joinClause, dataSets, filterJoins);
-    }
-    dataSets[entity][anEntity][joinEntity] = filterJoins[joinEntity];
-  }
-  return dataSets;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.joinEntity = void 0;
+var _siFunciona = _interopRequireDefault(require("si-funciona"));
+var _readEntity = require("./readEntity");
+var _useJoinClause = require("../utilities/useJoinClause");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const joinEntity = async (entity, joinEntity, dataSets = {}, joinClauses = [], entityAlreadyResolved = false) => {
+  // Same ambiguity readEntity() always has (can't tell "never loaded" from "loaded, zero rows
+  // matched") - runQuery already resolved entity's rows via an indexed condition in that second
+  // case, so entityAlreadyResolved tells this call not to reload and silently discard that result.
+  if (!entityAlreadyResolved) {
+    dataSets = await (0, _readEntity.readEntity)(entity, dataSets);
+  }
+  if (!joinClauses.length) {
+    return dataSets;
+  }
+  dataSets = await (0, _readEntity.readEntity)(joinEntity, dataSets);
+  for (const anEntity in dataSets[entity]) {
+    let filterJoins = _siFunciona.default.cloneObject(dataSets);
+    filterJoins[entity] = [dataSets[entity][anEntity]];
+    for (const joinClause of joinClauses) {
+      filterJoins = await (0, _useJoinClause.useJoinClause)(joinClause, dataSets, filterJoins);
+    }
+    dataSets[entity][anEntity][joinEntity] = filterJoins[joinEntity];
+  }
+  return dataSets;
+};
 exports.joinEntity = joinEntity;

package/dist/data/queries/limitOffset.js

@@ -1,21 +1,21 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.limitOffset = void 0;
-/**
- * Slice a dataSet down to at most `limit` rows, starting after the first `offset` of them.
- * @param dataSet
- * @param offset
- * @param limit
- */
-const limitOffset = (dataSet = [], offset, limit) => {
-  if (typeof offset === 'undefined' && typeof limit === 'undefined') {
-    return dataSet;
-  }
-  const start = offset ?? 0;
-  const end = typeof limit === 'number' ? start + limit : undefined;
-  return dataSet.slice(start, end);
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.limitOffset = void 0;
+/**
+ * Slice a dataSet down to at most `limit` rows, starting after the first `offset` of them.
+ * @param dataSet
+ * @param offset
+ * @param limit
+ */
+const limitOffset = (dataSet = [], offset, limit) => {
+  if (typeof offset === 'undefined' && typeof limit === 'undefined') {
+    return dataSet;
+  }
+  const start = offset ?? 0;
+  const end = typeof limit === 'number' ? start + limit : undefined;
+  return dataSet.slice(start, end);
+};
 exports.limitOffset = limitOffset;

package/dist/data/queries/mergeJoins.js

@@ -1,19 +1,19 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.mergeJoins = void 0;
-var _mergeJoin = require("../utilities/mergeJoin");
-var _reconcileJoins = require("../utilities/reconcileJoins");
-const mergeJoins = async (dataSet = {}, merges = []) => {
-  if (!merges.length) {
-    return dataSet;
-  }
-  for (const merge of merges) {
-    dataSet = await (0, _mergeJoin.mergeJoin)(merge.propertyA, merge.propertyB, dataSet);
-    dataSet = (0, _reconcileJoins.reconcileJoins)(merge.propertyA, merge.propertyB, dataSet);
-  }
-  return dataSet;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeJoins = void 0;
+var _mergeJoin = require("../utilities/mergeJoin");
+var _reconcileJoins = require("../utilities/reconcileJoins");
+const mergeJoins = async (dataSet = {}, merges = []) => {
+  if (!merges.length) {
+    return dataSet;
+  }
+  for (const merge of merges) {
+    dataSet = await (0, _mergeJoin.mergeJoin)(merge.propertyA, merge.propertyB, dataSet);
+    dataSet = (0, _reconcileJoins.reconcileJoins)(merge.propertyA, merge.propertyB, dataSet);
+  }
+  return dataSet;
+};
 exports.mergeJoins = mergeJoins;

package/dist/data/queries/parser.js

@@ -1,30 +1,30 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.parser = void 0;
-var _splitQueries = require("../utilities/parsers/splitQueries");
-var _parseQuery = require("../utilities/parsers/parseQuery");
-const parser = (queries = '') => {
-  const queryArray = (0, _splitQueries.splitQueries)(queries);
-  const parsedQueries = [];
-  let mergeQuery = '';
-  for (const query of queryArray) {
-    mergeQuery = mergeQuery ? `${mergeQuery}${query}` : query;
-    let parsedQuery = {};
-    try {
-      parsedQuery = (0, _parseQuery.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;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parser = void 0;
+var _splitQueries = require("../utilities/parsers/splitQueries");
+var _parseQuery = require("../utilities/parsers/parseQuery");
+const parser = (queries = '') => {
+  const queryArray = (0, _splitQueries.splitQueries)(queries);
+  const parsedQueries = [];
+  let mergeQuery = '';
+  for (const query of queryArray) {
+    mergeQuery = mergeQuery ? `${mergeQuery}${query}` : query;
+    let parsedQuery = {};
+    try {
+      parsedQuery = (0, _parseQuery.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;
+};
 exports.parser = parser;

package/dist/data/queries/query.js

@@ -1,18 +1,18 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.query = void 0;
-var _parser = require("./parser");
-var _runQuery = require("../utilities/runQuery");
-const query = async (queryString = '') => {
-  const parsedQueries = (0, _parser.parser)(queryString);
-  const queryResults = [];
-  for (const parsed of parsedQueries) {
-    const dataSet = await (0, _runQuery.runQuery)(parsed);
-    queryResults.push(dataSet[parsed.entity]);
-  }
-  return queryResults;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.query = void 0;
+var _parser = require("./parser");
+var _runQuery = require("../utilities/runQuery");
+const query = async (queryString = '') => {
+  const parsedQueries = (0, _parser.parser)(queryString);
+  const queryResults = [];
+  for (const parsed of parsedQueries) {
+    const dataSet = await (0, _runQuery.runQuery)(parsed);
+    queryResults.push(dataSet[parsed.entity]);
+  }
+  return queryResults;
+};
 exports.query = query;

package/dist/data/queries/readEntity.js

@@ -1,14 +1,14 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.readEntity = void 0;
-var _retrieveRecords = require("../utilities/retrieveRecords");
-const readEntity = async (entity = '', dataSet = {}) => {
-  if (!Object.prototype.hasOwnProperty.call(dataSet, entity) || !dataSet[entity].length) {
-    dataSet[entity] = await (0, _retrieveRecords.retrieveRecords)(entity);
-  }
-  return dataSet;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readEntity = void 0;
+var _retrieveRecords = require("../utilities/retrieveRecords");
+const readEntity = async (entity = '', dataSet = {}) => {
+  if (!Object.prototype.hasOwnProperty.call(dataSet, entity) || !dataSet[entity].length) {
+    dataSet[entity] = await (0, _retrieveRecords.retrieveRecords)(entity);
+  }
+  return dataSet;
+};
 exports.readEntity = readEntity;

package/dist/data/queries/selectFields.js

@@ -1,36 +1,36 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.selectFields = void 0;
-require("core-js/modules/esnext.iterator.constructor.js");
-require("core-js/modules/esnext.iterator.map.js");
-require("core-js/modules/esnext.iterator.reduce.js");
-const shapeRow = (row, selectClauses) => selectClauses.reduce((shaped, {
-  property,
-  alias
-}) => {
-  shaped[alias || property] = row[property];
-  return shaped;
-}, {});
-/**
- * Shape each row down to only the selected properties (aliased, when given). dataSet is either a plain array of
- * rows, or (once groupBy has run) a plain object keyed by group value, each value an array of rows - both are
- * shaped the same way, row by row.
- * @param dataSet
- * @param selectClauses
- */
-const selectFields = (dataSet = [], selectClauses = []) => {
-  if (!selectClauses.length) {
-    return dataSet;
-  }
-  if (Array.isArray(dataSet)) {
-    return dataSet.map(row => shapeRow(row, selectClauses));
-  }
-  return Object.keys(dataSet).reduce((shaped, key) => {
-    shaped[key] = dataSet[key].map(row => shapeRow(row, selectClauses));
-    return shaped;
-  }, {});
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectFields = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.map.js");
+require("core-js/modules/esnext.iterator.reduce.js");
+const shapeRow = (row, selectClauses) => selectClauses.reduce((shaped, {
+  property,
+  alias
+}) => {
+  shaped[alias || property] = row[property];
+  return shaped;
+}, {});
+/**
+ * Shape each row down to only the selected properties (aliased, when given). dataSet is either a plain array of
+ * rows, or (once groupBy has run) a plain object keyed by group value, each value an array of rows - both are
+ * shaped the same way, row by row.
+ * @param dataSet
+ * @param selectClauses
+ */
+const selectFields = (dataSet = [], selectClauses = []) => {
+  if (!selectClauses.length) {
+    return dataSet;
+  }
+  if (Array.isArray(dataSet)) {
+    return dataSet.map(row => shapeRow(row, selectClauses));
+  }
+  return Object.keys(dataSet).reduce((shaped, key) => {
+    shaped[key] = dataSet[key].map(row => shapeRow(row, selectClauses));
+    return shaped;
+  }, {});
+};
 exports.selectFields = selectFields;

package/dist/data/queries/sortBy.js

@@ -1,25 +1,25 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.sortBy = void 0;
-const sortBy = (dataSet = [], sortClauses = []) => {
-  if (!sortClauses.length) {
-    return dataSet;
-  }
-  dataSet.sort((a, b) => {
-    for (const sortClause of sortClauses) {
-      const property = sortClause.property;
-      const direction = sortClause.direction;
-      if (a[property] == b[property]) {
-        continue;
-      }
-      const result = a[property] < b[property] ? -1 : 1;
-      return direction === 'asc' ? result : result * -1;
-    }
-    return 0;
-  });
-  return dataSet;
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sortBy = void 0;
+const sortBy = (dataSet = [], sortClauses = []) => {
+  if (!sortClauses.length) {
+    return dataSet;
+  }
+  dataSet.sort((a, b) => {
+    for (const sortClause of sortClauses) {
+      const property = sortClause.property;
+      const direction = sortClause.direction;
+      if (a[property] == b[property]) {
+        continue;
+      }
+      const result = a[property] < b[property] ? -1 : 1;
+      return direction === 'asc' ? result : result * -1;
+    }
+    return 0;
+  });
+  return dataSet;
+};
 exports.sortBy = sortBy;