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

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

@@ -0,0 +1,207 @@
+'use strict';
+
+const environmentUtility = require('../../../../utility/lmdb/environmentUtility.js');
+const lmdbTerms = require('../../../../utility/lmdb/terms.js');
+const hdbTerms = require('../../../../utility/hdbTerms.ts');
+const hdbUtils = require('../../../../utility/common_utils.js');
+const { getTransactionAuditStorePath } = require('../lmdbUtility/initializePaths.js');
+const searchUtility = require('../../../../utility/lmdb/searchUtility.js');
+const LMDBTransactionObject = require('../lmdbUtility/LMDBTransactionObject.js');
+const log = require('../../../../utility/logging/harper_logger.js');
+
+module.exports = readAuditLog;
+
+/**
+ * function execute the readTransactionLog operation
+ * @param {ReadAuditLogObject} readAuditLogObj
+ * @returns {Promise<[]>}
+ */
+async function readAuditLog(readAuditLogObj) {
+	let basePath = getTransactionAuditStorePath(readAuditLogObj.schema, readAuditLogObj.table);
+	let env = await environmentUtility.openEnvironment(basePath, readAuditLogObj.table, true);
+	let allDbis = environmentUtility.listDBIs(env);
+
+	environmentUtility.initializeDBIs(env, lmdbTerms.TRANSACTIONS_DBI_NAMES_ENUM.TIMESTAMP, allDbis);
+	let hash_attribute;
+	switch (readAuditLogObj.search_type) {
+		case hdbTerms.READ_AUDIT_LOG_SEARCH_TYPES_ENUM.TIMESTAMP:
+			return searchTransactionsByTimestamp(env, readAuditLogObj.search_values);
+		case hdbTerms.READ_AUDIT_LOG_SEARCH_TYPES_ENUM.HASH_VALUE:
+			//get the hash attribute
+			hash_attribute = global.hdb_schema[readAuditLogObj.schema][readAuditLogObj.table].hash_attribute;
+			return searchTransactionsByHashValues(env, readAuditLogObj.search_values, hash_attribute);
+		case hdbTerms.READ_AUDIT_LOG_SEARCH_TYPES_ENUM.USERNAME:
+			return searchTransactionsByUsername(env, readAuditLogObj.search_values);
+		default:
+			return searchTransactionsByTimestamp(env);
+	}
+}
+
+/**
+ *
+ * @param {lmdb.RootDatabase} env
+ * @param {[number]} timestamps - this must be undefined or a 1 or 2 element numeric array, representing a start timestamp & end end timestamp (element 1 must be less than element 2).
+ * If undefined or empty array is passed the function will iterate the entire transaction log.
+ * If only 1 element is supplied the second will be set to now UTC and the transaction log will be traversed from the designated start time until now.
+ * If 2 elements are supplied the transaction log will be read between the two timestamps
+ */
+function searchTransactionsByTimestamp(env, timestamps = [0, Date.now()]) {
+	if (hdbUtils.isEmpty(timestamps[0])) {
+		timestamps[0] = 0;
+	}
+
+	if (hdbUtils.isEmpty(timestamps[1])) {
+		timestamps[1] = Date.now();
+	}
+
+	let timestampDbi = env.dbis[lmdbTerms.TRANSACTIONS_DBI_NAMES_ENUM.TIMESTAMP];
+
+	//advance the endValue by 1 key
+	let nextValue;
+	for (let key of timestampDbi.getKeys({ start: timestamps[1] })) {
+		if (key !== timestamps[1]) {
+			nextValue = key;
+			break;
+		}
+	}
+
+	return timestampDbi
+		.getRange({ start: timestamps[0], end: nextValue })
+		.map(({ value }) => Object.assign(new LMDBTransactionObject(), value));
+}
+
+/**
+ *
+ * @param {lmdb.RootDatabase} env
+ * @param {[string]} usernames
+ */
+function searchTransactionsByUsername(env, usernames = []) {
+	let results = new Map();
+	for (let x = 0; x < usernames.length; x++) {
+		let username = usernames[x];
+
+		let ids = [];
+		for (let value of env.dbis[lmdbTerms.TRANSACTIONS_DBI_NAMES_ENUM.USER_NAME].getValues(username)) {
+			ids.push(value);
+		}
+
+		results.set(username, batchSearchTransactions(env, ids));
+	}
+
+	return Object.fromEntries(results);
+}
+
+/**
+ *
+ * @param {lmdb.RootDatabase} env
+ * @param {[string]} hash_values
+ * @param {string} hash_attribute
+ */
+function searchTransactionsByHashValues(env, hash_values, hash_attribute) {
+	let timestampHashMap = new Map();
+	for (let x = 0, length = hash_values.length; x < length; x++) {
+		let hashValue = hash_values[x];
+		let hashResults = searchUtility.equals(
+			env,
+			lmdbTerms.TRANSACTIONS_DBI_NAMES_ENUM.TIMESTAMP,
+			lmdbTerms.TRANSACTIONS_DBI_NAMES_ENUM.HASH_VALUE,
+			hashValue
+		);
+
+		for (let { value } of hashResults) {
+			let numberKey = Number(value);
+			if (timestampHashMap.has(numberKey)) {
+				let entry = timestampHashMap.get(numberKey);
+				entry.push(hashValue.toString());
+			} else {
+				timestampHashMap.set(numberKey, [hashValue.toString()]);
+			}
+		}
+	}
+	let ids = Array.from(timestampHashMap.keys());
+	let txns = batchSearchTransactions(env, ids);
+
+	let resultsMap = new Map();
+	//iterate txns & pull out just the records related to the hash
+	for (let x = 0; x < txns.length; x++) {
+		let transaction = txns[x];
+		let timestamp = transaction.timestamp;
+		let hashes = timestampHashMap.get(timestamp);
+
+		loopRecords(transaction, 'records', hash_attribute, hashes, resultsMap);
+
+		loopRecords(transaction, 'original_records', hash_attribute, hashes, resultsMap);
+	}
+
+	return Object.fromEntries(resultsMap);
+}
+
+/**
+ *
+ * @param transaction
+ * @param recordsAttribute
+ * @param hash_attribute
+ * @param hashes
+ * @param resultsMap
+ */
+function loopRecords(transaction, recordsAttribute, hash_attribute, hashes, resultsMap) {
+	let timestamp = transaction.timestamp;
+
+	if (transaction[recordsAttribute]) {
+		for (let y = 0; y < transaction[recordsAttribute].length; y++) {
+			let record = transaction[recordsAttribute][y];
+			let hashValue = record[hash_attribute].toString();
+			if (hashes.indexOf(hashValue) >= 0) {
+				if (resultsMap.has(hashValue)) {
+					let txnObjects = resultsMap.get(hashValue);
+					let txnObject = txnObjects[txnObjects.length - 1];
+
+					if (txnObject.timestamp === timestamp) {
+						txnObject[recordsAttribute] = [record];
+					} else {
+						let newTxnObject = new LMDBTransactionObject(
+							transaction.operation,
+							transaction.user_name,
+							timestamp,
+							undefined
+						);
+						newTxnObject[recordsAttribute] = [record];
+						txnObjects.push(newTxnObject);
+					}
+				} else {
+					let txnObject = new LMDBTransactionObject(transaction.operation, transaction.user_name, timestamp, undefined);
+					txnObject[recordsAttribute] = [record];
+					resultsMap.set(hashValue, [txnObject]);
+				}
+			}
+		}
+	}
+}
+
+/**
+ *
+ * @param env
+ * @param ids
+ * @returns {[LMDBTransactionObject]}
+ */
+function batchSearchTransactions(env, ids) {
+	let results = [];
+	try {
+		//this sorts the ids numerically asc
+		let timestampDbi = env.dbis[lmdbTerms.TRANSACTIONS_DBI_NAMES_ENUM.TIMESTAMP];
+		for (let x = 0; x < ids.length; x++) {
+			try {
+				let value = timestampDbi.get(ids[x]);
+				if (value) {
+					let txnRecord = Object.assign(new LMDBTransactionObject(), value);
+					results.push(txnRecord);
+				}
+			} catch (e) {
+				log.warn(e);
+			}
+		}
+		return results;
+	} catch (e) {
+		throw e;
+	}
+}

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

