@harperfast/harper 5.0.25 → 5.1.0-beta.1

package/dataLayer/harperBridge/lmdbBridge/lmdbUtility/lmdbGetTableSize.ts

@@ -1,5 +1,5 @@
 import { TableSizeObject } from '../../TableSizeObject.ts';
-import logger from '../../../../utility/logging/harper_logger.js';
+import logger from '../../../../utility/logging/harper_logger.ts';
 import type { Table } from '../../../../resources/databases.ts';
 
 /**

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

@@ -1,12 +1,12 @@
 'use strict';
 
 // eslint-disable-next-line no-unused-vars
-const InsertObject = require('../../../InsertObject.js');
+const InsertObject = require('../../../InsertObject.ts').default || require('../../../InsertObject.ts');
 const hdbTerms = require('../../../../utility/hdbTerms.ts');
-const hdbUtils = require('../../../../utility/common_utils.js');
-const log = require('../../../../utility/logging/harper_logger.js');
+const hdbUtils = require('../../../../utility/common_utils.ts');
+const log = require('../../../../utility/logging/harper_logger.ts');
 const uuid = require('uuid');
-const { handleHDBError, hdbErrors } = require('../../../../utility/errors/hdbError.js');
+const { handleHDBError, hdbErrors } = require('../../../../utility/errors/hdbError.ts');
 const { HDB_ERROR_MSGS, HTTP_STATUS_CODES } = hdbErrors;
 
 module.exports = processRows;

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

@@ -1,12 +1,12 @@
 'use strict';
 
-const searchUtility = require('../../../../utility/lmdb/searchUtility.js');
-const environmentUtility = require('../../../../utility/lmdb/environmentUtility.js');
-const commonUtils = require('../../../../utility/common_utils.js');
-const lmdbTerms = require('../../../../utility/lmdb/terms.js');
+const searchUtility = require('../../../../utility/lmdb/searchUtility.ts');
+const environmentUtility = require('../../../../utility/lmdb/environmentUtility.ts');
+const commonUtils = require('../../../../utility/common_utils.ts');
+const lmdbTerms = require('../../../../utility/lmdb/terms.ts');
 const hdbTerms = require('../../../../utility/hdbTerms.ts');
 const systemSchema = require('../../../../json/systemSchema.json');
-const LMDB_ERRORS = require('../../../../utility/errors/commonErrors.js').LMDB_ERRORS_ENUM;
+const LMDB_ERRORS = require('../../../../utility/errors/commonErrors.ts').LMDB_ERRORS_ENUM;
 const { getSchemaPath } = require('./initializePaths.js');
 
 const WILDCARDS = hdbTerms.SEARCH_WILDCARDS;

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

@@ -1,15 +1,15 @@
 'use strict';
 
-const environmentUtil = require('../../../../utility/lmdb/environmentUtility.js');
+const environmentUtil = require('../../../../utility/lmdb/environmentUtility.ts');
 const LMDBInsertTransactionObject = require('./LMDBInsertTransactionObject.js');
 const LMDBUpdateTransactionObject = require('./LMDBUpdateTransactionObject.js');
 const LMDBUpsertTransactionObject = require('./LMDBUpsertTransactionObject.js');
 const LMDBDeleteTransactionObject = require('./LMDBDeleteTransactionObject.js');
 
-const lmdbTerms = require('../../../../utility/lmdb/terms.js');
-const hdbUtil = require('../../../../utility/common_utils.js');
+const lmdbTerms = require('../../../../utility/lmdb/terms.ts');
+const hdbUtil = require('../../../../utility/common_utils.ts');
 const { CONFIG_PARAMS } = require('../../../../utility/hdbTerms.ts');
-const envMngr = require('../../../../utility/environment/environmentManager.js');
+const envMngr = require('../../../../utility/environment/environmentManager.ts');
 envMngr.initSync();
 
 const OPERATIONS_ENUM = require('../../../../utility/hdbTerms.ts').OPERATIONS_ENUM;

package/dataLayer/{hdbInfoController.js → hdbInfoController.ts}

@@ -5,23 +5,23 @@
  * MINIMUM_SUPPORTED_VERSION_NUM as needed.
  */
 
