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

package/utility/packageUtils.js

@@ -0,0 +1,55 @@
+const { join, dirname } = require('node:path');
+const { existsSync, readFileSync } = require('node:fs');
+
+/**
+ * A naive find-up implementation to find the root package.json, and
+ * subsequently the root directory of the package. In theory we could require
+ * package.json directly (`require('../../package.json')`), but that would not
+ * give us the root directory of the repo, which is needed for other things.
+ * Furthermore, when this is eventually converted to TS, we should consider
+ * using `import('../../package.json')` as that will give type-safe access to
+ * the package.json file.
+ *
+ * The purpose of doing this instead of cobbling together a path directly is
+ * that in development mode this file will be resolved from its actual path
+ * `/utility/packageUtils.js`, but in production, it will be bundled into the
+ * built output and the path will be different. Since builds will not
+ * automatically transform a path like that (it will only do so for
+ * requires/imports), we need to stick to directory traversal to find the
+ * package root.
+ *
+ * This function isn't full-proof and could fail in some edge cases. The max
+ * iteration check is in place to prevent infinite loops.
+ *
+ * If we ever encounter this error, we should improve the function to handle
+ * the edge case instead of just increasing the `MAX` value.
+ *
+ * @returns {string} package.json file path
+ */
+function findPackageJson() {
+	const MAX = 10;
+	let dir = __dirname,
+		filePath,
+		i = 0;
+	while (!existsSync((filePath = join(dir, 'package.json')))) {
+		if (dir === (dir = dirname(dir)) || i++ > MAX) throw new Error('Could not find package root');
+	}
+	return filePath;
+}
+
+const packageJsonPath = findPackageJson();
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+
+/**
+ * The Harper package root directory.
+ *
+ * Works across dev and prod (built).
+ *
+ * @type {string}
+ */
+const PACKAGE_ROOT = dirname(packageJsonPath);
+
+module.exports = {
+	packageJson,
+	PACKAGE_ROOT,
+};

package/utility/password.ts

@@ -0,0 +1,99 @@
+import * as crypto from 'node:crypto';
+import * as argon2 from 'argon2';
+import { get } from './environment/environmentManager.js';
+import { CONFIG_PARAMS } from './hdbTerms.ts';
+const configuredHashFunction = get(CONFIG_PARAMS.AUTHENTICATION_HASHFUNCTION)?.toLowerCase();
+
+const SALT_LENGTH = 16;
+const SALT_LENGTH_MD5 = 9;
+export const HASH_FUNCTION = {
+	MD5: 'md5',
+	SHA256: 'sha256',
+	ARGON2ID: 'argon2id',
+};
+
+type HashFunction = (typeof HASH_FUNCTION)[keyof typeof HASH_FUNCTION];
+
+/**
+ * Generate a secure salt
+ * @param len Length of salt (defaults to SALT_LENGTH)
+ */
+function generateSalt(len: number = SALT_LENGTH): string {
+	const set = '0123456789abcdefghijklmnopqurstuvwxyzABCDEFGHIJKLMNOPQURSTUVWXYZ';
+	return Array.from(crypto.randomBytes(len))
+		.map((x) => set[x % set.length])
+		.join('');
+}
+
+const hashAlgorithms = {
+	[HASH_FUNCTION.MD5]: (password: string, salt = undefined) => {
+		salt = salt ?? generateSalt(SALT_LENGTH_MD5);
+		const hashed = crypto
+			.createHash(HASH_FUNCTION.MD5)
+			.update(password + salt)
+			.digest('hex');
+		return salt + hashed;
+	},
+
+	[HASH_FUNCTION.SHA256]: (password: string, salt = undefined) => {
+		salt = salt ?? generateSalt(SALT_LENGTH);
+		const hashed = crypto
+			.createHash(HASH_FUNCTION.SHA256)
+			.update(password + salt)
+			.digest('hex');
+		return salt + hashed;
+	},
+
+	[HASH_FUNCTION.ARGON2ID]: async (password: string) => {
+		const salt = generateSalt(SALT_LENGTH);
+		const hashed = await argon2.hash(password, {
+			type: argon2.argon2id,
+			salt: Buffer.from(salt),
+		});
+		return salt + hashed;
+	},
+};
+
+const validateAlgorithms = {
+	[HASH_FUNCTION.MD5]: (storedHash: string, password: string) => {
+		const salt = storedHash.slice(0, SALT_LENGTH_MD5);
+		return storedHash === hashAlgorithms[HASH_FUNCTION.MD5](password, salt);
+	},
+
+	[HASH_FUNCTION.SHA256]: (storedHash: string, password: string) => {
+		const salt = storedHash.slice(0, SALT_LENGTH);
+		return storedHash === hashAlgorithms[HASH_FUNCTION.SHA256](password, salt);
+	},
+
+	[HASH_FUNCTION.ARGON2ID]: async (storedHash: string, password: string) => {
+		return await argon2.verify(storedHash.slice(SALT_LENGTH), password);
+	},
+};
+
+/**
+ * Create a hash for the given password (MD5, SHA-256 or argon2id)
+ * @param password Plain text password
+ * @param algorithm Hashing algorithm to use (default: SHA-256)
+ */
+export function hash(
+	password: string,
+	algorithm: HashFunction = HASH_FUNCTION[configuredHashFunction?.toUpperCase()] ?? HASH_FUNCTION.SHA256
+): string | Promise<string> {
+	return hashAlgorithms[algorithm](password);
+}
+
+/**
+ * Validate a password against a stored hash
+ * @param storedHash Previously generated hash
+ * @param password Plain text password to validate
+ * @param algorithm Hashing algorithm to use (default: SHA-256)
+ */
+export function validate(
+	storedHash: string,
+	password: string,
+	algorithm: HashFunction = HASH_FUNCTION[configuredHashFunction?.toUpperCase()] ?? HASH_FUNCTION.SHA256
+): boolean | Promise<boolean> {
+	if (!storedHash) return false;
+
+	return validateAlgorithms[algorithm](storedHash, password);
+}

