@harperfast/harper 5.0.25 → 5.1.0-beta.1

package/dist/utility/lmdb/searchUtility.d.ts

@@ -1,3 +1,42 @@
+/** UTILITY CURSOR FUNCTIONS **/
+/**
+ * Creates the basis for a full iteration of a dbi with an evaluation function used to determine the logic inside the iteration
+ * @param {lmdb.Transaction} transactionOrEnv
+ * @param {String} hash_attribute
+ * @param {String} attribute
+ * @param {boolean} reverse - defines if the iterator goes from last to first
+ * @param {number} limit - defines the max number of entries to iterate
+ * @param {number} offset - defines the entries to skip
+ * @returns {[]}
+ */
+export declare function iterateFullIndex(this: any, transactionOrEnv: any, hash_attribute: any, attribute: any, reverse?: boolean, limit?: any, offset?: any): any;
+/**
+ * specific iterator function for perfroming betweens on numeric columns
+ * for this function specifically it is important to remember that the buffer representations of numbers are stored in the following order:
+ * 0,1,2,3,4,5,6.....1000,-1,-2,-3,-4,-5,-6....-1000
+ * as such we need to do some work with the cursor in order to move to the point we need depending on the type of range we are searching.
+ * another important point to remember is the search is always iterating forward.  this makes sense for positive number searches,
+ * but get wonky for negative number searches and especially for a range of between -4 & 6.  the reason is we will start the iterator at 0, move forward to 6,
+ * then we need to jump forward to the highest negative number and stop at the start of our range (-4).
+ * @param {TableTransaction} transactionOrEnv
+ * @param {String} hash_attribute
+ * @param {String} attribute
+ * @param {Number|String} lowerValue
+ * @param {Number|String} upperValue
+ * @param {boolean} reverse
+ * @param {number} limit - defines the max number of entries to iterate
+ * @param {number} offset - defines the entries to skip
+ * @returns {Iterable}
+ */
+export declare function iterateRangeBetween(this: any, transactionOrEnv: any, hash_attribute: any, attribute: any, lowerValue: any, upperValue: any, reverse?: boolean, limit?: any, offset?: any, exclusiveLower?: boolean, exclusiveUpper?: boolean): any;
+/**
+ * @param {lmdb.Transaction|lmdb.RootDatabase} transactionOrEnv
+ * @param {String} hash_attribute
+ * @param {String} attribute
+ * @param {Function} callback
+ */
+export declare function setupTransaction(this: any, transactionOrEnv: any, hash_attribute: any, attribute: any, callback: any): any;
+export declare function getOverflowCheck(this: any, env: any, transaction: any, hash_attribute: any, attribute: any): (key: any, value: any) => any;
 /**
  * iterates the entire  hash_attribute dbi and returns all objects back
  * @param {lmdb.Transaction} transaction - Transaction used to interact with all data in an environment
@@ -8,7 +47,7 @@
  * @param {number} limit - defines the max number of entries to iterate
  * @param {number} offset - defines the entries to skip
  */
-export function searchAll(transactionOrEnv: any, hash_attribute: string, fetchAttributes: Array<string>, reverse?: boolean, limit?: number, offset?: number): Array<any>;
+export declare function searchAll(this: any, transactionOrEnv: any, hash_attribute: any, fetchAttributes: any, reverse?: boolean, limit?: any, offset?: any): any;
 /**
 * iterates the entire  hash_attribute dbi and returns all objects back in a map
 * @param {lmdb.Transaction} transactionOrEnv - Transaction used to interact with all data in an environment
@@ -20,22 +59,24 @@ export function searchAll(transactionOrEnv: any, hash_attribute: string, fetchAt
 * @returns {{String|Number, Object}} - object array of fetched records
 
 */
