@harperfast/harper 5.0.0-alpha.10 → 5.0.0-beta.1

package/dataLayer/harperBridge/bridgeUtility/insertUpdateReturnObj.js

@@ -0,0 +1,28 @@
+'use strict';
+
+module.exports = returnObject;
+
+const INSERT_ACTION = 'inserted';
+
+/**
+ * constructs return object for insert and update.
+ * @param action
+ * @param written_hashes
+ * @param object
+ * @param skipped
+ * @returns {{skipped_hashes: *, update_hashes: *, message: string}}
+ */
+function returnObject(action, written_hashes, object, skipped) {
+	let return_object = {
+		message: `${action} ${written_hashes.length} of ${object.records.length} records`,
+		skipped_hashes: skipped,
+	};
+
+	if (action === INSERT_ACTION) {
+		return_object.inserted_hashes = written_hashes;
+		return return_object;
+	}
+
+	return_object.update_hashes = written_hashes;
+	return return_object;
+}

package/dataLayer/harperBridge/bridgeUtility/insertUpdateValidate.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const hdbUtils = require('../../../utility/common_utils.js');
+const log = require('../../../utility/logging/harper_logger.js');
+const { getDatabases } = require('../../../resources/databases.ts');
+const { ClientError } = require('../../../utility/errors/hdbError.js');
+
+module.exports = insertUpdateValidate;
+
+//IMPORTANT - This code is the same code as the async validation() function in dataLayer/insert - make sure any changes
+// below are also made there.  This is to resolve a circular dependency.
+/**
+ * Takes an insert/update object and validates attributes, also looks for dups and get a list of all attributes from the record set
+ * @param {Object} writeObject
+ * @returns {Promise<{tableSchema, hashes: any[], attributes: string[]}>}
+ */
+function insertUpdateValidate(writeObject) {
+	// Need to validate these outside of the validator as the getTableSchema call will fail with
+	// invalid values.
+
+	if (hdbUtils.isEmpty(writeObject)) {
+		throw new ClientError('invalid update parameters defined.');
+	}
+	if (hdbUtils.isEmptyOrZeroLength(writeObject.schema)) {
+		throw new ClientError('invalid schema specified.');
+	}
+	if (hdbUtils.isEmptyOrZeroLength(writeObject.table)) {
+		throw new ClientError('invalid table specified.');
+	}
+
+	if (!Array.isArray(writeObject.records)) {
+		throw new ClientError('records must be an array');
+	}
+
+	let schemaTable = getDatabases()[writeObject.schema]?.[writeObject.table];
+	if (hdbUtils.isEmpty(schemaTable)) {
+		throw new ClientError(`could not retrieve schema:${writeObject.schema} and table ${writeObject.table}`);
+	}
+
+	let hash_attribute = schemaTable.primaryKey;
+	let dups = new Set();
+	let attributes = {};
+
+	let isUpdate = false;
+	if (writeObject.operation === 'update') {
+		isUpdate = true;
+	}
+
+	writeObject.records.forEach((record) => {
+		if (isUpdate && hdbUtils.isEmptyOrZeroLength(record[hash_attribute])) {
+			log.error('a valid hash attribute must be provided with update record:', record);
+			throw new ClientError('a valid hash attribute must be provided with update record, check log for more info');
+		}
+
+		if (
+			!hdbUtils.isEmptyOrZeroLength(record[hash_attribute]) &&
+			(record[hash_attribute] === 'null' || record[hash_attribute] === 'undefined')
+		) {
+			log.error(`a valid hash value must be provided with ${writeObject.operation} record:`, record);
+			throw new ClientError(
+				`Invalid hash value: '${record[hash_attribute]}' is not a valid hash attribute value, check log for more info`
+			);
+		}
+
+		if (
+			!hdbUtils.isEmpty(record[hash_attribute]) &&
+			record[hash_attribute] !== '' &&
+			dups.has(hdbUtils.autoCast(record[hash_attribute]))
+		) {
+			record.skip = true;
+		}
+
+		dups.add(hdbUtils.autoCast(record[hash_attribute]));
+
+		for (let attr in record) {
+			attributes[attr] = 1;
+		}
+	});
+
+	//in case the hash_attribute was not on the object(s) for inserts where they want to auto-key we manually add the hash_attribute to attributes
+	attributes[hash_attribute] = 1;
+
+	return {
+		schema_table: schemaTable,
+		hashes: Array.from(dups),
+		attributes: Object.keys(attributes),
+	};
+}

