@harperfast/harper 5.0.25 → 5.1.0-beta.1

package/server/serverHelpers/contentTypes.ts

@@ -2,17 +2,18 @@ import { streamAsJSON, stringify, parse } from './JSONStream.ts';
 import { pack, unpack, encodeIter } from 'msgpackr';
 import { decode, Encoder, EncoderStream } from 'cbor-x';
 import { createBrotliCompress, brotliCompress, constants } from 'zlib';
-import { ClientError } from '../../utility/errors/hdbError.js';
+import { ClientError } from '../../utility/errors/hdbError.ts';
 import stream, { Readable, Transform } from 'node:stream';
 import { server } from '../Server.ts';
 import { _assignPackageExport } from '../../globals.js';
-import envMgr from '../../utility/environment/environmentManager.js';
+import * as envMgr from '../../utility/environment/environmentManager.ts';
 import { CONFIG_PARAMS } from '../../utility/hdbTerms.ts';
 import * as YAML from 'yaml';
 import { logger } from '../../utility/logging/logger.ts';
 import { Blob } from '../../resources/blob.ts';
 // TODO: Only load this if fastify is loaded
 import fp from 'fastify-plugin';
+import { parseMultipartRequest } from './multipartParser.ts';
 const SERIALIZATION_BIGINT = envMgr.get(CONFIG_PARAMS.SERIALIZATION_BIGINT) !== false;
 const JSONStringify = SERIALIZATION_BIGINT ? stringify : JSON.stringify;
 const JSONParse = SERIALIZATION_BIGINT ? parse : JSON.parse;
@@ -36,14 +37,14 @@ const mediaTypes = new Map<
 >();
 
 export const contentTypes = mediaTypes;
-server.contentTypes = contentTypes;
+server.contentTypes = contentTypes as any;
 _assignPackageExport('contentTypes', contentTypes);
 // TODO: Make these monomorphic for faster access. And use a Map
 mediaTypes.set('application/json', {
 	serializeStream: streamAsJSON,
 	serialize: JSONStringify,
 	deserialize(data) {
-		return JSONParse(data);
+		return JSONParse(data as any);
 	},
 	q: 0.8,
 });