-export function searchAllToMap(transactionOrEnv: lmdb.Transaction, hash_attribute: string, fetchAttributes: Array<string>, reverse?: boolean, limit?: number, offset?: number): {};
+export declare function searchAllToMap(this: any, transactionOrEnv: any, hash_attribute: any, fetchAttributes: any, reverse?: boolean, limit?: any, offset?: any): Map<any, any>;
 /**
- * Counts the number of entries for a key of a named dbi, returning the count
- * @param {lmdb.RootDatabase} env - Transaction used to interact with all data in an environment
- * @param {String} hash_attribute
- * @param {String} attribute - name of the attribute (dbi) to search
- * @param searchValue - value to search
+ * iterates a dbi and returns the key/value pairing for each entry
+ * @param env
+ * @param attribute
+ * @param {boolean} reverse - defines if the iterator goes from last to first
+ * @param {number} limit - defines the max number of entries to iterate
+ * @param {number} offset - defines the entries to skip
+ * @returns {Array.<Array>}
  */
-export function count(env: lmdb.RootDatabase, attribute: string, searchValue: any): number;
+export declare function iterateDBI(this: any, transactionOrEnv: any, attribute: any, reverse?: boolean, limit?: any, offset?: any): any;
 /**
  * counts all records in an environment based on the count from stating the hash_attribute  dbi
  * @param {lmdb.RootDatabase} env - Transaction used to interact with all data in an environment
  * @param {String} hash_attribute - name of the hash_attribute for this environment
  * @returns {number} - number of records in the environment
  */
-export function countAll(env: lmdb.RootDatabase, hash_attribute: string): number;
+export declare function countAll(this: any, env: any, hash_attribute: any): any;
 /**
  * performs an equal search on the key of a named dbi, returns a list of ids where their keys literally match the searchValue
  * @param {lmdb.Transaction} transactionOrEnv - Transaction used to interact with all data in an environment
@@ -47,7 +88,15 @@ export function countAll(env: lmdb.RootDatabase, hash_attribute: string): number
  * @param {number} offset - defines the entries to skip
  * @returns {[[],[]]} - ids matching the search
  */
-export function equals(transactionOrEnv: lmdb.Transaction, hash_attribute: string, attribute: string, searchValue: any, reverse?: boolean, limit?: number, offset?: number): [[], []];
+export declare function equals(this: any, transactionOrEnv: any, hash_attribute: any, attribute: any, searchValue: any, reverse?: boolean, limit?: any, offset?: any): any;
+/**
+ * Counts the number of entries for a key of a named dbi, returning the count
+ * @param {lmdb.RootDatabase} env - Transaction used to interact with all data in an environment
+ * @param {String} hash_attribute
+ * @param {String} attribute - name of the attribute (dbi) to search
+ * @param searchValue - value to search
+ */
+export declare function count(this: any, env: any, attribute: any, searchValue: any): any;
 /**
  * performs an startsWith search on the key of a named dbi, returns a list of ids where their keys begin with the searchValue
  * @param {lmdb.Transaction} transactionOrEnv - Transaction used to interact with all data in an environment
@@ -59,7 +108,7 @@ export function equals(transactionOrEnv: lmdb.Transaction, hash_attribute: strin
  * @param {number} offset - defines the entries to skip
  * @returns {lmdb.ArrayLikeIterable<unknown>} - ids matching the search
  */
-export function startsWith(transactionOrEnv: lmdb.Transaction, hash_attribute: string, attribute: string, searchValue: any, reverse?: boolean, limit?: number, offset?: number): lmdb.ArrayLikeIterable<unknown>;
+export declare function startsWith(this: any, transactionOrEnv: any, hash_attribute: any, attribute: any, searchValue: any, reverse?: boolean, limit?: any, offset?: any): any;
 /**
  * performs an endsWith search on the key of a named dbi, returns a list of ids where their keys end with searchValue
  * @param {lmdb.Transaction} transaction - Transaction used to interact with all data in an environment
@@ -71,7 +120,7 @@ export function startsWith(transactionOrEnv: lmdb.Transaction, hash_attribute: s
  * @param {number} offset - defines the entries to skip
  * @returns {[[],[]]} - ids matching the search
  */
