@harperfast/harper 5.0.30 → 5.1.0-beta.2

package/validation/{installValidator.js → installValidator.ts}

@@ -1,13 +1,13 @@
 'use strict';
 
-const Joi = require('joi');
+import Joi from 'joi';
 const { string, number } = Joi.types();
-const fs = require('fs-extra');
-const hdbTerms = require('../utility/hdbTerms.ts');
-const path = require('path');
-const validator = require('../validation/validationWrapper.js');
+import * as fs from 'fs-extra';
+import * as hdbTerms from '../utility/hdbTerms.ts';
+import * as path from 'path';
+import * as validator from './validationWrapper.ts';
 
-module.exports = installValidator;
+export default installValidator;
 
 /**
  * Used to validate any command or environment variables used passed to install.
@@ -17,11 +17,11 @@ module.exports = installValidator;
 function installValidator(param) {
 	const installSchema = Joi.object({
 		[hdbTerms.INSTALL_PROMPTS.ROOTPATH]: Joi.custom(validateRootAvailable),
-		[hdbTerms.INSTALL_PROMPTS.OPERATIONSAPI_NETWORK_PORT]: Joi.alternatives([number.min(0), string]).allow(
+		[(hdbTerms.INSTALL_PROMPTS as any).OPERATIONSAPI_NETWORK_PORT]: Joi.alternatives([number.min(0), string]).allow(
 			'null',
 			null
 		),
-		[hdbTerms.INSTALL_PROMPTS.TC_AGREEMENT]: string.valid('yes', 'YES', 'Yes'),
+		[(hdbTerms.INSTALL_PROMPTS as any).TC_AGREEMENT]: string.valid('yes', 'YES', 'Yes'),
 	});
 
 	return validator.validateBySchema(param, installSchema);

package/validation/{readLogValidator.js → readLogValidator.ts}

@@ -1,19 +1,19 @@
 'use strict';
 
-const Joi = require('joi');
-const validator = require('./validationWrapper.js');
-const moment = require('moment');
-const fs = require('fs-extra');
-const path = require('path');
-const { getConfigPath } = require('../config/configUtils.js');
-const hdbTerms = require('../utility/hdbTerms.ts');
-const { LOG_LEVELS } = require('../utility/hdbTerms.ts');
+import Joi from 'joi';
+import * as validator from './validationWrapper.ts';
+import moment from 'moment';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { getConfigPath } from '../config/configUtils.js';
+import * as hdbTerms from '../utility/hdbTerms.ts';
+import { LOG_LEVELS } from '../utility/hdbTerms.ts';
 
 const LOG_DATE_FORMAT = 'YYYY-MM-DD hh:mm:ss';
 
-module.exports = function (object) {
+export default function (object: any) {
 	return validator.validateBySchema(object, readLogSchema);
-};
+}
 
 const readLogSchema = Joi.object({
 	from: Joi.custom(validateDatetime),

package/validation/{role_validation.js → role_validation.ts}

@@ -1,8 +1,8 @@
-const validate = require('validate.js'),
-	validator = require('./validationWrapper.js'),
-	terms = require('../utility/hdbTerms.ts'),
-	{ validateOperations } = require('../utility/operationPermissions.ts'),
-	{ handleHDBError, hdbErrors } = require('../utility/errors/hdbError.js');
+const validate = require('validate.js');
+const validator = require('./validationWrapper');
+import * as terms from '../utility/hdbTerms.ts';
+import { validateOperations } from '../utility/operationPermissions.ts';
+import { handleHDBError, hdbErrors } from '../utility/errors/hdbError.ts';
 
 const { HDB_ERROR_MSGS, HTTP_STATUS_CODES } = hdbErrors;
 
@@ -34,7 +34,7 @@ const TABLE_PERM_KEYS = [ATTR_PERMS_KEY, ...Object.values(PERMS_CRUD_ENUM)];
 const ATTR_CRU_KEYS = [PERMS_CRUD_ENUM.READ, PERMS_CRUD_ENUM.INSERT, PERMS_CRUD_ENUM.UPDATE];
 const ATTR_PERMS_KEYS = [ATTR_NAME_KEY, ...ATTR_CRU_KEYS];
 
-function addRoleValidation(object) {
+export function addRoleValidation(object) {
 	const constraints = constraintsTemplate();
 	constraints.role.presence = true;
 	constraints.id.presence = false;
@@ -42,7 +42,7 @@ function addRoleValidation(object) {
 	return customValidate(object, constraints);
 }
 
-function alterRoleValidation(object) {
+export function alterRoleValidation(object) {
 	const constraints = constraintsTemplate();
 	constraints.role.presence = false;
 	constraints.id.presence = true;
@@ -50,7 +50,7 @@ function alterRoleValidation(object) {
 	return customValidate(object, constraints);
 }
 
-function dropRoleValidation(object) {
+export function dropRoleValidation(object) {
 	const constraints = constraintsTemplate();
 	constraints.role.presence = false;
 	constraints.id.presence = true;
@@ -76,13 +76,13 @@ function customValidate(object, constraints) {
 		}
 	}
 	if (invalidKeys.length > 0) {
-		addPermError(HDB_ERROR_MSGS.INVALID_ROLE_JSON_KEYS(invalidKeys), validationErrors);
+		addPermError(HDB_ERROR_MSGS.INVALID_ROLE_JSON_KEYS(invalidKeys), validationErrors, undefined, undefined);
 	}
 
 	let validateResult = validator.validateObject(object, constraints);
 	if (validateResult) {
 		validateResult.message.split(',').forEach((validationErr) => {
-			addPermError(validationErr, validationErrors);
+			addPermError(validationErr, validationErrors, undefined, undefined);
 		});
 	}
 
@@ -91,18 +91,18 @@ function customValidate(object, constraints) {
 		//check if role is SU or CU and has perms included
 		const suPermsError = validateNoSUPerms(object);
 		if (suPermsError) {
-			addPermError(suPermsError, validationErrors);
+			addPermError(suPermsError, validationErrors, undefined, undefined);
 		}
 		//check if cu or su values, if included, are booleans
 		ROLE_TYPES.forEach((role) => {
-			if (object.permission[role] && !validate.isBoolean(object.permission[role])) {
-				addPermError(HDB_ERROR_MSGS.SU_CU_ROLE_BOOLEAN_ERROR(role), validationErrors);
+			if (object.permission[role as any] && !validate.isBoolean(object.permission[role as any])) {
+				addPermError(HDB_ERROR_MSGS.SU_CU_ROLE_BOOLEAN_ERROR(role as any), validationErrors, undefined, undefined);
 			}
 		});
 	}
 
 	for (let item in object.permission) {
-		if (ROLE_TYPES.indexOf(item) < 0) {
+		if (ROLE_TYPES.indexOf(item as any) < 0) {
 			//validate the user type 'structure_user'.  acceptable data type is boolean or array of strings (this would be array of accepted schemas to interact with)
 			if (item === STRUCTURE_USER_ENUM.STRUCTURE_USER) {
 				let structureUserPerm = object.permission[item];
@@ -116,15 +116,15 @@ function customValidate(object, constraints) {
 				if (Array.isArray(structureUserPerm)) {
 					for (let k = 0, length = structureUserPerm.length; k < length; k++) {
 						let schemaPerm = structureUserPerm[k];
-						if (!global.hdb_schema[schemaPerm]) {
-							addPermError(HDB_ERROR_MSGS.SCHEMA_NOT_FOUND(schemaPerm), validationErrors);
+						if (!(global as any).hdb_schema[schemaPerm]) {
+							addPermError(HDB_ERROR_MSGS.SCHEMA_NOT_FOUND(schemaPerm), validationErrors, undefined, undefined);
 						}
 					}
 					continue;
 				}
 
 				//if we end up here then this is an invalid data type
-				addPermError(HDB_ERROR_MSGS.STRUCTURE_USER_ROLE_TYPE_ERROR(item), validationErrors);
+				addPermError(HDB_ERROR_MSGS.STRUCTURE_USER_ROLE_TYPE_ERROR(item), validationErrors, undefined, undefined);
 				continue;
 			}
 
@@ -133,29 +133,29 @@ function customValidate(object, constraints) {
 				const opUserPerm = object.permission[item];
 
 				if (!Array.isArray(opUserPerm)) {
-					addPermError(HDB_ERROR_MSGS.OPERATIONS_MUST_BE_ARRAY, validationErrors);
+					addPermError(HDB_ERROR_MSGS.OPERATIONS_MUST_BE_ARRAY, validationErrors, undefined, undefined);
 					continue;
 				}
 
 				const invalidOp = validateOperations(opUserPerm);
 				if (invalidOp !== null) {
-					addPermError(HDB_ERROR_MSGS.INVALID_OPERATIONS_OP(invalidOp), validationErrors);
+					addPermError(HDB_ERROR_MSGS.INVALID_OPERATIONS_OP(invalidOp), validationErrors, undefined, undefined);
 				}
 				continue;
 			}
 
 			let schema = object.permission[item];
 			//validate that schema exists
-			if (!item || !global.hdb_schema[item]) {
-				addPermError(HDB_ERROR_MSGS.SCHEMA_NOT_FOUND(item), validationErrors);
+			if (!item || !(global as any).hdb_schema[item]) {
+				addPermError(HDB_ERROR_MSGS.SCHEMA_NOT_FOUND(item), validationErrors, undefined, undefined);
 				continue;
 			}
 			if (schema.tables) {
 				for (let t in schema.tables) {
 					let table = schema.tables[t];
 					//validate that table exists in schema
-					if (!t || !global.hdb_schema[item][t]) {
-						addPermError(HDB_ERROR_MSGS.TABLE_NOT_FOUND(item, t), validationErrors);
+					if (!t || !(global as any).hdb_schema[item][t]) {
+						addPermError(HDB_ERROR_MSGS.TABLE_NOT_FOUND(item, t), validationErrors, undefined, undefined);
 						continue;
 					}
 
@@ -168,9 +168,9 @@ function customValidate(object, constraints) {
 
 					//validate table CRUD perms
 					Object.values(PERMS_CRUD_ENUM).forEach((permKey) => {
-						if (!validate.isDefined(table[permKey])) {
+						if (!validate.isDefined(table[permKey as any])) {
 							addPermError(HDB_ERROR_MSGS.TABLE_PERM_MISSING(permKey), validationErrors, item, t);
-						} else if (!validate.isBoolean(table[permKey])) {
+						} else if (!validate.isBoolean(table[permKey as any])) {
 							addPermError(HDB_ERROR_MSGS.TABLE_PERM_NOT_BOOLEAN(permKey), validationErrors, item, t);
 						}
 					});
@@ -186,7 +186,7 @@ function customValidate(object, constraints) {
 
 					//need this check here to ensure no unexpected errors if key is missing in table perms obj
 					if (table.attribute_permissions) {
-						let tableAttributeNames = global.hdb_schema[item][t].attributes.map(({ attribute }) => attribute);
+						let tableAttributeNames = (global as any).hdb_schema[item][t].attributes.map(({ attribute }) => attribute);
 						const attrPermsCheck = {
 							read: false,
 							insert: false,
@@ -255,12 +255,6 @@ function customValidate(object, constraints) {
 	return generateRolePermResponse(validationErrors);
 }
 
-module.exports = {
-	addRoleValidation,
-	alterRoleValidation,
-	dropRoleValidation,
-};
-
 /**
  * Validates that permissions object for CU or SU roles do not also include permissions
  * @param obj

package/validation/{schemaMetadataValidator.js → schemaMetadataValidator.ts}

@@ -1,14 +1,8 @@
 'use strict';
 
-const schemaDescribe = require('../dataLayer/schemaDescribe.js');
-const { hdbErrors } = require('../utility/errors/hdbError.js');
-const { getDatabases } = require('../resources/databases.ts');
-
-module.exports = {
-	checkSchemaExists,
-	checkSchemaTableExists,
-	schemaDescribe,
-};
+export const schemaDescribe = require('../dataLayer/schemaDescribe');
+import { hdbErrors } from '../utility/errors/hdbError.ts';
+import { getDatabases } from '../resources/databases.ts';
 
 /**
  * Checks the global hdbSchema for a schema and table
@@ -16,7 +10,7 @@ module.exports = {
  * @param tableName
  * @returns string returns a thrown message if schema and or table does not exist
  */