package/dataLayer/harperBridge/harperBridge.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const { ResourceBridge } = require('./ResourceBridge.ts');
+const envMngr = require('../../utility/environment/environmentManager.js');
+envMngr.initSync();
+
+let harperBridge;
+
+/**
+ *
+ * @returns {LMDBBridge|undefined}
+ */
+function getBridge() {
+	if (harperBridge) {
+		return harperBridge;
+	}
+	harperBridge = new ResourceBridge();
+	return harperBridge;
+}
+
+module.exports = getBridge();

package/dataLayer/harperBridge/lmdbBridge/LMDBBridge.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const log = require('../../../utility/logging/harper_logger.js');
+const { handleHDBError } = require('../../../utility/errors/hdbError.js');
+const BridgeMethods = require('../BridgeMethods.js');
+const lmdbCreateAttribute = require('./lmdbMethods/lmdbCreateAttribute.js');
+const lmdbCreateRecords = require('./lmdbMethods/lmdbCreateRecords.js');
+const lmdbCreateSchema = require('./lmdbMethods/lmdbCreateSchema.js');
+const lmdbDeleteRecords = require('./lmdbMethods/lmdbDeleteRecords.js');
+const lmdbGetDataByHash = require('./lmdbMethods/lmdbGetDataByHash.js');
+const lmdbSearchByHash = require('./lmdbMethods/lmdbSearchByHash.js');
+const lmdbGetDataByValue = require('./lmdbMethods/lmdbGetDataByValue.js');
+const lmdbSearchByValue = require('./lmdbMethods/lmdbSearchByValue.js');
+const lmdbSearchByConditions = require('./lmdbMethods/lmdbSearchByConditions.js');
+const lmdbDropSchema = require('./lmdbMethods/lmdbDropSchema.js');
+const lmdbCreateTable = require('./lmdbMethods/lmdbCreateTable.js');
+const lmdbUpdateRecords = require('./lmdbMethods/lmdbUpdateRecords.js');
+const lmdbUpsertRecords = require('./lmdbMethods/lmdbUpsertRecords.js');
+const lmdbDeleteAuditLogsBefore = require('./lmdbMethods/lmdbDeleteAuditLogsBefore.js');
+const lmdbDropTable = require('./lmdbMethods/lmdbDropTable.js');
+const lmdbDropAttribute = require('./lmdbMethods/lmdbDropAttribute.js');
+const lmdbReadAuditLog = require('./lmdbMethods/lmdbReadAuditLog.js');
+const lmdbTransaction = require('./lmdbMethods/lmdbTransaction.js');
+const lmdbFlush = require('./lmdbMethods/lmdbFlush.js');
+const lmdbGetBackup = require('./lmdbMethods/lmdbGetBackup.js');
+
+class LMDBBridge extends BridgeMethods {
+	async searchByConditions(searchObject) {
+		return lmdbSearchByConditions(searchObject);
+	}
+
+	async getDataByHash(searchObject) {
+		return await lmdbGetDataByHash(searchObject);
+	}
+
+	async searchByHash(searchObject) {
+		return await lmdbSearchByHash(searchObject);
+	}
+
+	async getDataByValue(searchObject, comparator) {
+		return await lmdbGetDataByValue(searchObject, comparator);
+	}
+
+	async searchByValue(searchObject) {
+		return await lmdbSearchByValue(searchObject);
+	}
+
+	async createSchema(schemaCreateObj) {
+		return await lmdbCreateSchema(schemaCreateObj);
+	}
+
+	async dropSchema(dropSchemaObj) {
+		return await lmdbDropSchema(dropSchemaObj);
+	}
+
+	async createTable(table, tableCreateObj) {
+		return await lmdbCreateTable(table, tableCreateObj);
+	}
+
+	async dropTable(dropTableObj) {
+		return await lmdbDropTable(dropTableObj);
+	}
+
+	async createAttribute(createAttributeObj) {
+		return await lmdbCreateAttribute(createAttributeObj);
+	}
+
+	async createRecords(insertObj) {
+		return await lmdbCreateRecords(insertObj);
+	}
+
+	async updateRecords(updateObj) {
+		return await lmdbUpdateRecords(updateObj);
+	}
+
+	async upsertRecords(upsertObj) {
+		try {
+			return await lmdbUpsertRecords(upsertObj);
+		} catch (err) {
+			//NOTE: this method call will either return the HdbError generated below this OR create a new HdbError w/ the
+			// default system error msg and 500 code AND log the error caught here (the error log will only happen if the
+			// error has not already been handled (i.e. translated and passed as a HdbError)
+			throw handleHDBError(err, null, null, log.ERR, err);
+		}
+	}
+
+	async deleteRecords(deleteObj) {
+		return await lmdbDeleteRecords(deleteObj);
+	}
+
+	async dropAttribute(dropAttrObj) {
+		return await lmdbDropAttribute(dropAttrObj);
+	}
+
+	async deleteAuditLogsBefore(deleteObj) {
+		return await lmdbDeleteAuditLogsBefore(deleteObj);
+	}
+
+	async readAuditLog(readAuditLogObj) {
+		return await lmdbReadAuditLog(readAuditLogObj);
+	}
+
+	writeTransaction(schema, table, callback) {
+		return lmdbTransaction.writeTransaction(schema, table, callback);
+	}
+
+	flush(schema, table) {
+		return lmdbFlush.flush(schema, table);
+	}
+
+	resetReadTxn(schema, table) {
+		return lmdbFlush.resetReadTxn(schema, table);
+	}
+	getBackup(getBackupObj) {
+		return lmdbGetBackup(getBackupObj);
+	}
+}
+
+module.exports = LMDBBridge;