-export function endsWith(transaction: lmdb.Transaction, hash_attribute: string, attribute: string, searchValue: any, reverse?: boolean, limit?: number, offset?: number): [[], []];
+export declare function endsWith(this: any, transaction: any, hash_attribute: any, attribute: any, searchValue: any, reverse?: boolean, limit?: any, offset?: any): any;
 /**
  * performs a contains search on the key of a named dbi, returns a list of ids where their keys contain the searchValue
  * @param {lmdb.Transaction|lmdb.RootDatabase} transactionOrEnv - Transaction used to interact with all data in an
@@ -85,61 +134,7 @@ export function endsWith(transaction: lmdb.Transaction, hash_attribute: string,
  * @param {boolean} ends_with - Must only contain this value at the end
  * @returns {[[],[]]} - ids matching the search
  */
-export function contains(transactionOrEnv: lmdb.Transaction | lmdb.RootDatabase, hash_attribute: string, attribute: string, searchValue: string | number, reverse?: boolean, limit?: number, offset?: number, ends_with?: boolean): [[], []];
-/**
- * finds a single record based on the id passed
- * @param {lmdb.Transaction} transactionOrEnv - Transaction used to interact with all data in an environment
- * @param {String} hash_attribute - name of the hash_attribute for this environment
- * @param {Array.<String>} fetchAttributes - string array of attributes to pull from the object
- * @param {String} id - id value to search
- * @returns {{}} - object found
- */
-export function searchByHash(transactionOrEnv: lmdb.Transaction, hash_attribute: string, fetchAttributes: Array<string>, id: string): {};
-/**
- * determines if the intent is to return the whole row based on fetchAttributes having 1 entry that is wildcard * or %
- * @param env
- * @param fetchAttributes
- * @returns {Array}
- */
-export function setGetWholeRowAttributes(env: any, fetchAttributes: any): any[];
-/**
- * finds an array of records based on the ids passed
- * @param {lmdb.Transaction} transactionOrEnv - Transaction used to interact with all data in an environment
- * @param {String} hash_attribute - name of the hash_attribute for this environment
- * @param {Array.<String>} fetchAttributes - string array of attributes to pull from the object
- * @param {Array.<String>} ids - list of ids to search
- * @param {[]} [notFound] - optional, meant to be an array passed by reference so that skipped ids can be aggregated.
- * @returns {Map} - Map of records found
- */
-export function batchSearchByHash(transactionOrEnv: lmdb.Transaction, hash_attribute: string, fetchAttributes: Array<string>, ids: Array<string>, notFound?: []): Map<any, any>;
-/**
- * finds an array of records based on the ids passed and returns a map of the results
- * @param {lmdb.Transaction} transactionOrEnv - Transaction used to interact with all data in an environment
- * @param {String} hash_attribute - name of the hash_attribute for this environment
- * @param {Array.<String>} fetchAttributes - string array of attributes to pull from the object
- * @param {Array.<String>} ids - list of ids to search
- * @param {[]} [notFound] - optional, meant to be an array passed by reference so that skipped ids can be aggregated.
- * @returns {Map} - Map of records found
- */
-export function batchSearchByHashToMap(transactionOrEnv: lmdb.Transaction, hash_attribute: string, fetchAttributes: Array<string>, ids: Array<string>, notFound?: []): Map<any, any>;
-/**
- * checks if a hash value exists based on the id passed
- * @param {lmdb.Transaction} transactionOrEnv - Transaction used to interact with all data in an environment
- * @param {String} hash_attribute - name of the hash_attribute for this environment
- * @param {String|Number} id - id value to check exists
- * @returns {boolean} - whether the hash exists (true) or not (false)
- */
-export function checkHashExists(transactionOrEnv: lmdb.Transaction, hash_attribute: string, id: string | number): boolean;
-/**
- * iterates a dbi and returns the key/value pairing for each entry
- * @param env
- * @param attribute
- * @param {boolean} reverse - defines if the iterator goes from last to first
- * @param {number} limit - defines the max number of entries to iterate
- * @param {number} offset - defines the entries to skip
- * @returns {Array.<Array>}
- */
-export function iterateDBI(transactionOrEnv: any, attribute: any, reverse?: boolean, limit?: number, offset?: number): Array<any[]>;
+export declare function contains(this: any, transactionOrEnv: any, hash_attribute: any, attribute: any, searchValue: any, reverse?: boolean, limit?: any, offset?: any, ends_with?: boolean): any;
 /** RANGE FUNCTIONS **/
 /**
  * performs a greater than search for string / numeric search value
@@ -152,7 +147,7 @@ export function iterateDBI(transactionOrEnv: any, attribute: any, reverse?: bool
  * @param {number} offset - defines the entries to skip
  * @returns {[[],[]]}
  */