package/utility/processManagement/processManagement.js

@@ -0,0 +1,187 @@
+'use strict';
+
+const hdbTerms = require('../hdbTerms.ts');
+const servicesConfig = require('./servicesConfig.js');
+const envMangr = require('../environment/environmentManager.js');
+const hdbLogger = require('../../utility/logging/harper_logger.js');
+const { onMessageFromWorkers } = require('../../server/threads/manageThreads.js');
+const fs = require('fs');
+const path = require('node:path');
+const { setTimeout: delay } = require('node:timers/promises');
+const { execFile, fork } = require('node:child_process');
+
+module.exports = {
+	start,
+	restart,
+	kill,
+	startService,
+	getHdbPid,
+	isProcessRunning,
+	cleanupChildrenProcesses,
+	expectedRestartOfChildren,
+};
+
+onMessageFromWorkers((message) => {
+	if (message.type === 'restart') envMangr.initSync(true);
+});
+
+let childProcesses = [];
+const MAX_RESTARTS = 10;
+let shuttingDown;
+/**
+ * Starts a service
+ * @param procConfig
+ * @returns void
+ */
+function start(procConfig, noKill = false) {
+	const args = typeof procConfig.args === 'string' ? procConfig.args.split(' ') : procConfig.args;
+	procConfig.silent = true;
+	procConfig.detached = true;
+	procConfig.env = {
+		...procConfig.env,
+		HARPER_PARENT_PROCESS_PID: process.pid.toString(),
+	};
+	const subprocess = procConfig.script
+		? fork(procConfig.script, args, procConfig)
+		: execFile(procConfig.binFile, args, procConfig);
+	subprocess.name = procConfig.name;
+	subprocess.config = procConfig;
+	subprocess.on('error', (code, message) => {
+		console.error(code, message);
+	});
+	subprocess.on('exit', async (code) => {
+		let index = childProcesses.indexOf(subprocess); // dead, remove it from processes to kill now
+		if (index > -1) childProcesses.splice(index, 1);
+		if (!shuttingDown && code !== 0) {
+			procConfig.restarts = (procConfig.restarts || 0) + 1;
+			// restart the child process
+			if (procConfig.restarts < MAX_RESTARTS) {
+				start(procConfig);
+			}
+		}
+	});
+
+	subprocess.stdout.on('data', (log) => hdbLogger.info(log.toString()));
+	subprocess.stderr.on('data', (log) => hdbLogger.error(log.toString()));
+	subprocess.unref();
+
+	// if we are running in standard mode, then we want to clean up our child processes when we exit
+	if (childProcesses.length === 0) {
+		if (!noKill) {
+			process.on('exit', cleanupChildrenProcesses);
+			process.on('SIGINT', cleanupChildrenProcesses);
+			process.on('SIGQUIT', cleanupChildrenProcesses);
+			process.on('SIGTERM', cleanupChildrenProcesses);
+		}
+	}
+	childProcesses.push(subprocess);
+}
+function cleanupChildrenProcesses(exit = true) {
+	if (shuttingDown) return;
+	shuttingDown = true;
+	if (childProcesses.length === 0) return;
+	hdbLogger.info('Killing child processes...');
+	childProcesses.map((proc) => proc.kill());
+	if (exit) process.exit(0);
+	else return delay(2000); // give these processes some time to exit
+}
+
+/**
+ * restart processes
+ * @param serviceName
+ * @returns {Promise<unknown>}
+ */
+function restart(serviceName) {
+	expectedRestartOfChildren();
+	for (let childProcess of childProcesses) {
+		// kill the child process and let it (auto) restart
+		if (childProcess.name === serviceName) {
+			childProcess.kill();
+		}
+	}
+}
+
+/**
+ * Reset the restart counts for all child processes because we are doing an intentional restart
+ */
+function expectedRestartOfChildren() {
+	for (let childProcess of childProcesses) {
+		if (childProcess.config) childProcess.config.restarts = 0; // reset the restart count
+	}
+}
+
+/**
+ * Checks to see if Harper is currently running, returning the pid if it is
+ * @returns {number|undefined}
+ */
+function getHdbPid() {
+	const harperPath = envMangr.getHdbBasePath();
+	if (!harperPath) return;
+	const pidFile = path.join(harperPath, hdbTerms.HDB_PID_FILE);
+	const hdbPid = readPidFile(pidFile);
+	// If the pid file doesn't exist or the pid is the same as the current process, return.
+	// In a Docker container, the pid is usually 1, and so if a previous process crashed, there will still
+	// be a pid file with 1, even though this process is also 1 (and is running, but is not another harper process).
+	if (!hdbPid || hdbPid === process.pid) return;
+	if (isProcessRunning(hdbPid)) return hdbPid;
+	// return undefined
+}
+function kill() {
+	for (let process of childProcesses) {
+		process.kill();
+	}
+	childProcesses = [];
+	return;
+}
+
+/**
+ * start a specific service
+ * @param serviceName
+ * @returns {Promise<void>}
+ */
+async function startService(serviceName, noKill = false) {
+	let startConfig;
+	serviceName = serviceName.toLowerCase();
+	switch (serviceName) {
+		case hdbTerms.PROCESS_DESCRIPTORS.HDB.toLowerCase():
+			startConfig = servicesConfig.generateMainServerConfig();
+			break;
+		default:
+			throw new Error(`Start service called with unknown service config: ${serviceName}`);
+	}
+	start(startConfig, noKill);
+}
+
+/**
+ * Reads the Harper PID file and returns the PID as a number.
+ * @param {string} pidFile - The path to the Harper PID file
+ * @returns {number|null} - The PID as a number, or null if the file is not found or cannot be read
+ */
+function readPidFile(pidFile) {
+	try {
+		return Number.parseInt(fs.readFileSync(pidFile, 'utf8'), 10);
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Checks if a process is running by attempting to send a signal 0 to the process.
+ * @param {number} pid - The process ID to check
+ * @returns {boolean} - True if the process is running, false otherwise
+ */
+function isProcessRunning(pid) {
+	try {
+		// process.kill with signal 0 tests if process exists
+		// throws error if process doesn't exist
+		process.kill(pid, 0);
+		return true;
+	} catch (err) {
+		// EPERM means process exists but we don't have permission
+		// which still indicates the process is running
+		if (err.code === 'EPERM') {
+			return true;
+		}
+		return false;
+	}
+}

package/utility/processManagement/servicesConfig.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const hdbTerms = require('../hdbTerms.ts');
+const path = require('path');
+const { PACKAGE_ROOT } = require('../../utility/packageUtils.js');
+const hdbUtils = require('../common_utils.js');
+const SCRIPTS_DIR = path.join(PACKAGE_ROOT, 'utility/scripts');
+const RESTART_SCRIPT = path.join(SCRIPTS_DIR, hdbTerms.HDB_RESTART_SCRIPT);
+
+function generateMainServerConfig() {
+	const envVars = {
+		[hdbTerms.PROCESS_NAME_ENV_PROP]: hdbTerms.PROCESS_DESCRIPTORS.HDB,
+		IS_SCRIPTED_SERVICE: true,
+		...process.env,
+	};
+	if (hdbUtils.noBootFile()) envVars[hdbTerms.CONFIG_PARAMS.ROOTPATH.toUpperCase()] = hdbUtils.getEnvCliRootPath();
+
+	return {
+		name: hdbTerms.PROCESS_DESCRIPTORS.HDB,
+		script: hdbTerms.LAUNCH_SERVICE_SCRIPTS.MAIN,
+		exec_mode: 'fork',
+		env: envVars,
+		execArgv: process.execArgv,
+		cwd: PACKAGE_ROOT,
+	};
+}
+
+function generateRestart() {
+	const envVars = { [hdbTerms.PROCESS_NAME_ENV_PROP]: hdbTerms.PROCESS_DESCRIPTORS.RESTART_HDB };
+	if (hdbUtils.noBootFile()) envVars[hdbTerms.CONFIG_PARAMS.ROOTPATH.toUpperCase()] = hdbUtils.getEnvCliRootPath();
+	const restartConfig = {
+		name: hdbTerms.PROCESS_DESCRIPTORS.RESTART_HDB,
+		exec_mode: 'fork',
+		env: envVars,
+		instances: 1,
+		autorestart: false,
+		cwd: SCRIPTS_DIR,
+	};
+
+	return {
+		...restartConfig,
+		script: RESTART_SCRIPT,
+	};
+}
+
+function generateAllServiceConfigs() {
+	return {
+		apps: [generateMainServerConfig()],
+	};
+}
+
+module.exports = {
+	generateAllServiceConfigs,
+	generateMainServerConfig,
+	generateRestart,
+};

package/utility/scripts/restartHdb.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const pm2Utils = require('../processManagement/processManagement.js');
+const hdbTerms = require('../hdbTerms.ts');
+
+/**
+ * Gets a list of all the running Harper processes and calls reload on each one.
+ * NOTE: Calling reload on the "Harper" service was causing only some of the processes to restart so I went with the
+ * loop and call each individual process approach. I also needed to be sure all processes had been reloaded before calling delete.
+ */
+(async function () {
+	try {
+		const hdbProcessMeta = await pm2Utils.describe(hdbTerms.PROCESS_DESCRIPTORS.HDB);
+		for (const proc of hdbProcessMeta) {
+			await pm2Utils.reload(proc.pm_id);
+		}
+
+		await pm2Utils.deleteProcess(hdbTerms.PROCESS_DESCRIPTORS.RESTART_HDB);
+		// Once this script has finished reloading all the Harper processes, delete this process from processManagement.
+	} catch (err) {
+		console.error(err);
+		throw err;
+	}
+})();

package/utility/scripts/user_data.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+echo "##### Start of user_data.sh #####"
+
+# Create and enable a 2GB swap file
+dd if=/dev/zero of=/swapfile bs=128M count=16
+chmod 600 /swapfile
+mkswap /swapfile
+swapon /swapfile
+echo "/swapfile swap swap defaults 0 0" | tee -a /etc/fstab
+
+# Adjust the per-user open file limits
+echo "ubuntu soft nofile 1000000" | tee -a /etc/security/limits.conf
+echo "ubuntu hard nofile 1000000" | tee -a /etc/security/limits.conf

package/utility/signalling.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const hdbTerms = require('./hdbTerms.ts');
+const hdbLogger = require('../utility/logging/harper_logger.js');
+const ITCEventObject = require('../server/itc/utility/ITCEventObject.js');
+let serverItcHandlers;
+const { sendItcEvent } = require('../server/threads/itc.js');
+
+function signalSchemaChange(message) {
+	try {
+		hdbLogger.debug('signalSchemaChange called with message:', message);
+		serverItcHandlers = serverItcHandlers || require('../server/itc/serverHandlers.js');
+		const itcEventSchema = new ITCEventObject(hdbTerms.ITC_EVENT_TYPES.SCHEMA, message);
+		serverItcHandlers.schema(itcEventSchema);
+		return sendItcEvent(itcEventSchema);
+	} catch (err) {
+		hdbLogger.error(err);
+	}
+}
+
+function signalUserChange(message) {
+	try {
+		hdbLogger.trace('signalUserChange called with message:', message);
+		serverItcHandlers = serverItcHandlers || require('../server/itc/serverHandlers.js');
+		const itcEventUser = new ITCEventObject(hdbTerms.ITC_EVENT_TYPES.USER, message);
+		serverItcHandlers.user(itcEventUser);
+		return sendItcEvent(itcEventUser);
+	} catch (err) {
+		hdbLogger.error(err);
+	}
+}
+
+module.exports = {
+	signalSchemaChange,
+	signalUserChange,
+};

package/utility/terms/certificates.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const CERTIFICATE_VALUES = {
+	cert: '-----BEGIN CERTIFICATE-----\rMIIDXDCCAkSgAwIBAgIFNTE4MzQwDQYJKoZIhvcNAQELBQAwXTEXMBUGA1UEAxMO\rSGFycGVyREIsIEluYy4xCzAJBgNVBAYTAlVTMQswCQYDVQQIEwJDTzEPMA0GA1UE\rBxMGRGVudmVyMRcwFQYDVQQKEw5IYXJwZXJEQiwgSW5jLjAeFw0yMjAzMTEyMzAz\rNDlaFw0yNzAzMTAyMzAzNDlaMF0xFzAVBgNVBAMTDkhhcnBlckRCLCBJbmMuMQsw\rCQYDVQQGEwJVUzELMAkGA1UECBMCQ08xDzANBgNVBAcTBkRlbnZlcjEXMBUGA1UE\rChMOSGFycGVyREIsIEluYy4wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB\rAQCsEUlBF8WImS78rCFXVKyntxfrW++4qZ3hGnoD2MHZAuDHyeP/5eGnaE9GQhKc\r4DwG4DGvh0wP2zIYnBfiQ3L2ZtnlDR9ZkKIQYGlVxTUn6T43krhK5nZKqDF43Yg3\rZEvO3cbJBjiKZx0eA2/toehdSsTAHHQx5gTDcggNe2tgoJHYPwi9YF/AxSBZrbgb\ryWlYgtYDmF32ytHP03GUCIdKOFuBPsHTGu4SkdEIdLIqO9oglW1YFH5qZ6NiwApW\rsP+GCuqOwDXXbdjr75iq9Tq/CDrjGFLaTPmvd2Q0qG/BtaCll0ghpG+yIHvt/iQs\rajS+LxEWAnVlGMaDdFErbDUtAgMBAAGjIzAhMA8GA1UdEwEB/wQFMAMBAf8wDgYD\rVR0PAQH/BAQDAgIEMA0GCSqGSIb3DQEBCwUAA4IBAQASR4YW/rPK7PNArHVe9zzM\rb0rKNX/2T9/0nybRhmE/+hdlSgliTAeebmwkUS2APckmekYt/q2ZY2NS65Fo/jjp\rG8TJrtcF4h+ylVqUp0ZXQLFtIsr7r2JZA7hJ6njW6G4DHSZ0gxtECLi4CBlTjzm5\rNmnmIDObvGRTuqmcdAZmXeObbta/He2XIzietukPAYX062pNM+G5XT5UM1eG/Vlp\rN86vjhpyI+ffKy+C60SJqxmKM3ydgN7oLscE7+2wLPN25XqN4W99OwGsp5dTdu/f\r5lPtFayXdJ55e/sNQKmGN+UGLrL05c2MWgjb8U/LFilnupUianceoeSERZmVjzKX\r-----END CERTIFICATE-----\r'.replace(
+		/\r/g,
+		String.fromCharCode(13, 10)
+	),
+	key: '-----BEGIN RSA PRIVATE KEY-----\rMIIEowIBAAKCAQEArBFJQRfFiJku/KwhV1Ssp7cX61vvuKmd4Rp6A9jB2QLgx8nj\r/+Xhp2hPRkISnOA8BuAxr4dMD9syGJwX4kNy9mbZ5Q0fWZCiEGBpVcU1J+k+N5K4\rSuZ2SqgxeN2IN2RLzt3GyQY4imcdHgNv7aHoXUrEwBx0MeYEw3IIDXtrYKCR2D8I\rvWBfwMUgWa24G8lpWILWA5hd9srRz9NxlAiHSjhbgT7B0xruEpHRCHSyKjvaIJVt\rWBR+amejYsAKVrD/hgrqjsA1123Y6++YqvU6vwg64xhS2kz5r3dkNKhvwbWgpZdI\rIaRvsiB77f4kLGo0vi8RFgJ1ZRjGg3RRK2w1LQIDAQABAoIBAQCEOmh78EOpnGZC\rYBjjHrvrysVD5gvLcfVUtl8Ls7gMB60re1eOIF+PoZZCHKZnDd6zPfiQtj1adg0C\rYnnsM/8VoaZS4gm0b3RLd3ubIQifWhuo40RissY2yxfxlPSH9LhZCY8ojnJG0cTL\resK579E8WCfopjUY33XLqEbN7Ylv39J+DSqInjqV3efJZUa+HqUJ98VxxzodcKMD\rP3bwUU4gHoSSp4pAsOFH5sQhaIWH1IcNjrAwpee2cJQuh4G157RRIuuUpagtaEG/\rXJIiAyBguJyu3JQFnIBQF01N5+omJgXYJ1L0m54543/iIRThmF3zDCDgCyUzmOk+\rH6As9fv1AoGBANOpOtOZLSAScjGsgJamT3ceJ2wCa86g2j8Oxu8lJUmUp5s3tA0v\rBFW5O3S4KR1EXwkLMBUMrfFM8YvzHWxsXBI6XV8azGLvyqPHxr65OhmpGYkGZMXu\rn9okgjkqlewnY2I073gvyK7ppX51UL5y9fF1vlsk+UlW+Rgx/vMHbdcjAoGBANAc\rxRUsxs4QJpbS4zD3JOkHjr24a97TrS3kCybAHUMpR2NrEHPZw9zex0/aphOJUHfL\rIMkOZdpfDqMfxWy4FAEmqBEMkO2SB+h0Wp4P+qp81ax4vGFiB0cD3wtixr11U1tt\rlZ/ZTdv4VDpDFNK1KaplhTDeyuCjeYfS3/GJia9vAoGAcOsAgjBevZR5rXx84WH6\rVO8WUu37u7FenXNxt9VWTinrPMh72uixZFY8nOk+rely1e1NCn3IMko9Ns9NbDFm\r8SaH95vhXArXTYbfxZIlp9jp0YtCqcHDL+p4Oq04bFMbFyJseu7rHj1x18QYfnHw\rOY/6LL/N6k1m+Hx7qgXVmIcCgYB/w0nTCBw84XlvWqSTqQaF8VfWbWP79mP5KmkW\rLxdH5g2noVEGbohqDnK6OXd/wusdwByukiJBf94Skyy25AOT+VFwthA7aU1ljhkb\rtJ+lDuJ28eBkwLPLCzthWBC+u0qjdJFJAzVjd/7tjcU43nNn4s90AzL12iaAFhvZ\rwyA+DQKBgGc/4cdyGJ3YkcA8150gQBawgJZ7q8V1JND87ggWA8wnK3cHn7rMZQl2\r3emDp9HEFXFex5dbGDDqZFAoesZCDxjknIn9oNfW4PvaWS8q7b6ZKLZG1p03Pu7/\rtYaD0kPbo0kysfFT/co+NgHbdykvIyboomfGdNLTUjYuy6lpwpvs\r-----END RSA PRIVATE KEY-----\r'.replace(
+		/\r/g,
+		String.fromCharCode(13, 10)
+	),
+};
+
+const CERTIFICATE_PEM_NAME = 'certificate.pem';
+const PRIVATEKEY_PEM_NAME = 'privateKey.pem';
+const CA_PEM_NAME = 'caCertificate.pem';
+
+const CERT_NAME = {
+	'DEFAULT': 'default',
+	'DEFAULT-CA': 'default-ca',
+	'SERVER': 'server',
+	'CA': 'ca',
+	'OPERATIONS-API': 'operations-api',
+	'OPERATIONS-CA': 'operations-ca',
+};
+
+const CERT_CONFIG_NAME_MAP = {
+	tls_certificate: CERT_NAME.SERVER,
+	tlsCertificateAuthority: CERT_NAME.CA,
+	customFunctions_tls_certificate: CERT_NAME.SERVER,
+	customFunctionsTlsCertificateAuthority: CERT_NAME.CA,
+	operationsApi_tls_certificate: CERT_NAME['OPERATIONS-API'],
+	operationsApiTlsCertificateAuthority: CERT_NAME['OPERATIONS-CA'],
+};
+
+const CERT_PREFERENCE_APP = {
+	[CERT_NAME.SERVER]: 2,
+	[CERT_NAME.DEFAULT]: 1,
+};
+
+const CERT_PREFERENCE_OPS = {
+	[CERT_NAME['OPERATIONS-API']]: 3,
+	[CERT_NAME.SERVER]: 2,
+	[CERT_NAME.DEFAULT]: 1,
+};
+
+const CERT_PREFERENCE_REP = {
+	[CERT_NAME['OPERATIONS-API']]: 3,
+	[CERT_NAME.SERVER]: 2,
+	[CERT_NAME.DEFAULT]: 1,
+};
+
+const CA_CERT_PREFERENCE_REP = {
+	[CERT_NAME['OPERATIONS-CA']]: 3,
+	[CERT_NAME.CA]: 2,
+	[CERT_NAME['DEFAULT-CA']]: 1,
+};
+
+const CA_CERT_PREFERENCE_OPS = {
+	[CERT_NAME['OPERATIONS-CA']]: 3,
+	[CERT_NAME.CA]: 2,
+	[CERT_NAME['DEFAULT-CA']]: 1,
+};
+
+const CA_CERT_PREFERENCE_APP = {
+	[CERT_NAME.CA]: 2,
+	[CERT_NAME['DEFAULT-CA']]: 1,
+};
+
+exports.CERTIFICATE_PEM_NAME = CERTIFICATE_PEM_NAME;
+exports.PRIVATEKEY_PEM_NAME = PRIVATEKEY_PEM_NAME;
+exports.CA_PEM_NAME = CA_PEM_NAME;
+exports.CERT_NAME = CERT_NAME;
+exports.CERT_CONFIG_NAME_MAP = CERT_CONFIG_NAME_MAP;
+exports.CERT_PREFERENCE_APP = CERT_PREFERENCE_APP;
+exports.CERT_PREFERENCE_OPS = CERT_PREFERENCE_OPS;
+exports.CERT_PREFERENCE_REP = CERT_PREFERENCE_REP;
+exports.CA_CERT_PREFERENCE_REP = CA_CERT_PREFERENCE_REP;
+exports.CA_CERT_PREFERENCE_OPS = CA_CERT_PREFERENCE_OPS;
+exports.CA_CERT_PREFERENCE_APP = CA_CERT_PREFERENCE_APP;
+exports.CERTIFICATE_VALUES = CERTIFICATE_VALUES;

package/utility/when.ts

@@ -0,0 +1,20 @@
+import type { RequestTarget, RequestTargetOrId } from '../resources/RequestTarget.ts';
+
+// wait for a promise or plain object to resolve
+export function when<T, R>(
+	value: T | Promise<T>,
+	callback: (value: T) => R,
+	reject?: (error: any) => void
+): R | Promise<R | void> {
+	if ((value as Promise<T>)?.then) {
+		return (value as Promise<T>).then(callback, reject);
+	}
+	return callback(value as T);
+}
+
+export function promiseNormalize<T>(returnValue: T | Promise<T>, target: RequestTargetOrId): T | Promise<T> {
+	if (!(returnValue as Promise<T>)?.then && !(target as RequestTarget)?.syncAllowed) {
+		return Promise.resolve(returnValue);
+	}
+	return returnValue;
+}

package/v1.d.ts

@@ -0,0 +1,39 @@
+export { Resource } from './resources/Resource.ts';
+export type {
+	Context,
+	Query,
+	RequestTargetOrId,
+	Session,
+	SourceContext,
+	SubscriptionRequest,
+} from './resources/ResourceInterface.ts';
+export { ResourceInterface } from './resources/ResourceInterface.ts';
+export type { User } from './security/user.ts';
+export type { RecordObject } from './resources/RecordEncoder.ts';
+export type { IterableEventQueue } from './resources/IterableEventQueue.ts';
+export { RequestTarget } from './resources/RequestTarget.ts';
+export { server } from './server/Server';
+export { tables, databases, type Table } from './resources/databases.ts';
+export type { Attribute } from './resources/Table.ts';
+
+import type { Logger } from './components/Logger.ts';
+declare const logger: Logger;
+export { type Logger, logger };
+
+export type { Scope } from './components/Scope.ts';
+export type { FilesOption, FilesOptionObject } from './components/deriveGlobOptions.ts';
+export type { FileAndURLPathConfig } from './components/Component.ts';
+export { OptionsWatcher, type Config, type ConfigValue } from './components/OptionsWatcher.ts';
+export {
+	EntryHandler,
+	type BaseEntry,
+	type FileEntry,
+	type EntryEvent,
+	type AddFileEvent,
+	type ChangeFileEvent,
+	type UnlinkFileEvent,
+	type FileEntryEvent,
+	type AddDirectoryEvent,
+	type UnlinkDirectoryEvent,
+	type DirectoryEntryEvent,
+} from './components/EntryHandler.ts';

package/v1.js

@@ -0,0 +1,41 @@
+const workerThreads = require('node:worker_threads');
+if (!workerThreads.isMainThread) {
+	// Prevents server from starting in worker threads if this was directly imported from a non-server user thread
+	if (!workerThreads.workerData) workerThreads.workerData = {};
+	workerThreads.workerData.noServerStart = true;
+}
+const { globals } = require('./server/threads/threadServer.js');
+
+// exported types are needed for parsing as well
+exports.Attribute = undefined;
+exports.Config = undefined;
+exports.ConfigValue = undefined;
+exports.Context = undefined;
+exports.FileAndURLPathConfig = undefined;
+exports.FilesOption = undefined;
+exports.FilesOptionObject = undefined;
+exports.IterableEventQueue = undefined;
+exports.Logger = undefined;
+exports.Query = undefined;
+exports.RecordObject = undefined;
+exports.RequestTarget = undefined;
+exports.RequestTargetOrId = undefined;
+exports.Resource = undefined;
+exports.ResourceInterface = undefined;
+exports.Scope = undefined;
+exports.Session = undefined;
+exports.SourceContext = undefined;
+exports.SubscriptionRequest = undefined;
+exports.Table = undefined;
+exports.User = undefined;
+
+// these are all overwritten by the globals, but need to be here so that Node's static
+// exports parser can analyze them
+exports.tables = {};
+exports.databases = {};
+exports.getUser = undefined;
+exports.server = {};
+exports.contentTypes = null;
+exports.threads = [];
+exports.logger = {};
+Object.assign(exports, globals);