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

package/server/operationsServer.ts

@@ -0,0 +1,313 @@
+import cluster from 'cluster';
+import zlib from 'node:zlib';
+import env from '../utility/environment/environmentManager.js';
+env.initSync();
+import * as terms from '../utility/hdbTerms.ts';
+import harperLogger from '../utility/logging/harper_logger.js';
+import fastify, { FastifyInstance, FastifyReply, FastifyRequest, FastifyServerOptions } from 'fastify';
+import fastifyCors, { type FastifyCorsOptions } from '@fastify/cors';
+import fastifyCompress from '@fastify/compress';
+import fastifyStatic from '@fastify/static';
+import requestTimePlugin from './serverHelpers/requestTimePlugin.js';
+import guidePath from 'path';
+import { PACKAGE_ROOT } from '../utility/packageUtils.js';
+import globalSchema from '../utility/globalSchema.js';
+import commonUtils from '../utility/common_utils.js';
+import * as userSchema from '../security/user.ts';
+import { server as serverRegistration, type ServerOptions } from '../server/Server.ts';
+import {
+	authHandler,
+	authAndEnsureUserOnRequest,
+	handlePostRequest,
+	serverErrorHandler,
+	reqBodyValidationHandler,
+} from './serverHelpers/serverHandlers.js';
+import { registerContentHandlers } from './serverHelpers/contentTypes.ts';
+import type { OperationFunctionName } from './serverHelpers/serverUtilities.ts';
+import type { ParsedSqlObject } from '../sqlTranslator/index.js';
+import { generateJsonApi } from '../resources/openApi.ts';
+import { Resources } from '../resources/Resources.ts';
+import { ServerError } from '../utility/errors/hdbError.js';
+
+const DEFAULT_HEADERS_TIMEOUT = 60000;
+const REQ_MAX_BODY_SIZE = env.get(terms.CONFIG_PARAMS.OPERATIONSAPI_NETWORK_MAXREQUESTBODYSIZE) ?? 1024 * 1024 * 1024; //this defaults to 1GB in bytes
+const TRUE_COMPARE_VAL = 'TRUE';
+
+const { CONFIG_PARAMS } = terms;
+let server;
+
+export { operationsServer as hdbServer };
+export { operationsServer as start };
+
+/**
+ * Builds a Harper server.
+ */
+async function operationsServer(options: ServerOptions & { resources?: Resources }) {
+	try {
+		harperLogger.debug('In Fastify server' + process.cwd());
+		harperLogger.debug(`Running with NODE_ENV set as: ${process.env.NODE_ENV}`);
+		harperLogger.debug(`Harper server process ${process.pid} starting up.`);
+
+		global.clustering_on = false;
+		global.isMaster = cluster.isMaster;
+
+		await setUp();
+		// if we have a secure port, need to use the secure HTTP server for fastify (it can be used for HTTP as well)
+		const isHttps = options.securePort > 0;
+
+		//generate a Fastify server instance
+		server = buildServer(isHttps, options.resources);
+
+		//make sure the process waits for the server to be fully instantiated before moving forward
+		await server.ready();
+		if (!options) options = {};
+		options.usageType = 'operations-api';
+		// fastify can't clean up properly
+		try {
+			// now that server is fully loaded/ready, start listening on port provided in config settings or just use
+			// zero to wait for sockets from the main thread
+			serverRegistration.http(server.server, options);
+			if (!server.server.closeIdleConnections) {
+				// before Node v18, closeIdleConnections is not available, and we have to setup a listener for fastify
+				// to handle closing by setting up the dynamic port
+				await server.listen({ port: 0, host: '::' });
+			}
+		} catch (err) {
+			server.close();
+			harperLogger.error(err);
+			harperLogger.error(`Error configuring operations server`);
+			throw err;
+		}
+	} catch (err) {
+		console.error(`Failed to build server on ${process.pid}`, err);
+		harperLogger.fatal(err);
+		process.exit(1);
+	}
+}
+
+/**
+ * Makes sure global values are set and that clustering connections are set/ready before server starts.
+ */
+async function setUp() {
+	harperLogger.trace('Configuring Harper process.');
+	globalSchema.setSchemaDataToGlobal();
+	return userSchema.setUsersWithRolesCache();
+}
+
+export interface ImpersonatePayload {
+	username?: string;
+	role?: {
+		permission: Partial<userSchema.UserRoleNamedPermissions & userSchema.UserRoleDatabasePermissions>;
+	};
+	role_name?: string;
+}
+
+interface BaseOperationRequestBody {
+	operation: OperationFunctionName;
+	bypassAuth: boolean;
+	hdb_user?: userSchema.User;
+	hdbAuthHeader?: unknown;
+	bypass_auth?: boolean;
+	impersonate?: ImpersonatePayload;
+	password?: string;
+	payload?: string;
+	sql?: string;
+	parsedSqlObject?: ParsedSqlObject;
+	[key: string]: unknown;
+}
+
+type SearchOperation = BaseOperationRequestBody;
+
+interface SearchOperationRequestBody {
+	search_operation: SearchOperation;
+}
+
+export type OperationRequestBody = BaseOperationRequestBody & Partial<SearchOperationRequestBody>;
+
+export interface OperationRequest {
+	body: OperationRequestBody;
+}
+
+export interface OperationResult {
+	message?: any;
+}
+
+/**
+ * This method configures and returns a Fastify server - for either HTTP or HTTPS - based on the provided config settings
+ */
+function buildServer(isHttps: boolean, resources: Resources): FastifyInstance {
+	harperLogger.debug(`Harper process starting to build ${isHttps ? 'HTTPS' : 'HTTP'} server.`);
+	const serverOpts = getServerOptions(isHttps);
+
+	const app = fastify(serverOpts);
+
+	// Fastify does not set this property in the initial app construction
+	app.server.headersTimeout = getHeaderTimeoutConfig();
+
+	// Set a top-level error handler for the server - all errors caught/thrown within the API will bubble up to this
+	// handler so that they can be handled in a coordinated way
+	app.setErrorHandler(serverErrorHandler);
+
+	const corsOptions = getCORSOpts();
+	if (corsOptions) {
+		app.register(fastifyCors, corsOptions);
+	}
+
+	app.register(function (instance, options, done) {
+		instance.setNotFoundHandler(function (request, reply) {
+			if (reply.sent || reply.raw.headersSent || reply.raw.writableEnded) return;
+			app.server.emit('unhandled', request.raw, reply.raw);
+		});
+		done();
+	});
+
+	app.register(requestTimePlugin);
+
+	// This handles all get requests for the studio
+	app.register(fastifyCompress, {
+		brotliOptions: {
+			params: {
+				[zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT, // useful for APIs that primarily return text
+				[zlib.constants.BROTLI_PARAM_QUALITY]: 2, // default is 4, max is 11, min is 0
+			},
+		},
+	});
+	registerContentHandlers(app);
+
+	// Add a simple health check
+	app.get('/health', () => 'Harper is running.');
+
+	// Add a top-level GET handler for browsers.
+	app.register(fastifyStatic, { root: guidePath.join(PACKAGE_ROOT, 'studio/web') });
+	const studioOn = env.get(terms.HDB_SETTINGS_NAMES.LOCAL_STUDIO_ON);
+	if (!commonUtils.isEmpty(studioOn) && studioOn.toString().toLowerCase() === 'true') {
+		app.get('/', (req, res) => res.sendFile('index.html'));
+	} else {
+		app.get('/', (req, res) => res.sendFile('running.html'));
+	}
+
+	// Describe the APIs.
+	app.get('/api/openapi/rest', { preValidation: [authAndEnsureUserOnRequest] }, restOpenAPIHandler(resources));
+
+	// Add the top-level POST handler.
+	app.post<{ Body: OperationRequestBody }, { isOperation?: boolean }>(
+		'/',
+		{
+			preValidation: [reqBodyValidationHandler, authHandler],
+			config: { isOperation: true },
+		},
+		handler
+	);
+
+	harperLogger.debug(`Harper process starting up ${isHttps ? 'HTTPS' : 'HTTP'} server listener.`);
+
+	return app;
+}
+
+function restOpenAPIHandler(resources: Resources) {
+	const httpPort = env.get(terms.CONFIG_PARAMS.HTTP_PORT);
+	const httpSecurePort = env.get(terms.CONFIG_PARAMS.HTTP_SECUREPORT);
+	return (req: FastifyRequest & { hdb_user?: { role?: { permission?: { super_user: boolean } } } }) => {
+		if (req.hdb_user?.role?.permission?.super_user) {
+			return generateJsonApi(resources, calculateRestHttpURL(httpPort, httpSecurePort, req));
+		} else {
+			harperLogger.warn(
+				`{"ip":"${req.socket.remoteAddress}", "error":"attempt to access /api/openapi/rest without being super_user"`
+			);
+			return new ServerError(`Forbidden`, 403);
+		}
+	};
+}
+
+export function calculateRestHttpURL(
+	httpPort: string | undefined,
+	httpSecurePort: string | undefined,
+	req: { hostname: string; protocol: string }
+): string {
+	const httpURL = new URL(`${req.protocol}://${req.hostname}`);
+	// note that the request is from fastify, which doesn't seem to have a correct hostname property (includes port), so the URL needs to be used for hostname
+	if (httpURL.hostname.toLowerCase() === 'localhost' || httpURL.hostname.match(/^[\d.:]+$/)) {
+		// Only use ports when running against localhost, or an ip address.
+		if (httpSecurePort) {
+			httpURL.port = httpSecurePort;
+			httpURL.protocol = 'https:';
+		} else if (httpPort) {
+			httpURL.port = httpPort;
+			httpURL.protocol = 'http:';
+		}
+	} else {
+		// Otherwise, assume that port forwarding is happening, and possibly SSL termination.
+		httpURL.port = '443';
+		httpURL.protocol = 'https:';
+	}
+	return httpURL.toString();
+}
+
+function handler(req: FastifyRequest<{ Body?: OperationRequestBody }>, reply: FastifyReply) {
+	// if the operation is a restart, we have to tell the client not to use keep alive on this connection
+	// anymore; it needs to be closed because this thread is going to be terminated
+	if (req.body?.operation?.startsWith('restart')) {
+		reply.header('Connection', 'close');
+	}
+	//if no error is thrown below, the response 'data' returned from the handler will be returned with 200/OK code
+	return handlePostRequest(req, reply);
+}
+
+interface HttpServerOptions extends FastifyServerOptions {
+	https?: boolean;
+	http2?: boolean;
+}
+
+/**
+ * Builds server options object to pass to Fastify when using server factory.
+ */
+function getServerOptions(isHttps: boolean): HttpServerOptions {
+	const server_timeout = env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_TIMEOUT);
+	const keep_alive_timeout = env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_KEEPALIVETIMEOUT);
+	return {
+		bodyLimit: REQ_MAX_BODY_SIZE,
+		connectionTimeout: server_timeout,
+		keepAliveTimeout: keep_alive_timeout,
+		forceCloseConnections: true,
+		return503OnClosing: false,
+		http2: env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_HTTP2),
+		https: isHttps /* && {
+			allowHTTP1: true,
+		},*/,
+	};
+}
+
+/**
+ * Builds CORS options object to pass to cors plugin when/if it needs to be registered with Fastify
+ */
+function getCORSOpts(): FastifyCorsOptions {
+	const propsCors = env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_CORS);
+	const propsCorsAccesslist = env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_CORSACCESSLIST);
+	let corsOptions: FastifyCorsOptions;
+
+	if (propsCors && (propsCors === true || propsCors.toUpperCase() === TRUE_COMPARE_VAL)) {
+		corsOptions = {
+			origin: true,
+			allowedHeaders: ['Content-Type', 'Authorization', 'Accept'],
+			credentials: false,
+		};
+		if (
+			propsCorsAccesslist &&
+			propsCorsAccesslist.length > 0 &&
+			propsCorsAccesslist[0] !== null &&
+			propsCorsAccesslist[0] !== '*'
+		) {
+			corsOptions.origin = (origin, callback) => {
+				return callback(null, propsCorsAccesslist.indexOf(origin) !== -1);
+			};
+		}
+	}
+	return corsOptions;
+}
+
+/**
+ * Returns header timeout value from config file or, if not entered, the default value
+ */
+function getHeaderTimeoutConfig(): number {
+	return env.get(CONFIG_PARAMS.OPERATIONSAPI_NETWORK_HEADERSTIMEOUT) ?? DEFAULT_HEADERS_TIMEOUT;
+}