@@ -0,0 +1,156 @@
+'use strict';
+
+// eslint-disable-next-line no-unused-vars
+const { SearchByConditionsObject, SearchCondition } = require('../../../SearchByConditionsObject.js');
+const SearchObject = require('../../../SearchObject.js');
+const searchValidator = require('../../../../validation/searchValidator.js');
+const searchUtility = require('../../../../utility/lmdb/searchUtility.js');
+const lmdbTerms = require('../../../../utility/lmdb/terms.js');
+const lmdb_search = require('../lmdbUtility/lmdbSearch.js');
+const cursorFunctions = require('../../../../utility/lmdb/searchCursorFunctions.js');
+const _ = require('lodash');
+const { getSchemaPath } = require('../lmdbUtility/initializePaths.js');
+const environmentUtility = require('../../../../utility/lmdb/environmentUtility.js');
+const { handleHDBError, hdbErrors } = require('../../../../utility/errors/hdbError.js');
+const { HTTP_STATUS_CODES } = hdbErrors;
+const RANGE_ESTIMATE = 100000000;
+
+module.exports = lmdbSearchByConditions;
+
+/**
+ * gets records by conditions - returns array of Objects
+ * @param {SearchByConditionsObject} searchObject
+ * @returns {Array.<Object>}
+ */
+async function lmdbSearchByConditions(searchObject) {
+	let validationError = searchValidator(searchObject, 'conditions');
+	if (validationError) {
+		throw handleHDBError(
+			validationError,
+			validationError.message,
+			HTTP_STATUS_CODES.BAD_REQUEST,
+			undefined,
+			undefined,
+			true
+		);
+	}
+
+	//set the operator to always be lowercase for later evaluations
+	searchObject.operator = searchObject.operator ? searchObject.operator.toLowerCase() : undefined;
+
+	searchObject.offset = Number.isInteger(searchObject.offset) ? searchObject.offset : 0;
+	let schemaPath = getSchemaPath(searchObject.schema, searchObject.table);
+	let env = await environmentUtility.openEnvironment(schemaPath, searchObject.table);
+
+	const tableInfo = global.hdb_schema[searchObject.schema][searchObject.table];
+
+	// make sure the dbis have been opened prior to the read transaction starting
+	for (let condition of searchObject.conditions) {
+		environmentUtility.openDBI(env, condition.attribute);
+	}
+	// Sort the conditions by narrowest to broadest. Note that we want to do this both for intersection where
+	// it allows us to do minimal filtering, and for union where we can return the fastest results first
+	// in an iterator/stream.
+	let sortedConditions = _.sortBy(searchObject.conditions, (condition) => {
+		if (condition.estimated_count === undefined) {
+			// skip if it is cached
+			let searchType = condition.comparator;
+			if (searchType === lmdbTerms.SEARCH_TYPES.EQUALS)
+				// we only attempt to estimate count on equals operator because that's really all that LMDB supports (some other key-value stores like libmdbx could be considered if we need to do estimated counts of ranges at some point)
+				condition.estimated_count = searchUtility.count(env, condition.attribute, condition.value);
+			else if (searchType === lmdbTerms.SEARCH_TYPES.CONTAINS || searchType === lmdbTerms.SEARCH_TYPES.ENDS_WITH)
+				condition.estimated_count = Infinity;
+			// this search types can't/doesn't use indices, so try do them last
+			// for range queries (betweens, starts-with, greater, etc.), just arbitrarily guess
+			else condition.estimated_count = RANGE_ESTIMATE;
+		}
+		return condition.estimated_count; // use cached count
+	});
+	// we create the read transaction after ensuring that the dbis have been opened (necessary for a stable read
+	// transaction, and we really don't care if the
+	// counts are done in the same read transaction because they are just estimates.
+	let transaction = env.useReadTransaction();
+	transaction.database = env;
+	// both AND and OR start by getting an iterator for the ids for first condition
+	let ids = await executeConditionSearch(transaction, searchObject, sortedConditions[0], tableInfo.hash_attribute);
+	// and then things diverge...
+	let records;
+	if (!searchObject.operator || searchObject.operator.toLowerCase() === 'and') {
+		// get the intersection of condition searches by using the indexed query for the first condition
+		// and then filtering by all subsequent conditions
+		let primaryDbi = env.dbis[tableInfo.hash_attribute];
+		let filters = sortedConditions.slice(1).map(lmdb_search.filterByType);
+		let filtersLength = filters.length;
+		let fetchAttributes = searchUtility.setGetWholeRowAttributes(env, searchObject.get_attributes);
+		records = ids.map((id) => primaryDbi.get(id, { transaction, lazy: true }));
+		if (filtersLength > 0)
+			records = records.filter((record) => {
+				for (let i = 0; i < filtersLength; i++) {
+					if (!filters[i](record)) return false; // didn't match filters
+				}
+				return true;
+			});
+		if (searchObject.offset || searchObject.limit !== undefined)
+			records = records.slice(
+				searchObject.offset,
+				searchObject.limit !== undefined ? (searchObject.offset || 0) + searchObject.limit : undefined
+			);
+		records = records.map((record) => cursorFunctions.parseRow(record, fetchAttributes));
+	} else {
+		//get the union of ids from all condition searches
+		for (let i = 1; i < sortedConditions.length; i++) {
+			let condition = sortedConditions[i];
+			// might want to lazily execute this after getting to this point in the iteration
+			let nextIds = await executeConditionSearch(transaction, searchObject, condition, tableInfo.hash_attribute);
+			ids = ids.concat(nextIds);
+		}
+		let returnedIds = new Set();
+		let offset = searchObject.offset || 0;
+		ids = ids
+			.filter((id) => {
+				if (returnedIds.has(id))
+					// skip duplicates
+					return false;
+				returnedIds.add(id);
+				return true;
+			})
+			.slice(offset, searchObject.limit && searchObject.limit + offset);
+		records = searchUtility.batchSearchByHash(transaction, tableInfo.hash_attribute, searchObject.get_attributes, ids);
+	}
+	records.onDone = () => {
+		transaction.done(); // need to complete the transaction once iteration is complete
+	};
+	return records;
+}
+
+/**
+ *
+ * @param transaction
+ * @param {SearchByConditionsObject} searchObject
+ * @param {SearchCondition} condition
+ * @param {String} hash_attribute
+ * @returns {Promise<unknown[]>}
+ */
+async function executeConditionSearch(transaction, searchObject, condition, hash_attribute) {
+	//build a prototype object for search
+	let search = new SearchObject(
+		searchObject.schema,
+		searchObject.table,
+		undefined,
+		undefined,
+		hash_attribute,
+		searchObject.get_attributes
+	);
+
+	//execute conditional search
+	let comparator = condition.comparator;
+	search.attribute = condition.attribute;
+
+	if (comparator === lmdbTerms.SEARCH_TYPES.BETWEEN) {
+		search.value = condition.value[0];
+		search.end_value = condition.value[1];
+	} else {
+		search.value = condition.value;
+	}
+	return lmdb_search.searchByType(transaction, search, comparator, hash_attribute).map((e) => e.value);
+}

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

