@harperfast/harper 5.0.25 → 5.1.0-beta.1

package/utility/{mount_hdb.js → mount_hdb.ts}

@@ -1,17 +1,15 @@
 'use strict';
 
 const { mkdirpSync, copySync } = require('fs-extra');
-const path = require('path');
-const terms = require('../utility/hdbTerms.ts');
-const hdbLogger = require('../utility/logging/harper_logger.js');
-const bridge = require('../dataLayer/harperBridge/harperBridge.js');
-const systemSchema = require('../json/systemSchema.json');
-const initPaths = require('../dataLayer/harperBridge/lmdbBridge/lmdbUtility/initializePaths.js');
-const { PACKAGE_ROOT } = require('../utility/packageUtils');
-
-module.exports = mountHdb;
-
-async function mountHdb(hdbPath) {
+import * as path from 'path';
+import * as terms from '../utility/hdbTerms.ts';
+import hdbLogger from '../utility/logging/harper_logger.ts';
+import bridge from '../dataLayer/harperBridge/harperBridge.ts';
+import systemSchema from '../json/systemSchema.json';
+import * as initPaths from '../dataLayer/harperBridge/lmdbBridge/lmdbUtility/initializePaths.js';
+import { PACKAGE_ROOT } from '../utility/packageUtils.js';
+
+export default async function mountHdb(hdbPath: string) {
 	hdbLogger.trace('Mounting Harper');
 
 	makeDirectory(hdbPath);
@@ -30,16 +28,17 @@ async function mountHdb(hdbPath) {
  * @returns {Promise<void>}
  */
 async function createTables() {
-	const CreateTableObject = require('../dataLayer/CreateTableObject.js');
+	const CreateTableObject =
+		require('../dataLayer/CreateTableObject').default || require('../dataLayer/CreateTableObject');
 
 	let tables = Object.keys(systemSchema);
 
 	for (const tableName of tables) {
-		let hash_attribute = systemSchema[tableName].hash_attribute;
+		let hash_attribute = (systemSchema as any)[tableName].hash_attribute;
 		try {
 			initPaths.initSystemSchemaPaths(terms.SYSTEM_SCHEMA_NAME, tableName);
-			let createTable = new CreateTableObject(terms.SYSTEM_SCHEMA_NAME, tableName, hash_attribute);
-			createTable.attributes = systemSchema[tableName].attributes;
+			let createTable = new (CreateTableObject as any)(terms.SYSTEM_SCHEMA_NAME, tableName, hash_attribute);
+			createTable.attributes = (systemSchema as any)[tableName].attributes;
 			let primaryKeyAttribute = createTable.attributes.find(({ attribute }) => attribute === hash_attribute);
 			primaryKeyAttribute.isPrimaryKey = true;
 
@@ -53,7 +52,7 @@ async function createTables() {
 	}
 }
 
-function makeDirectory(targetDir) {
+function makeDirectory(targetDir: string) {
 	mkdirpSync(targetDir, { mode: terms.HDB_FILE_PERMISSIONS });
 	hdbLogger.info(`Directory ${targetDir} created`);
 }

package/utility/{npmUtilities.js → npmUtilities.ts}

@@ -1,28 +1,25 @@
 'use strict';
 
-const Joi = require('joi');
-const path = require('path');
+import Joi from 'joi';
+import * as path from 'path';
 
-const { handleHDBError, hdbErrors } = require('./errors/hdbError.js');
-const { HTTP_STATUS_CODES } = hdbErrors;
+import { handleHDBError, hdbErrors } from './errors/hdbError.ts';
 
-const validator = require('../validation/validationWrapper.js');
-const harperLogger = require('./logging/harper_logger.js');
+const { HTTP_STATUS_CODES } = hdbErrors;
 
-module.exports = {
-	installModules,
-};
+import * as validator from '../validation/validationWrapper.ts';
+import harperLogger from './logging/harper_logger.ts';
 
-const { CONFIG_PARAMS } = require('./hdbTerms.ts');
-const { getConfigPath } = require('../config/configUtils.js');
-const { nonInteractiveSpawn } = require('../components/Application.ts');
+import { CONFIG_PARAMS } from './hdbTerms.ts';
+import { getConfigPath } from '../config/configUtils.js';
+import { nonInteractiveSpawn } from '../components/Application.ts';
 
 /**
  * Executes npm install against specified custom function projects
  * @param {Object} req
  * @returns {Promise<{}>}
  */
-async function installModules(req) {
+export async function installModules(req: any) {
 	const deprecationWarning =
 		'install_node_modules is deprecated. Dependencies are automatically installed on' +
 		' deploy, and install_node_modules can lead to inconsistent behavior';
@@ -36,7 +33,7 @@ async function installModules(req) {
 
 	const componentsRootDirPath = getConfigPath(CONFIG_PARAMS.COMPONENTSROOT);
 
-	const responseObject = {};
+	const responseObject: any = {};
 
 	const args = ['install', '--force', '--omit=dev', '--json'];
 	if (dryRun) args.push('--dry-run');
@@ -45,7 +42,7 @@ async function installModules(req) {
 		responseObject[project] = { npm_output: null, npm_error: null };
 		const projectPath = path.join(componentsRootDirPath, project);
 		try {
-			let { stdout, stderr } = nonInteractiveSpawn(project, 'npm', args, projectPath);
+			let { stdout, stderr } = await nonInteractiveSpawn(project, 'npm', args, projectPath);
 			stdout = stdout ? stdout.replace('\n', '') : null;
 			stderr = stderr ? stderr.replace('\n', '') : null;
 
@@ -75,7 +72,7 @@ async function installModules(req) {
 	return responseObject;
 }
 
-function parseNPMStdErr(stderr) {
+function parseNPMStdErr(stderr: string) {
 	//npm returns errors inconsistently, on 6 it returns json, on 8 it returns json stringified inside of a larger string
 	let startSearchString = '"error": {';
 	let start = stderr.indexOf('"error": {');
@@ -92,7 +89,7 @@ function parseNPMStdErr(stderr) {
  * @param {Object} req
  * @returns {*}
  */
-function modulesValidator(req) {
+function modulesValidator(req: any) {
 	const funcSchema = Joi.object({
 		projects: Joi.array().min(1).items(Joi.string()).required(),
 		dry_run: Joi.boolean().default(false),

package/utility/{operation_authorization.js → operation_authorization.ts}

@@ -10,35 +10,37 @@
  * The requiredPermissions member contains the permissions needed for each operation.  Any new operations added to
  * Harper need to have operations specified in here or they will never pass the permissions checks.
  * */
-const write = require('../dataLayer/insert.js');
-const search = require('../dataLayer/search.js');
-const schema = require('../dataLayer/schema.js');
-const schemaDescribe = require('../dataLayer/schemaDescribe.js');
-const delete_ = require('../dataLayer/delete.js');
-const readAuditLog = require('../dataLayer/readAuditLog.js');
-const getBackup = require('../dataLayer/getBackup.js');
-const user = require('../security/user.ts');
-const role = require('../security/role.js');
-const harperLogger = require('../utility/logging/harper_logger.js');
-const readLog = require('../utility/logging/readLog.js');
-const commonUtils = require('./common_utils.js');
-const restart = require('../bin/restart.js');
-const terms = require('./hdbTerms.ts');
-const { expandOperationsPerms } = require('./operationPermissions.ts');
-const permsTranslator = require('../security/permissionsTranslator.js');
-const { systemInformation } = require('../utility/environment/systemInformation.ts');
-const tokenAuthentication = require('../security/tokenAuthentication.ts');
-const auth = require('../security/auth.ts');
-const configUtils = require('../config/configUtils.js');
-const functionsOperations = require('../components/operations.js');
-const transactionLog = require('../utility/logging/transactionLog.js');
-const npmUtilities = require('./npmUtilities.js');
-const analytics = require('../resources/analytics/read.ts');
-const status = require('../server/status/index.ts');
-const PermissionResponseObject = require('../security/data_objects/PermissionResponseObject.js');
-const { handleHDBError, hdbErrors } = require('../utility/errors/hdbError.js');
-const { HDB_ERROR_MSGS, HTTP_STATUS_CODES } = hdbErrors;
-const regDeprecated = require('../resources/registrationDeprecated.ts');
+import * as write from '../dataLayer/insert.ts';
+import { HDB_ERROR_MSGS, HTTP_STATUS_CODES } from './errors/commonErrors.ts';
+import * as search from '../dataLayer/search.ts';
+import * as schema from '../dataLayer/schema.ts';
+import * as schemaDescribe from '../dataLayer/schemaDescribe.ts';
+import * as delete_ from '../dataLayer/delete.ts';
+import readAuditLog from '../dataLayer/readAuditLog.ts';
+import getBackup from '../dataLayer/getBackup.ts';
+import * as user from '../security/user.ts';
+import * as role from '../security/role.ts';
+import harperLogger from '../utility/logging/harper_logger.ts';
+import readLog from '../utility/logging/readLog.ts';
+import * as commonUtils from './common_utils.ts';
+import * as restart from '../bin/restart.ts';
+import * as terms from './hdbTerms.ts';
+import { expandOperationsPerms } from './operationPermissions.ts';
+import * as permsTranslator from '../security/permissionsTranslator.js';
+import { systemInformation } from '../utility/environment/systemInformation.ts';
+import * as tokenAuthentication from '../security/tokenAuthentication.ts';
+import * as auth from '../security/auth.ts';
+import * as configUtils from '../config/configUtils.js';
+import * as functionsOperations from '../components/operations.js';
+import * as transactionLog from '../utility/logging/transactionLog.ts';
+import * as npmUtilities from './npmUtilities.ts';
+import * as analytics from '../resources/analytics/read.ts';
+import * as status from '../server/status/index.ts';
+import PermissionResponseObject from '../security/data_objects/PermissionResponseObject.ts';
+import { handleHDBError, hdbErrors } from '../utility/errors/hdbError.ts';
+
+import * as regDeprecated from '../resources/registrationDeprecated.ts';
+import * as deploymentOperations from '../components/deploymentOperations.ts';
 
 const requiredPermissions = new Map();
 const DELETE_PERM = 'delete';
@@ -94,6 +96,9 @@ const DATA_EXPORT = {
 };
 
 class permission {
+	requires_su: boolean;
+	perms: any;
+	api_name: string;
 	constructor(requiresSu, perms, apiName) {
 		this.requires_su = requiresSu;
 		this.perms = perms;
@@ -103,161 +108,196 @@ class permission {
 	}
 }
 
-requiredPermissions.set(write.insert.name, new permission(false, [INSERT_PERM], terms.OPERATIONS_ENUM.INSERT));
-requiredPermissions.set(write.update.name, new permission(false, [UPDATE_PERM], terms.OPERATIONS_ENUM.UPDATE));
+requiredPermissions.set(write.insert.name, new (permission as any)(false, [INSERT_PERM], terms.OPERATIONS_ENUM.INSERT));
+requiredPermissions.set(write.update.name, new (permission as any)(false, [UPDATE_PERM], terms.OPERATIONS_ENUM.UPDATE));
 requiredPermissions.set(
 	write.upsert.name,
-	new permission(false, [INSERT_PERM, UPDATE_PERM], terms.OPERATIONS_ENUM.UPSERT)
+	new (permission as any)(false, [INSERT_PERM, UPDATE_PERM], terms.OPERATIONS_ENUM.UPSERT)
 );
 requiredPermissions.set(
 	search.searchByConditions.name,
-	new permission(false, [READ_PERM], terms.OPERATIONS_ENUM.SEARCH_BY_CONDITIONS)
+	new (permission as any)(false, [READ_PERM], terms.OPERATIONS_ENUM.SEARCH_BY_CONDITIONS)
 );
 requiredPermissions.set(
 	search.searchByHash.name,
-	new permission(false, [READ_PERM], terms.OPERATIONS_ENUM.SEARCH_BY_HASH)
+	new (permission as any)(false, [READ_PERM], terms.OPERATIONS_ENUM.SEARCH_BY_HASH)
 );
 requiredPermissions.set(
 	search.searchByValue.name,
-	new permission(false, [READ_PERM], terms.OPERATIONS_ENUM.SEARCH_BY_VALUE)
+	new (permission as any)(false, [READ_PERM], terms.OPERATIONS_ENUM.SEARCH_BY_VALUE)
 );
-requiredPermissions.set(search.search.name, new permission(false, [READ_PERM], terms.OPERATIONS_ENUM.SEARCH));
-requiredPermissions.set(schema.createSchema.name, new permission(true, [], terms.OPERATIONS_ENUM.CREATE_DATABASE));
-requiredPermissions.set(schema.createTable.name, new permission(true, [], terms.OPERATIONS_ENUM.CREATE_TABLE));
+requiredPermissions.set(search.search.name, new (permission as any)(false, [READ_PERM], terms.OPERATIONS_ENUM.SEARCH));
+requiredPermissions.set(
+	schema.createSchema.name,
+	new (permission as any)(true, [], terms.OPERATIONS_ENUM.CREATE_DATABASE)
+);
+requiredPermissions.set(schema.createTable.name, new (permission as any)(true, [], terms.OPERATIONS_ENUM.CREATE_TABLE));
 requiredPermissions.set(
 	schema.createAttribute.name,
-	new permission(false, [INSERT_PERM], terms.OPERATIONS_ENUM.CREATE_ATTRIBUTE)
+	new (permission as any)(false, [INSERT_PERM], terms.OPERATIONS_ENUM.CREATE_ATTRIBUTE)
+);
+requiredPermissions.set(schema.dropSchema.name, new (permission as any)(true, [], terms.OPERATIONS_ENUM.DROP_DATABASE));
+requiredPermissions.set(schema.dropTable.name, new (permission as any)(true, [], terms.OPERATIONS_ENUM.DROP_TABLE));
+requiredPermissions.set(
+	schema.dropAttribute.name,
+	new (permission as any)(true, [], terms.OPERATIONS_ENUM.DROP_ATTRIBUTE)
 );
-requiredPermissions.set(schema.dropSchema.name, new permission(true, [], terms.OPERATIONS_ENUM.DROP_DATABASE));
-requiredPermissions.set(schema.dropTable.name, new permission(true, [], terms.OPERATIONS_ENUM.DROP_TABLE));
-requiredPermissions.set(schema.dropAttribute.name, new permission(true, [], terms.OPERATIONS_ENUM.DROP_ATTRIBUTE));
 requiredPermissions.set(
 	schemaDescribe.describeSchema.name,
-	new permission(false, [READ_PERM], terms.OPERATIONS_ENUM.DESCRIBE_SCHEMA)
+	new (permission as any)(false, [READ_PERM], terms.OPERATIONS_ENUM.DESCRIBE_SCHEMA)
 );
 requiredPermissions.set(
 	schemaDescribe.describeTable.name,
-	new permission(false, [READ_PERM], terms.OPERATIONS_ENUM.DESCRIBE_TABLE)
-);
-requiredPermissions.set(delete_.deleteRecord.name, new permission(false, [DELETE_PERM], terms.OPERATIONS_ENUM.DELETE));
-requiredPermissions.set(user.addUser.name, new permission(true, [], terms.OPERATIONS_ENUM.ADD_USER));
-requiredPermissions.set(user.alterUser.name, new permission(true, [], terms.OPERATIONS_ENUM.ALTER_USER));
-requiredPermissions.set(user.dropUser.name, new permission(true, [], terms.OPERATIONS_ENUM.DROP_USER));
-requiredPermissions.set(user.listUsersExternal.name, new permission(true, [], terms.OPERATIONS_ENUM.LIST_USERS));
-requiredPermissions.set(role.listRoles.name, new permission(true, [], terms.OPERATIONS_ENUM.LIST_ROLES));
-requiredPermissions.set(role.addRole.name, new permission(true, [], terms.OPERATIONS_ENUM.ADD_ROLE));
-requiredPermissions.set(role.alterRole.name, new permission(true, [], terms.OPERATIONS_ENUM.ALTER_ROLE));
-requiredPermissions.set(role.dropRole.name, new permission(true, [], terms.OPERATIONS_ENUM.DROP_ROLE));
-requiredPermissions.set(readLog.name, new permission(true, [], terms.OPERATIONS_ENUM.READ_LOG));
-requiredPermissions.set(configUtils.setConfiguration.name, new permission(true, []));
-requiredPermissions.set(delete_.deleteFilesBefore.name, new permission(true, []));
-requiredPermissions.set(delete_.deleteAuditLogsBefore.name, new permission(true, []));
-requiredPermissions.set(restart.restart.name, new permission(true, [], terms.OPERATIONS_ENUM.RESTART));
-requiredPermissions.set(restart.restartService.name, new permission(true, []));
-requiredPermissions.set(readAuditLog.name, new permission(true, [], terms.OPERATIONS_ENUM.READ_AUDIT_LOG));
-requiredPermissions.set(getBackup.name, new permission(true, [READ_PERM]));
-requiredPermissions.set(schema.cleanupOrphanBlobs.name, new permission(true, []));
-requiredPermissions.set(systemInformation.name, new permission(true, [], terms.OPERATIONS_ENUM.SYSTEM_INFORMATION));
+	new (permission as any)(false, [READ_PERM], terms.OPERATIONS_ENUM.DESCRIBE_TABLE)
+);
+requiredPermissions.set(
+	delete_.deleteRecord.name,
+	new (permission as any)(false, [DELETE_PERM], terms.OPERATIONS_ENUM.DELETE)
+);
+requiredPermissions.set(user.addUser.name, new (permission as any)(true, [], terms.OPERATIONS_ENUM.ADD_USER));
+requiredPermissions.set(user.alterUser.name, new (permission as any)(true, [], terms.OPERATIONS_ENUM.ALTER_USER));
+requiredPermissions.set(user.dropUser.name, new (permission as any)(true, [], terms.OPERATIONS_ENUM.DROP_USER));
+requiredPermissions.set(
+	user.listUsersExternal.name,
+	new (permission as any)(true, [], terms.OPERATIONS_ENUM.LIST_USERS)
+);
+requiredPermissions.set(role.listRoles.name, new (permission as any)(true, [], terms.OPERATIONS_ENUM.LIST_ROLES));
+requiredPermissions.set(role.addRole.name, new (permission as any)(true, [], terms.OPERATIONS_ENUM.ADD_ROLE));
+requiredPermissions.set(role.alterRole.name, new (permission as any)(true, [], terms.OPERATIONS_ENUM.ALTER_ROLE));
+requiredPermissions.set(role.dropRole.name, new (permission as any)(true, [], terms.OPERATIONS_ENUM.DROP_ROLE));
+requiredPermissions.set(readLog.name, new (permission as any)(true, [], terms.OPERATIONS_ENUM.READ_LOG));
+requiredPermissions.set(configUtils.setConfiguration.name, new (permission as any)(true, []));
+requiredPermissions.set(delete_.deleteFilesBefore.name, new (permission as any)(true, []));
+requiredPermissions.set(delete_.deleteAuditLogsBefore.name, new (permission as any)(true, []));
+requiredPermissions.set(restart.restart.name, new (permission as any)(true, [], terms.OPERATIONS_ENUM.RESTART));
+requiredPermissions.set(restart.restartService.name, new (permission as any)(true, []));
+requiredPermissions.set(readAuditLog.name, new (permission as any)(true, [], terms.OPERATIONS_ENUM.READ_AUDIT_LOG));
+requiredPermissions.set(getBackup.name, new (permission as any)(true, [READ_PERM]));
+requiredPermissions.set(schema.cleanupOrphanBlobs.name, new (permission as any)(true, []));
+requiredPermissions.set(
+	systemInformation.name,
+	new (permission as any)(true, [], terms.OPERATIONS_ENUM.SYSTEM_INFORMATION)
+);
 requiredPermissions.set(
 	configUtils.getConfiguration.name,
-	new permission(true, [], terms.OPERATIONS_ENUM.GET_CONFIGURATION)
+	new (permission as any)(true, [], terms.OPERATIONS_ENUM.GET_CONFIGURATION)
+);
+requiredPermissions.set(transactionLog.readTransactionLog.name, new (permission as any)(true, []));
+requiredPermissions.set(transactionLog.deleteTransactionLogsBefore.name, new (permission as any)(true, []));
+requiredPermissions.set(npmUtilities.installModules.name, new (permission as any)(true, []));
+requiredPermissions.set(
+	analytics.getOp.name,
+	new (permission as any)(false, [READ_PERM], terms.OPERATIONS_ENUM.GET_ANALYTICS)
 );
-requiredPermissions.set(transactionLog.readTransactionLog.name, new permission(true, []));
-requiredPermissions.set(transactionLog.deleteTransactionLogsBefore.name, new permission(true, []));
-requiredPermissions.set(npmUtilities.installModules.name, new permission(true, []));
-requiredPermissions.set(analytics.getOp.name, new permission(false, [READ_PERM], terms.OPERATIONS_ENUM.GET_ANALYTICS));
 requiredPermissions.set(
 	analytics.listMetricsOp.name,
-	new permission(false, [READ_PERM], terms.OPERATIONS_ENUM.LIST_METRICS)
+	new (permission as any)(false, [READ_PERM], terms.OPERATIONS_ENUM.LIST_METRICS)
 );
 requiredPermissions.set(
 	analytics.describeMetricOp.name,
-	new permission(false, [READ_PERM], terms.OPERATIONS_ENUM.DESCRIBE_METRIC)
+	new (permission as any)(false, [READ_PERM], terms.OPERATIONS_ENUM.DESCRIBE_METRIC)
 );
-requiredPermissions.set(status.clear.name, new permission(true, []));
-requiredPermissions.set(status.get.name, new permission(true, []));
-requiredPermissions.set(status.set.name, new permission(true, []));
+requiredPermissions.set(status.clear.name, new (permission as any)(true, []));
+requiredPermissions.set(status.get.name, new (permission as any)(true, []));
+requiredPermissions.set(status.set.name, new (permission as any)(true, []));
 
 //this operation must be available to all users so they can create authentication tokens and login
 requiredPermissions.set(
 	tokenAuthentication.createTokens.name,
-	new permission(false, [], terms.OPERATIONS_ENUM.CREATE_AUTHENTICATION_TOKENS)
+	new (permission as any)(false, [], terms.OPERATIONS_ENUM.CREATE_AUTHENTICATION_TOKENS)
 );
 requiredPermissions.set(
 	tokenAuthentication.refreshOperationToken.name,
-	new permission(false, [], terms.OPERATIONS_ENUM.REFRESH_OPERATION_TOKEN)
+	new (permission as any)(false, [], terms.OPERATIONS_ENUM.REFRESH_OPERATION_TOKEN)
 );
-requiredPermissions.set(auth.login.name, new permission(false, []));
-requiredPermissions.set(auth.logout.name, new permission(false, []));
+requiredPermissions.set(auth.login.name, new (permission as any)(false, []));
+requiredPermissions.set(auth.logout.name, new (permission as any)(false, []));
 
 //Operations specific to HDB Functions
 requiredPermissions.set(
 	functionsOperations.customFunctionsStatus.name,
-	new permission(true, [], terms.OPERATIONS_ENUM.CUSTOM_FUNCTIONS_STATUS)
+	new (permission as any)(true, [], terms.OPERATIONS_ENUM.CUSTOM_FUNCTIONS_STATUS)
 );
 requiredPermissions.set(
 	functionsOperations.getCustomFunctions.name,
-	new permission(true, [], terms.OPERATIONS_ENUM.GET_CUSTOM_FUNCTIONS)
+	new (permission as any)(true, [], terms.OPERATIONS_ENUM.GET_CUSTOM_FUNCTIONS)
 );
 requiredPermissions.set(
 	functionsOperations.getComponents.name,
-	new permission(true, [], terms.OPERATIONS_ENUM.GET_COMPONENTS)
+	new (permission as any)(true, [], terms.OPERATIONS_ENUM.GET_COMPONENTS)
 );
 requiredPermissions.set(
 	functionsOperations.getComponentFile.name,
-	new permission(true, [], terms.OPERATIONS_ENUM.GET_COMPONENT_FILE)
+	new (permission as any)(true, [], terms.OPERATIONS_ENUM.GET_COMPONENT_FILE)
 );
-requiredPermissions.set(functionsOperations.setComponentFile.name, new permission(true, []));
-requiredPermissions.set(functionsOperations.dropComponent.name, new permission(true, []));
+requiredPermissions.set(functionsOperations.setComponentFile.name, new (permission as any)(true, []));
+requiredPermissions.set(functionsOperations.dropComponent.name, new (permission as any)(true, []));
 requiredPermissions.set(
 	functionsOperations.getCustomFunction.name,
-	new permission(true, [], terms.OPERATIONS_ENUM.GET_CUSTOM_FUNCTION)
+	new (permission as any)(true, [], terms.OPERATIONS_ENUM.GET_CUSTOM_FUNCTION)
+);
+requiredPermissions.set(functionsOperations.setCustomFunction.name, new (permission as any)(true, []));
+requiredPermissions.set(functionsOperations.dropCustomFunction.name, new (permission as any)(true, []));
+requiredPermissions.set(functionsOperations.addComponent.name, new (permission as any)(true, []));
+requiredPermissions.set(functionsOperations.dropCustomFunctionProject.name, new (permission as any)(true, []));
+requiredPermissions.set(functionsOperations.packageComponent.name, new (permission as any)(true, []));
+requiredPermissions.set(functionsOperations.deployComponent.name, new (permission as any)(true, []));
+requiredPermissions.set(
+	deploymentOperations.handleListDeployments.name,
+	new (permission as any)(true, [], terms.OPERATIONS_ENUM.LIST_DEPLOYMENTS)
+);
+requiredPermissions.set(
+	deploymentOperations.handleGetDeployment.name,
+	new (permission as any)(true, [], terms.OPERATIONS_ENUM.GET_DEPLOYMENT)
 );
-requiredPermissions.set(functionsOperations.setCustomFunction.name, new permission(true, []));
-requiredPermissions.set(functionsOperations.dropCustomFunction.name, new permission(true, []));
-requiredPermissions.set(functionsOperations.addComponent.name, new permission(true, []));
-requiredPermissions.set(functionsOperations.dropCustomFunctionProject.name, new permission(true, []));
-requiredPermissions.set(functionsOperations.packageComponent.name, new permission(true, []));
-requiredPermissions.set(functionsOperations.deployComponent.name, new permission(true, []));
 
 //Below are functions that are currently open to all roles
-requiredPermissions.set(regDeprecated.getRegistrationInfo.name, new permission(false, []));
-requiredPermissions.set(user.userInfo.name, new permission(false, [], terms.OPERATIONS_ENUM.USER_INFO));
+requiredPermissions.set(regDeprecated.getRegistrationInfo.name, new (permission as any)(false, []));
+requiredPermissions.set(user.userInfo.name, new (permission as any)(false, [], terms.OPERATIONS_ENUM.USER_INFO));
 //DescribeAll will only return the schema values a user has permissions for
-requiredPermissions.set(schemaDescribe.describeAll.name, new permission(false, [], terms.OPERATIONS_ENUM.DESCRIBE_ALL));
+requiredPermissions.set(
+	schemaDescribe.describeAll.name,
+	new (permission as any)(false, [], terms.OPERATIONS_ENUM.DESCRIBE_ALL)
+);
 
 //Below function names are hardcoded b/c of circular dependency issues
-requiredPermissions.set(HANDLE_GET_JOB, new permission(false, [], terms.OPERATIONS_ENUM.GET_JOB));
-requiredPermissions.set(HANDLE_GET_JOB_BY_START_DATE, new permission(true, []));
-requiredPermissions.set(CATCHUP, new permission(true, []));
+requiredPermissions.set(HANDLE_GET_JOB, new (permission as any)(false, [], terms.OPERATIONS_ENUM.GET_JOB));
+requiredPermissions.set(HANDLE_GET_JOB_BY_START_DATE, new (permission as any)(true, []));
+requiredPermissions.set(CATCHUP, new (permission as any)(true, []));
 requiredPermissions.set(
 	BULK_OPS.CSV_DATA_LOAD,
-	new permission(false, [INSERT_PERM, UPDATE_PERM], terms.OPERATIONS_ENUM.CSV_DATA_LOAD)
+	new (permission as any)(false, [INSERT_PERM, UPDATE_PERM], terms.OPERATIONS_ENUM.CSV_DATA_LOAD)
 );
 requiredPermissions.set(
 	BULK_OPS.CSV_URL_LOAD,
-	new permission(false, [INSERT_PERM, UPDATE_PERM], terms.OPERATIONS_ENUM.CSV_URL_LOAD)
+	new (permission as any)(false, [INSERT_PERM, UPDATE_PERM], terms.OPERATIONS_ENUM.CSV_URL_LOAD)
 );
 requiredPermissions.set(
 	BULK_OPS.CSV_FILE_LOAD,
-	new permission(false, [INSERT_PERM, UPDATE_PERM], terms.OPERATIONS_ENUM.CSV_FILE_LOAD)
+	new (permission as any)(false, [INSERT_PERM, UPDATE_PERM], terms.OPERATIONS_ENUM.CSV_FILE_LOAD)
 );
 requiredPermissions.set(
 	BULK_OPS.IMPORT_FROM_S3,
-	new permission(false, [INSERT_PERM, UPDATE_PERM], terms.OPERATIONS_ENUM.IMPORT_FROM_S3)
+	new (permission as any)(false, [INSERT_PERM, UPDATE_PERM], terms.OPERATIONS_ENUM.IMPORT_FROM_S3)
+);
+requiredPermissions.set(
+	DATA_EXPORT.EXPORT_TO_S3,
+	new (permission as any)(true, [], terms.OPERATIONS_ENUM.EXPORT_TO_S3)
+);
+requiredPermissions.set(
+	DATA_EXPORT.EXPORT_LOCAL,
+	new (permission as any)(true, [], terms.OPERATIONS_ENUM.EXPORT_LOCAL)
 );
-requiredPermissions.set(DATA_EXPORT.EXPORT_TO_S3, new permission(true, [], terms.OPERATIONS_ENUM.EXPORT_TO_S3));
-requiredPermissions.set(DATA_EXPORT.EXPORT_LOCAL, new permission(true, [], terms.OPERATIONS_ENUM.EXPORT_LOCAL));
 
 // SQL operations are distinct from operations above, so we need to store required perms for both.
-requiredPermissions.set(terms.VALID_SQL_OPS_ENUM.DELETE, new permission(false, [DELETE_PERM]));
-requiredPermissions.set(terms.VALID_SQL_OPS_ENUM.SELECT, new permission(false, [READ_PERM]));
-requiredPermissions.set(terms.VALID_SQL_OPS_ENUM.INSERT, new permission(false, [INSERT_PERM]));
-requiredPermissions.set(terms.VALID_SQL_OPS_ENUM.UPDATE, new permission(false, [UPDATE_PERM]));
+requiredPermissions.set(terms.VALID_SQL_OPS_ENUM.DELETE, new (permission as any)(false, [DELETE_PERM]));
+requiredPermissions.set(terms.VALID_SQL_OPS_ENUM.SELECT, new (permission as any)(false, [READ_PERM]));
+requiredPermissions.set(terms.VALID_SQL_OPS_ENUM.INSERT, new (permission as any)(false, [INSERT_PERM]));
+requiredPermissions.set(terms.VALID_SQL_OPS_ENUM.UPDATE, new (permission as any)(false, [UPDATE_PERM]));
 
 module.exports = {
 	verifyPerms,
-	verifyPermsAst,
+	verifyPermsAST,
 	verifyBulkLoadAttributePerms,
 };
 
@@ -268,7 +308,7 @@ module.exports = {
  * @param operation - The operation specified in the call.
  * @returns {null | PermissionResponseObject} - null if permissions match, errors returned in the PermissionResponseObject
  */
-function verifyPermsAst(ast, userObject, operation) {
+export function verifyPermsAST(ast, userObject, operation) {
 	//TODO - update these validation checks to use validate.js
 	if (commonUtils.isEmptyOrZeroLength(ast)) {
 		harperLogger.info('verify_perms_ast has an empty user parameter');
@@ -283,7 +323,8 @@ function verifyPermsAst(ast, userObject, operation) {
 		throw handleHDBError(new Error());
 	}
 	try {
-		const bucket = require('../sqlTranslator/sql_statement_bucket.js');
+		const bucket =
+			require('../sqlTranslator/sql_statement_bucket').default || require('../sqlTranslator/sql_statement_bucket');
 		const alasql = require('alasql');
 
 		const permsResponse = new PermissionResponseObject();
@@ -294,7 +335,7 @@ function verifyPermsAst(ast, userObject, operation) {
 		// Should not continue if there are no schemas defined and there are table columns defined.
 		// This is defined so we can do calc selects like : SELECT ABS(-12)
 		if ((!schemas || schemas.length === 0) && parsedAst.affected_attributes && parsedAst.affected_attributes.size > 0) {
-			harperLogger.info(`No schemas defined in verifyPermsAst(), will not continue.`);
+			harperLogger.info(`No schemas defined in verifyPermsAST(), will not continue.`);
 			throw handleHDBError(new Error());
 		}
 		// set to true if this operation affects a system table.  Only su can read from system tables, but can't update/delete.
@@ -327,7 +368,7 @@ function verifyPermsAst(ast, userObject, operation) {
 			}
 		}
 
-		let tablePermRestriction = hasPermissions(userObject, operation, schemaTableMap, permsResponse); //NOSONAR;
+		let tablePermRestriction = hasPermissions(userObject, operation, schemaTableMap, permsResponse, undefined); //NOSONAR;
 		if (tablePermRestriction) {
 			return tablePermRestriction;
 		}
@@ -336,7 +377,15 @@ function verifyPermsAst(ast, userObject, operation) {
 			for (let t = 0; t < tables.length; t++) {
 				let attributes = parsedAst.getAttributesBySchemaTableName(schemaKey, tables[t]);
 				const attribute_permissions = getAttributePermissions(userObject.role.permission, schemaKey, tables[t]);
-				checkAttributePerms(attributes, attribute_permissions, operation, tables[t], schemaKey, permsResponse);
+				checkAttributePerms(
+					attributes,
+					attribute_permissions,
+					operation,
+					tables[t],
+					schemaKey,
+					permsResponse,
+					undefined
+				);
 			}
 		});
 
@@ -353,7 +402,7 @@ function verifyPermsAst(ast, userObject, operation) {
  * @param operation - The name of the operation specified in the request.
  * @returns { null | PermissionResponseObject } - null if permissions match, errors are consolidated into PermissionResponseObj.
  */
-function verifyPerms(requestJson, operation) {
+export function verifyPerms(requestJson: any, operation: any, _options?: any) {
 	if (
 		requestJson === null ||
 		operation === null ||
@@ -477,22 +526,22 @@ function verifyPerms(requestJson, operation) {
 	if (requestJson.hdb_user?.role) requestJson.hdb_user.role.permission = fullRolePerms;
 
 	if (op === DESCRIBE_SCHEMA_KEY || op === DESCRIBE_TABLE_KEY) {
-		if (!fullRolePerms.super_user) {
+		if (!(fullRolePerms as any).super_user) {
 			if (operationSchema === terms.SYSTEM_SCHEMA_NAME) {
 				return permsResponse.handleUnauthorizedItem(HDB_ERROR_MSGS.SCHEMA_PERM_ERROR(operationSchema));
 			}
 
 			if (op === DESCRIBE_SCHEMA_KEY) {
-				if (!fullRolePerms[operationSchema] || !fullRolePerms[operationSchema][DESCRIBE_PERM]) {
+				if (!(fullRolePerms as any)[operationSchema] || !(fullRolePerms as any)[operationSchema][DESCRIBE_PERM]) {
 					return permsResponse.handleInvalidItem(HDB_ERROR_MSGS.SCHEMA_NOT_FOUND(operationSchema));
 				}
 			}
 
 			if (
 				op === DESCRIBE_TABLE_KEY &&
-				(!fullRolePerms[operationSchema] ||
-					!fullRolePerms[operationSchema].tables[table] ||
-					!fullRolePerms[operationSchema].tables[table][DESCRIBE_PERM])
+				(!(fullRolePerms as any)[operationSchema] ||
+					!(fullRolePerms as any)[operationSchema].tables[table] ||
+					!(fullRolePerms as any)[operationSchema].tables[table][DESCRIBE_PERM])
 			) {
 				return permsResponse.handleInvalidItem(HDB_ERROR_MSGS.TABLE_NOT_FOUND(operationSchema, table));
 			}
@@ -513,7 +562,7 @@ function verifyPerms(requestJson, operation) {
 	//we will convert the * to the specific attributes the user has READ permissions for via their role.
 	if (!isSuperUser && requestJson.get_attributes && terms.SEARCH_WILDCARDS.includes(requestJson.get_attributes[0])) {
 		let finalGetAttrs = [];
-		const table_perms = fullRolePerms[operationSchema].tables[table];
+		const table_perms = (fullRolePerms as any)[operationSchema].tables[table];
 
 		if (table_perms[terms.PERMS_CRUD_ENUM.READ]) {
 			if (table_perms.attribute_permissions.length > 0) {
@@ -544,7 +593,7 @@ function verifyPerms(requestJson, operation) {
  * @param schemaTableMap - A map in the format [schemaKey, [tables]].
  * @returns {PermissionResponseObject | null} - null value if permissions match, PermissionResponseObject if not.
  */
-function hasPermissions(userObject, op, schemaTableMap, permsResponse, action) {
+export function hasPermissions(userObject, op, schemaTableMap, permsResponse, action) {
 	if (commonUtils.arrayHasEmptyValues([userObject, op, schemaTableMap])) {
 		harperLogger.info(`hasPermissions has an invalid parameter`);
 		throw handleHDBError(new Error());
@@ -650,7 +699,7 @@ function hasPermissions(userObject, op, schemaTableMap, permsResponse, action) {
  * @param permsResponse - PermissionResponseObject instance being used to track permissions issues to return in response, if necessary
  * @returns {} - this function does not return a value - it updates the permsResponse which is checked later
  */
-function checkAttributePerms(
+export function checkAttributePerms(
 	recordAttributes,
 	roleAttributePermissions,
 	operation,
@@ -792,7 +841,7 @@ function getRecordAttributes(json) {
  * @param table - The table specified.
  * @returns {Map} A Map of attribute permissions of the form [attribute_name, attributePermission];
  */
-function getAttributePermissions(rolePerms, operationSchema, table) {
+export function getAttributePermissions(rolePerms, operationSchema, table) {
 	let roleAttributePermissions = new Map();
 	if (commonUtils.isEmpty(rolePerms)) {
 		harperLogger.info(`no hdb_user specified in getAttributePermissions`);
@@ -818,7 +867,7 @@ function getAttributePermissions(rolePerms, operationSchema, table) {
 	return roleAttributePermissions;
 }
 
-function verifyBulkLoadAttributePerms(
+export function verifyBulkLoadAttributePerms(
 	rolePerms,
 	op,
 	action,