package/dataLayer/harperBridge/lmdbBridge/lmdbMethods/DeleteAuditLogsBeforeResults.js

@@ -0,0 +1,19 @@
+'use strict';
+
+/**
+ * represents the response object from Delete audit logs Before
+ */
+class DeleteAuditLogsBeforeResults {
+	/**
+	 * @param {number} startTimestamp
+	 * @param {number} endTimestamp
+	 * @param {number} transactionsDeleted
+	 */
+	constructor(startTimestamp = undefined, endTimestamp = undefined, transactionsDeleted = 0) {
+		this.start_timestamp = startTimestamp;
+		this.end_timestamp = endTimestamp;
+		this.transactions_deleted = transactionsDeleted;
+	}
+}
+
+module.exports = DeleteAuditLogsBeforeResults;

package/dataLayer/harperBridge/lmdbBridge/lmdbMethods/lmdbCreateAttribute.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const hdbTerms = require('../../../../utility/hdbTerms.ts');
+const environmentUtility = require('../../../../utility/lmdb/environmentUtility.js');
+const writeUtility = require('../../../../utility/lmdb/writeUtility.js');
+const { getSystemSchemaPath, getSchemaPath } = require('../lmdbUtility/initializePaths.js');
+const { validateBySchema } = require('../../../../validation/validationWrapper.js');
+const Joi = require('joi');
+const LMDBCreateAttributeObject = require('../lmdbUtility/LMDBCreateAttributeObject.js');
+const returnObject = require('../../bridgeUtility/insertUpdateReturnObj.js');
+const { handleHDBError, hdbErrors, ClientError } = require('../../../../utility/errors/hdbError.js');
+const hdbUtils = require('../../../../utility/common_utils.js');
+const { HTTP_STATUS_CODES } = hdbErrors;
+
+const ACTION = 'inserted';
+
+module.exports = lmdbCreateAttribute;
+
+/**
+ * First adds the attribute to the system attribute table, then creates the dbi.
+ * @param {LMDBCreateAttributeObject} createAttributeObj
+ * @returns {{skipped_hashes: *, update_hashes: *, message: string}}
+ */
+async function lmdbCreateAttribute(createAttributeObj) {
+	const validation = validateBySchema(
+		createAttributeObj,
+		Joi.object({
+			database: Joi.string(),
+			schema: Joi.string(),
+			table: Joi.string().required(),
+			attribute: Joi.string().required(),
+		})
+	);
+	if (validation) throw new ClientError(validation.message);
+
+	//check if schema.table does not exist throw error
+	let checkSchemaTable =
+		!createAttributeObj.skip_table_check &&
+		hdbUtils.checkGlobalSchemaTable(createAttributeObj.schema, createAttributeObj.table);
+	if (checkSchemaTable) {
+		throw handleHDBError(new Error(), checkSchemaTable, HTTP_STATUS_CODES.NOT_FOUND);
+	}
+
+	//the validator strings everything so we need to recast the booleans on createAttributeObj
+	createAttributeObj.isPrimaryKey = createAttributeObj.isPrimaryKey == 'true';
+	createAttributeObj.dup_sort = hdbUtils.isEmpty(createAttributeObj.dup_sort) || createAttributeObj.dup_sort == 'true';
+
+	let attributesObjArray = [];
+	//on initial creation of a table it will not exist in hdbSchema yet
+	if (
+		global.hdb_schema[createAttributeObj.schema] &&
+		global.hdb_schema[createAttributeObj.schema][createAttributeObj.table]
+	) {
+		attributesObjArray = global.hdb_schema[createAttributeObj.schema][createAttributeObj.table]['attributes'];
+	}
+	if (Array.isArray(attributesObjArray) && attributesObjArray.length > 0) {
+		for (let attribute of attributesObjArray) {
+			if (attribute.attribute === createAttributeObj.attribute) {
+				throw new Error(
+					`attribute '${attribute.attribute}' already exists in ${createAttributeObj.schema}.${createAttributeObj.table}`
+				);
+			}
+		}
+	}
+
+	//insert the attribute metaData into system.hdb_attribute
+	let record = new LMDBCreateAttributeObject(
+		createAttributeObj.schema,
+		createAttributeObj.table,
+		createAttributeObj.attribute,
+		createAttributeObj.id
+	);
+
+	try {
+		//create dbi into the environment for this table
+		let env = await environmentUtility.openEnvironment(
+			getSchemaPath(createAttributeObj.schema, createAttributeObj.table),
+			createAttributeObj.table
+		);
+		if (env.dbis[createAttributeObj.attribute] !== undefined) {
+			throw new Error(
+				`attribute '${createAttributeObj.attribute}' already exists in ${createAttributeObj.schema}.${createAttributeObj.table}`
+			);
+		}
+		environmentUtility.createDBI(
+			env,
+			createAttributeObj.attribute,
+			createAttributeObj.dup_sort,
+			createAttributeObj.isPrimaryKey
+		);
+
+		let hdbAttributeEnv = await environmentUtility.openEnvironment(
+			getSystemSchemaPath(),
+			hdbTerms.SYSTEM_TABLE_NAMES.ATTRIBUTE_TABLE_NAME
+		);
+
+		let { written_hashes, skipped_hashes } = await writeUtility.insertRecords(
+			hdbAttributeEnv,
+			// I'm not sure what else to do with these for now, but I do want to eslint to check the rest of the codebase
+			// for undefined vars. - WSM 2025-11-26
+			// eslint-disable-next-line no-undef
+			HDB_TABLE_INFO.hash_attribute,
+			// eslint-disable-next-line no-undef
+			hdbAttributeAttributes,
+			[record]
+		);
+
+		return returnObject(ACTION, written_hashes, { records: [record] }, skipped_hashes);
+	} catch (e) {
+		throw e;
+	}
+}

