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

package/dataLayer/schema.js

@@ -0,0 +1,366 @@
+'use strict';
+
+const schemaMetadataValidator = require('../validation/schemaMetadataValidator.js');
+const { validateBySchema } = require('../validation/validationWrapper.js');
+const { commonValidators, schemaRegex } = require('../validation/common_validators.js');
+const Joi = require('joi');
+const logger = require('../utility/logging/harper_logger.js');
+const uuidV4 = require('uuid').v4;
+const signalling = require('../utility/signalling.js');
+const hdbTerms = require('../utility/hdbTerms.ts');
+const util = require('util');
+const harperBridge = require('./harperBridge/harperBridge.js');
+const { handleHDBError, hdbErrors, ClientError } = require('../utility/errors/hdbError.js');
+const { HDB_ERROR_MSGS, HTTP_STATUS_CODES } = hdbErrors;
+const { SchemaEventMsg } = require('../server/threads/itc.js');
+const { getDatabases, dropTableMeta } = require('../resources/databases.ts');
+const { transformReq } = require('../utility/common_utils.js');
+const { server } = require('../server/Server.ts');
+const { cleanupOrphans } = require('../resources/blob.ts');
+
+const DB_NAME_CONSTRAINTS = Joi.string()
+	.min(1)
+	.max(commonValidators.schema_length.maximum)
+	.pattern(schemaRegex)
+	.messages({ 'string.pattern.base': '{:#label} ' + commonValidators.schema_format.message });
+
+const TABLE_NAME_CONSTRAINTS = Joi.string()
+	.min(1)
+	.max(commonValidators.schema_length.maximum)
+	.pattern(schemaRegex)
+	.messages({ 'string.pattern.base': '{:#label} ' + commonValidators.schema_format.message })
+	.required();
+
+const PRIMARY_KEY_CONSTRAINTS = Joi.string()
+	.min(1)
+	.max(commonValidators.schema_length.maximum)
+	.pattern(schemaRegex)
+	.messages({
+		'string.pattern.base': '{:#label} ' + commonValidators.schema_format.message,
+		'any.required': "'primary_key' is required",
+		'string.base': "'primary_key' must be a string",
+	})
+	.required();
+
+module.exports = {
+	createSchema,
+	createSchemaStructure,
+	createTable,
+	createTableStructure,
+	createAttribute,
+	dropSchema,
+	dropTable,
+	dropAttribute,
+	getBackup,
+	cleanupOrphanBlobs,
+};
+
+/** EXPORTED FUNCTIONS **/
+
+async function createSchema(schemaCreateObject) {
+	let schemaStructure = await createSchemaStructure(schemaCreateObject);
+	signalling.signalSchemaChange(
+		new SchemaEventMsg(process.pid, schemaCreateObject.operation, schemaCreateObject.schema)
+	);
+
+	return schemaStructure;
+}
+
+async function createSchemaStructure(schemaCreateObject) {
+	const validation = validateBySchema(
+		schemaCreateObject,
+		Joi.object({
+			database: DB_NAME_CONSTRAINTS,
+			schema: DB_NAME_CONSTRAINTS,
+		})
+	);
+	if (validation) throw new ClientError(validation.message);
+
+	transformReq(schemaCreateObject);
+
+	if (!(await schemaMetadataValidator.checkSchemaExists(schemaCreateObject.schema))) {
+		throw handleHDBError(
+			new Error(),
+			HDB_ERROR_MSGS.SCHEMA_EXISTS_ERR(schemaCreateObject.schema),
+			HTTP_STATUS_CODES.BAD_REQUEST,
+			hdbTerms.LOG_LEVELS.ERROR,
+			HDB_ERROR_MSGS.SCHEMA_EXISTS_ERR(schemaCreateObject.schema),
+			true
+		);
+	}
+
+	await harperBridge.createSchema(schemaCreateObject);
+
+	return `database '${schemaCreateObject.schema}' successfully created`;
+}
+
+async function createTable(createTableObject) {
+	transformReq(createTableObject);
+	createTableObject.primary_key = createTableObject.primary_key ?? createTableObject.hash_attribute;
+	return await createTableStructure(createTableObject);
+}
+
+async function createTableStructure(createTableObject) {
+	const validation = validateBySchema(
+		createTableObject,
+		Joi.object({
+			database: DB_NAME_CONSTRAINTS,
+			schema: DB_NAME_CONSTRAINTS,
+			table: TABLE_NAME_CONSTRAINTS,
+			residence: Joi.array().items(Joi.string().min(1)).optional(),
+			primary_key: PRIMARY_KEY_CONSTRAINTS,
+		})
+	);
+	if (validation) throw new ClientError(validation.message);
+
+	let invalidTableMsg = await schemaMetadataValidator.checkSchemaTableExists(
+		createTableObject.schema,
+		createTableObject.table
+	);
+	if (!invalidTableMsg) {
+		throw handleHDBError(
+			new Error(),
+			HDB_ERROR_MSGS.TABLE_EXISTS_ERR(createTableObject.schema, createTableObject.table),
+			HTTP_STATUS_CODES.BAD_REQUEST,
+			hdbTerms.LOG_LEVELS.ERROR,
+			HDB_ERROR_MSGS.TABLE_EXISTS_ERR(createTableObject.schema, createTableObject.table),
+			true
+		);
+	}
+
+	let tableSystemData = {
+		name: createTableObject.table,
+		schema: createTableObject.schema,
+		id: uuidV4(),
+		primary_key: createTableObject.primary_key,
+	};
+
+	if (createTableObject.residence) {
+		if (global.clustering_on) {
+			tableSystemData.residence = createTableObject.residence;
+			await harperBridge.createTable(tableSystemData, createTableObject);
+		} else {
+			throw handleHDBError(
+				new Error(),
+				`Clustering does not appear to be enabled. Cannot insert table with property 'residence'.`,
+				HTTP_STATUS_CODES.BAD_REQUEST
+			);
+		}
+	} else {
+		await harperBridge.createTable(tableSystemData, createTableObject);
+	}
+
+	return `table '${createTableObject.schema}.${createTableObject.table}' successfully created.`;
+}
+
+async function dropSchema(dropSchemaObject) {
+	const validation = validateBySchema(
+		dropSchemaObject,
+		Joi.object({
+			database: Joi.string(),
+			schema: Joi.string(),
+		})
+			.or('database', 'schema')
+			.messages({
+				'object.missing': "'database' is required",
+			})
+	);
+	if (validation) throw new ClientError(validation.message);
+
+	transformReq(dropSchemaObject);
+
+	let invalidSchemaMsg = await schemaMetadataValidator.checkSchemaExists(dropSchemaObject.schema);
+	if (invalidSchemaMsg) {
+		throw handleHDBError(
+			new Error(),
+			invalidSchemaMsg,
+			HTTP_STATUS_CODES.NOT_FOUND,
+			hdbTerms.LOG_LEVELS.ERROR,
+			invalidSchemaMsg,
+			true
+		);
+	}
+
+	await harperBridge.dropSchema(dropSchemaObject);
+	signalling.signalSchemaChange(new SchemaEventMsg(process.pid, dropSchemaObject.operation, dropSchemaObject.schema));
+
+	let response = await server.replication.replicateOperation(dropSchemaObject);
+	response.message = `successfully deleted '${dropSchemaObject.schema}'`;
+	return response;
+}
+
+async function dropTable(dropTableObject) {
+	const validation = validateBySchema(
+		dropTableObject,
+		Joi.object({
+			database: Joi.string(),
+			schema: Joi.string(),
+			table: Joi.string().required(),
+		})
+	);
+	if (validation) throw new ClientError(validation.message);
+
+	transformReq(dropTableObject);
+
+	let invalidSchemaTableMsg = await schemaMetadataValidator.checkSchemaTableExists(
+		dropTableObject.schema,
+		dropTableObject.table
+	);
+	if (invalidSchemaTableMsg) {
+		throw handleHDBError(
+			new Error(),
+			invalidSchemaTableMsg,
+			HTTP_STATUS_CODES.NOT_FOUND,
+			hdbTerms.LOG_LEVELS.ERROR,
+			invalidSchemaTableMsg,
+			true
+		);
+	}
+
+	await harperBridge.dropTable(dropTableObject);
+
+	await dropTableMeta({ table: dropTableObject.table, database: dropTableObject.schema });
+
+	let response = await server.replication.replicateOperation(dropTableObject);
+	response.message = `successfully deleted table '${dropTableObject.schema}.${dropTableObject.table}'`;
+	return response;
+}
+
+/**
+ * Drops all files for the specified attribute.
+ * @param dropAttributeObject - The JSON formatted inbound message.
+ * @returns {Promise<*>}
+ */
+async function dropAttribute(dropAttributeObject) {
+	const validation = validateBySchema(
+		dropAttributeObject,
+		Joi.object({
+			database: Joi.string(),
+			schema: Joi.string(),
+			table: Joi.string().required(),
+			attribute: Joi.string().required(),
+		})
+	);
+	if (validation) throw new ClientError(validation.message);
+
+	transformReq(dropAttributeObject);
+
+	let invalidSchemaTableMsg = await schemaMetadataValidator.checkSchemaTableExists(
+		dropAttributeObject.schema,
+		dropAttributeObject.table
+	);
+	if (invalidSchemaTableMsg) {
+		throw handleHDBError(
+			new Error(),
+			invalidSchemaTableMsg,
+			HTTP_STATUS_CODES.NOT_FOUND,
+			hdbTerms.LOG_LEVELS.ERROR,
+			invalidSchemaTableMsg,
+			true
+		);
+	}
+
+	if (
+		dropAttributeObject.attribute ===
+		global.hdb_schema[dropAttributeObject.schema][dropAttributeObject.table].primary_key
+	) {
+		throw handleHDBError(
+			new Error(),
+			'You cannot drop a hash attribute',
+			HTTP_STATUS_CODES.BAD_REQUEST,
+			undefined,
+			undefined,
+			true
+		);
+	}
+
+	if (hdbTerms.TIME_STAMP_NAMES.indexOf(dropAttributeObject.attribute) >= 0) {
+		throw handleHDBError(
+			new Error(),
+			`cannot drop internal timestamp attribute: ${dropAttributeObject.attribute}`,
+			HTTP_STATUS_CODES.BAD_REQUEST,
+			undefined,
+			undefined,
+			true
+		);
+	}
+
+	try {
+		await harperBridge.dropAttribute(dropAttributeObject);
+		dropAttributeFromGlobal(dropAttributeObject);
+		signalling.signalSchemaChange(
+			new SchemaEventMsg(
+				process.pid,
+				dropAttributeObject.operation,
+				dropAttributeObject.schema,
+				dropAttributeObject.table,
+				dropAttributeObject.attribute
+			)
+		);
+
+		return `successfully deleted attribute '${dropAttributeObject.attribute}'`;
+	} catch (err) {
+		logger.error(`Got an error deleting attribute ${util.inspect(dropAttributeObject)}.`);
+		throw err;
+	}
+}
+
+/**
+ * Removes the dropped attribute from the global hdb schema object.
+ * @param dropAttributeObject
+ */
+function dropAttributeFromGlobal(dropAttributeObject) {
+	let attributesObj = Object.values(
+		global.hdb_schema[dropAttributeObject.schema][dropAttributeObject.table]['attributes']
+	);
+
+	for (let i = 0; i < attributesObj.length; i++) {
+		if (attributesObj[i].attribute === dropAttributeObject.attribute) {
+			global.hdb_schema[dropAttributeObject.schema][dropAttributeObject.table]['attributes'].splice(i, 1);
+		}
+	}
+}
+
+async function createAttribute(createAttributeObject) {
+	transformReq(createAttributeObject);
+
+	const tableAttr = getDatabases()[createAttributeObject.schema][createAttributeObject.table].attributes;
+	for (const { name } of tableAttr) {
+		if (name === createAttributeObject.attribute) {
+			throw handleHDBError(
+				new Error(),
+				`attribute '${createAttributeObject.attribute}' already exists in ${createAttributeObject.schema}.${createAttributeObject.table}`,
+				HTTP_STATUS_CODES.BAD_REQUEST,
+				undefined,
+				undefined,
+				true
+			);
+		}
+	}
+
+	await harperBridge.createAttribute(createAttributeObject);
+	signalling.signalSchemaChange(
+		new SchemaEventMsg(
+			process.pid,
+			createAttributeObject.operation,
+			createAttributeObject.schema,
+			createAttributeObject.table,
+			createAttributeObject.attribute
+		)
+	);
+
+	return `attribute '${createAttributeObject.schema}.${createAttributeObject.table}.${createAttributeObject.attribute}' successfully created.`;
+}
+
+function getBackup(getBackupObject) {
+	return harperBridge.getBackup(getBackupObject);
+}
+
+function cleanupOrphanBlobs(request) {
+	if (!request.database) throw new ClientError('Must provide "database" name for search for orphaned blobs');
+	const database = databases[request.database];
+	if (!database) throw new ClientError(`Unknown database '${request.database}'`);
+	// don't await, it will probably take hours
+	cleanupOrphans(databases[request.database], request.database);
+	return { message: 'Orphaned blobs cleanup started, check logs for progress' };
+}

