json-fs-query 1.1.0 → 2.1.0

package/dist/data/queries/where.js

@@ -1,68 +1,86 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.where = void 0;
-require("core-js/modules/es.array.includes.js");
-require("core-js/modules/esnext.iterator.constructor.js");
-require("core-js/modules/esnext.iterator.filter.js");
-require("core-js/modules/esnext.iterator.some.js");
-var _compareAs = require("../utilities/compareAs");
-const likeMatch = (dataValue, pattern) => {
-  if (typeof dataValue !== 'string' || typeof pattern !== 'string') {
-    return false;
-  }
-  const regexPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/%/g, '.*').replace(/_/g, '.');
-  return new RegExp(`^${regexPattern}$`, 'i').test(dataValue);
-};
-/**
- * Equality (=, !=, <>, in) compares by the field's declared type when given one (see sameValue), so
- * '3' and 3 match in a string or int field. Ordering (>, <, between, like) compares the raw values.
- * @param data
- * @param property
- * @param comparator
- * @param value
- * @param type
- */
-const makeCondition = (data, property, comparator, value, type = undefined) => {
-  if (!Object.prototype.hasOwnProperty.call(data, property)) {
-    return false;
-  }
-  const dataValue = data[property];
-  switch (comparator) {
-    case '=':
-      return (0, _compareAs.sameValue)(type, dataValue, value);
-    case '!=':
-    case '<>':
-      return !(0, _compareAs.sameValue)(type, dataValue, value);
-    case '>':
-      return dataValue > value;
-    case '>=':
-      return dataValue >= value;
-    case '<':
-      return dataValue < value;
-    case '<=':
-      return dataValue <= value;
-    case 'in':
-      return Array.isArray(value) && (type ? value.some(item => (0, _compareAs.sameValue)(type, dataValue, item)) : value.includes(dataValue));
-    case 'between':
-      return Array.isArray(value) && value.length === 2 && dataValue >= value[0] && dataValue <= value[1];
-    case 'like':
-      return likeMatch(dataValue, value);
-  }
-  return false;
-};
-const where = (dataSet = [], {
-  property = '',
-  joinEntity = undefined,
-  comparator = '=',
-  value = null,
-  type = undefined
-} = {}) => {
-  return dataSet.filter(data => {
-    const testProperty = joinEntity ? `${joinEntity}.${property}` : property;
-    return makeCondition(data, testProperty, comparator, value, type);
-  });
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.where = void 0;
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.some.js");
+var _compareAs = require("../utilities/compareAs");
+const likeMatch = (dataValue, pattern) => {
+  if (typeof dataValue !== 'string' || typeof pattern !== 'string') {
+    return false;
+  }
+  const regexPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/%/g, '.*').replace(/_/g, '.');
+  return new RegExp(`^${regexPattern}$`, 'i').test(dataValue);
+};
+/**
+ * Equality (=, !=, <>, in) compares by the field's declared type when given one (see sameValue), so
+ * '3' and 3 match in a string or int field. Ordering (>, <, between, like) compares the raw values.
+ *
+ * Null and missing are their own cases, as in SQL: a field that is null or missing matches no comparison (not even
+ * `!=`), and a null never equals anything, not even another null. Only these test for them:
+ * - `is null`: the field is there and holds null
+ * - `is not null`: the field is there and holds a value (so a missing field doesn't match either)
+ * - `exists` / `does not exist`: the field is there (null counts) / is missing
+ * @param data
+ * @param property
+ * @param comparator
+ * @param value
+ * @param type
+ */
+const makeCondition = (data, property, comparator, value, type = undefined) => {
+  const exists = Object.prototype.hasOwnProperty.call(data, property);
+  switch (comparator) {
+    case 'exists':
+      return exists;
+    case 'does not exist':
+      return !exists;
+    case 'is null':
+      return exists && data[property] === null;
+    case 'is not null':
+      return exists && data[property] !== null;
+  }
+  if (!exists || data[property] === null || value === null) {
+    return false;
+  }
+  const dataValue = data[property];
+  switch (comparator) {
+    case '=':
+      return (0, _compareAs.sameValue)(type, dataValue, value);
+    case '!=':
+    case '<>':
+      return !(0, _compareAs.sameValue)(type, dataValue, value);
+    case '>':
+      return dataValue > value;
+    case '>=':
+      return dataValue >= value;
+    case '<':
+      return dataValue < value;
+    case '<=':
+      return dataValue <= value;
+    case 'in':
+      return Array.isArray(value) && (type ? value.some(item => (0, _compareAs.sameValue)(type, dataValue, item)) : value.includes(dataValue));
+    case 'between':
+      // A null bound would act as 0 in >= / <=: it bounds nothing, so nothing matches (the parser refuses it)
+      return Array.isArray(value) && value.length === 2 && !value.includes(null) && dataValue >= value[0] && dataValue <= value[1];
+    case 'like':
+      return likeMatch(dataValue, value);
+  }
+  return false;
+};
+const where = (dataSet = [], {
+  property = '',
+  joinEntity = undefined,
+  comparator = '=',
+  value = null,
+  type = undefined
+} = {}) => {
+  return dataSet.filter(data => {
+    const testProperty = joinEntity ? `${joinEntity}.${property}` : property;
+    return makeCondition(data, testProperty, comparator, value, type);
+  });
+};
 exports.where = where;