package/dataLayer/harperBridge/lmdbBridge/lmdbMethods/lmdbCreateRecords.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const insertUpdateValidate = require('../../bridgeUtility/insertUpdateValidate.js');
+// eslint-disable-next-line no-unused-vars
+const InsertObject = require('../../../InsertObject.js');
+const hdbTerms = require('../../../../utility/hdbTerms.ts');
+const lmdbProcessRows = require('../lmdbUtility/lmdbProcessRows.js');
+const lmdbInsertRecords = require('../../../../utility/lmdb/writeUtility.js').insertRecords;
+const environmentUtility = require('../../../../utility/lmdb/environmentUtility.js');
+const logger = require('../../../../utility/logging/harper_logger.js');
+
+const lmdbCheckNewAttributes = require('../lmdbUtility/lmdbCheckForNewAttributes.js');
+const { getSchemaPath } = require('../lmdbUtility/initializePaths.js');
+const writeTransaction = require('../lmdbUtility/lmdbWriteTransaction.js');
+
+module.exports = lmdbCreateRecords;
+
+/**
+ * Orchestrates the insertion of data into LMDB and the creation of new attributes/dbis
+ * if they do not already exist.
+ * @param {InsertObject} insertObj
+ * @returns {Promise<{skipped_hashes: *, written_hashes: *, schema_table: *}>}
+ */
+async function lmdbCreateRecords(insertObj) {
+	try {
+		let { schemaTable, attributes } = insertUpdateValidate(insertObj);
+
+		lmdbProcessRows(insertObj, attributes, schemaTable.hash_attribute);
+
+		if (insertObj.schema !== hdbTerms.SYSTEM_SCHEMA_NAME) {
+			if (!attributes.includes(hdbTerms.TIME_STAMP_NAMES_ENUM.CREATED_TIME)) {
+				attributes.push(hdbTerms.TIME_STAMP_NAMES_ENUM.CREATED_TIME);
+			}
+
+			if (!attributes.includes(hdbTerms.TIME_STAMP_NAMES_ENUM.UPDATED_TIME)) {
+				attributes.push(hdbTerms.TIME_STAMP_NAMES_ENUM.UPDATED_TIME);
+			}
+		}
+
+		let new_attributes = await lmdbCheckNewAttributes(insertObj.hdb_auth_header, schemaTable, attributes);
+		let envBasePath = getSchemaPath(insertObj.schema, insertObj.table);
+		let environment = await environmentUtility.openEnvironment(envBasePath, insertObj.table);
+		let lmdbResponse = await lmdbInsertRecords(
+			environment,
+			schemaTable.hash_attribute,
+			attributes,
+			insertObj.records,
+			insertObj.__origin?.timestamp
+		);
+
+		try {
+			await writeTransaction(insertObj, lmdbResponse);
+		} catch (e) {
+			logger.error(`unable to write transaction due to ${e.message}`);
+		}
+
+		return {
+			written_hashes: lmdbResponse.written_hashes,
+			skipped_hashes: lmdbResponse.skipped_hashes,
+			schemaTable,
+			new_attributes,
+			txn_time: lmdbResponse.txn_time,
+		};
+	} catch (err) {
+		throw err;
+	}
+}