@@ -0,0 +1,21 @@
+'use strict';
+
+const searchUtility = require('../../../../utility/lmdb/searchUtility.js');
+const hashSearchInit = require('../lmdbUtility/initializeHashSearch.js');
+
+module.exports = lmdbSearchByHash;
+
+/**
+ * fetches records by their hash values and returns an Array of the results
+ * @param {SearchByHashObject} searchObject
+ */
+async function lmdbSearchByHash(searchObject) {
+	let environment = await hashSearchInit(searchObject);
+	const tableInfo = global.hdb_schema[searchObject.schema][searchObject.table];
+	return searchUtility.batchSearchByHash(
+		environment,
+		tableInfo.hash_attribute,
+		searchObject.get_attributes,
+		searchObject.hash_values
+	);
+}

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

@@ -0,0 +1,30 @@
+'use strict';
+
+// eslint-disable-next-line no-unused-vars
+const SearchObject = require('../../../SearchObject.js');
+const searchValidator = require('../../../../validation/searchValidator.js');
+const commonUtils = require('../../../../utility/common_utils.js');
+const hdbTerms = require('../../../../utility/hdbTerms.ts');
+const lmdb_search = require('../lmdbUtility/lmdbSearch.js');
+
+module.exports = lmdbSearchByValue;
+
+/**
+ * gets records by value - returns array of Objects
+ * @param {SearchObject} searchObject
+ * @param {hdbTerms.VALUE_SEARCH_COMPARATORS} [comparator]
+ * @returns {Promise<{}|{}[]>}
+ */
+async function lmdbSearchByValue(searchObject, comparator) {
+	let comparatorSearch = !commonUtils.isEmpty(comparator);
+	if (comparatorSearch && hdbTerms.VALUE_SEARCH_COMPARATORS_REVERSE_LOOKUP[comparator] === undefined) {
+		throw new Error(`Value search comparator - ${comparator} - is not valid`);
+	}
+
+	let validationError = searchValidator(searchObject, 'value');
+	if (validationError) {
+		throw validationError;
+	}
+
+	return lmdb_search.prepSearch(searchObject, comparator, false);
+}

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