-export function greaterThan(transactionOrEnv: lmdb.Transaction, hash_attribute: string, attribute: string, searchValue: string | number, reverse?: boolean, limit?: number, offset?: number): [[], []];
+export declare function greaterThan(this: any, transactionOrEnv: any, hash_attribute: any, attribute: any, searchValue: any, reverse?: boolean, limit?: any, offset?: any): any;
 /**
  * performs a greater than equal search for string / numeric search value
  * @param {lmdb.Transaction} transactionOrEnv
@@ -164,7 +159,7 @@ export function greaterThan(transactionOrEnv: lmdb.Transaction, hash_attribute:
  * @param {number} offset - defines the entries to skip
  * @returns {[[],[]]}
  */
-export function greaterThanEqual(transactionOrEnv: lmdb.Transaction, hash_attribute: string, attribute: string, searchValue: string | number, reverse?: boolean, limit?: number, offset?: number): [[], []];
+export declare function greaterThanEqual(this: any, transactionOrEnv: any, hash_attribute: any, attribute: any, searchValue: any, reverse?: boolean, limit?: any, offset?: any): any;
 /**
  * performs a less than search for string / numeric search value
  * @param {lmdb.Transaction} transactionOrEnv
@@ -176,7 +171,7 @@ export function greaterThanEqual(transactionOrEnv: lmdb.Transaction, hash_attrib
  * @param {number} offset - defines the entries to skip
  * @returns {[[],[]]}
  */
-export function lessThan(transactionOrEnv: lmdb.Transaction, hash_attribute: string, attribute: string, searchValue: string | number, reverse?: boolean, limit?: number, offset?: number): [[], []];
+export declare function lessThan(this: any, transactionOrEnv: any, hash_attribute: any, attribute: any, searchValue: any, reverse?: boolean, limit?: any, offset?: any): any;
 /**
  * performs a less than equal search for string / numeric search value
  * @param {lmdb.Transaction} transactionOrEnv
@@ -188,7 +183,7 @@ export function lessThan(transactionOrEnv: lmdb.Transaction, hash_attribute: str
  * @param {number} offset - defines the entries to skip
  * @returns {[[],[]]}
  */
-export function lessThanEqual(transactionOrEnv: lmdb.Transaction, hash_attribute: string, attribute: string, searchValue: string | number, reverse?: boolean, limit?: number, offset?: number): [[], []];
+export declare function lessThanEqual(this: any, transactionOrEnv: any, hash_attribute: any, attribute: any, searchValue: any, reverse?: boolean, limit?: any, offset?: any): any;
 /**
  * performs a between search for string / numeric search value
  * @param {lmdb.Transaction} transactionOrEnv
@@ -201,5 +196,79 @@ export function lessThanEqual(transactionOrEnv: lmdb.Transaction, hash_attribute
  * @param {number} offset - defines the entries to skip
  * @returns {*[]}
  */