package/dataLayer/harperBridge/lmdbBridge/lmdbMethods/lmdbCreateSchema.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const hdbTerms = require('../../../../utility/hdbTerms.ts');
+const lmdbCreateRecords = require('./lmdbCreateRecords.js');
+const InsertObject = require('../../../InsertObject.js');
+const fs = require('fs-extra');
+const { getSchemaPath } = require('../lmdbUtility/initializePaths.js');
+
+module.exports = lmdbCreateSchema;
+
+/**
+ * creates the meta data for the schema
+ * @param createSchemaObj
+ */
+async function lmdbCreateSchema(createSchemaObj) {
+	let records = [
+		{
+			name: createSchemaObj.schema,
+			createddate: Date.now(),
+		},
+	];
+	let insertObject = new InsertObject(
+		hdbTerms.SYSTEM_SCHEMA_NAME,
+		hdbTerms.SYSTEM_TABLE_NAMES.SCHEMA_TABLE_NAME,
+		undefined,
+		records
+	);
+
+	await lmdbCreateRecords(insertObject);
+	await fs.mkdirp(getSchemaPath(createSchemaObj.schema));
+}

package/dataLayer/harperBridge/lmdbBridge/lmdbMethods/lmdbCreateTable.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const hdbTerms = require('../../../../utility/hdbTerms.ts');
+const environmentUtility = require('../../../../utility/lmdb/environmentUtility.js');
+const writeUtility = require('../../../../utility/lmdb/writeUtility.js');
+const { getSystemSchemaPath, getSchemaPath } = require('../lmdbUtility/initializePaths.js');
+const lmdbCreateAttribute = require('./lmdbCreateAttribute.js');
+const LMDBCreateAttributeObject = require('../lmdbUtility/LMDBCreateAttributeObject.js');
+const log = require('../../../../utility/logging/harper_logger.js');
+const createTxnEnvironments = require('../lmdbUtility/lmdbCreateTransactionsAuditEnvironment.js');
+
+module.exports = lmdbCreateTable;
+
+/**
+ * Writes new table data to the system tables creates the environment file and creates two datastores to track created and updated
+ * timestamps for new table data.
+ * @param tableSystemData
+ * @param tableCreateObj
+ */
+async function lmdbCreateTable(tableSystemData, tableCreateObj) {
+	let schemaPath = getSchemaPath(tableCreateObj.schema, tableCreateObj.table);
+
+	let createdTimeAttr = new LMDBCreateAttributeObject(
+		tableCreateObj.schema,
+		tableCreateObj.table,
+		hdbTerms.TIME_STAMP_NAMES_ENUM.CREATED_TIME,
+		undefined,
+		true
+	);
+	let updatedTimeAttr = new LMDBCreateAttributeObject(
+		tableCreateObj.schema,
+		tableCreateObj.table,
+		hdbTerms.TIME_STAMP_NAMES_ENUM.UPDATED_TIME,
+		undefined,
+		true
+	);
+	let hashAttr = new LMDBCreateAttributeObject(
+		tableCreateObj.schema,
+		tableCreateObj.table,
+		tableCreateObj.hash_attribute,
+		undefined,
+		false,
+		true
+	);
+
+	try {
+		//create the new environment
+		await environmentUtility.createEnvironment(schemaPath, tableCreateObj.table);
+
+		if (tableSystemData !== undefined) {
+			let hdbTableEnv = await environmentUtility.openEnvironment(
+				getSystemSchemaPath(),
+				hdbTerms.SYSTEM_TABLE_NAMES.TABLE_TABLE_NAME
+			);
+
+			//add the meta data to system.hdb_table
+			await writeUtility.insertRecords(
+				hdbTableEnv,
+				// I'm not sure what else to do with these for now, but I do want to eslint to check the rest of the codebase
+				// for undefined vars. - WSM 2025-11-26
+				// eslint-disable-next-line no-undef
+				HDB_TABLE_INFO.hash_attribute,
+				// eslint-disable-next-line no-undef
+				hdbTableAttributes,
+				[tableSystemData]
+			);
+			//create attributes for hash attribute created/updated time stamps
+			createdTimeAttr.skip_table_check = true;
+			updatedTimeAttr.skip_table_check = true;
+			hashAttr.skip_table_check = true;
+
+			await createAttribute(createdTimeAttr);
+			await createAttribute(updatedTimeAttr);
+			await createAttribute(hashAttr);
+		}
+
+		await createTxnEnvironments(tableCreateObj);
+	} catch (e) {
+		throw e;
+	}
+}
+
+/**
+ * used to individually create the required attributes for a new table, logs a warning if any fail
+ * @param {LMDBCreateAttributeObject} attributeObject
+ * @returns {Promise<void>}
+ */
+async function createAttribute(attributeObject) {
+	try {
+		await lmdbCreateAttribute(attributeObject);
+	} catch (e) {
+		log.warn(`failed to create attribute ${attributeObject.attribute} due to ${e.message}`);
+	}
+}