package/dataLayer/schemaDescribe.js

@@ -0,0 +1,289 @@
+'use strict';
+
+const logger = require('../utility/logging/harper_logger.js');
+const { validateBySchema } = require('../validation/validationWrapper.js');
+const Joi = require('joi');
+const hdbUtils = require('../utility/common_utils.js');
+const { handleHDBError, hdbErrors, ClientError } = require('../utility/errors/hdbError.js');
+const { HDB_ERROR_MSGS, HTTP_STATUS_CODES } = hdbErrors;
+const envMngr = require('../utility/environment/environmentManager.js');
+envMngr.initSync();
+const { getDatabases } = require('../resources/databases.ts');
+const fs = require('fs-extra');
+
+module.exports = {
+	describeAll,
+	describeTable: descTable,
+	describeSchema,
+};
+
+/**
+ * This method is exposed to the API and internally for system operations.  If the op is being made internally, the `opObj`
+ * argument is not passed and, therefore, no permissions are used to filter the final schema metadata results.
+ * @param opObj
+ * @returns {Promise<{}|HdbError>}
+ */
+async function describeAll(opObj = {}) {
+	try {
+		const sysCall = hdbUtils.isEmptyOrZeroLength(opObj);
+		const bypassAuth = !!opObj.bypass_auth;
+		let rolePerms;
+		let isSu;
+		if (!sysCall && !bypassAuth) {
+			rolePerms = opObj.hdb_user?.role?.permission;
+			isSu = rolePerms?.super_user;
+		}
+		let databases = getDatabases();
+		let schemaList = {};
+		let schemaPerms = {};
+		let tResults = [];
+		const exact_count = opObj?.exact_count;
+		const include_computed = opObj?.include_computed;
+		for (let schema in databases) {
+			schemaList[schema] = true;
+			if (!sysCall && !isSu && !bypassAuth) schemaPerms[schema] = opObj.hdb_user?.role?.permission[schema]?.describe;
+			let tables = databases[schema];
+			for (let table in tables) {
+				try {
+					let desc;
+					if (sysCall || isSu || bypassAuth) {
+						desc = await descTable({ schema, table, exact_count, include_computed });
+					} else if (rolePerms && rolePerms[schema].describe && rolePerms[schema].tables[table].describe) {
+						const tAttrPerms = rolePerms[schema].tables[table].attribute_permissions;
+						desc = await descTable({ schema, table, exact_count, include_computed }, tAttrPerms);
+					}
+					if (desc) {
+						tResults.push(desc);
+					}
+				} catch (e) {
+					logger.error(e);
+				}
+			}
+		}
+
+		let hdbDescription = {};
+		for (let t in tResults) {
+			if (sysCall || isSu || bypassAuth) {
+				if (hdbDescription[tResults[t].schema] == null) {
+					hdbDescription[tResults[t].schema] = {};
+				}
+
+				hdbDescription[tResults[t].schema][tResults[t].name] = tResults[t];
+				if (schemaList[tResults[t].schema]) {
+					delete schemaList[tResults[t].schema];
+				}
+			} else if (schemaPerms[tResults[t].schema]) {
+				if (hdbDescription[tResults[t].schema] == null) {
+					hdbDescription[tResults[t].schema] = {};
+				}
+
+				hdbDescription[tResults[t].schema][tResults[t].name] = tResults[t];
+				if (schemaList[tResults[t].schema]) {
+					delete schemaList[tResults[t].schema];
+				}
+			}
+		}
+
+		for (let schema in schemaList) {
+			if (sysCall || isSu || bypassAuth) {
+				hdbDescription[schema] = {};
+			} else if (schemaPerms[schema]) {
+				hdbDescription[schema] = {};
+			}
+		}
+		return hdbDescription;
+	} catch (e) {
+		logger.error('Got an error in describeAll');
+		logger.error(e);
+		return handleHDBError(new Error(), HDB_ERROR_MSGS.DESCRIBE_ALL_ERR);
+	}
+}
+
+/**
+ * This method will return the metadata for a table - if `attrPerms` are passed as an argument (or included in the `describeTableObject` arg),
+ * the final results w/ be filtered based on those permissions
+ *
+ * @param describeTableObject
+ * @param attrPerms - optional - permissions for the role requesting metadata for the table used when chained to other
+ * internal operations.  If this method is hit via the API, perms will be grabbed from the describeTableObject which
+ * includes the users role and permissions.
+ * @returns {Promise<{}|*>}
+ */
+async function descTable(describeTableObject, attrPerms) {
+	hdbUtils.transformReq(describeTableObject);
+	let { schema, table } = describeTableObject;
+	schema = schema?.toString();
+	table = table?.toString();
+	let tableAttrPerms = attrPerms;
+
+	//If the describeTableObject includes a `hdb_user` value, it is being called from the API and we can grab the user's
+	// role permissions from there
+	if (describeTableObject.hdb_user && !describeTableObject.hdb_user?.role?.permission?.super_user) {
+		tableAttrPerms = describeTableObject.hdb_user?.role?.permission[schema]?.tables[table]?.attribute_permissions;
+	}
+
+	const validation = validateBySchema(
+		describeTableObject,
+		Joi.object({
+			database: Joi.string(),
+			table: Joi.string().required(),
+			exact_count: Joi.boolean().strict(),
+			include_computed: Joi.boolean().strict(),
+		})
+	);
+	if (validation) throw new ClientError(validation.message);
+
+	let databases = getDatabases();
+	let tables = databases[schema];
+	if (!tables) {
+		throw handleHDBError(
+			new Error(),
+			HDB_ERROR_MSGS.SCHEMA_NOT_FOUND(describeTableObject.schema),
+			HTTP_STATUS_CODES.NOT_FOUND
+		);
+	}
+	let tableObj = tables[table];
+	if (!tableObj)
+		throw handleHDBError(
+			new Error(),
+			HDB_ERROR_MSGS.TABLE_NOT_FOUND(describeTableObject.schema, describeTableObject.table),
+			HTTP_STATUS_CODES.NOT_FOUND
+		);
+
+	function pushAtt(att) {
+		if (!att.computed || describeTableObject.include_computed)
+			attributes.push({
+				attribute: att.attribute,
+				type: att.type,
+				elements: att.elements?.type,
+				indexed: att.indexed,
+				is_primary_key: att.isPrimaryKey,
+				assigned_created_time: att.assignCreatedTime,
+				assigned_updated_time: att.assignUpdatedTime,
+				nullable: att.nullable,
+				computed: att.computed ? true : undefined, // only include if computed
+				properties: att.properties
+					? att.properties.map((prop) => {
+							return { type: prop.type, name: prop.name };
+						})
+					: undefined,
+			});
+	}
+
+	let attributes = [];
+	if (tableAttrPerms) {
+		let permittedAttr = {};
+		tableAttrPerms.forEach((a) => {
+			if (a.describe) permittedAttr[a.attribute_name] = true;
+		});
+
+		tableObj.attributes.forEach((a) => {
+			if (permittedAttr[a.name]) pushAtt(a);
+		});
+	} else {
+		tableObj.attributes?.forEach((att) => pushAtt(att));
+	}
+	let db_size;
+	try {
+		db_size = (await fs.stat(tableObj.primaryStore.path)).size;
+	} catch (error) {
+		logger.warn(`unable to get database size`, error);
+	}
+	let tableResult = {
+		schema,
+		name: tableObj.tableName,
+		primary_key: tableObj.attributes.find((attribute) => attribute.isPrimaryKey || attribute.isPrimaryKey)?.name,
+		audit: tableObj.audit,
+		schema_defined: tableObj.schemaDefined,
+		attributes,
+		db_size,
+	};
+	if (tableObj.replicate !== undefined) tableResult.replicate = tableObj.replicate;
+	if (tableObj.expirationMS !== undefined) tableResult.expiration = tableObj.expirationMS / 1000 + 's';
+	if (tableObj.sealed !== undefined) tableResult.sealed = tableObj.sealed;
+	if (tableObj.sources?.length > 0)
+		tableResult.sources = tableObj.sources
+			.map((source) => source.name)
+			.filter((source) => source && source !== 'Replicator');
+
+	try {
+		const recordCount = await tableObj.getRecordCount({ exactCount: !!describeTableObject.exact_count });
+		tableResult.record_count = recordCount.recordCount;
+		tableResult.table_size = tableObj.getSize();
+		tableResult.db_audit_size = tableObj.getAuditSize();
+		tableResult.estimated_record_range = recordCount.estimatedRange;
+		let auditStore = tableObj.auditStore;
+		if (auditStore) {
+			for (let key of auditStore.getKeys({ reverse: true, limit: 1 })) {
+				tableResult.last_updated_record = key[0];
+			}
+		}
+		if (!tableResult.last_updated_record && tableObj.indices.__updatedtime__) {
+			for (let key of tableObj.indices.__updatedtime__.getKeys({ reverse: true, limit: 1 })) {
+				tableResult.last_updated_record = key;
+			}
+		}
+	} catch (e) {
+		logger.warn(`unable to stat table dbi due to ${e}`);
+	}
+	return tableResult;
+}
+
+/**
+ * Returns the schema metadata filtered based on permissions for the user role making the request
+ *
+ * @param describeSchemaObject
+ * @returns {Promise<{}|[]>}
+ */
+async function describeSchema(describeSchemaObject) {
+	hdbUtils.transformReq(describeSchemaObject);
+
+	const validation = validateBySchema(
+		describeSchemaObject,
+		Joi.object({
+			database: Joi.string(),
+			exact_count: Joi.boolean().strict(),
+			include_computed: Joi.boolean().strict(),
+		})
+	);
+	if (validation) throw new ClientError(validation.message);
+
+	let schemaPerms;
+
+	if (describeSchemaObject.hdb_user && !describeSchemaObject.hdb_user?.role?.permission?.super_user) {
+		schemaPerms = describeSchemaObject.hdb_user?.role?.permission[describeSchemaObject.schema];
+	}
+	const schemaName = describeSchemaObject.schema.toString();
+
+	let databases = getDatabases();
+	let schema = databases[schemaName];
+	if (!schema) {
+		throw handleHDBError(
+			new Error(),
+			HDB_ERROR_MSGS.SCHEMA_NOT_FOUND(describeSchemaObject.schema),
+			HTTP_STATUS_CODES.NOT_FOUND
+		);
+	}
+	let results = {};
+	for (let tableName in schema) {
+		let table_perms;
+		if (schemaPerms && schemaPerms.tables[tableName]) {
+			table_perms = schemaPerms.tables[tableName];
+		}
+		if (hdbUtils.isEmpty(table_perms) || table_perms.describe) {
+			let data = await descTable(
+				{
+					schema: describeSchemaObject.schema,
+					table: tableName,
+					exact_count: describeSchemaObject.exact_count,
+					include_computed: describeSchemaObject.include_computed,
+				},
+				table_perms ? table_perms.attribute_permissions : null
+			);
+			if (data) {
+				results[data.name] = data;
+			}
+		}
+	}
+	return results;
+}