package/server/serverHelpers/Headers.ts

@@ -0,0 +1,108 @@
+/**
+ * Fast implementation of standard Headers
+ */
+export class Headers extends Map<string, string | string[]> {
+	constructor(init?: Headers | HeadersInit) {
+		if (init) {
+			if (init[Symbol.iterator]) {
+				super(init);
+			} else {
+				super();
+				for (const name in init) this.set(name, init[name]);
+			}
+		} else super();
+	}
+	set(name, value) {
+		if (typeof name !== 'string') name = '' + name;
+		if (Array.isArray(value)) {
+			// Ensure all array elements are strings
+			value = value.map((v) => (typeof v === 'string' ? v : '' + v));
+		} else if (typeof value !== 'string') {
+			value = '' + value;
+		}
+		return super.set(name.toLowerCase(), [name, value]);
+	}
+	get(name) {
+		if (typeof name !== 'string') name = '' + name;
+		return super.get(name.toLowerCase())?.[1];
+	}
+	has(name) {
+		if (typeof name !== 'string') name = '' + name;
+		return super.has(name.toLowerCase());
+	}
+	setIfNone(name, value) {
+		if (typeof name !== 'string') name = '' + name;
+		if (typeof value !== 'string') value = '' + value;
+		const lowerName = name.toLowerCase();
+		if (!super.has(lowerName)) return super.set(lowerName, [name, value]);
+	}
+	append(name, value, commaDelimited) {
+		if (typeof name !== 'string') name = '' + name;
+		if (typeof value !== 'string') value = '' + value;
+		const lowerName = name.toLowerCase();
+		const existing = super.get(lowerName);
+		if (existing) {
+			const existingValue = existing[1];
+			if (commaDelimited)
+				value = (typeof existingValue === 'string' ? existingValue : existingValue.join(', ')) + ', ' + value;
+			else if (typeof existingValue === 'string') value = [existingValue, value];
+			else {
+				existingValue.push(value);
+				return;
+			}
+		}
+		return super.set(lowerName, [name, value]);
+	}
+	[Symbol.iterator]() {
+		return super.values()[Symbol.iterator]();
+	}
+}
+
+export function appendHeader(headers, name, value, commaDelimited) {
+	if (headers.append) {
+		headers.append(name, value, commaDelimited);
+	} else if (headers.set) {
+		const existingValue = headers.get(name);
+		if (existingValue) {
+			if (commaDelimited)
+				value = (typeof existingValue === 'string' ? existingValue : existingValue.join(', ')) + ', ' + value;
+			else if (typeof existingValue === 'string') value = [existingValue, value];
+			else {
+				existingValue.push(value);
+				return;
+			}
+		}
+		return headers.set(name, value);
+	} else {
+		headers[name] = (headers[name] ? headers[name] + ', ' : '') + value;
+	}
+}
+
+/**
+ * Merge headers from source into target, ensuring that target is a Headers object, and avoiding any overwrite
+ * of existing headers in target.
+ * @param target
+ * @param source
+ */
+export function mergeHeaders(target: any, source: Headers) {
+	// ensure target is a Headers object, which could be this Headers class, the global.Headers, or even a Map, which is ok
+	if (typeof target.set !== 'function' || typeof target.has !== 'function') target = new Headers(target);
+	for (const [name, value] of source) {
+		if (!target.has(name)) target.set(name, value);
+		else if (name.toLowerCase() === 'set-cookie') {
+			// Set-Cookie headers must NEVER be comma-delimited
+			// If value is an array, append each one separately; otherwise append the single value
+			const values = Array.isArray(value) ? value : [value];
+			if (target.append) {
+				for (const v of values) target.append(name, v);
+			} else {
+				// Fallback for Map or objects without append method
+				// We know existing exists because we're in the else-if branch (target.has(name) is true)
+				const existing = target.get(name);
+				const newValue = Array.isArray(existing) ? [...existing, ...values] : [existing, ...values];
+				target.set(name, newValue);
+			}
+		}
+	}
+	return target;
+}

