Eliminate TypeScript Errors and Convert foundational .js files to .ts

.oxlintrc.json

@@ -9,7 +9,25 @@
 		"no-constant-condition": "off",
 		"prefer-const": "off",
 		"typescript/no-explicit-any": "off",
-		"typescript/no-var-requires": "off"
+		"typescript/no-var-requires": "off",
+		"no-unused-expressions": "off",
+		"no-unreachable": "off",
+		"no-useless-catch": "off",
+		"unicorn/no-new-array": "off",
+		"unicorn/no-thenable": "off",
+		"typescript/no-this-alias": "off",
+		"no-async-promise-executor": "off",
+		"no-useless-escape": "off",
+		"no-unsafe-finally": "off",
+		"no-unassigned-vars": "off",
+		"no-unused-private-class-members": "off",
+		"no-loss-of-precision": "off",
+		"no-ex-assign": "off",
+		"no-eval": "off",
+		"no-dupe-keys": "off",
+		"unicorn/no-useless-spread": "off",
+		"unicorn/no-invalid-fetch-options": "off",
+		"oxc/const-comparisons": "off"
 	},
 	"settings": {
 		"jsdoc": {

bin/BinObjects.js → bin/BinObjects.ts

@@ -4,14 +4,13 @@
  * This is meant as a central place to defined POJOs used by functions in the /bin/ directory.
  */
 
-class HdbInfoInsertObject {
+export class HdbInfoInsertObject {
+	info_id: any;
+	data_version_num: any;
+	hdb_version_num: any;
 	constructor(id, dataVersionNum, hdbVersionNum) {
 		this.info_id = id;
 		this.data_version_num = dataVersionNum;
 		this.hdb_version_num = hdbVersionNum;
 	}
 }
-
-module.exports = {
-	HdbInfoInsertObject,
-};

bin/cliOperations.js → bin/cliOperations.ts

@@ -1,21 +1,21 @@
 'use strict';
 
-const envMgr = require('../utility/environment/environmentManager.js');
+import * as envMgr from '../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');
+import * as terms from '../utility/hdbTerms.js';
+import { httpRequest } from '../utility/common_utils.js';
+import * as path from 'path';
+import * as fs from 'fs-extra';
+import * as YAML from 'yaml';
+import { packageDirectory } from '../components/packageComponent.js';
+import { encode } from 'cbor-x';
+import { getHdbPid } from '../utility/processManagement/processManagement.js';
+import { initConfig, getConfigPath } from '../config/configUtils.js';
 
 const OP_ALIASES = { deploy: 'deploy_component', package: 'package_component' };
 
-module.exports = { cliOperations, buildRequest };
-const PREPARE_OPERATION = {
+export { cliOperations, buildRequest };
+const PREPARE_OPERATION: any = {
 	deploy_component: async (req) => {
 		if (req.package) {
 			return;
@@ -31,22 +31,22 @@ const PREPARE_OPERATION = {
 /**
  * Builds an Op-API request object from CLI args
  */
-function buildRequest() {
-	const req = {};
+function buildRequest(): any {
+	const req: any = {};
 	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('=');
+			let restStr: any = rest.join('=');
 
 			try {
-				rest = JSON.parse(rest);
+				restStr = JSON.parse(restStr);
 			} catch {
 				/* noop */
 			}
 
-			req[first] = rest;
+			req[first] = restStr;
 		} else {
 			// operation should only be in the first arg
 			req.operation ??= arg;
@@ -61,7 +61,7 @@ function buildRequest() {
  * @param req
  * @returns {Promise<void>}
  */
-async function cliOperations(req) {
+async function cliOperations(req: any) {
 	if (!req.target) {
 		req.target = process.env.HARPER_CLI_TARGET || process.env.CLI_TARGET;
 	}
@@ -115,7 +115,7 @@ async function cliOperations(req) {
 			options.headers['Content-Type'] = 'application/cbor';
 			req = encode(req);
 		}
-		let response = await httpRequest(options, req);
+		let response: any = await httpRequest(options, req);
 
 		let responseData;
 		try {

bin/copyDb.ts

@@ -163,7 +163,7 @@ export async function copyDb(sourceDatabase: string, targetDatabasePath: string)
 	const sourceDbisDb = rootStore.dbisDb;
 	const sourceAuditStore = rootStore.auditStore;
 	const targetEnv = open(new OpenEnvironmentObject(targetDatabasePath));
-	const targetDbisDb = targetEnv.openDB(INTERNAL_DBIS_NAME);
+	const targetDbisDb = targetEnv.openDB({ name: INTERNAL_DBIS_NAME });
 	let written;
 	let outstandingWrites = 0;
 	// we use a single transaction to get a snapshot, also we can't use snapshot: false on dupsort dbs
@@ -196,8 +196,8 @@ export async function copyDb(sourceDatabase: string, targetDatabasePath: string)
 			sourceDbi.decoderCopies = false;
 			sourceDbi.encoding = 'binary';
 			dbiInit.compression = newCompression;
-			const targetDbi = targetEnv.openDB(key, dbiInit);
-			targetDbi.encoder = null;
+			const targetDbi = (targetEnv as any).openDB(key, dbiInit);
+			(targetDbi as any).encoder = null;
 			console.log('copying', key, 'from', sourceDatabase, 'to', targetDatabasePath);
 			await copyDbi(sourceDbi, targetDbi, isPrimary, transaction);
 		}
@@ -291,7 +291,7 @@ function openRocksDb(path: string, options: RocksDatabaseOptions & { dupSort?: b
 	}
 	let db;
 	if (options.dupSort) {
-		db = new RocksIndexStore(path, options).open();
+		db = new (RocksIndexStore as any)(path, options).open();
 	} else {
 		db = RocksDatabase.open(path, options);
 		db.encoder.name = options.name;

bin/harper.js → bin/harper.ts

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 'use strict';
 
-const fs = require('node:fs');
-const path = require('node:path');
-const logger = require('../utility/logging/harper_logger.js');
-const cliOperations = require('./cliOperations.js');
-const { packageJson } = require('../utility/packageUtils.js');
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import logger from '../utility/logging/harper_logger.js';
+import * as cliOperations from './cliOperations.js';
+import { packageJson } from '../utility/packageUtils.js';
 const checkNode = require('../launchServiceScripts/utility/checkNodeVersion.js');
-const hdbTerms = require('../utility/hdbTerms.ts');
-const { SERVICE_ACTIONS_ENUM } = hdbTerms;
+import * as hdbTerms from '../utility/hdbTerms.js';
+const { SERVICE_ACTIONS_ENUM } = hdbTerms as any;
 if (typeof process.setSourceMapsEnabled === 'function') {
 	process.setSourceMapsEnabled(true); // this is necessary for source maps to work, at least on the main thread.
 }
@@ -64,9 +64,9 @@ async function harper() {
 		case SERVICE_ACTIONS_ENUM.START:
 			return require('./run.js').launch();
 		case SERVICE_ACTIONS_ENUM.INSTALL:
-			return require('./install.js')();
+			return (require('./install.js').default || require('./install.js'))();
 		case SERVICE_ACTIONS_ENUM.STOP:
-			return require('./stop.js')().then(() => {
+			return (require('./stop.js').default || require('./stop.js'))().then(() => {
 				process.exit(0);
 			});
 		case SERVICE_ACTIONS_ENUM.RESTART:
@@ -80,18 +80,18 @@ async function harper() {
 				.upgrade(null)
 				.then(() => 'Your instance of Harper is up to date!');
 		case SERVICE_ACTIONS_ENUM.STATUS:
-			return require('./status.js')();
+			return (require('./status.js').default || require('./status.js'))();
 		case SERVICE_ACTIONS_ENUM.RENEWCERTS:
 			return require('../security/keys.js')
 				.renewSelfSigned()
 				.then(() => 'Successfully renewed self-signed certificates');
 		case SERVICE_ACTIONS_ENUM.COPYDB: {
 			let sourceDb = process.argv[3];
 			let targetDbPath = process.argv[4];
-			return require('./copyDb.ts').copyDb(sourceDb, targetDbPath);
+			return require('./copyDb.js').copyDb(sourceDb, targetDbPath);
 		}
 		case SERVICE_ACTIONS_ENUM.DEV:
-			process.env.DEV_MODE = true;
+			process.env.DEV_MODE = 'true';
 		// fall through
 		case SERVICE_ACTIONS_ENUM.RUN: {
 			// Run a specific application folder
@@ -136,7 +136,7 @@ async function harper() {
 			return;
 	}
 }
-exports.harper = harper;
+export { harper };
 if (require.main === module) {
 	harper()
 		.then((message) => {

bin/install.js → bin/install.ts

@@ -1,7 +1,7 @@
-const installer = require('../utility/install/installer.js');
-const hdbLogger = require('../utility/logging/harper_logger.js');
+import * as installer from '../utility/install/installer.js';
+import hdbLogger from '../utility/logging/harper_logger.js';
 
-module.exports = install;
+export default install;
 
 async function install() {
 	try {

bin/lite.ts

@@ -0,0 +1,2 @@
+import { startHTTPThreads } from '../server/threads/socketRouter.js';
+startHTTPThreads(1);

bin/restart.js → bin/restart.ts

@@ -1,29 +1,26 @@
 'use strict';
 
-const minimist = require('minimist');
-const { isMainThread, parentPort } = require('worker_threads');
-const hdbTerms = require('../utility/hdbTerms.ts');
-const hdbLogger = require('../utility/logging/harper_logger.js');
-const processMan = require('../utility/processManagement/processManagement.js');
-const { compactOnStart } = require('./copyDb.ts');
-const { restartWorkers, onMessageByType, shutdownWorkersNow } = require('../server/threads/manageThreads.js');
-const { handleHDBError, hdbErrors } = require('../utility/errors/hdbError.js');
+import minimist from 'minimist';
+import { isMainThread, parentPort } from 'worker_threads';
+import * as hdbTerms from '../utility/hdbTerms.js';
+import hdbLogger from '../utility/logging/harper_logger.js';
+import * as processMan from '../utility/processManagement/processManagement.js';
+import { compactOnStart } from './copyDb.js';
+import { restartWorkers, onMessageByType, shutdownWorkersNow } from '../server/threads/manageThreads.js';
+import { handleHDBError, hdbErrors } from '../utility/errors/hdbError.js';
 const { HTTP_STATUS_CODES } = hdbErrors;
-const envMgr = require('../utility/environment/environmentManager.js');
-const path = require('node:path');
-const { unlinkSync } = require('node:fs');
-const { getThisNodeName } = require('../server/nodeName.ts');
+import * as envMgr from '../utility/environment/environmentManager.js';
+import * as path from 'node:path';
+import { unlinkSync } from 'node:fs';
+import { getThisNodeName } from '../server/nodeName.js';
 envMgr.initSync();
 
 const RESTART_RESPONSE = `Restarting Harper. This may take up to ${hdbTerms.RESTART_TIMEOUT_MS / 1000} seconds.`;
 const INVALID_SERVICE_ERR = 'Invalid service';
 
 let calledFromCli;
 
-module.exports = {
-	restart,
-	restartService,
-};
+export { restart, restartService };
 
 // Add ITC event listener to main thread which will be called from child that receives restart request.
 if (isMainThread) {
@@ -40,7 +37,7 @@ if (isMainThread) {
  * @param req
  * @returns {Promise<string>}
  */
-async function restart(req) {
+async function restart(req: any) {
 	calledFromCli = Object.keys(req).length === 0;
 
 	const cliArgs = minimist(process.argv);
@@ -73,7 +70,7 @@ async function restart(req) {
 			await closeServers();
 			await processMan.cleanupChildrenProcesses(false);
 			// remove pid file so it doesn't trip up the launch
-			await unlinkSync(path.join(envMgr.get(hdbTerms.CONFIG_PARAMS.ROOTPATH), hdbTerms.HDB_PID_FILE), `${process.pid}`);
+			unlinkSync(path.join(envMgr.get(hdbTerms.CONFIG_PARAMS.ROOTPATH), hdbTerms.HDB_PID_FILE));
 			hdbLogger.debug('Starting new process...');
 			if (process.env.HARPER_EXIT_ON_RESTART) {
 				// use this to exit the process so that it will be restarted by the
@@ -100,22 +97,22 @@ async function restart(req) {
  * @param req
  * @returns {Promise<string>}
  */
-async function restartService(req) {
+async function restartService(req: any) {
 	let { service } = req;
 	if (hdbTerms.HDB_PROCESS_SERVICES[service] === undefined) {
 		throw handleHDBError(new Error(), INVALID_SERVICE_ERR, HTTP_STATUS_CODES.BAD_REQUEST, undefined, undefined, true);
 	}
 	processMan.expectedRestartOfChildren();
 	if (!isMainThread) {
 		if (req.replicated) {
-			server.replication.monitorNodeCAs(); // get all the CAs from the nodes we know about
+			(global as any).server.replication.monitorNodeCAs(); // get all the CAs from the nodes we know about
 		}
 		parentPort.postMessage({
 			type: hdbTerms.ITC_EVENT_TYPES.RESTART,
 			workerType: service,
 		});
 		parentPort.ref(); // don't let the parent thread exit until we're done
-		await new Promise((resolve) => {
+		await new Promise<void>((resolve) => {
 			parentPort.on('message', (msg) => {
 				if (msg.type === 'restart-complete') {
 					resolve();
@@ -127,12 +124,12 @@ async function restartService(req) {
 		if (req.replicated) {
 			req.replicated = false; // don't send a replicated flag to the nodes we are sending to
 			replicatedResponses = [];
-			for (let node of server.nodes) {
+			for (let node of (global as any).server.nodes) {
 				if (node.name === getThisNodeName()) continue;
 				// for now, only one at a time
 				let job_id;
 				try {
-					({ job_id } = await server.replication.sendOperationToNode(node, req));
+					({ job_id } = await (global as any).server.replication.sendOperationToNode(node, req));
 				} catch (err) {
 					// If request to node fails, add the error to the response and continue to the next node
 					replicatedResponses.push({ node: node.name, message: err.message });
@@ -146,11 +143,11 @@ async function restartService(req) {
 						let interval = setInterval(async () => {
 							if (retriesLeft-- <= 0) {
 								clearInterval(interval);
-								let error = new Error('Timed out waiting for restart job to complete');
+								let error: any = new Error('Timed out waiting for restart job to complete');
 								error.replicated = replicatedResponses; // report the finished restarts
 								reject(error);
 							}
-							let response = await server.replication.sendOperationToNode(node, {
+							let response = await (global as any).server.replication.sendOperationToNode(node, {
 								operation: 'get_job',
 								id: job_id,
 							});
@@ -161,7 +158,7 @@ async function restartService(req) {
 							}
 							if (jobResult.status === 'ERROR') {
 								clearInterval(interval);
-								let error = new Error(jobResult.message);
+								let error: any = new Error(jobResult.message);
 								error.replicated = replicatedResponses; // report the finished restarts
 								reject(error);
 							}