-async function checkSchemaExists(schemaName) {
+export async function checkSchemaExists(schemaName) {
 	let databases = getDatabases();
 	if (!databases[schemaName]) {
 		return hdbErrors.HDB_ERROR_MSGS.SCHEMA_NOT_FOUND(schemaName);
@@ -29,7 +23,7 @@ async function checkSchemaExists(schemaName) {
  * @param tableName
  * @returns string returns a thrown message if schema and or table does not exist
  */
-async function checkSchemaTableExists(schemaName, tableName) {
+export async function checkSchemaTableExists(schemaName, tableName) {
 	let invalidSchema = await checkSchemaExists(schemaName);
 	if (invalidSchema) {
 		return invalidSchema;

package/validation/{searchValidator.js → searchValidator.ts}

@@ -1,10 +1,11 @@
-const _ = require('lodash'),
-	validator = require('./validationWrapper.js');
-const Joi = require('joi');
-const hdbUtils = require('../utility/common_utils.js');
-const { hdbSchemaTable, checkValidTable, hdbTable, hdbDatabase } = require('./common_validators.js');
-const { handleHDBError, hdbErrors } = require('../utility/errors/hdbError.js');
-const { getDatabases } = require('../resources/databases.ts');
+import * as _ from 'lodash';
+import * as validator from './validationWrapper.ts';
+import Joi from 'joi';
+import * as hdbUtils from '../utility/common_utils.ts';
+import { hdbSchemaTable, checkValidTable, hdbTable, hdbDatabase } from './common_validators.ts';
+import { handleHDBError, hdbErrors } from '../utility/errors/hdbError.ts';
+import { getDatabases } from '../resources/databases.ts';
+
 const { HTTP_STATUS_CODES } = hdbErrors;
 
 const searchByValueSchema = Joi.object({
@@ -70,7 +71,7 @@ const searchByConditionsSchema = Joi.object({
 		.required(),
 });
 
-module.exports = function (searchObject, type) {
+export default function (searchObject: any, type: any) {
 	let validationError = null;
 	switch (type) {
 		case 'value':
@@ -144,11 +145,11 @@ module.exports = function (searchObject, type) {
 				!_.some(
 					allTableAttributes,
 					(
-						tableAttribute // attribute should match one of the attribute in global
+						tableAttribute: any // attribute should match one of the attribute in global
 					) =>
 						tableAttribute === attribute ||
 						tableAttribute.attribute === attribute ||
-						tableAttribute.attribute === attribute.attribute
+						tableAttribute.attribute === (attribute as any).attribute
 				)
 		);
 
@@ -163,4 +164,4 @@ module.exports = function (searchObject, type) {
 	}
 
 	return validationError;
-};
+}

package/validation/statusValidator.ts

@@ -1,5 +1,5 @@
 import Joi from 'joi';
-import * as validator from './validationWrapper.js';
+import * as validator from './validationWrapper.ts';
 import { STATUS_DEFINITIONS, STATUS_IDS, DEFAULT_STATUS_ID, type StatusId } from '../server/status/definitions.ts';
 
 // Re-export constants for backward compatibility

package/validation/{transactionLogValidator.js → transactionLogValidator.ts}

@@ -1,14 +1,9 @@
 'use strict';
 
-const Joi = require('joi');
-const validator = require('./validationWrapper.js');
+import Joi from 'joi';
+import * as validator from './validationWrapper.ts';
 
-module.exports = {
-	readTransactionLogValidator,
-	deleteTransactionLogsBeforeValidator,
-};
-
-function readTransactionLogValidator(req) {
+export function readTransactionLogValidator(req) {
 	const schema = Joi.object({
 		schema: Joi.string(),
 		database: Joi.string(),
@@ -21,7 +16,7 @@ function readTransactionLogValidator(req) {
 	return validator.validateBySchema(req, schema);
 }
 
-function deleteTransactionLogsBeforeValidator(req) {
+export function deleteTransactionLogsBeforeValidator(req) {
 	// `table` will need to be required for lmdb, but not for rocksdb
 	const schema = Joi.object({
 		schema: Joi.string(),

package/validation/{user_validation.js → user_validation.ts}

@@ -1,4 +1,4 @@
-const validator = require('./validationWrapper.js');
+import * as validator from './validationWrapper.ts';
 
 const constraints = {
 	username: {
@@ -24,7 +24,7 @@ const constraints = {
 	},
 };
 
-function addUserValidation(object) {
+export function addUserValidation(object) {
 	constraints.password.presence = true;
 	constraints.username.presence = true;
 	constraints.role.presence = true;
@@ -32,7 +32,7 @@ function addUserValidation(object) {
 	return validator.validateObject(object, constraints);
 }
 
-function alterUserValidation(object) {
+export function alterUserValidation(object) {
 	constraints.password.presence = false;
 	constraints.username.presence = true;
 	constraints.role.presence = false;
@@ -40,16 +40,10 @@ function alterUserValidation(object) {
 	return validator.validateObject(object, constraints);
 }
 
-function dropUserValidation(object) {
+export function dropUserValidation(object) {
 	constraints.password.presence = false;
 	constraints.username.presence = true;
 	constraints.role.presence = false;
 	constraints.active.presence = false;
 	return validator.validateObject(object, constraints);
 }
-
-module.exports = {
-	addUserValidation,
-	alterUserValidation,
-	dropUserValidation,
-};

package/validation/{validationWrapper.js → validationWrapper.ts}

@@ -52,13 +52,7 @@ validate.validators.hasValidFileExt = function (value, options) {
 		: `must include one of the following valid file extensions - '${options.join("', '")}'`;
 };
 
-module.exports = {
-	validateObject,
-	validateObjectAsync,
-	validateBySchema,
-};
-
-function validateObject(object, fileConstraints) {
+export function validateObject(object, fileConstraints) {
 	if (!object || !fileConstraints) {
 		return new Error('validateObject parameters were null');
 	}
@@ -74,7 +68,7 @@ function validateObject(object, fileConstraints) {
  * @param fileConstraints - validation rules for the json object
  * @returns {Promise<Error|null>}
  */
-async function validateObjectAsync(object, fileConstraints) {
+export async function validateObjectAsync(object, fileConstraints) {
 	if (!object || !fileConstraints) {
 		return new Error('validateObject parameters were null');
 	}
@@ -96,7 +90,7 @@ async function validateObjectAsync(object, fileConstraints) {
  * @param {Joi.ObjectSchema} schema
  * @returns {*}
  */
-function validateBySchema(object, schema) {
+export function validateBySchema(object, schema) {
 	let result = schema.validate(object, { allowUnknown: true, abortEarly: false, errors: { wrap: { label: "'" } } });
 
 	if (result.error) {

package/bin/cliOperations.js

@@ -1,159 +0,0 @@
-'use strict';
-
-const envMgr = require('../utility/environment/environmentManager.js');
-envMgr.initSync();
-const terms = require('../utility/hdbTerms.ts');
-const { httpRequest } = require('../utility/common_utils.js');
-const path = require('path');
-const fs = require('fs-extra');
-const YAML = require('yaml');
-const { packageDirectory } = require('../components/packageComponent.ts');
-const { encode } = require('cbor-x');
-const { getHdbPid } = require('../utility/processManagement/processManagement.js');
-const { initConfig, getConfigPath } = require('../config/configUtils.js');
-
-const OP_ALIASES = { deploy: 'deploy_component', package: 'package_component' };
-
-module.exports = { cliOperations, buildRequest };
-const PREPARE_OPERATION = {
-	deploy_component: async (req) => {
-		if (req.package) {
-			return;
-		}
-
-		const projectPath = process.cwd();
-		req.payload = await packageDirectory(projectPath, { skip_node_modules: true, ...req });
-		req.cborEncode = true;
-		if (!req.project) req.project = path.basename(projectPath);
-	},
-};
-
-/**
- * Builds an Op-API request object from CLI args
- */
-function buildRequest() {
-	const req = {};
-	for (const arg of process.argv.slice(2)) {
-		if (OP_ALIASES.hasOwnProperty(arg)) {
-			req.operation = OP_ALIASES[arg];
-		} else if (arg.includes('=')) {
-			let [first, ...rest] = arg.split('=');
-			rest = rest.join('=');
-
-			try {
-				rest = JSON.parse(rest);
-			} catch {
-				/* noop */
-			}
-
-			req[first] = rest;
-		} else {
-			// operation should only be in the first arg
-			req.operation ??= arg;
-		}
-	}
-
-	return req;
-}
-
-/**
- * Using a unix domain socket will send a request to hdb operations API server
- * @param req
- * @returns {Promise<void>}
- */
-async function cliOperations(req) {
-	if (!req.target) {
-		req.target = process.env.HARPER_CLI_TARGET || process.env.CLI_TARGET;
-	}
-	let target;
-	if (req.target) {
-		try {
-			target = new URL(req.target);
-		} catch (error) {
-			try {
-				target = new URL(`https://${req.target}:9925`);
-			} catch {
-				throw error;
-			}
-		}
-		target = {
-			protocol: target.protocol,
-			hostname: target.hostname,
-			port: target.port,
-			username: req.username || target.username || process.env.HARPER_CLI_USERNAME || process.env.CLI_TARGET_USERNAME,
-			password: req.password || target.password || process.env.HARPER_CLI_PASSWORD || process.env.CLI_TARGET_PASSWORD,
-			rejectUnauthorized: req.rejectUnauthorized,
-		};
-		console.error(`Connecting to ${target.protocol}//${target.hostname}:${target.port}`);
-	} else {
-		// if we aren't doing a targeted operation (like deploy), we initialize the config and verify that local harper
-		// is running and that we can communicate with it.
-		console.error('Connecting to local Harper instance');
-		initConfig();
-		if (!getHdbPid()) {
-			console.error('Harper must be running to perform this operation');
-			process.exit(1);
-		}
-
-		if (!fs.existsSync(getConfigPath(terms.CONFIG_PARAMS.OPERATIONSAPI_NETWORK_DOMAINSOCKET))) {
-			console.error('No domain socket found, unable to perform this operation');
-			process.exit(1);
-		}
-	}
-	await PREPARE_OPERATION[req.operation]?.(req);
-	try {
-		let options = target ?? {
-			protocol: 'http:',
-			socketPath: getConfigPath(terms.CONFIG_PARAMS.OPERATIONSAPI_NETWORK_DOMAINSOCKET),
-		};
-		options.method = 'POST';
-		options.headers = { 'Content-Type': 'application/json' };
-		if (target?.username) {
-			options.headers.Authorization = `Basic ${Buffer.from(`${target.username}:${target.password}`).toString('base64')}`;
-		}
-		if (req.cborEncode) {
-			options.headers['Content-Type'] = 'application/cbor';
-			req = encode(req);
-		}
-		let response = await httpRequest(options, req);
-
-		let responseData;
-		try {
-			responseData = JSON.parse(response.body);
-		} catch {
-			responseData = {
-				status: response.statusCode + ' ' + (response.statusMessage || 'Unknown'),
-				body: response.body,
-			};
-		}
-
-		let responseLog;
-		if (req.json) {
-			responseLog = JSON.stringify(responseData, null, 2);
-		} else {
-			responseLog = YAML.stringify(responseData).trim();
-		}
-
-		const { statusCode } = response;
-		if (statusCode < 200 || (statusCode >= 300 && statusCode !== 304)) {
-			const errorPrefix = responseLog.startsWith('error:') ? '' : 'error: ';
-			console.error(`${errorPrefix}${responseLog}`);
-			process.exit(1);
-		}
-
-		console.log(responseLog);
-
-		return responseData;
-	} catch (err) {
-		if (err.code === 'ENOENT' || err.code === 'ECONNREFUSED') {
-			console.error(`error: Failed to connect to Harper (${err.code}): ${err.message}`);
-		} else if (err.code === 'EACCES') {
-			console.error(`error: Permission denied accessing the domain socket: ${err.message}`);
-		} else if (err.code === 'ENOTFOUND') {
-			console.error(`error: Host not found: "${err.hostname}" ${err.message}`);
-		} else {
-			console.error(`error: ${err.message ?? err}`);
-		}
-		process.exit(1);
-	}
-}

package/bin/lite.js

@@ -1,5 +0,0 @@
-const { startHTTPThreads, startSocketServer } = require('../server/threads/socketRouter.ts');
-
-startHTTPThreads(0, true);
-startSocketServer(9925);
-startSocketServer(9926);

package/dataLayer/harperBridge/BridgeMethods.js

@@ -1,85 +0,0 @@
-'use strict';
-
-/**
- * BridgeMethods Class provides a framework for all HarperBridge method classes
- */
-
-class BridgeMethods {
-	createSchema() {
-		throw new Error('createSchema bridge method is not defined');
-	}
-
-	dropSchema() {
-		throw new Error('dropSchema bridge method is not defined');
-	}
-
-	createTable() {
-		throw new Error('createTable bridge method is not defined');
-	}
-
-	dropTable() {
-		throw new Error('dropTable bridge method is not defined');
-	}
-
-	createRecords() {
-		throw new Error('createRecords bridge method is not defined');
-	}
-
-	updateRecords() {
-		throw new Error('updateRecords bridge method is not defined');
-	}
-
-	async upsertRecords() {
-		throw new Error('upsertRecords bridge method is not defined');
-	}
-
-	deleteRecords() {
-		throw new Error('deleteRecords bridge method is not defined');
-	}
-
-	createAttribute() {
-		throw new Error('createAttribute bridge method is not defined');
-	}
-
-	dropAttribute() {
-		throw new Error('dropAttribute bridge method is not defined');
-	}
-
-	searchByConditions() {
-		throw new Error('searchByConditions bridge method is not defined');
-	}
-
-	searchByHash() {
-		throw new Error('searchByHash bridge method is not defined');
-	}
-
-	searchByValue() {
-		throw new Error('searchByValue bridge method is not defined');
-	}
-
-	getDataByHash() {
-		throw new Error('getDataByHash bridge method is not defined');
-	}
-
-	async getDataByValue(_searchObject, _comparator) {
-		throw new Error('getDataByValue bridge method is not defined');
-	}
-
-	async deleteRecordsBefore(_deleteObj) {
-		throw new Error('deleteRecordsBefore bridge method is not defined');
-	}
-
-	async deleteAuditLogsBefore(_deleteObj) {
-		throw new Error('deleteAuditLogsBefore bridge method is not defined');
-	}
-
-	async deleteTransactionLogsBefore(_deleteObj) {
-		throw new Error('deleteTransactionLogsBefore bridge method is not defined');
-	}
-
-	async readAuditLog(_readAuditLogObj) {
-		throw new Error('readAuditLog bridge method is not defined');
-	}
-}
-
-module.exports = BridgeMethods;