package/server/serverHelpers/JSONStream.ts

@@ -0,0 +1,269 @@
+import { Readable } from 'stream';
+import * as harperLogger from '../../utility/logging/harper_logger.js';
+import { when } from '../../utility/when.ts';
+import JSONbig from 'json-bigint-fixes';
+const JSONbigint = JSONbig({ useNativeBigInt: true });
+const BUFFER_SIZE = 10000;
+const BIGINT_SERIALIZATION = { message: 'Cannot serialize BigInt to JSON' };
+BigInt.prototype.toJSON = function () {
+	throw BIGINT_SERIALIZATION;
+};
+const { errorToString } = harperLogger;
+export function streamAsJSON(value) {
+	return new JSONStream({ value });
+}
+// a readable stream for serializing a set of variables to a JSON stream
+class JSONStream extends Readable {
+	constructor(options) {
+		// Calls the stream.Readable(options) constructor
+		super(options);
+		this.buffer = [];
+		this.bufferSize = 0;
+		this.iterator = this.serialize(options.value, true);
+		this.activeIterators = [];
+	}
+
+	*serialize(object) {
+		// using a generator to serialize JSON for convenience of recursive pause and resume functionality
+		// serialize a value to an iterator that can be consumed by streaming API
+		if (object && typeof object === 'object') {
+			const hasAsyncIterator = object[Symbol.asyncIterator];
+			const hasIterator = object[Symbol.iterator];
+			if ((hasIterator || hasAsyncIterator) && !object.then) {
+				yield '[';
+				let first = true;
+				if ((hasAsyncIterator || hasIterator) && !(object instanceof Array)) {
+					let iterator = hasAsyncIterator ? object[Symbol.asyncIterator]() : object[Symbol.iterator]();
+					this.activeIterators.push(iterator);
+					let iteratorResult;
+					while (true) {
+						try {
+							iteratorResult = iterator.next();
+							if (iteratorResult.then) {
+								yield iteratorResult.then(
+									(result) => {
+										// don't send anything here, assign the iteratorResult and continue
+										// with the serialization loop
+										iteratorResult = result;
+										return ''; // return nothing now and serialization will continue below
+									},
+									(error) => {
+										// try to properly serialize the error, but then finish the iterator
+										harperLogger.warn('Error serializing in stream', error);
+										iteratorResult = { done: false, value: { error: errorToString(error) } };
+										iterator = {
+											next: () => ({ done: true }),
+										};
+										return '';
+									}
+								);
+							}
+						} catch (error) {
+							iteratorResult = { done: false, value: { error: errorToString(error) } };
+							iterator = {
+								next: () => ({ done: true }),
+							};
+						}
+						if (iteratorResult.done) {
+							this.activeIterators.splice(this.activeIterators.indexOf(iterator), 1);
+							yield ']';
+							return;
+						} else {
+							if (first) {
+								first = false;
+							} else {
+								yield ',';
+							}
+							yield* this.serialize(iteratorResult.value);
+						}
+					}
+				}
+				for (const element of object) {
+					if (first) first = false;
+					else {
+						yield ',';
+					}
+					yield* this.serialize(element);
+				}
+				yield ']';
+				return;
+			}
+			if (object.then) {
+				try {
+					yield object.then((object) => this.serialize(object), handleError);
+				} catch (error) {
+					yield handleError(error);
+				}
+			} else {
+				yield stringify(object);
+			}
+		} else {
+			yield stringify(object);
+		}
+	}
+
+	_read() {
+		if (this._amReading) {
+			// I don't know why _read is called from within a push call, but if we are already reading, ignore the call
+			return;
+		}
+		this._amReading = true;
+		if (this.done) {
+			return this.push(null);
+		}
+		when(
+			this.readIterator(this.iterator),
+			(done) => {
+				if (done) {
+					this.done = true;
+					this.push(null);
+				} else {
+					this._amReading = false;
+				}
+			},
+			(error) => {
+				console.error(error);
+				this.done = true;
+				this.push(errorToString(error));
+				this.push(null);
+			}
+		);
+	}
+
+	push(content) {
+		if (content === null || content instanceof Buffer) {
+			if (this.bufferSize > 0) this.flush();
+			return super.push(content);
+		}
+		this.bufferSize += content.length || content.toString().length;
+		this.buffer.push(content);
+		if (this.bufferSize > BUFFER_SIZE) {
+			return this.flush();
+		}
+		return true;
+	}
+
+	flush() {
+		const pushResult = super.push(this.buffer.join(''));
+		this.buffer = [];
+		this.bufferSize = 0;
+		return pushResult;
+	}
+
+	readIterator(iterator) {
+		try {
+			// eventually we should be able to just put this around iterator.next()
+			let nextString;
+			if (iterator.childIterator) {
+				// resuming in a child iterator
+				return when(this.readIterator(iterator.childIterator), (done) => {
+					if (done) {
+						iterator.childIterator = null;
+						// continue on with the current iterator
+						return this.readIterator(iterator);
+					}
+				});
+			}
+			do {
+				const stepReturn = iterator.next();
+				if (stepReturn.done) {
+					return true;
+				}
+				nextString = stepReturn.value;
+				if (nextString == null) {
+					nextString = 'null';
+				} else {
+					if (nextString.then) {
+						this.flush();
+						return Promise.resolve(nextString).then((resolved) => {
+							if (resolved && typeof resolved.return === 'function') {
+								iterator.childIterator = resolved;
+								return this.readIterator(iterator);
+							} else if (this.push(resolved + '')) {
+								return this.readIterator(iterator);
+							} // else return false
+						});
+					}
+					if (typeof nextString.return === 'function') {
+						iterator.childIterator = nextString;
+						return this.readIterator(iterator);
+					}
+				}
+			} while (this.push(nextString));
+		} catch (error) {
+			console.error(error);
+			this.push(errorToString(error));
+			this.push(null);
+			return true;
+		}
+	}
+
+	_destroy(error, callback) {
+		for (const iterator of this.activeIterators) {
+			if (error) iterator.throw(error);
+			else iterator.return();
+		}
+		callback();
+	}
+}
+
+function handleError(error) {
+	console.error(error);
+	return JSON.stringify(errorToString(error));
+}
+
+export function stringify(value) {
+	try {
+		return JSON.stringify(value) ?? 'null';
+	} catch (error) {
+		if (error === BIGINT_SERIALIZATION) {
+			return jsStringify(value);
+		}
+		if (error.resolution) {
+			return error.resolution.then(() => stringify(value));
+		}
+		throw error;
+	}
+}
+
+function jsStringify(value) {
+	const type = typeof value;
+	if (type === 'object') {
+		if (value === null) return 'null';
+		if (value.toJSON) value = value.toJSON();
+		let str;
+		if (Array.isArray(value)) {
+			str = '[';
+			for (let i = 0; i < value.length; i++) {
+				if (i > 0) str += ',';
+				// we continue to use jsStringify assuming that if one element has a BigInt, they all do
+				str += jsStringify(value[i]);
+			}
+			return str + ']';
+		} else {
+			str = '{';
+			let first = true;
+			for (const key in value) {
+				if (first) first = false;
+				else str += ',';
+				// we assume probably only one element has a BigInt, so we can use stringify for the rest
+				str += JSON.stringify(key) + ':' + stringify(value[key]);
+			}
+			return str + '}';
+		}
+	} else if (type === 'string') {
+		return JSON.stringify(value);
+	} else if (type === 'undefined') {
+		return 'null';
+	}
+	return value.toString(); // this handles bigint, number, boolean, undefined, symbol
+}
+const HAS_BIG_NUMBER = /[[,:]\s*-?\d{16,}/;
+export function parse(json) {
+	if (!(json?.length > 0)) return null; // empty string or null
+	if (typeof json !== 'string') json = json.toString(); // make sure we just do this once
+	// we use JSONbig if there is a big number in the JSON, otherwise we use the native JSON parser
+	// because JSONbig is much slower (about 4x slower)
+	if (HAS_BIG_NUMBER.test(json)) return JSONbigint.parse(json);
+	else return JSON.parse(json);
+}

package/server/serverHelpers/OperationFunctionObject.ts

@@ -0,0 +1,13 @@
+/**
+ * represents the operation function object used for get operation
+ */
+export class OperationFunctionObject {
+	operation_function: Function;
+	job_operation_function: Function | undefined;
+	httpMethod?: string;
+
+	constructor(operation_function: Function, job_operation_function: Function = undefined) {
+		this.operation_function = operation_function;
+		this.job_operation_function = job_operation_function;
+	}
+}