-export function between(transactionOrEnv: lmdb.Transaction, hash_attribute: string, attribute: string, startValue: string | number, endValue: string | number, reverse?: boolean, limit?: number, offset?: number): any[];
-import lmdb = require("lmdb");
+export declare function between(this: any, transactionOrEnv: any, hash_attribute: any, attribute: any, startValue: any, endValue: any, reverse?: boolean, limit?: any, offset?: any): any;
+/**
+ * finds a single record based on the id passed
+ * @param {lmdb.Transaction} transactionOrEnv - Transaction used to interact with all data in an environment
+ * @param {String} hash_attribute - name of the hash_attribute for this environment
+ * @param {Array.<String>} fetchAttributes - string array of attributes to pull from the object
+ * @param {String} id - id value to search
+ * @returns {{}} - object found
+ */
+export declare function searchByHash(this: any, transactionOrEnv: any, hash_attribute: any, fetchAttributes: any, id: any): any;
+/**
+ * checks if a hash value exists based on the id passed
+ * @param {lmdb.Transaction} transactionOrEnv - Transaction used to interact with all data in an environment
+ * @param {String} hash_attribute - name of the hash_attribute for this environment
+ * @param {String|Number} id - id value to check exists
+ * @returns {boolean} - whether the hash exists (true) or not (false)
+ */
+export declare function checkHashExists(this: any, transactionOrEnv: any, hash_attribute: any, id: any): boolean;
+/**
+ * finds an array of records based on the ids passed
+ * @param {lmdb.Transaction} transactionOrEnv - Transaction used to interact with all data in an environment
+ * @param {String} hash_attribute - name of the hash_attribute for this environment
+ * @param {Array.<String>} fetchAttributes - string array of attributes to pull from the object
+ * @param {Array.<String>} ids - list of ids to search
+ * @param {[]} [notFound] - optional, meant to be an array passed by reference so that skipped ids can be aggregated.
+ * @returns {Map} - Map of records found
+ */
+export declare function batchSearchByHash(this: any, transactionOrEnv: any, hash_attribute: any, fetchAttributes: any, ids: any, notFound?: any[]): any;
+/**
+ * finds an array of records based on the ids passed and returns a map of the results
+ * @param {lmdb.Transaction} transactionOrEnv - Transaction used to interact with all data in an environment
+ * @param {String} hash_attribute - name of the hash_attribute for this environment
+ * @param {Array.<String>} fetchAttributes - string array of attributes to pull from the object
+ * @param {Array.<String>} ids - list of ids to search
+ * @param {[]} [notFound] - optional, meant to be an array passed by reference so that skipped ids can be aggregated.
+ * @returns {Map} - Map of records found
+ */
+export declare function batchSearchByHashToMap(this: any, transactionOrEnv: any, hash_attribute: any, fetchAttributes: any, ids: any, notFound?: any[]): Map<any, any>;
+/**
+ * finds an array of records based on the ids passed and returns a map of the results
+ * @param {lmdb.Transaction} transactionOrEnv - Transaction used to interact with all data in an environment
+ * @param {String} hash_attribute - name of the hash_attribute for this environment
+ * @param {Array.<String>} fetchAttributes - string array of attributes to pull from the object
+ * @param {Array.<String>} ids - list of ids to search
+ * @param {[]} [notFound] - optional, meant to be an array passed by reference so that skipped ids can be aggregated.
+ * @returns {Object}
+ */
+export declare function batchHashSearch(this: any, transactionOrEnv: any, hash_attribute: any, fetchAttributes: any, ids: any, notFound?: any[]): any;
+/**
+ * function used to intialize the batchSearchByHash functions
+ * @param {lmdb.Transaction} transactionOrEnv - Transaction used to interact with all data in an environment
+ * @param {String} hash_attribute - name of the hash_attribute for this environment
+ * @param {Array.<String>} fetchAttributes - string array of attributes to pull from the object
+ * @param {Array.<String>} ids - list of ids to search
+ * @param {[]} [_notFound] -optional,  meant to be an array passed by reference so that skipped ids can be aggregated.
+ */
+export declare function initializeBatchSearchByHash(this: any, transactionOrEnv: any, hash_attribute: any, fetchAttributes: any, ids: any, _notFound: any): void;
+/**
+ * validates the fetchAttributes argument
+ * @param fetchAttributes - string array of attributes to pull from the object
+ */
+export declare function validateFetchAttributes(this: any, fetchAttributes: any): void;
+/**
+ * common validation function for all of the comparison searches (equals, startsWith, endsWith, contains)
+ * @param {lmdb.RootDatabase} env - The env used to interact with all data in an environment
+ * @param attribute - name of the attribute (dbi) to search
+ * @param searchValue - value to search
+ */
+export declare function validateComparisonFunctions(this: any, env: any, attribute: any, searchValue: any): void;
+/**
+ * determines if the intent is to return the whole row based on fetchAttributes having 1 entry that is wildcard * or %
+ * @param env
+ * @param fetchAttributes
+ * @returns {Array}
+ */
+export declare function setGetWholeRowAttributes(this: any, env: any, fetchAttributes: any): any;

package/dist/utility/lmdb/searchUtility.js

@@ -1,14 +1,71 @@
 'use strict';