package/dataLayer/search.js

@@ -0,0 +1,60 @@
+'use strict';
+
+module.exports = {
+	searchByConditions,
+	searchByHash,
+	searchByValue,
+	search,
+};
+
+const harperBridge = require('./harperBridge/harperBridge.js');
+const { transformReq } = require('../utility/common_utils.js');
+
+async function searchByConditions(searchObject) {
+	transformReq(searchObject);
+	return harperBridge.searchByConditions(searchObject);
+}
+
+async function searchByHash(searchObject) {
+	transformReq(searchObject);
+	if (searchObject.ids) searchObject.hash_values = searchObject.ids;
+	let array = [];
+	for await (let record of harperBridge.searchByHash(searchObject)) {
+		if (record) array.push(record);
+	}
+	return array;
+}
+
+async function searchByValue(searchObject) {
+	transformReq(searchObject);
+	if (searchObject.hasOwnProperty('desc') === true) {
+		searchObject.reverse = searchObject.desc;
+	}
+	const array = [];
+	for await (let record of harperBridge.searchByValue(searchObject)) {
+		array.push(record);
+	}
+	return array;
+}
+
+function search(statement, callback) {
+	try {
+		const SelectValidator = require('../sqlTranslator/SelectValidator.js');
+		const SQLSearch = require('./SQLSearch.js');
+		let validator = new SelectValidator(statement);
+		validator.validate();
+
+		let sqlSearch = new SQLSearch(validator.statement, validator.attributes);
+
+		sqlSearch
+			.search()
+			.then((data) => {
+				callback(null, data);
+			})
+			.catch((e) => {
+				callback(e, null);
+			});
+	} catch (e) {
+		return callback(e);
+	}
+}