-const util = require('util');
-const chalk = require('chalk');
-const os = require('os');
-
-const insert = require('./insert.js');
-const search = require('./search.js');
-const hdbTerms = require('../utility/hdbTerms.ts');
-const BinObjects = require('../bin/BinObjects.js');
-const DataLayerObjects = require('./DataLayerObjects.js');
-const { UpgradeObject } = require('../upgrade/UpgradeObjects.js');
-const { forceDowngradePrompt } = require('../upgrade/upgradePrompt.js');
-const { packageJson } = require('../utility/packageUtils.js');
-const log = require('../utility/logging/harper_logger.js');
-const hdbUtils = require('../utility/common_utils.js');
-const globalSchema = require('../utility/globalSchema.js');
-const tableLoader = require('../resources/databases.ts');
-const directiveManager = require('../upgrade/directives/directivesController.js');
+import * as util from 'util';
+import chalk from 'chalk';
+import * as os from 'os';
+
+import * as insert from './insert.ts';
+import * as search from './search.ts';
+import * as hdbTerms from '../utility/hdbTerms.ts';
+import * as BinObjects from '../bin/BinObjects.ts';
+import * as DataLayerObjects from './DataLayerObjects.ts';
+import { UpgradeObject } from '../upgrade/UpgradeObjects.ts';
+import { forceDowngradePrompt } from '../upgrade/upgradePrompt.ts';
+import { packageJson } from '../utility/packageUtils.js';
+import log from '../utility/logging/harper_logger.ts';
+import * as hdbUtils from '../utility/common_utils.ts';
+import * as globalSchema from '../utility/globalSchema.ts';
+import * as tableLoader from '../resources/databases.ts';
+import * as directiveManager from '../upgrade/directives/directivesController.ts';
 let pSetSchemaDataToGlobal = util.promisify(globalSchema.setSchemaDataToGlobal);
 
 let pSearchSearchByValue = search.searchByValue;
@@ -43,7 +43,7 @@ const MINIMUM_SUPPORTED_VERSION_NUM = '3.0.0';
  * @param newVersionString - The version of this install
  * @returns {Promise<{message: string, new_attributes: *, txn_time: *}|undefined>}
  */