package/dist/data/queries/where.min.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.where=void 0,require("core-js/modules/es.array.includes.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.some.js");var _compareAs=require("../utilities/compareAs");const likeMatch=(e,r)=>{if("string"!=typeof e||"string"!=typeof r)return!1;const t=r.replace(/[.*+?^${}()|[\]\\]/g,"\\$&").replace(/%/g,".*").replace(/_/g,".");return new RegExp(`^${t}$`,"i").test(e)},makeCondition=(e,r,t,s,a=void 0)=>{if(!Object.prototype.hasOwnProperty.call(e,r))return!1;const o=e[r];switch(t){case"=":return(0,_compareAs.sameValue)(a,o,s);case"!=":case"<>":return!(0,_compareAs.sameValue)(a,o,s);case">":return o>s;case">=":return o>=s;case"<":return o<s;case"<=":return o<=s;case"in":return Array.isArray(s)&&(a?s.some((e=>(0,_compareAs.sameValue)(a,o,e))):s.includes(o));case"between":return Array.isArray(s)&&2===s.length&&o>=s[0]&&o<=s[1];case"like":return likeMatch(o,s)}return!1},where=(e=[],{property:r="",joinEntity:t,comparator:s="=",value:a=null,type:o}={})=>e.filter((e=>makeCondition(e,t?`${t}.${r}`:r,s,a,o)));exports.where=where;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.where=void 0,require("core-js/modules/es.array.includes.js"),require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.filter.js"),require("core-js/modules/esnext.iterator.some.js");var _compareAs=require("../utilities/compareAs");const likeMatch=(e,r)=>{if("string"!=typeof e||"string"!=typeof r)return!1;const t=r.replace(/[.*+?^${}()|[\]\\]/g,"\\$&").replace(/%/g,".*").replace(/_/g,".");return new RegExp(`^${t}$`,"i").test(e)},makeCondition=(e,r,t,s,n=void 0)=>{const a=Object.prototype.hasOwnProperty.call(e,r);switch(t){case"exists":return a;case"does not exist":return!a;case"is null":return a&&null===e[r];case"is not null":return a&&null!==e[r]}if(!a||null===e[r]||null===s)return!1;const o=e[r];switch(t){case"=":return(0,_compareAs.sameValue)(n,o,s);case"!=":case"<>":return!(0,_compareAs.sameValue)(n,o,s);case">":return o>s;case">=":return o>=s;case"<":return o<s;case"<=":return o<=s;case"in":return Array.isArray(s)&&(n?s.some((e=>(0,_compareAs.sameValue)(n,o,e))):s.includes(o));case"between":return Array.isArray(s)&&2===s.length&&!s.includes(null)&&o>=s[0]&&o<=s[1];case"like":return likeMatch(o,s)}return!1},where=(e=[],{property:r="",joinEntity:t,comparator:s="=",value:n=null,type:a}={})=>e.filter((e=>makeCondition(e,t?`${t}.${r}`:r,s,n,a)));exports.where=where;

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