-const environmentUtility = require('./environmentUtility.js');
-const common = require('./commonUtility.js');
-const lmdbTerms = require('./terms.js');
-const LMDB_ERRORS = require('../errors/commonErrors.js').LMDB_ERRORS_ENUM;
-const hdbTerms = require("../hdbTerms.js");
-const cursorFunctions = require('./searchCursorFunctions.js');
-const { parseRow } = cursorFunctions;
-// eslint-disable-next-line no-unused-vars
-const lmdb = require('lmdb');
-const { OVERFLOW_MARKER, MAX_SEARCH_KEY_LENGTH } = lmdbTerms;
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iterateFullIndex = iterateFullIndex;
+exports.iterateRangeBetween = iterateRangeBetween;
+exports.setupTransaction = setupTransaction;
+exports.getOverflowCheck = getOverflowCheck;
+exports.searchAll = searchAll;
+exports.searchAllToMap = searchAllToMap;
+exports.iterateDBI = iterateDBI;
+exports.countAll = countAll;
+exports.equals = equals;
+exports.count = count;
+exports.startsWith = startsWith;
+exports.endsWith = endsWith;
+exports.contains = contains;
+exports.greaterThan = greaterThan;
+exports.greaterThanEqual = greaterThanEqual;
+exports.lessThan = lessThan;
+exports.lessThanEqual = lessThanEqual;
+exports.between = between;
+exports.searchByHash = searchByHash;
+exports.checkHashExists = checkHashExists;
+exports.batchSearchByHash = batchSearchByHash;
+exports.batchSearchByHashToMap = batchSearchByHashToMap;
+exports.batchHashSearch = batchHashSearch;
+exports.initializeBatchSearchByHash = initializeBatchSearchByHash;
+exports.validateFetchAttributes = validateFetchAttributes;
+exports.validateComparisonFunctions = validateComparisonFunctions;
+exports.setGetWholeRowAttributes = setGetWholeRowAttributes;
+const environmentUtility = __importStar(require("./environmentUtility.js"));
+const common = __importStar(require("./commonUtility.js"));
+const lmdbTerms = __importStar(require("./terms.js"));
+const commonErrors_ts_1 = require("../errors/commonErrors.js");
+const hdbTerms = __importStar(require("../hdbTerms.js"));
+const cursorFunctions = __importStar(require("./searchCursorFunctions.js"));
 /** UTILITY CURSOR FUNCTIONS **/
 /**
  * Creates the basis for a full iteration of a dbi with an evaluation function used to determine the logic inside the iteration
@@ -110,7 +167,7 @@ function setupTransaction(transactionOrEnv, hash_attribute, attribute, callback)
 function getOverflowCheck(env, transaction, hash_attribute, attribute) {
     let primaryDbi;
     return function (key, value) {
-        if (typeof key === 'string' && key.endsWith(OVERFLOW_MARKER)) {
+        if (typeof key === 'string' && key.endsWith(lmdbTerms.OVERFLOW_MARKER)) {
             // the entire value couldn't be encoded because it was too long, so need to search the attribute from
             // the original record.
             // first get the hash/primary dbi
@@ -148,7 +205,7 @@ function getOverflowCheck(env, transaction, hash_attribute, attribute) {
 function searchAll(transactionOrEnv, hash_attribute, fetchAttributes, reverse = false, limit = undefined, offset = undefined) {
     common.validateEnv(transactionOrEnv);
     if (hash_attribute === undefined) {
-        throw new Error(LMDB_ERRORS.HASH_ATTRIBUTE_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.HASH_ATTRIBUTE_REQUIRED);
     }
     return setupTransaction(transactionOrEnv, hash_attribute, hash_attribute, (transaction, dbi, env) => {
         validateFetchAttributes(fetchAttributes);
@@ -163,7 +220,7 @@ function searchAll(transactionOrEnv, hash_attribute, fetchAttributes, reverse =
             reverse,
         })
             .map((entry) => {
-            return parseRow(entry.value, fetchAttributes);
+            return cursorFunctions.parseRow(entry.value, fetchAttributes);
         });
     });
 }
@@ -181,7 +238,7 @@ function searchAll(transactionOrEnv, hash_attribute, fetchAttributes, reverse =
 function searchAllToMap(transactionOrEnv, hash_attribute, fetchAttributes, reverse = false, limit = undefined, offset = undefined) {
     common.validateEnv(transactionOrEnv);
     if (hash_attribute === undefined) {
-        throw new Error(LMDB_ERRORS.HASH_ATTRIBUTE_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.HASH_ATTRIBUTE_REQUIRED);
     }
     validateFetchAttributes(fetchAttributes);
     fetchAttributes = setGetWholeRowAttributes(transactionOrEnv.database || transactionOrEnv, fetchAttributes);
@@ -203,7 +260,7 @@ function searchAllToMap(transactionOrEnv, hash_attribute, fetchAttributes, rever
 function iterateDBI(transactionOrEnv, attribute, reverse = false, limit = undefined, offset = undefined) {
     common.validateEnv(transactionOrEnv);
     if (attribute === undefined) {
-        throw new Error(LMDB_ERRORS.ATTRIBUTE_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.ATTRIBUTE_REQUIRED);
     }
     let results = Object.create(null);
     let iterator = iterateFullIndex(transactionOrEnv, undefined, attribute, reverse, limit, offset);
@@ -227,7 +284,7 @@ function iterateDBI(transactionOrEnv, attribute, reverse = false, limit = undefi
 function countAll(env, hash_attribute) {
     common.validateEnv(env);
     if (hash_attribute === undefined) {
-        throw new Error(LMDB_ERRORS.HASH_ATTRIBUTE_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.HASH_ATTRIBUTE_REQUIRED);
     }
     let stat = environmentUtility.statDBI(env, hash_attribute);
     return stat.entryCount;
@@ -379,7 +436,7 @@ function contains(transactionOrEnv, hash_attribute, attribute, searchValue, reve
             .getKeys({ transaction, end: reverse ? false : undefined, reverse })
             .flatMap((key) => {
             let foundStr = key.toString();
-            if (foundStr.endsWith(OVERFLOW_MARKER)) {
+            if (foundStr.endsWith(lmdbTerms.OVERFLOW_MARKER)) {
                 // the entire value couldn't be encoded because it was too long, so need to search the attributes from
                 // the original record
                 return attrDbi
@@ -515,18 +572,18 @@ function lessThanEqual(transactionOrEnv, hash_attribute, attribute, searchValue,
 function between(transactionOrEnv, hash_attribute, attribute, startValue, endValue, reverse = false, limit = undefined, offset = undefined) {
     common.validateEnv(transactionOrEnv);
     if (attribute === undefined) {
-        throw new Error(LMDB_ERRORS.ATTRIBUTE_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.ATTRIBUTE_REQUIRED);
     }
     if (startValue === undefined) {
-        throw new Error(LMDB_ERRORS.START_VALUE_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.START_VALUE_REQUIRED);
     }
     if (endValue === undefined) {
-        throw new Error(LMDB_ERRORS.END_VALUE_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.END_VALUE_REQUIRED);
     }
     startValue = common.convertKeyValueToWrite(startValue);
     endValue = common.convertKeyValueToWrite(endValue);
     if (startValue > endValue) {
-        throw new Error(LMDB_ERRORS.END_VALUE_MUST_BE_GREATER_THAN_START_VALUE);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.END_VALUE_MUST_BE_GREATER_THAN_START_VALUE);
     }
     return iterateRangeBetween(transactionOrEnv, hash_attribute, attribute, startValue, endValue, reverse, limit, offset);
 }
@@ -543,12 +600,12 @@ function searchByHash(transactionOrEnv, hash_attribute, fetchAttributes, id) {
     let env = transactionOrEnv.database || transactionOrEnv;
     let transaction = transactionOrEnv.database ? transactionOrEnv : null;
     if (hash_attribute === undefined) {
-        throw new Error(LMDB_ERRORS.HASH_ATTRIBUTE_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.HASH_ATTRIBUTE_REQUIRED);
     }
     validateFetchAttributes(fetchAttributes);
     fetchAttributes = setGetWholeRowAttributes(env, fetchAttributes);
     if (id === undefined) {
-        throw new Error(LMDB_ERRORS.ID_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.ID_REQUIRED);
     }
     let obj = null;
     let object = env.dbis[hash_attribute].get(id, { transaction, lazy: fetchAttributes.length < 3 });
@@ -569,10 +626,10 @@ function checkHashExists(transactionOrEnv, hash_attribute, id) {
     let env = transactionOrEnv.database || transactionOrEnv;
     let transaction = transactionOrEnv.database ? transactionOrEnv : null;
     if (hash_attribute === undefined) {
-        throw new Error(LMDB_ERRORS.HASH_ATTRIBUTE_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.HASH_ATTRIBUTE_REQUIRED);
     }
     if (id === undefined) {
-        throw new Error(LMDB_ERRORS.ID_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.ID_REQUIRED);
     }
     let foundKey = true;
     let value = env.dbis[hash_attribute].get(id, { transaction, lazy: true });
@@ -648,14 +705,14 @@ function batchHashSearch(transactionOrEnv, hash_attribute, fetchAttributes, ids,
 function initializeBatchSearchByHash(transactionOrEnv, hash_attribute, fetchAttributes, ids, _notFound) {
     common.validateEnv(transactionOrEnv);
     if (hash_attribute === undefined) {
-        throw new Error(LMDB_ERRORS.HASH_ATTRIBUTE_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.HASH_ATTRIBUTE_REQUIRED);
     }
     validateFetchAttributes(fetchAttributes);
     if (ids === undefined || ids === null) {
-        throw new Error(LMDB_ERRORS.IDS_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.IDS_REQUIRED);
     }
     if (!ids[Symbol.iterator]) {
-        throw new Error(LMDB_ERRORS.IDS_MUST_BE_ITERABLE);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.IDS_MUST_BE_ITERABLE);
     }
 }
 /**
@@ -665,9 +722,9 @@ function initializeBatchSearchByHash(transactionOrEnv, hash_attribute, fetchAttr
 function validateFetchAttributes(fetchAttributes) {
     if (!Array.isArray(fetchAttributes)) {
         if (fetchAttributes === undefined) {
-            throw new Error(LMDB_ERRORS.FETCH_ATTRIBUTES_REQUIRED);
+            throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.FETCH_ATTRIBUTES_REQUIRED);
         }
-        throw new Error(LMDB_ERRORS.FETCH_ATTRIBUTES_MUST_BE_ARRAY);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.FETCH_ATTRIBUTES_MUST_BE_ARRAY);
     }
 }
 /**
@@ -679,13 +736,13 @@ function validateFetchAttributes(fetchAttributes) {
 function validateComparisonFunctions(env, attribute, searchValue) {
     common.validateEnv(env);
     if (attribute === undefined) {
-        throw new Error(LMDB_ERRORS.ATTRIBUTE_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.ATTRIBUTE_REQUIRED);
     }
     if (searchValue === undefined) {
-        throw new Error(LMDB_ERRORS.SEARCH_VALUE_REQUIRED);
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.SEARCH_VALUE_REQUIRED);
     }
-    if (searchValue?.length > MAX_SEARCH_KEY_LENGTH) {
-        throw new Error(LMDB_ERRORS.SEARCH_VALUE_TOO_LARGE);
+    if (searchValue?.length > lmdbTerms.MAX_SEARCH_KEY_LENGTH) {
+        throw new Error(commonErrors_ts_1.LMDB_ERRORS_ENUM.SEARCH_VALUE_TOO_LARGE);
     }
 }
 /**
@@ -700,25 +757,4 @@ function setGetWholeRowAttributes(env, fetchAttributes) {
     }
     return fetchAttributes;
 }
-module.exports = {
-    searchAll,
-    searchAllToMap,
-    count,
-    countAll,
-    equals,
-    startsWith,
-    endsWith,
-    contains,
-    searchByHash,
-    setGetWholeRowAttributes,
-    batchSearchByHash,
-    batchSearchByHashToMap,
-    checkHashExists,
-    iterateDBI,
-    greaterThan,
-    greaterThanEqual,
-    lessThan,
-    lessThanEqual,
-    between,
-};
 //# sourceMappingURL=searchUtility.js.map