package/dataLayer/harperBridge/lmdbBridge/lmdbMethods/lmdbDeleteAuditLogsBefore.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const environmentUtility = require('../../../../utility/lmdb/environmentUtility.js');
+const { getTransactionAuditStorePath } = require('../lmdbUtility/initializePaths.js');
+// eslint-disable-next-line no-unused-vars
+const DeleteBeforeObject = require('../../../DeleteBeforeObject.js');
+const lmdbTerms = require('../../../../utility/lmdb/terms.js');
+const hdbUtils = require('../../../../utility/common_utils.js');
+const DeleteAuditLogsBeforeResults = require('./DeleteAuditLogsBeforeResults.js');
+const promisify = require('util').promisify;
+const pSettimeout = promisify(setTimeout);
+
+const BATCH_SIZE = 10000;
+const SLEEP_TIME_MS = 100;
+
+module.exports = deleteAuditLogsBefore;
+
+/**
+ *
+ * @param {DeleteBeforeObject} deleteAuditLogsObj
+ */
+async function deleteAuditLogsBefore(deleteAuditLogsObj) {
+	let schemaPath = getTransactionAuditStorePath(deleteAuditLogsObj.schema, deleteAuditLogsObj.table);
+	let env = await environmentUtility.openEnvironment(schemaPath, deleteAuditLogsObj.table, true);
+	let allDbis = environmentUtility.listDBIs(env);
+	environmentUtility.initializeDBIs(env, lmdbTerms.TRANSACTIONS_DBI_NAMES_ENUM.TIMESTAMP, allDbis);
+
+	let chunkResults;
+	let totalResults = new DeleteAuditLogsBeforeResults();
+
+	do {
+		chunkResults = await deleteTransactions(env, deleteAuditLogsObj.timestamp);
+		if (totalResults.start_timestamp === undefined) {
+			totalResults.start_timestamp = chunkResults.start_timestamp;
+		}
+
+		if (chunkResults.end_timestamp !== undefined) {
+			totalResults.end_timestamp = chunkResults.end_timestamp;
+		}
+
+		totalResults.transactions_deleted += chunkResults.transactions_deleted;
+
+		//we do a pause on delete so it opens access to the txn environment for other processes.
+		await pSettimeout(SLEEP_TIME_MS);
+	} while (chunkResults.transactions_deleted > 0);
+
+	return totalResults;
+}
+
+/**
+ *
+ * @param env
+ * @param {number} timestamp
+ * @returns {Promise<DeleteAuditLogsBeforeResults>}
+ */
+async function deleteTransactions(env, timestamp) {
+	let results = new DeleteAuditLogsBeforeResults();
+	try {
+		let timestampDbi = env.dbis[lmdbTerms.TRANSACTIONS_DBI_NAMES_ENUM.TIMESTAMP];
+
+		let promise;
+		for (let { key, value: txnRecord } of timestampDbi.getRange({ start: false })) {
+			if (key >= timestamp) {
+				break;
+			}
+
+			if (results.start_timestamp === undefined) {
+				results.start_timestamp = key;
+			}
+
+			//delete the transaction record
+			promise = timestampDbi.remove(key);
+
+			//delete user index entry
+			let userName = txnRecord[lmdbTerms.TRANSACTIONS_DBI_NAMES_ENUM.USER_NAME];
+			if (!hdbUtils.isEmpty(userName)) {
+				promise = env.dbis[lmdbTerms.TRANSACTIONS_DBI_NAMES_ENUM.USER_NAME].remove(userName, key);
+			}
+
+			//delete each hash value entry
+			for (let k = 0; k < txnRecord.hash_values.length; k++) {
+				promise = env.dbis[lmdbTerms.TRANSACTIONS_DBI_NAMES_ENUM.HASH_VALUE].remove(txnRecord.hash_values[k], key);
+			}
+
+			results.transactions_deleted++;
+			results.end_timestamp = key;
+			if (results.transactions_deleted > BATCH_SIZE) {
+				break;
+			}
+		}
+		// we wait for the last promise to finish
+		await promise;
+
+		return results;
+	} catch (e) {
+		throw e;
+	}
+}