-async function insertHdbInstallInfo(newVersionString) {
+export async function insertHdbInstallInfo(newVersionString: string) {
 	const infoTableInsertObject = new BinObjects.HdbInfoInsertObject(1, newVersionString, newVersionString);
 
 	//Insert the initial version record into the hdbInfo table.
@@ -65,7 +65,7 @@ async function insertHdbInstallInfo(newVersionString) {
  * @param newVersionString
  * @returns {Promise<void>}
  */
-async function insertHdbUpgradeInfo(newVersionString) {
+export async function insertHdbUpgradeInfo(newVersionString: string) {
 	let newInfoRecord;
 	let versionData = await getAllHdbInfoRecords();
 
@@ -158,7 +158,7 @@ async function getLatestHdbInfoRecord() {
  *
  * @returns {Promise<UpgradeObject> || undefined} - returns an UpgradeObject, if an upgrade is required, OR undefined, if not.
  */
-async function getVersionUpdateInfo() {
+export async function getVersionUpdateInfo() {
 	log.info('Checking if HDB software has been updated');
 	try {
 		const upgradeVersion = packageJson.version;
@@ -246,9 +246,3 @@ function checkIfInstallIsSupported(dataVNum) {
 		throw new Error(errMsg);
 	}
 }
-
-module.exports = {
-	insertHdbInstallInfo,
-	insertHdbUpgradeInfo,
-	getVersionUpdateInfo,
-};

package/dataLayer/{insert.js → insert.ts}

@@ -6,15 +6,15 @@
  * This module is used to validate and insert or update data.  Note insert.update should be used over the update module,
  * as the update module is meant to be used in more specific circumstances.
  */
-const insertValidator = require('../validation/insertValidator.js');
-const hdbUtils = require('../utility/common_utils.js');
-const util = require('util');
+import insertValidator from '../validation/insertValidator.ts';
+import * as hdbUtils from '../utility/common_utils.ts';
+import * as util from 'util';
 // Leave this unused signalling import here. Due to circular dependencies we bring it in early to load it before the bridge
-const harperBridge = require('./harperBridge/harperBridge.js');
-const globalSchema = require('../utility/globalSchema.js');
-const log = require('../utility/logging/harper_logger.js');
-const { handleHDBError, hdbErrors } = require('../utility/errors/hdbError.js');
-const { HTTP_STATUS_CODES } = hdbErrors;
+const harperBridge = require('./harperBridge/harperBridge').default;
+import * as globalSchema from '../utility/globalSchema.ts';
+import log from '../utility/logging/harper_logger.ts';
+import { handleHDBError } from '../utility/errors/hdbError.ts';
+import { HTTP_STATUS_CODES } from '../utility/errors/commonErrors.ts';
 
 const pGlobalSchema = util.promisify(globalSchema.getTableSchema);
 
@@ -22,14 +22,6 @@ const UPDATE_ACTION = 'updated';
 const INSERT_ACTION = 'inserted';
 const UPSERT_ACTION = 'upserted';
 
-module.exports = {
-	insert: insertData,
-	update: updateData,
-	upsert: upsertData,
-	validation,
-	flush,
-};
-
 //IMPORTANT - This validation function is the async version of the code in harperBridge/bridgeUtility/insertUpdateValidate.js
 // make sure any changes below are also made there. This is to resolve a circular dependency.
 /**
@@ -37,7 +29,7 @@ module.exports = {
  * @param {Object} writeObject
  * @returns {Promise<{tableSchema, hashes: any[], attributes: string[]}>}
  */
-async function validation(writeObject) {
+export async function validation(writeObject: any) {
 	// Need to validate these outside of the validator as the getTableSchema call will fail with
 	// invalid values.
 
@@ -51,7 +43,7 @@ async function validation(writeObject) {
 		throw new Error('invalid table specified.');
 	}
 
-	let schemaTable = await pGlobalSchema(writeObject.schema, writeObject.table);
+	let schemaTable: any = await pGlobalSchema(writeObject.schema, writeObject.table);
 
 	//validate insertObject for required attributes
 	let validator = insertValidator(writeObject);
@@ -121,7 +113,7 @@ async function validation(writeObject) {
  * Inserts data specified in the insertObject parameter.
  * @param insertObject
  */
-async function insertData(insertObject) {
+async function insertData(insertObject: any) {
 	if (insertObject.operation !== 'insert') {
 		throw new Error('invalid operation, must be insert');
 	}
@@ -154,7 +146,7 @@ async function insertData(insertObject) {
  * Updates the data in the updateObject parameter.
  * @param updateObject - The data that will be updated in the database
  */
-async function updateData(updateObject) {
+async function updateData(updateObject: any) {
 	if (updateObject.operation !== 'update') {
 		throw new Error('invalid operation, must be update');
 	}
@@ -197,7 +189,7 @@ async function updateData(updateObject) {
  * Upsert the data in the upsertObject parameter.
  * @param upsertObject - Represents the data that will be upserted in the database
  */
-async function upsertData(upsertObject) {
+async function upsertData(upsertObject: any) {
 	if (upsertObject.operation !== 'upsert') {
 		throw handleHDBError(new Error(), 'invalid operation, must be upsert', HTTP_STATUS_CODES.INTERNAL_SERVER_ERROR);
 	}
@@ -237,8 +229,15 @@ async function upsertData(upsertObject) {
  * @returns {{ message: string, new_attributes: *, txn_time: * }}
  */
 
-function returnObject(action, written_hashes, object, skipped, new_attributes, txnTime) {
-	let return_object = {
+function returnObject(
+	action: string,
+	written_hashes: any[],
+	object: any,
+	skipped: any[],
+	new_attributes: any,
+	txnTime: any
+) {
+	let return_object: any = {
 		message: `${action} ${written_hashes.length} of ${written_hashes.length + skipped.length} records`,
 		new_attributes,
 		txn_time: txnTime,
@@ -260,7 +259,8 @@ function returnObject(action, written_hashes, object, skipped, new_attributes, t
 	return return_object;
 }
 
-function flush(object) {
+export function flush(object: any) {
 	hdbUtils.transformReq(object);
 	return harperBridge.flush(object.schema, object.table);
 }
+export { insertData as insert, updateData as update, upsertData as upsert };

package/dataLayer/{readAuditLog.js → readAuditLog.ts}

@@ -1,25 +1,23 @@
 'use strict';
 
-const harperBridge = require('./harperBridge/harperBridge.js');
+const harperBridge = require('./harperBridge/harperBridge').default;
 // eslint-disable-next-line no-unused-vars
-const ReadAuditLogObject = require('./ReadAuditLogObject.js');
-const hdbUtils = require('../utility/common_utils.js');
-const hdbTerms = require('../utility/hdbTerms.ts');
-const envMgr = require('../utility/environment/environmentManager.js');
-const { handleHDBError, hdbErrors } = require('../utility/errors/hdbError.js');
-const { HDB_ERROR_MSGS, HTTP_STATUS_CODES } = hdbErrors;
+import ReadAuditLogObject from './ReadAuditLogObject.ts';
+import * as hdbUtils from '../utility/common_utils.ts';
+import * as hdbTerms from '../utility/hdbTerms.ts';
+import * as envMgr from '../utility/environment/environmentManager.ts';
+import { handleHDBError } from '../utility/errors/hdbError.ts';
+import { HDB_ERROR_MSGS, HTTP_STATUS_CODES } from '../utility/errors/commonErrors.ts';
 
 const SEARCH_TYPES = Object.values(hdbTerms.READ_AUDIT_LOG_SEARCH_TYPES_ENUM);
 const LOG_NOT_ENABLED_ERR = 'To use this operation audit log must be enabled in harperdb-config.yaml';
 
-module.exports = readAuditLog;
-
 /**
  *
  * @param {ReadAuditLogObject} readAuditLogObject
  * @returns {Promise<void>}
  */
-async function readAuditLog(readAuditLogObject) {
+export default async function readAuditLog(readAuditLogObject: any) {
 	const database = readAuditLogObject.database || readAuditLogObject.schema;
 	if (hdbUtils.isEmpty(database)) {
 		throw new Error(HDB_ERROR_MSGS.SCHEMA_REQUIRED_ERR);

package/dataLayer/{schema.js → schema.ts}

@@ -1,22 +1,23 @@
 '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');
+import * as schemaMetadataValidator from '../validation/schemaMetadataValidator.ts';
+import { validateBySchema } from '../validation/validationWrapper.ts';
+import { commonValidators, schemaRegex } from '../validation/common_validators.ts';
+import Joi from 'joi';
+import logger from '../utility/logging/harper_logger.ts';
+import { v4 as uuidV4 } from 'uuid';
+import * as signalling from '../utility/signalling.ts';
+import * as hdbTerms from '../utility/hdbTerms.ts';
+import * as util from 'util';
+const harperBridge = require('./harperBridge/harperBridge').default;
+import { handleHDBError, ClientError } from '../utility/errors/hdbError.ts';
+import { HDB_ERROR_MSGS, HTTP_STATUS_CODES } from '../utility/errors/commonErrors.ts';
+
+import { SchemaEventMsg } from '../server/threads/itc.js';
+import { getDatabases, dropTableMeta } from '../resources/databases.ts';
+import { transformReq } from '../utility/common_utils.ts';
+import { server } from '../server/Server.ts';
+import { cleanupOrphans } from '../resources/blob.ts';
 
 const DB_NAME_CONSTRAINTS = Joi.string()
 	.min(1)
@@ -42,22 +43,9 @@ const PRIMARY_KEY_CONSTRAINTS = Joi.string()
 	})
 	.required();
 
-module.exports = {
-	createSchema,
-	createSchemaStructure,
-	createTable,
-	createTableStructure,
-	createAttribute,
-	dropSchema,
-	dropTable,
-	dropAttribute,
-	getBackup,
-	cleanupOrphanBlobs,
-};
-
 /** EXPORTED FUNCTIONS **/
 
-async function createSchema(schemaCreateObject) {
+export async function createSchema(schemaCreateObject: any) {
 	let schemaStructure = await createSchemaStructure(schemaCreateObject);
 	signalling.signalSchemaChange(
 		new SchemaEventMsg(process.pid, schemaCreateObject.operation, schemaCreateObject.schema)
@@ -66,7 +54,7 @@ async function createSchema(schemaCreateObject) {
 	return schemaStructure;
 }
 
-async function createSchemaStructure(schemaCreateObject) {
+export async function createSchemaStructure(schemaCreateObject: any) {
 	const validation = validateBySchema(
 		schemaCreateObject,
 		Joi.object({
@@ -94,13 +82,13 @@ async function createSchemaStructure(schemaCreateObject) {
 	return `database '${schemaCreateObject.schema}' successfully created`;
 }
 
-async function createTable(createTableObject) {
+export async function createTable(createTableObject: any) {
 	transformReq(createTableObject);
 	createTableObject.primary_key = createTableObject.primary_key ?? createTableObject.hash_attribute;
 	return await createTableStructure(createTableObject);
 }
 
-async function createTableStructure(createTableObject) {
+export async function createTableStructure(createTableObject: any) {
 	const validation = validateBySchema(
 		createTableObject,
 		Joi.object({
@@ -128,7 +116,7 @@ async function createTableStructure(createTableObject) {
 		);
 	}
 
-	let tableSystemData = {
+	let tableSystemData: any = {
 		name: createTableObject.table,
 		schema: createTableObject.schema,
 		id: uuidV4(),
@@ -153,7 +141,7 @@ async function createTableStructure(createTableObject) {
 	return `table '${createTableObject.schema}.${createTableObject.table}' successfully created.`;
 }
 
-async function dropSchema(dropSchemaObject) {
+export async function dropSchema(dropSchemaObject: any) {
 	const validation = validateBySchema(
 		dropSchemaObject,
 		Joi.object({
@@ -189,7 +177,7 @@ async function dropSchema(dropSchemaObject) {
 	return response;
 }
 
-async function dropTable(dropTableObject) {
+export async function dropTable(dropTableObject: any) {
 	const validation = validateBySchema(
 		dropTableObject,
 		Joi.object({
@@ -231,7 +219,7 @@ async function dropTable(dropTableObject) {
  * @param dropAttributeObject - The JSON formatted inbound message.
  * @returns {Promise<*>}
  */
-async function dropAttribute(dropAttributeObject) {
+export async function dropAttribute(dropAttributeObject: any) {
 	const validation = validateBySchema(
 		dropAttributeObject,
 		Joi.object({
@@ -315,13 +303,13 @@ function dropAttributeFromGlobal(dropAttributeObject) {
 	);
 
 	for (let i = 0; i < attributesObj.length; i++) {
-		if (attributesObj[i].attribute === dropAttributeObject.attribute) {
+		if ((attributesObj[i] as any).attribute === dropAttributeObject.attribute) {
 			global.hdb_schema[dropAttributeObject.schema][dropAttributeObject.table]['attributes'].splice(i, 1);
 		}
 	}
 }
 
-async function createAttribute(createAttributeObject) {
+export async function createAttribute(createAttributeObject: any) {
 	transformReq(createAttributeObject);
 
 	const tableAttr = getDatabases()[createAttributeObject.schema][createAttributeObject.table].attributes;
@@ -352,15 +340,15 @@ async function createAttribute(createAttributeObject) {
 	return `attribute '${createAttributeObject.schema}.${createAttributeObject.table}.${createAttributeObject.attribute}' successfully created.`;
 }
 
-function getBackup(getBackupObject) {
+export function getBackup(getBackupObject: any) {
 	return harperBridge.getBackup(getBackupObject);
 }
 
-function cleanupOrphanBlobs(request) {
+export function cleanupOrphanBlobs(request: any) {
 	if (!request.database) throw new ClientError('Must provide "database" name for search for orphaned blobs');
-	const database = databases[request.database];
+	const database: any = (databases as any)[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);
+	cleanupOrphans((databases as any)[request.database], request.database);
 	return { message: 'Orphaned blobs cleanup started, check logs for progress' };
 }

package/dataLayer/{schemaDescribe.js → schemaDescribe.ts}

@@ -1,22 +1,17 @@
-'use strict';
+import { RocksDatabase } from '@harperfast/rocksdb-js';
+('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');
-const { RocksDatabase } = require('@harperfast/rocksdb-js');
+import logger from '../utility/logging/harper_logger.ts';
+import { validateBySchema } from '../validation/validationWrapper.ts';
+import Joi from 'joi';
+import * as hdbUtils from '../utility/common_utils.ts';
+import { handleHDBError, ClientError } from '../utility/errors/hdbError.ts';
+import { HDB_ERROR_MSGS, HTTP_STATUS_CODES } from '../utility/errors/commonErrors.ts';
 
-module.exports = {
-	describeAll,
-	describeTable: descTable,
-	describeSchema,
-};
+import * as envMngr from '../utility/environment/environmentManager.ts';
+envMngr.initSync();
+import { getDatabases } from '../resources/databases.ts';
+import * as fs from 'fs-extra';
 
 /**
  * This method is exposed to the API and internally for system operations.  If the op is being made internally, the `opObj`
@@ -24,7 +19,7 @@ module.exports = {
  * @param opObj
  * @returns {Promise<{}|HdbError>}
  */
-async function describeAll(opObj = {}) {
+export async function describeAll(opObj: any = {}) {
 	try {
 		const sysCall = hdbUtils.isEmptyOrZeroLength(opObj);
 		const bypassAuth = !!opObj.bypass_auth;
@@ -110,7 +105,7 @@ async function describeAll(opObj = {}) {
  * includes the users role and permissions.
  * @returns {Promise<{}|*>}
  */
-async function descTable(describeTableObject, attrPerms) {
+async function descTable(describeTableObject: any, attrPerms?: any) {
 	hdbUtils.transformReq(describeTableObject);
 	let { schema, table } = describeTableObject;
 	schema = schema?.toString();
@@ -163,6 +158,7 @@ async function descTable(describeTableObject, attrPerms) {
 				assigned_updated_time: att.assignUpdatedTime,
 				nullable: att.nullable,
 				computed: att.computed ? true : undefined, // only include if computed
+				embed: att.embed ? { source: att.embed.source, model: att.embed.model } : undefined,
 				properties: att.properties
 					? att.properties.map((prop) => {
 							return { type: prop.type, name: prop.name };
@@ -194,7 +190,7 @@ async function descTable(describeTableObject, attrPerms) {
 	} catch (error) {
 		logger.warn(`unable to get database size`, error);
 	}
-	let tableResult = {
+	let tableResult: any = {
 		schema,
 		name: tableObj.tableName,
 		primary_key: tableObj.attributes.find((attribute) => attribute.isPrimaryKey || attribute.isPrimaryKey)?.name,
@@ -206,10 +202,10 @@ async function descTable(describeTableObject, attrPerms) {
 	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');
+	if ((tableObj as any).sources?.length > 0)
+		tableResult.sources = (tableObj as any).sources
+			.map((source: any) => source.name)
+			.filter((source: any) => source && source !== 'Replicator');
 
 	try {
 		const recordCount = await tableObj.getRecordCount({ exactCount: !!describeTableObject.exact_count });
@@ -238,9 +234,9 @@ async function descTable(describeTableObject, attrPerms) {
  * Returns the schema metadata filtered based on permissions for the user role making the request
  *
  * @param describeSchemaObject
- * @returns {Promise<{}|[]>}
+ * @returns {Promise<Record<string, any>>}
  */
-async function describeSchema(describeSchemaObject) {
+export async function describeSchema(describeSchemaObject: any) {
 	hdbUtils.transformReq(describeSchemaObject);
 
 	const validation = validateBySchema(
@@ -292,3 +288,4 @@ async function describeSchema(describeSchemaObject) {
 	}
 	return results;
 }
+export { descTable as describeTable };

package/dataLayer/{search.js → search.ts}

@@ -1,21 +1,14 @@
 'use strict';
 
-module.exports = {
-	searchByConditions,
-	searchByHash,
-	searchByValue,
-	search,
-};
+const harperBridge = require('./harperBridge/harperBridge').default;
+import { transformReq } from '../utility/common_utils.ts';
 
-const harperBridge = require('./harperBridge/harperBridge.js');
-const { transformReq } = require('../utility/common_utils.js');
-
-async function searchByConditions(searchObject) {
+export async function searchByConditions(searchObject: any) {
 	transformReq(searchObject);
 	return harperBridge.searchByConditions(searchObject);
 }
 
-async function searchByHash(searchObject) {
+export async function searchByHash(searchObject: any) {
 	transformReq(searchObject);
 	if (searchObject.ids) searchObject.hash_values = searchObject.ids;
 	let array = [];
@@ -25,7 +18,7 @@ async function searchByHash(searchObject) {
 	return array;
 }
 
-async function searchByValue(searchObject) {
+export async function searchByValue(searchObject: any) {
 	transformReq(searchObject);
 	if (searchObject.hasOwnProperty('desc') === true) {
 		searchObject.reverse = searchObject.desc;
@@ -37,10 +30,11 @@ async function searchByValue(searchObject) {
 	return array;
 }
 
-function search(statement, callback) {
+export function search(statement: any, callback: any) {
 	try {
-		const SelectValidator = require('../sqlTranslator/SelectValidator.js');
-		const SQLSearch = require('./SQLSearch.js');
+		const SelectValidator =
+			require('../sqlTranslator/SelectValidator').default || require('../sqlTranslator/SelectValidator');
+		const SQLSearch = require('./SQLSearch').default || require('./SQLSearch');
 		let validator = new SelectValidator(statement);
 		validator.validate();
 

package/dataLayer/{transaction.js → transaction.ts}

@@ -1,10 +1,7 @@
 'use strict';
 
-const harperBridge = require('./harperBridge/harperBridge.js');
+const harperBridge = require('./harperBridge/harperBridge').default;
 
-module.exports = {
-	writeTransaction,
-};
 /**
  * This is wrapper for write transactions, ensuring that all reads and writes within the callback occur atomically
  * @param schema
@@ -12,6 +9,6 @@ module.exports = {
  * @param callback
  * @returns {Promise<any>}
  */
-function writeTransaction(schema, table, callback) {
+export function writeTransaction(schema: string, table: string, callback: any) {
 	return harperBridge.writeTransaction(schema, table, callback);
 }