@@ -0,0 +1,19 @@
+'use strict';
+
+const { database } = require('../../../../resources/databases.ts');
+
+module.exports = {
+	writeTransaction,
+};
+
+/**
+ * This is wrapper for write transactions, ensuring that all reads and writes within the callback occur atomically
+ * @param schema
+ * @param table
+ * @param callback
+ * @returns {Promise<any>}
+ */
+async function writeTransaction(schema, table, callback) {
+	let rootStore = database({ database: schema, table });
+	return rootStore.transaction(callback);
+}

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

@@ -0,0 +1,64 @@
+'use strict';
+
+const insertUpdateValidate = require('../../bridgeUtility/insertUpdateValidate.js');
+const lmdbProcessRows = require('../lmdbUtility/lmdbProcessRows.js');
+const lmdbCheckNewAttributes = require('../lmdbUtility/lmdbCheckForNewAttributes.js');
+const hdbTerms = require('../../../../utility/hdbTerms.ts');
+const lmdb_update_records = require('../../../../utility/lmdb/writeUtility.js').updateRecords;
+const environmentUtility = require('../../../../utility/lmdb/environmentUtility.js');
+const { getSchemaPath } = require('../lmdbUtility/initializePaths.js');
+const writeTransaction = require('../lmdbUtility/lmdbWriteTransaction.js');
+const logger = require('../../../../utility/logging/harper_logger.js');
+
+module.exports = lmdbUpdateRecords;
+
+/**
+ * Orchestrates the update of data in LMDB and the creation of new attributes/dbis
+ * if they do not already exist.
+ * @param updateObj
+ * @returns {{skipped_hashes: *, written_hashes: *, schema_table: *}}
+ */
+async function lmdbUpdateRecords(updateObj) {
+	try {
+		let { schemaTable, attributes } = insertUpdateValidate(updateObj);
+
+		lmdbProcessRows(updateObj, attributes, schemaTable.hash_attribute);
+
+		if (updateObj.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(updateObj.hdb_auth_header, schemaTable, attributes);
+		let envBasePath = getSchemaPath(updateObj.schema, updateObj.table);
+		let environment = await environmentUtility.openEnvironment(envBasePath, updateObj.table);
+		let lmdbResponse = await lmdb_update_records(
+			environment,
+			schemaTable.hash_attribute,
+			attributes,
+			updateObj.records,
+			updateObj.__origin?.timestamp
+		);
+
+		try {
+			await writeTransaction(updateObj, 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/lmdbUpsertRecords.js

@@ -0,0 +1,70 @@
+'use strict';
+
+// eslint-disable-next-line no-unused-vars
+const UpsertObject = require('../../../dataObjects/UpsertObject.js');
+const insertUpdateValidate = require('../../bridgeUtility/insertUpdateValidate.js');
+const lmdbProcessRows = require('../lmdbUtility/lmdbProcessRows.js');
+const lmdbCheckNewAttributes = require('../lmdbUtility/lmdbCheckForNewAttributes.js');
+const hdbTerms = require('../../../../utility/hdbTerms.ts');
+const lmdb_upsert_records = require('../../../../utility/lmdb/writeUtility.js').upsertRecords;
+const environmentUtility = require('../../../../utility/lmdb/environmentUtility.js');
+const { getSchemaPath } = require('../lmdbUtility/initializePaths.js');
+const writeTransaction = require('../lmdbUtility/lmdbWriteTransaction.js');
+
+const logger = require('../../../../utility/logging/harper_logger.js');
+const { handleHDBError, hdbErrors } = require('../../../../utility/errors/hdbError.js');
+
+module.exports = lmdbUpsertRecords;
+
+/**
+ * Orchestrates the UPSERT of data in LMDB and the creation of new attributes/dbis
+ * if they do not already exist.
+ * @param {UpsertObject} upsertObj
+ * @returns {{ skipped_hashes: *, written_hashes: *, schema_table: *, new_attributes: *, txn_time: * }}
+ */
+async function lmdbUpsertRecords(upsertObj) {
+	let validationResult;
+	try {
+		validationResult = insertUpdateValidate(upsertObj);
+	} catch (err) {
+		throw handleHDBError(err, err.message, hdbErrors.HTTP_STATUS_CODES.BAD_REQUEST, undefined, undefined, true);
+	}
+
+	let { schemaTable, attributes } = validationResult;
+
+	lmdbProcessRows(upsertObj, attributes, schemaTable.hash_attribute);
+
+	if (upsertObj.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(upsertObj.hdb_auth_header, schemaTable, attributes);
+	let envBasePath = getSchemaPath(upsertObj.schema, upsertObj.table);
+	let environment = await environmentUtility.openEnvironment(envBasePath, upsertObj.table);
+	let lmdbResponse = await lmdb_upsert_records(
+		environment,
+		schemaTable.hash_attribute,
+		attributes,
+		upsertObj.records,
+		upsertObj.__origin?.timestamp
+	);
+
+	try {
+		await writeTransaction(upsertObj, lmdbResponse);
+	} catch (e) {
+		logger.error(`unable to write transaction due to ${e.message}`);
+	}
+
+	return {
+		written_hashes: lmdbResponse.written_hashes,
+		schemaTable,
+		new_attributes,
+		txn_time: lmdbResponse.txn_time,
+	};
+}

package/dataLayer/harperBridge/lmdbBridge/lmdbUtility/LMDBCreateAttributeObject.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const CreateAttributeObject = require('../../../CreateAttributeObject.js');
+
+class LMDBCreateAttributeObject extends CreateAttributeObject {
+	/**
+	 *
+	 * @param {String} schema
+	 * @param {String} table
+	 * @param {String} attribute
+	 * @param {*} [id] - optional, the predefined id for this attribute
+	 * @param {Boolean} [dupSort] - optional, whether this attribute will allow duplicate keys in the lmdb dbi, defaults to true
+	 * @param {Boolean} [isHashAttribute]
+	 */
+	constructor(schema, table, attribute, id, dupSort = true, isHashAttribute = false) {
+		super(schema, table, attribute, id);
+		this.dup_sort = dupSort;
+		this.isPrimaryKey = isHashAttribute;
+	}
+}
+
+module.exports = LMDBCreateAttributeObject;

package/dataLayer/harperBridge/lmdbBridge/lmdbUtility/LMDBDeleteTransactionObject.js

@@ -0,0 +1,23 @@
+'use strict';
+const LMDBTransactionObject = require('./LMDBTransactionObject.js');
+const OPERATIONS_ENUM = require('../../../../utility/hdbTerms.ts').OPERATIONS_ENUM;
+
+/**
+ * class to define a delete transaction
+ */
+class LMDBDeleteTransactionObject extends LMDBTransactionObject {
+	/**
+	 * @param {Array.<string|number>} hash_values - hash values of deleted records
+	 * @param {Array.<Object>} originalRecords - original records prior to delete
+	 * @param {string} userName - username that executed transaction
+	 * @param {number} timestamp - timestamp of transaction
+	 * @param {any} origin
+	 */
+	constructor(hash_values, originalRecords, userName, timestamp, origin = undefined) {
+		super(OPERATIONS_ENUM.DELETE, userName, timestamp, hash_values, origin);
+		this.original_records = originalRecords;
+		//this.hash_values = hash_values;
+	}
+}
+
+module.exports = LMDBDeleteTransactionObject;

package/dataLayer/harperBridge/lmdbBridge/lmdbUtility/LMDBInsertTransactionObject.js

@@ -0,0 +1,22 @@
+'use strict';
+const LMDBTransactionObject = require('./LMDBTransactionObject.js');
+const OPERATIONS_ENUM = require('../../../../utility/hdbTerms.ts').OPERATIONS_ENUM;
+
+/**
+ * class to define an insert transaction
+ */
+class LMDBInsertTransactionObject extends LMDBTransactionObject {
+	/**
+	 * @param {Array.<Object>} records - inserted records
+	 * @param {string} userName - username that executed trasaction
+	 * @param {number} timestamp - timestamp of the transaction
+	 * @param {[String|Number]} hash_values
+	 * @param {any} origin
+	 */
+	constructor(records, userName, timestamp, hash_values, origin = undefined) {
+		super(OPERATIONS_ENUM.INSERT, userName, timestamp, hash_values, origin);
+		this.records = records;
+	}
+}
+
+module.exports = LMDBInsertTransactionObject;

package/dataLayer/harperBridge/lmdbBridge/lmdbUtility/LMDBTransactionObject.js

@@ -0,0 +1,23 @@
+'use strict';
+
+/**
+ * base class for transactions
+ */
+class LMDBTransactionObject {
+	/**
+	 * @param {string} operation - name of operation
+	 * @param {string} userName - username that executed transaction
+	 * @param {number} timestamp - timestamp of transaction
+	 * @param {[string|number]} hash_values
+	 * @param {any} origin
+	 */
+	constructor(operation, userName, timestamp, hash_values, origin = undefined) {
+		this.operation = operation;
+		this.user_name = userName;
+		this.timestamp = timestamp;
+		this.hash_values = hash_values;
+		this.origin = origin;
+	}
+}
+
+module.exports = LMDBTransactionObject;