@@ -1,20 +1,20 @@
-/**
- * Normalize a value to a field's declared type for an equality comparison - never written back,
- * only compared. Writes are coerced to the declared type (typeCheck), but values already stored
- * may not match it (ids declared string, so they can hold an integer or a UUID, are often stored
- * as numbers), and query literals carry their own type. A declared type is what says '3' and 3
- * are the same value. A missing or unrecognized type returns the value unchanged.
- * @param type
- * @param value
- */
-export declare const compareAs: (type: string | undefined, value: any) => any;
-/**
- * Whether two values are equal for a field of the given declared type: both are normalized to
- * that type (see compareAs) and compared strictly. A field with no declared type, or one that
- * can't be normalized (object, array, or an unrecognized type), keeps loose equality.
- * @param type
- * @param a
- * @param b
- */
-export declare const sameValue: (type: string | undefined, a: any, b: any) => boolean;
+/**
+ * Normalize a value to a field's declared type for an equality comparison - never written back,
+ * only compared. Writes are coerced to the declared type (typeCheck), but values already stored
+ * may not match it (ids declared string, so they can hold an integer or a UUID, are often stored
+ * as numbers), and query literals carry their own type. A declared type is what says '3' and 3
+ * are the same value. A missing or unrecognized type returns the value unchanged.
+ * @param type
+ * @param value
+ */
+export declare const compareAs: (type: string | undefined, value: any) => any;
+/**
+ * Whether two values are equal for a field of the given declared type: both are normalized to
+ * that type (see compareAs) and compared strictly. A field with no declared type, or one that
+ * can't be normalized (object, array, or an unrecognized type), keeps loose equality.
+ * @param type
+ * @param a
+ * @param b
+ */
+export declare const sameValue: (type: string | undefined, a: any, b: any) => boolean;
 //# sourceMappingURL=compareAs.d.ts.map

package/dist/data/utilities/compareAs.js