@@ -60,7 +61,7 @@ mediaTypes.set('application/cbor', {
 mediaTypes.set('application/x-msgpack', {
 	serializeStream(data: any) {
 		if ((data?.[Symbol.iterator] || data?.[Symbol.asyncIterator]) && !Array.isArray(data)) {
-			return Readable.from(encodeIter(data, PUBLIC_ENCODE_OPTIONS));
+			return Readable.from(encodeIter(data, PUBLIC_ENCODE_OPTIONS) as any);
 		}
 		return pack(data);
 	},
@@ -101,6 +102,29 @@ mediaTypes.set('text/yaml', {
 	q: 0.7,
 });
 
+const ndjsonHandler = {
+	serializeStream(data: any) {
+		if (data?.[Symbol.iterator] || data?.[Symbol.asyncIterator]) {
+			return Readable.from(transformIterable(data, (msg: any) => JSONStringify(msg) + '\n'));
+		}
+		return JSONStringify(data) + '\n';
+	},
+	serialize(data: any) {
+		return JSONStringify(data) + '\n';
+	},
+	deserialize(data: Buffer) {
+		return data
+			.toString()
+			.split('\n')
+			.map((line) => line.trim())
+			.filter(Boolean)
+			.map((line) => JSONParse(line));
+	},
+	q: 0.7,
+};
+mediaTypes.set('application/x-ndjson', ndjsonHandler);
+mediaTypes.set('application/ndjson', ndjsonHandler);
+
 mediaTypes.set('text/event-stream', {
 	// Server-Sent Events (SSE)
 	serializeStream: function (iterable) {
@@ -196,7 +220,7 @@ export function registerContentHandlers(app) {
 				regex: /^application\/(x-)?msgpack$/,
 				serializer: function (data) {
 					if ((data?.[Symbol.iterator] || data?.[Symbol.asyncIterator]) && !Array.isArray(data)) {
-						return Readable.from(encodeIter(data, PUBLIC_ENCODE_OPTIONS));
+						return Readable.from(encodeIter(data, PUBLIC_ENCODE_OPTIONS) as any);
 					}
 					return pack(data);
 				},
@@ -227,6 +251,13 @@ export function registerContentHandlers(app) {
 			done(error);
 		}
 	});
+
+	// multipart/form-data is streamed: we hand the operation handler a Readable for the file
+	// part rather than buffering the body, so deploy_component payloads can exceed the 2 GB
+	// Node Buffer cap. See multipartParser.ts for the part ordering contract.
+	app.addContentTypeParser(/^multipart\/form-data/, (req, payload, done) => {
+		parseMultipartRequest(req, payload, done);
+	});
 }
 
 const registerFastifySerializers = fp(
@@ -299,7 +330,7 @@ export function findBestSerializer(incomingMessage) {
 			const quality = (serializer.q || 1) * clientQuality;
 			if (quality > bestQuality) {
 				bestSerializer = serializer;
-				bestType = serializer.type || type;
+				bestType = (serializer as any).type || type;
 				bestQuality = quality;
 				bestParameters = parameters;
 			}
@@ -421,11 +452,11 @@ export function serializeMessage(
 	try {
 		let serialized: Buffer | string;
 		if (request) {
-			let serialize = request.serialize;
+			let serialize = (request as any).serialize;
 			if (serialize) serialized = serialize(message);
 			else {
 				const serializer = findBestSerializer(request);
-				serialize = request.serialize = serializer.serializer.serialize;
+				serialize = (request as any).serialize = serializer.serializer.serialize;
 				serialized = serialize(message);
 			}
 		} else {
@@ -573,7 +604,7 @@ function deserializerUnknownType(contentType: ContentType): Deserialize {
 				// try to parse as JSON if no content type
 				try {
 					// if the first byte is `{` then it is likely JSON
-					if (data?.[0] === 123) return JSONParse(data);
+					if (data?.[0] === 123) return JSONParse(data as any);
 				} catch {
 					// continue if cannot parse as JSON
 				}
@@ -618,7 +649,7 @@ function transformIterable(iterable, transform) {
  * @param data
  * @returns stream
  */
-export function toCsvStream(data, columns) {
+export function toCsvStream(data, columns?) {
 	// ensure that we pass it an iterable
 	const readStream = stream.Readable.from(data?.[Symbol.iterator] || data?.[Symbol.asyncIterator] ? data : [data]);
 

package/server/serverHelpers/multipartParser.ts

@@ -0,0 +1,152 @@
+import busboy from 'busboy';
+import type { FastifyRequest } from 'fastify';
+import type { Readable } from 'node:stream';
+import { ClientError } from '../../utility/errors/hdbError.ts';
+import { logger } from '../../utility/logging/logger.ts';
+
+interface MultipartBody {
+	[key: string]: unknown;
+	payload?: Readable;
+}
+
+const FIELD_SIZE_LIMIT = 1024 * 1024; // 1 MB per non-file field — generous for JSON params
+const MAX_FIELDS = 64;
+// Operation handlers stream the file part directly into extraction (gunzip + tar-fs),
+// so there is no separate filesize cap to enforce here. Backpressure flows through busboy
+// → the file Readable → the consumer, bounded by disk space rather than memory.
+
+/**
+ * Parse a multipart/form-data request body for the operations API.
+ *
+ * Field parts populate properties on the returned body object; values that look like JSON
+ * (`{...}`, `[...]`, numbers, booleans, null) are decoded so the operations API sees the
+ * same shape it would from a JSON/CBOR body. The (optional) file part — by convention the
+ * last part, named `payload` — is exposed as a Readable on `body.payload` and streamed
+ * lazily by the operation handler; this lets us deploy components larger than the Node.js
+ * 2 GB Buffer cap.
+ *
+ * The CLI must place the file part LAST so all dispatching fields (`operation`, auth-
+ * relevant flags, etc.) have arrived by the time the route handler runs.
+ */
+export function parseMultipartRequest(
+	request: FastifyRequest,
+	rawStream: Readable,
+	done: (err: Error | null, body?: MultipartBody) => void
+): void {
+	const contentType = request.headers['content-type'];
+	if (!contentType) {
+		done(new ClientError('Missing Content-Type header', 400));
+		return;
+	}
+
+	let bb: ReturnType<typeof busboy>;
+	try {
+		bb = busboy({
+			headers: { 'content-type': contentType },
+			limits: {
+				fieldSize: FIELD_SIZE_LIMIT,
+				fields: MAX_FIELDS,
+				files: 1,
+			},
+		});
+	} catch (err) {
+		done(toClientError(err, 'Invalid multipart request'));
+		return;
+	}
+
+	const body: MultipartBody = {};
+	let fileSeen = false;
+	let doneCalled = false;
+
+	const callDone = (err: Error | null, value?: MultipartBody) => {
+		if (doneCalled) return;
+		doneCalled = true;
+		done(err, value);
+	};
+
+	bb.on('field', (name, value) => {
+		if (fileSeen) {
+			// Fields after the file part are out-of-order and ignored. We can't propagate them
+			// to the route handler — by the time busboy emits the event, `done` has already
+			// fired and the file stream has typically ended too. The CLI always sends fields
+			// first; this branch only fires on malformed/hand-crafted clients.
+			logger.warn?.(`Multipart field "${name}" arrived after the file part; ignoring`);
+			return;
+		}
+		body[name] = decodeFieldValue(value);
+	});
+
+	bb.on('file', (name, fileStream) => {
+		fileSeen = true;
+		if (name !== 'payload') {
+			// We only consume a single field named `payload`. Other file fields are an error
+			// rather than silently consumed — the CLI never sends them and accepting them
+			// would mask client bugs.
+			fileStream.resume(); // drain so busboy can finish
+			callDone(new ClientError(`Unexpected file field "${name}"; expected "payload"`, 400));
+			return;
+		}
+		body.payload = fileStream;
+		// Hand control to the route handler immediately — the file stream is now wired
+		// into body.payload and will be drained by extraction. busboy keeps pumping data
+		// out of rawStream as the consumer reads, providing natural backpressure.
+		callDone(null, body);
+	});
+
+	bb.on('error', (err) => {
+		callDone(toClientError(err, 'Malformed multipart body'));
+	});
+
+	bb.on('close', () => {
+		// If the request had no file part, the handler still needs to dispatch on the fields
+		// we collected (e.g. an operation that doesn't need a payload at all).
+		if (!doneCalled) callDone(null, body);
+	});
+
+	rawStream.on('error', (err) => {
+		const clientErr = toClientError(err, 'Request stream error');
+		// If `done` hasn't fired yet, the route handler hasn't started and this surfaces as a
+		// dispatch error. If it has — i.e. the file part is mid-stream — `callDone` is a no-op
+		// but the file Readable already handed out as `body.payload` is its own object that
+		// `bb.destroy()` does NOT propagate to. We have to destroy it explicitly, otherwise
+		// the consumer (`pipeline(tarball, gunzip(), extract(...))` in Application.ts) hangs
+		// until TCP keepalives close the socket. Node's `.pipe()` doesn't forward errors from
+		// source to destination either, hence we don't rely on it here.
+		callDone(clientErr);
+		const payload = body.payload as (Readable & { destroyed?: boolean }) | undefined;
+		if (payload && !payload.destroyed) payload.destroy(clientErr);
+		bb.destroy(clientErr);
+	});
+
+	rawStream.pipe(bb);
+}
+
+function decodeFieldValue(raw: string): unknown {
+	if (raw === '') return raw;
+	const first = raw.charCodeAt(0);
+	// Only attempt JSON parse for values that begin with a JSON sentinel — otherwise the
+	// overwhelming common case of a plain string identifier ("my-project") needlessly
+	// goes through a try/catch.
+	const looksLikeJson =
+		first === 0x7b /* { */ ||
+		first === 0x5b /* [ */ ||
+		first === 0x22 /* " */ ||
+		first === 0x2d /* - */ ||
+		(first >= 0x30 && first <= 0x39) /* 0-9 */ ||
+		raw === 'true' ||
+		raw === 'false' ||
+		raw === 'null';
+	if (!looksLikeJson) return raw;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return raw;
+	}
+}
+
+function toClientError(err: unknown, fallbackMessage: string): ClientError {
+	if (err instanceof ClientError) return err;
+	const message = err instanceof Error ? err.message : fallbackMessage;
+	logger.debug?.('Multipart parse error: ' + message);
+	return new ClientError(message || fallbackMessage, 400);
+}

package/server/serverHelpers/progressEmitter.ts

@@ -0,0 +1,110 @@
+import { PassThrough, Readable } from 'node:stream';
+
+export interface ProgressEvent {
+	event: string;
+	data: unknown;
+}
+
+export type ProgressListener = (event: ProgressEvent) => void;
+
+/**
+ * Lightweight pub-sub used to report phase/install/replicate events from a long-running
+ * operation back to the HTTP layer. We deliberately don't use Node's EventEmitter here:
+ * we only need broadcast semantics for a small set of event types, and we want the
+ * `emit(event, data)` shape that matches the SSE wire format directly.
+ */
+export class ProgressEmitter {
+	private listeners: ProgressListener[] = [];
+
+	emit(event: string, data: unknown): void {
+		// Snapshot before iteration so a listener that unsubscribes itself during dispatch
+		// doesn't shift indexes underneath us.
+		const snapshot = this.listeners.slice();
+		for (const listener of snapshot) {
+			try {
+				listener({ event, data });
+			} catch {
+				// A buggy listener must never break the operation. Swallow and continue.
+			}
+		}
+	}
+
+	subscribe(listener: ProgressListener): () => void {
+		this.listeners.push(listener);
+		return () => {
+			const i = this.listeners.indexOf(listener);
+			if (i !== -1) this.listeners.splice(i, 1);
+		};
+	}
+}
+
+/**
+ * Wrap a long-running operation so its progress events stream back as Server-Sent Events.
+ *
+ * The returned Readable emits one SSE message per `emitter.emit(...)` call, then a final
+ * `done` (or `error`) event with the operation's result, then ends. The caller is
+ * expected to set Content-Type: text/event-stream on the response.
+ */
+export function createSSEResponseStream(emitter: ProgressEmitter, operation: () => Promise<unknown>): Readable {
+	const stream = new PassThrough();
+	// Prime the stream with an SSE comment line so the response body is non-empty by the time
+	// Fastify starts piping. Without this, Fastify buffers the PassThrough's internal queue
+	// until its end and only flushes the final chunk to the wire — making intermediate
+	// progress events invisible to the client. The comment ": ..." is a valid SSE record
+	// that consumers ignore, so it's safe filler.
+	stream.write(`: stream open\n\n`);
+
+	let active = true;
+	let errorEmitted = false;
+	const unsubscribe = emitter.subscribe((event) => {
+		if (active) {
+			writeSSE(stream, event);
+			if (event.event === 'error') errorEmitted = true;
+		}
+	});
+
+	const cleanup = () => {
+		if (active) {
+			active = false;
+			unsubscribe();
+		}
+	};
+
+	// If the client disconnects (Ctrl-C, network drop) stop writing to the stream and
+	// release the emitter subscription so it doesn't accumulate for the operation lifetime.
+	stream.on('close', cleanup);
+	stream.on('end', cleanup);
+
+	operation()
+		.then((result) => {
+			if (active) writeSSE(stream, { event: 'done', data: { result } });
+		})
+		.catch((err) => {
+			// Only emit a framework-level error event if the operation itself didn't already
+			// emit one (with richer context like phase) through the emitter subscriber above.
+			if (active && !errorEmitted) {
+				writeSSE(stream, {
+					event: 'error',
+					data: {
+						message: err?.message ?? String(err),
+						code: err?.statusCode ?? err?.code,
+					},
+				});
+			}
+		})
+		.finally(() => {
+			cleanup();
+			stream.end();
+		});
+
+	return stream;
+}
+
+function writeSSE(stream: PassThrough, event: ProgressEvent): void {
+	const data = typeof event.data === 'string' ? event.data : JSON.stringify(event.data);
+	stream.write(`event: ${event.event}\n`);
+	for (const line of data.split(/\r?\n/)) {
+		stream.write(`data: ${line}\n`);
+	}
+	stream.write('\n');
+}

package/server/serverHelpers/serverHandlers.js

@@ -1,20 +1,35 @@
 'use strict';
 
 const terms = require('../../utility/hdbTerms.ts');
-const hdbUtil = require('../../utility/common_utils.js');
-const harperLogger = require('../../utility/logging/harper_logger.js');
-const { handleHDBError, hdbErrors } = require('../../utility/errors/hdbError.js');
+const hdbUtil = require('../../utility/common_utils.ts');
+const harperLogger = require('../../utility/logging/harper_logger.ts');
+const { realExit } = require('../threads/workerProcessGuard.ts');
+const { handleHDBError, hdbErrors } = require('../../utility/errors/hdbError.ts');
 const { isMainThread } = require('worker_threads');
 const { Readable } = require('stream');
 
 const os = require('os');
-const util = require('util');
 
-const auth = require('../../security/fastifyAuth.js');
-const pAuthorize = util.promisify(auth.authorize);
+const auth = require('../../security/fastifyAuth.ts');
+
+// this is a hack to suppress a deprecation warning and can be removed once `auth.authorize`
+// is converted to an async function
+function pAuthorize(req, resp) {
+	return new Promise((resolve, reject) => {
+		auth.authorize(req, resp, (err, user) => (err ? reject(err) : resolve(user)));
+	});
+}
+
 const serverUtilities = require('./serverUtilities.ts');
 const { applyImpersonation } = require('../../security/impersonation.ts');
 const { createGzip, constants } = require('zlib');
+const { ProgressEmitter, createSSEResponseStream } = require('./progressEmitter.ts');
+
+// Operations that support `Accept: text/event-stream` for live progress streaming. The
+// handler attaches a ProgressEmitter as req.body.progress so the operation can emit phase
+// events; the response body is the SSE-encoded emitter output. Non-SSE clients see the
+// historical single-response shape because progress is undefined on that path.
+const SSE_PROGRESS_OPERATIONS = new Set([terms.OPERATIONS_ENUM.DEPLOY_COMPONENT, terms.OPERATIONS_ENUM.GET_DEPLOYMENT]);
 
 const NO_AUTH_OPERATIONS = [
 	terms.OPERATIONS_ENUM.CREATE_AUTHENTICATION_TOKENS,
@@ -28,7 +43,9 @@ function handleServerUncaughtException(err) {
 	}Terminating ${isMainThread ? 'HDB' : 'thread'}.`;
 	console.error(message);
 	harperLogger.fatal(message);
-	process.exit(1);
+	// Harper-intentional fatal termination on uncaught exception. Use realExit
+	// so the worker process guard does not intercept it.
+	realExit(1);
 }
 
 function serverErrorHandler(error, req, resp) {
@@ -119,6 +136,25 @@ async function handlePostRequest(req, res, _bypassAuth = false) {
 		if (req.body.bypass_auth) delete req.body.bypass_auth;
 
 		operation_function = serverUtilities.chooseOperation(req.body);
+
+		// SSE progress branch — when the client asks for `text/event-stream` on an operation
+		// that supports it, run the operation in the background and stream events back as they
+		// happen. The progress emitter is attached to req.body so the operation handler can
+		// emit without changing its return signature; non-SSE callers leave `progress`
+		// undefined and the handler stays on its synchronous result path.
+		// Optional-chained `req.headers` because unit tests dispatch through this path with
+		// synthetic req shapes that don't set headers; production Fastify requests always do.
+		// `Accept` parsing only checks for the text/event-stream token; allow comma-separated
+		// values like `text/event-stream, application/json` and quality params per RFC 7231.
+		if (req.headers?.accept?.includes('text/event-stream') && SSE_PROGRESS_OPERATIONS.has(req.body.operation)) {
+			const emitter = new ProgressEmitter();
+			req.body.progress = emitter;
+			res.header('Content-Type', 'text/event-stream');
+			res.header('Cache-Control', 'no-cache');
+			res.header('X-Accel-Buffering', 'no'); // disable proxy buffering so events flush in real time
+			return createSSEResponseStream(emitter, () => serverUtilities.processLocalTransaction(req, operation_function));
+		}
+
 		let result = await serverUtilities.processLocalTransaction(req, operation_function);
 		if (result instanceof Readable && result.headers) {
 			for (let [name, value] of result.headers) {

package/server/serverHelpers/serverUtilities.ts

@@ -1,47 +1,48 @@
-import search from '../../dataLayer/search.js';
-import bulkLoad from '../../dataLayer/bulkLoad.js';
-import schema from '../../dataLayer/schema.js';
-import schemaDescribe from '../../dataLayer/schemaDescribe.js';
-import delete_ from '../../dataLayer/delete.js';
-import readAuditLog from '../../dataLayer/readAuditLog.js';
+import * as search from '../../dataLayer/search.ts';
+import * as bulkLoad from '../../dataLayer/bulkLoad.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 * as user from '../../security/user.ts';
-import role from '../../security/role.js';
+import * as role from '../../security/role.ts';
 import customFunctionOperations from '../../components/operations.js';
-import harperLogger from '../../utility/logging/harper_logger.js';
-import readLog from '../../utility/logging/readLog.js';
-import export_ from '../../dataLayer/export.js';
-import opAuth from '../../utility/operation_authorization.js';
-import jobs from '../jobs/jobs.js';
+import harperLogger from '../../utility/logging/harper_logger.ts';
+import readLog from '../../utility/logging/readLog.ts';
+import * as export_ from '../../dataLayer/export.ts';
+import * as opAuth from '../../utility/operation_authorization.ts';
+import * as jobs from '../jobs/jobs.ts';
 import * as terms from '../../utility/hdbTerms.ts';
-import { hdbErrors, handleHDBError } from '../../utility/errors/hdbError.js';
+import { hdbErrors, handleHDBError } from '../../utility/errors/hdbError.ts';
 const { HTTP_STATUS_CODES } = hdbErrors;
-import restart from '../../bin/restart.js';
+import * as restart from '../../bin/restart.ts';
 import * as util from 'util';
-import insert from '../../dataLayer/insert.js';
-import globalSchema from '../../utility/globalSchema.js';
+import * as insert from '../../dataLayer/insert.ts';
+import * as globalSchema from '../../utility/globalSchema.ts';
 import { systemInformation } from '../../utility/environment/systemInformation.ts';
-import jobRunner from '../jobs/jobRunner.js';
+import * as jobRunner from '../jobs/jobRunner.ts';
 import * as tokenAuthentication from '../../security/tokenAuthentication.ts';
 import * as auth from '../../security/auth.ts';
 import configUtils from '../../config/configUtils.js';
-import transactionLog from '../../utility/logging/transactionLog.js';
-import npmUtilities from '../../utility/npmUtilities.js';
+import * as transactionLog from '../../utility/logging/transactionLog.ts';
+import * as npmUtilities from '../../utility/npmUtilities.ts';
 import { _assignPackageExport } from '../../globals.js';
-import { transformReq } from '../../utility/common_utils.js';
+import { transformReq } from '../../utility/common_utils.ts';
 import { server } from '../Server.ts';
 const operationLog = harperLogger.loggerWithTag('operation');
 import * as analytics from '../../resources/analytics/read.ts';
-import operationFunctionCaller from '../../utility/OperationFunctionCaller.js';
+import * as operationFunctionCaller from '../../utility/OperationFunctionCaller.ts';
 import type { OperationRequest, OperationRequestBody } from '../operationsServer.ts';
 import type { Context } from '../../resources/ResourceInterface.ts';
 import * as status from '../status/index.ts';
 import * as regDeprecated from '../../resources/registrationDeprecated.ts';
+import * as deploymentOperations from '../../components/deploymentOperations.ts';
 
 const pSearchSearch = util.promisify(search.search);
 let pEvaluateSql: (sql: string) => Promise<any>;
 function evaluateSQL(command) {
 	if (!pEvaluateSql) {
-		const sql = require('../../sqlTranslator/index.js');
+		const sql = require('../../sqlTranslator/index');
 		pEvaluateSql = util.promisify(sql.evaluateSQL);
 	}
 	return pEvaluateSql(command);
@@ -70,9 +71,9 @@ export async function processLocalTransaction(req: OperationRequest, operationFu
 	try {
 		if (
 			req.body.operation !== 'read_log' &&
-			(harperLogger.log_level === terms.LOG_LEVELS.INFO ||
-				harperLogger.log_level === terms.LOG_LEVELS.DEBUG ||
-				harperLogger.log_level === terms.LOG_LEVELS.TRACE)
+			(harperLogger.logLevel === terms.LOG_LEVELS.INFO ||
+				harperLogger.logLevel === terms.LOG_LEVELS.DEBUG ||
+				harperLogger.logLevel === terms.LOG_LEVELS.TRACE)
 		) {
 			// Need to remove auth variables, but we don't want to create an object unless
 			// the logging is actually going to happen.
@@ -103,7 +104,7 @@ export async function processLocalTransaction(req: OperationRequest, operationFu
 	return data;
 }
 
-const OPERATION_FUNCTION_MAP = initializeOperationFunctionMap();
+export const OPERATION_FUNCTION_MAP = initializeOperationFunctionMap();
 
 server.operation = operation;
 export type OperationDefinition = {
@@ -111,6 +112,7 @@ export type OperationDefinition = {
 	execute: (operation: any) => any | Promise<any>;
 	httpMethod?: 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE'; // method to use for REST
 	isJob?: boolean;
+	parametersSchema?: any[];
 };
 
 /**
@@ -118,7 +120,7 @@ export type OperationDefinition = {
  * @param operationDefinition
  */
 server.registerOperation = (operationDefinition: OperationDefinition) => {
-	OPERATION_FUNCTION_MAP.set(operationDefinition.name, new OperationFunctionObject(operationDefinition.execute));
+	OPERATION_FUNCTION_MAP.set(operationDefinition.name as any, new OperationFunctionObject(operationDefinition.execute));
 };
 
 export function chooseOperation(json: OperationRequestBody) {
@@ -136,7 +138,7 @@ export function chooseOperation(json: OperationRequestBody) {
 	// on all affected tables/attributes.
 	try {
 		if (json.operation === 'sql' || (json.search_operation && json.search_operation.operation === 'sql')) {
-			const sql = require('../../sqlTranslator/index.js');
+			const sql = require('../../sqlTranslator/index');
 			const sqlStatement = json.operation === 'sql' ? json.sql : json.search_operation.sql;
 			const parsedSqlObject = sql.convertSQLToAST(sqlStatement);
 			json.parsed_sql_object = parsedSqlObject;
@@ -186,7 +188,7 @@ export function chooseOperation(json: OperationRequestBody) {
 			}
 		}
 	} catch (err) {
-		throw handleHDBError(err, `There was an error when trying to choose an operation path`);
+		throw handleHDBError(err, `There was an error when trying to choose an operation path`, 500);
 	}
 	return operation_function;
 }
@@ -296,7 +298,7 @@ export async function executeJob(json: OperationRequestBody): Promise<JobResult>
 		const error = err instanceof Error ? err : null;
 		const message = `There was an error executing job: ${error && 'http_resp_msg' in error ? error.http_resp_msg : err}`;
 		operationLog.error(message);
-		throw handleHDBError(err, message);
+		throw handleHDBError(err, message, 500);
 	}
 }
 
@@ -445,6 +447,14 @@ function initializeOperationFunctionMap(): Map<OperationFunctionName, OperationF
 		terms.OPERATIONS_ENUM.DEPLOY_COMPONENT,
 		new OperationFunctionObject(customFunctionOperations.deployComponent)
 	);
+	opFuncMap.set(
+		terms.OPERATIONS_ENUM.LIST_DEPLOYMENTS,
+		new OperationFunctionObject(deploymentOperations.handleListDeployments)
+	);
+	opFuncMap.set(
+		terms.OPERATIONS_ENUM.GET_DEPLOYMENT,
+		new OperationFunctionObject(deploymentOperations.handleGetDeployment)
+	);
 	opFuncMap.set(
 		terms.OPERATIONS_ENUM.READ_TRANSACTION_LOG,
 		new OperationFunctionObject(transactionLog.readTransactionLog)