@@ -1,58 +1,58 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.sameValue = exports.compareAs = void 0;
-require("core-js/modules/es.array.includes.js");
-/**
- * Normalize a value to a field's declared type for an equality comparison - never written back,
- * only compared. Writes are coerced to the declared type (typeCheck), but values already stored
- * may not match it (ids declared string, so they can hold an integer or a UUID, are often stored
- * as numbers), and query literals carry their own type. A declared type is what says '3' and 3
- * are the same value. A missing or unrecognized type returns the value unchanged.
- * @param type
- * @param value
- */
-const compareAs = (type, value) => {
-  if (value === null || typeof value === 'undefined') {
-    return value;
-  }
-  switch (type) {
-    case 'string':
-      return typeof value === 'object' ? value : String(value);
-    case 'int':
-      {
-        const coerced = Number(value);
-        return Number.isNaN(coerced) ? value : coerced;
-      }
-    case 'boolean':
-      if (value === 'true') {
-        return true;
-      }
-      if (value === 'false') {
-        return false;
-      }
-      return value;
-    default:
-      return value;
-  }
-};
-exports.compareAs = compareAs;
-const comparableTypes = ['string', 'int', 'boolean'];
-/**
- * Whether two values are equal for a field of the given declared type: both are normalized to
- * that type (see compareAs) and compared strictly. A field with no declared type, or one that
- * can't be normalized (object, array, or an unrecognized type), keeps loose equality.
- * @param type
- * @param a
- * @param b
- */
-const sameValue = (type, a, b) => {
-  if (!comparableTypes.includes(type)) {
-    // eslint-disable-next-line eqeqeq
-    return a == b;
-  }
-  return compareAs(type, a) === compareAs(type, b);
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sameValue = exports.compareAs = void 0;
+require("core-js/modules/es.array.includes.js");
+/**
+ * Normalize a value to a field's declared type for an equality comparison - never written back,
+ * only compared. Writes are coerced to the declared type (typeCheck), but values already stored
+ * may not match it (ids declared string, so they can hold an integer or a UUID, are often stored
+ * as numbers), and query literals carry their own type. A declared type is what says '3' and 3
+ * are the same value. A missing or unrecognized type returns the value unchanged.
+ * @param type
+ * @param value
+ */
+const compareAs = (type, value) => {
+  if (value === null || typeof value === 'undefined') {
+    return value;
+  }
+  switch (type) {
+    case 'string':
+      return typeof value === 'object' ? value : String(value);
+    case 'int':
+      {
+        const coerced = Number(value);
+        return Number.isNaN(coerced) ? value : coerced;
+      }
+    case 'boolean':
+      if (value === 'true') {
+        return true;
+      }
+      if (value === 'false') {
+        return false;
+      }
+      return value;
+    default:
+      return value;
+  }
+};
+exports.compareAs = compareAs;
+const comparableTypes = ['string', 'int', 'boolean'];
+/**
+ * Whether two values are equal for a field of the given declared type: both are normalized to
+ * that type (see compareAs) and compared strictly. A field with no declared type, or one that
+ * can't be normalized (object, array, or an unrecognized type), keeps loose equality.
+ * @param type
+ * @param a
+ * @param b
+ */
+const sameValue = (type, a, b) => {
+  if (!comparableTypes.includes(type)) {
+    // eslint-disable-next-line eqeqeq
+    return a == b;
+  }
+  return compareAs(type, a) === compareAs(type, b);
+};
 exports.sameValue = sameValue;

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

@@ -3,6 +3,18 @@ export type RuntimeSettings = {
     relativePath: string;
     enforceForeignKeys: boolean;
 };
+/**
+ * The folder a databasePath points to, so that `database/`, `./database` and its absolute path count as one database.
+ * Node only (only Node calls are counted, see trackDatabaseCall).
+ * @param databasePath
+ */
+export declare const resolveDatabasePath: (databasePath: string) => string;
+/**
+ * Count a database call (taken by withDatabaseLock as soon as a call is queued) until the returned function is called.
+ * While any call is counted, configure() refuses to point databasePath somewhere else: every step of a call reads
+ * databasePath again, so a change halfway would write part of the call to one folder and the rest to another.
+ */
+export declare const trackDatabaseCall: () => (() => void);
 /**
  * Set where this package's data lives: databasePath (a filesystem path, used in Node) and/or
  * relativePath (a URL prefix prepended to databasePath, used when reading over fetch() in a
@@ -13,7 +25,10 @@ export type RuntimeSettings = {
  * that would leave another record's foreign key pointing at a value that no longer exists -
  * mirroring MySQL's own foreign_key_checks setting, which is also toggleable rather than always
  * on, since strict enforcement isn't always what every consumer wants.
+ *
+ * Changing databasePath while calls are still running or queued throws (see trackDatabaseCall): await them first.
  * @param newSettings
+ * @throws {Error} When databasePath would point to another folder while database calls are in progress.
  */
 export declare const configure: (newSettings: Partial<RuntimeSettings>) => void;
 /**

package/dist/data/utilities/config.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getSetting = exports.configure = void 0;
+exports.trackDatabaseCall = exports.resolveDatabasePath = exports.getSetting = exports.configure = void 0;
 const defaults = {
   databasePath: 'database/',
   relativePath: '',
@@ -12,6 +12,29 @@ const defaults = {
 let settings = {
   ...defaults
 };
+let activeCalls = 0;
+/**
+ * The folder a databasePath points to, so that `database/`, `./database` and its absolute path count as one database.
+ * Node only (only Node calls are counted, see trackDatabaseCall).
+ * @param databasePath
+ */
+const resolveDatabasePath = databasePath => require('path').resolve(databasePath);
+/**
+ * Count a database call (taken by withDatabaseLock as soon as a call is queued) until the returned function is called.
+ * While any call is counted, configure() refuses to point databasePath somewhere else: every step of a call reads
+ * databasePath again, so a change halfway would write part of the call to one folder and the rest to another.
+ */
+exports.resolveDatabasePath = resolveDatabasePath;
+const trackDatabaseCall = () => {
+  activeCalls++;
+  let ended = false;
+  return () => {
+    if (!ended) {
+      ended = true;
+      activeCalls--;
+    }
+  };
+};
 /**
  * Set where this package's data lives: databasePath (a filesystem path, used in Node) and/or
  * relativePath (a URL prefix prepended to databasePath, used when reading over fetch() in a
@@ -22,9 +45,16 @@ let settings = {
  * that would leave another record's foreign key pointing at a value that no longer exists -
  * mirroring MySQL's own foreign_key_checks setting, which is also toggleable rather than always
  * on, since strict enforcement isn't always what every consumer wants.
+ *
+ * Changing databasePath while calls are still running or queued throws (see trackDatabaseCall): await them first.
  * @param newSettings
+ * @throws {Error} When databasePath would point to another folder while database calls are in progress.
  */
+exports.trackDatabaseCall = trackDatabaseCall;
 const configure = newSettings => {
+  if (activeCalls > 0 && typeof newSettings.databasePath !== 'undefined' && resolveDatabasePath(newSettings.databasePath) !== resolveDatabasePath(settings.databasePath)) {
+    throw new Error(`Can't change databasePath while ${activeCalls} database call(s) are still running or queued: await them first`);
+  }
   settings = {
     ...settings,
     ...newSettings

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

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.getSetting=exports.configure=void 0;const defaults={databasePath:"database/",relativePath:"",enforceForeignKeys:!0};let settings={...defaults};const configure=t=>{settings={...settings,...t}};exports.configure=configure;const getSetting=(t,e)=>void 0!==settings[t]?settings[t]:e;exports.getSetting=getSetting;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.trackDatabaseCall=exports.resolveDatabasePath=exports.getSetting=exports.configure=void 0;const defaults={databasePath:"database/",relativePath:"",enforceForeignKeys:!0};let settings={...defaults},activeCalls=0;const resolveDatabasePath=t=>require("path").resolve(t);exports.resolveDatabasePath=resolveDatabasePath;const trackDatabaseCall=()=>{activeCalls++;let t=!1;return()=>{t||(t=!0,activeCalls--)}};exports.trackDatabaseCall=trackDatabaseCall;const configure=t=>{if(activeCalls>0&&void 0!==t.databasePath&&resolveDatabasePath(t.databasePath)!==resolveDatabasePath(settings.databasePath))throw new Error(`Can't change databasePath while ${activeCalls} database call(s) are still running or queued: await them first`);settings={...settings,...t}};exports.configure=configure;const getSetting=(t,a)=>void 0!==settings[t]?settings[t]:a;exports.getSetting=getSetting;

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

@@ -0,0 +1,16 @@
+/**
+ * Run `task` once every earlier task on the same database (the configured databasePath) has finished, so that calls
+ * never interleave. Every write is several files in turn (an entry, the record's entry list, each index), each read and
+ * rewritten whole, so two writes running at once overwrite each other's changes: ten parallel inserts used to leave
+ * nine of the rows unreadable, and two parallel inserts of one unique value both succeeded. Reads take their turn too,
+ * so a read never sees a write half done. A task that throws still lets the next one run.
+ *
+ * Only the public functions (query, create, drop, describe) take the lock; what they call inside doesn't take it
+ * again, so it can't deadlock. In the browser nothing can be written, so tasks just run.
+ *
+ * The queue is per folder (`database/` and `./database` share one). Every step of a task reads databasePath when it
+ * runs, so configure() refuses to change it while tasks are queued or running (see trackDatabaseCall).
+ * @param task
+ */
+export declare const withDatabaseLock: <T>(task: () => Promise<T>) => Promise<T>;
+//# sourceMappingURL=databaseLock.d.ts.map

package/dist/data/utilities/databaseLock.js

@@ -0,0 +1,63 @@
+"use strict";
+
+require("core-js/modules/esnext.weak-map.delete-all.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withDatabaseLock = void 0;
+require("core-js/modules/esnext.map.delete-all.js");
+require("core-js/modules/esnext.map.every.js");
+require("core-js/modules/esnext.map.filter.js");
+require("core-js/modules/esnext.map.find.js");
+require("core-js/modules/esnext.map.find-key.js");
+require("core-js/modules/esnext.map.includes.js");
+require("core-js/modules/esnext.map.key-of.js");
+require("core-js/modules/esnext.map.map-keys.js");
+require("core-js/modules/esnext.map.map-values.js");
+require("core-js/modules/esnext.map.merge.js");
+require("core-js/modules/esnext.map.reduce.js");
+require("core-js/modules/esnext.map.some.js");
+require("core-js/modules/esnext.map.update.js");
+var jsEnv = _interopRequireWildcard(require("browser-or-node"));
+var _config = require("./config");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const queues = new Map();
+/**
+ * Run `task` once every earlier task on the same database (the configured databasePath) has finished, so that calls
+ * never interleave. Every write is several files in turn (an entry, the record's entry list, each index), each read and
+ * rewritten whole, so two writes running at once overwrite each other's changes: ten parallel inserts used to leave
+ * nine of the rows unreadable, and two parallel inserts of one unique value both succeeded. Reads take their turn too,
+ * so a read never sees a write half done. A task that throws still lets the next one run.
+ *
+ * Only the public functions (query, create, drop, describe) take the lock; what they call inside doesn't take it
+ * again, so it can't deadlock. In the browser nothing can be written, so tasks just run.
+ *
+ * The queue is per folder (`database/` and `./database` share one). Every step of a task reads databasePath when it
+ * runs, so configure() refuses to change it while tasks are queued or running (see trackDatabaseCall).
+ * @param task
+ */
+const withDatabaseLock = async task => {
+  if (!jsEnv.isNode) {
+    return task();
+  }
+  const database = (0, _config.resolveDatabasePath)((0, _config.getSetting)('databasePath', 'database/'));
+  const ended = (0, _config.trackDatabaseCall)();
+  const previous = queues.get(database) || Promise.resolve();
+  let release;
+  const turn = new Promise(resolve => {
+    release = resolve;
+  });
+  const queued = previous.then(() => turn);
+  queues.set(database, queued);
+  await previous;
+  try {
+    return await task();
+  } finally {
+    ended();
+    release();
+    if (queues.get(database) === queued) {
+      queues.delete(database);
+    }
+  }
+};
+exports.withDatabaseLock = withDatabaseLock;

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

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.withDatabaseLock=void 0,require("core-js/modules/esnext.map.delete-all.js"),require("core-js/modules/esnext.map.every.js"),require("core-js/modules/esnext.map.filter.js"),require("core-js/modules/esnext.map.find.js"),require("core-js/modules/esnext.map.find-key.js"),require("core-js/modules/esnext.map.includes.js"),require("core-js/modules/esnext.map.key-of.js"),require("core-js/modules/esnext.map.map-keys.js"),require("core-js/modules/esnext.map.map-values.js"),require("core-js/modules/esnext.map.merge.js"),require("core-js/modules/esnext.map.reduce.js"),require("core-js/modules/esnext.map.some.js"),require("core-js/modules/esnext.map.update.js");var jsEnv=_interopRequireWildcard(require("browser-or-node")),_config=require("./config");function _interopRequireWildcard(e,r){if("function"==typeof WeakMap)var s=new WeakMap,t=new WeakMap;return(_interopRequireWildcard=function(e,r){if(!r&&e&&e.__esModule)return e;var o,a,u={__proto__:null,default:e};if(null===e||"object"!=typeof e&&"function"!=typeof e)return u;if(o=r?t:s){if(o.has(e))return o.get(e);o.set(e,u)}for(const r in e)"default"!==r&&{}.hasOwnProperty.call(e,r)&&((a=(o=Object.defineProperty)&&Object.getOwnPropertyDescriptor(e,r))&&(a.get||a.set)?o(u,r,a):u[r]=e[r]);return u})(e,r)}const queues=new Map,withDatabaseLock=async e=>{if(!jsEnv.isNode)return e();const r=(0,_config.resolveDatabasePath)((0,_config.getSetting)("databasePath","database/")),s=(0,_config.trackDatabaseCall)(),t=queues.get(r)||Promise.resolve();let o;const a=new Promise((e=>{o=e})),u=t.then((()=>a));queues.set(r,u),await t;try{return await e()}finally{s(),o(),queues.get(r)===u&&queues.delete(r)}};exports.withDatabaseLock=withDatabaseLock;

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

@@ -1,16 +1,16 @@
-import { recordDefinition } from '../introspect/definitions/record';
-import { keyDefinition } from '../introspect/definitions/key';
-/**
- * The declared type of one of a record's fields, or undefined when the record or field is unknown.
- * @param record
- * @param property
- */
-export declare const fieldType: (record: recordDefinition | undefined, property: string) => string | undefined;
-/**
- * The declared type of the value a key indexes: its field's type for a single-field key. A
- * multi-field key's value is a composite (see computeKeyValue), so it has no single declared type.
- * @param record
- * @param key
- */
-export declare const keyValueType: (record: recordDefinition | undefined, key: keyDefinition) => string | undefined;
+import { recordDefinition } from '../introspect/definitions/record';
+import { keyDefinition } from '../introspect/definitions/key';
+/**
+ * The declared type of one of a record's fields, or undefined when the record or field is unknown.
+ * @param record
+ * @param property
+ */
+export declare const fieldType: (record: recordDefinition | undefined, property: string) => string | undefined;
+/**
+ * The declared type of the value a key indexes: its field's type for a single-field key. A
+ * multi-field key's value is a composite (see computeKeyValue), so it has no single declared type.
+ * @param record
+ * @param key
+ */
+export declare const keyValueType: (record: recordDefinition | undefined, key: keyDefinition) => string | undefined;
 //# sourceMappingURL=fieldType.d.ts.map

package/dist/data/utilities/fieldType.js

@@ -1,23 +1,23 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.keyValueType = exports.fieldType = void 0;
-require("core-js/modules/esnext.iterator.constructor.js");
-require("core-js/modules/esnext.iterator.find.js");
-/**
- * The declared type of one of a record's fields, or undefined when the record or field is unknown.
- * @param record
- * @param property
- */
-const fieldType = (record, property) => record?.definition?.find(field => field.name === property)?.type;
-/**
- * The declared type of the value a key indexes: its field's type for a single-field key. A
- * multi-field key's value is a composite (see computeKeyValue), so it has no single declared type.
- * @param record
- * @param key
- */
-exports.fieldType = fieldType;
-const keyValueType = (record, key) => key.fields.length === 1 ? fieldType(record, key.fields[0]) : undefined;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.keyValueType = exports.fieldType = void 0;
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.find.js");
+/**
+ * The declared type of one of a record's fields, or undefined when the record or field is unknown.
+ * @param record
+ * @param property
+ */
+const fieldType = (record, property) => record?.definition?.find(field => field.name === property)?.type;
+/**
+ * The declared type of the value a key indexes: its field's type for a single-field key. A
+ * multi-field key's value is a composite (see computeKeyValue), so it has no single declared type.
+ * @param record
+ * @param key
+ */
+exports.fieldType = fieldType;
+const keyValueType = (record, key) => key.fields.length === 1 ? fieldType(record, key.fields[0]) : undefined;
 exports.keyValueType = keyValueType;