@harperfast/harper 5.0.25 → 5.1.0-beta.1

package/server/DurableSubscriptionsSession.ts

@@ -1,7 +1,7 @@
 import { table } from '../resources/databases.ts';
 import { keyArrayToString, resources } from '../resources/Resources.ts';
-import { getNextMonotonicTime } from '../utility/lmdb/commonUtility.js';
-import { warn, trace } from '../utility/logging/harper_logger.js';
+import { getNextMonotonicTime } from '../utility/lmdb/commonUtility.ts';
+import { warn, trace } from '../utility/logging/harper_logger.ts';
 import { transaction } from '../resources/transaction.ts';
 import { getWorkerIndex } from '../server/threads/manageThreads.js';
 import { whenComponentsLoaded } from '../server/threads/threadServer.js';
@@ -10,46 +10,59 @@ import { RequestTarget } from '../resources/RequestTarget';
 import { cloneDeep } from 'lodash';
 
 const AWAITING_ACKS_HIGH_WATER_MARK = 100;
-const DurableSession = table({
-	database: 'system',
-	table: 'hdb_durable_session',
-	attributes: [
-		{ name: 'id', isPrimaryKey: true },
-		{
-			name: 'subscriptions',
-			type: 'array',
-			elements: {
-				attributes: [{ name: 'topic' }, { name: 'qos' }, { name: 'startTime' }, { name: 'acks' }],
-			},
-		},
-	],
-});
-const LastWill = table({
-	database: 'system',
-	table: 'hdb_session_will',
-	attributes: [
-		{ name: 'id', isPrimaryKey: true },
-		{ name: 'topic', type: 'string' },
-		{ name: 'data' },
-		{ name: 'qos', type: 'number' },
-		{ name: 'retain', type: 'boolean' },
-		{ name: 'user', type: 'any' },
-	],
-});
+let _DurableSession: any;
+function getDurableSession() {
+	if (!_DurableSession) {
+		_DurableSession = table({
+			database: 'system',
+			table: 'hdb_durable_session',
+			attributes: [
+				{ name: 'id', isPrimaryKey: true },
+				{
+					name: 'subscriptions',
+					type: 'array',
+				},
+				{
+					name: 'awaitingAcks',
+					type: 'array',
+				},
+			],
+		});
+	}
+	return _DurableSession;
+}
+let _LastWill: any;
+function getLastWill() {
+	if (!_LastWill) {
+		_LastWill = table({
+			database: 'system',
+			table: 'hdb_session_will',
+			attributes: [
+				{ name: 'id', isPrimaryKey: true },
+				{ name: 'topic', type: 'string' },
+				{ name: 'data' },
+				{ name: 'qos', type: 'number' },
+				{ name: 'retain', type: 'boolean' },
+				{ name: 'user', type: 'any' },
+			],
+		});
+	}
+	return _LastWill;
+}
 if (getWorkerIndex() === 0) {
 	(async () => {
 		await whenComponentsLoaded;
 		await new Promise((resolve) => setTimeout(resolve, 2000));
-		for await (const will of LastWill.search({})) {
+		for await (const will of getLastWill().search({})) {
 			const data = will.data;
 			const message = { ...will };
-			if (message.user?.username) message.user = await server.getUser(message.user.username);
+			if (message.user?.username) message.user = await (server as any).getUser(message.user.username);
 			try {
-				await publish(message, data, message);
+				await publishMessage(message, data, message);
 			} catch {
 				warn('Failed to publish will', data);
 			}
-			LastWill.delete(will.id);
+			getLastWill().delete(will.id);
 		}
 	})();
 }
@@ -84,6 +97,7 @@ export async function getSession({
 	clientId: sessionId,
 	user,
 	clean: nonDurable,
+	properties,
 	will,
 	keepalive,
 }: {
@@ -91,26 +105,28 @@ export async function getSession({
 	user;
 	listener: Function;
 	clean?: boolean;
+	properties?: any;
 	will: any;
 	keepalive?: number;
 }) {
 	let session;
+	if (properties?.sessionExpiryInterval > 0) nonDurable = false;
 	if (sessionId && !nonDurable) {
-		const sessionResource = await DurableSession.get(sessionId, { returnNonexistent: true });
+		const sessionResource = await getDurableSession().get(sessionId, { returnNonexistent: true });
 		session = new DurableSubscriptionsSession(sessionId, user, sessionResource);
 		if (sessionResource) session.sessionWasPresent = true;
 	} else {
 		if (sessionId) {
 			// connecting with a clean session and session id is how durable sessions are deleted
-			const sessionResource = await DurableSession.get(sessionId);
-			if (sessionResource) DurableSession.delete(sessionId);
+			const sessionResource = await getDurableSession().get(sessionId);
+			if (sessionResource) getDurableSession().delete(sessionId);
 		}
 		session = new SubscriptionsSession(sessionId, user);
 	}
 	if (will) {
 		will.id = sessionId;
 		will.user = { username: user?.username };
-		LastWill.put(will);
+		getLastWill().put(will);
 	}
 	if (keepalive) {
 		// keep alive is the interval in seconds that the client will send a ping to the server
@@ -174,7 +190,7 @@ class SubscriptionsSession {
 			const notFoundError = new Error(
 				`The topic ${topic} does not exist, no resource has been defined to handle this topic`
 			);
-			notFoundError.statusCode = 404;
+			(notFoundError as any).statusCode = 404;
 			throw notFoundError;
 		}
 		let url = entry.relativeURL;
@@ -333,10 +349,10 @@ class SubscriptionsSession {
 	}
 	async publish(message, data) {
 		// each publish gets it own context so that each publish gets it own transaction
-		return publish(message, data, this.createContext());
+		return publishMessage(message, data, this.createContext());
 	}
 	createContext(): any {
-		const context = {
+		const context: any = {
 			session: this,
 			socket: this.socket,
 			user: this.user,
@@ -358,13 +374,13 @@ class SubscriptionsSession {
 		transaction(context, async () => {
 			try {
 				if (!clientTerminated) {
-					const will = await LastWill.get(this.sessionId);
+					const will = await getLastWill().get(this.sessionId);
 					if (will) {
-						await publish(will, will.data, context);
+						await publishMessage(will, will.data, context);
 					}
 				}
 			} finally {
-				await LastWill.delete(this.sessionId);
+				await getLastWill().delete(this.sessionId);
 			}
 		}).catch((error) => {
 			warn(`Error publishing MQTT will for ${this.sessionId}`, error);
@@ -385,7 +401,7 @@ class SubscriptionsSession {
 		}
 	}
 }
-function publish(message, data, context) {
+async function publishMessage(message: any, data: any, context: any) {
 	const { topic, retain } = message;
 	message = { ...message, data, async: true };
 	context.authorize = true;
@@ -409,6 +425,7 @@ function publish(message, data, context) {
 	});
 }
 export class DurableSubscriptionsSession extends SubscriptionsSession {
+	committed: Promise<void> | void;
 	sessionRecord: any;
 	constructor(sessionId, user, record?) {
 		super(sessionId, user);
@@ -459,7 +476,7 @@ export class DurableSubscriptionsSession extends SubscriptionsSession {
 							}
 							subscription.acks.push(update.timestamp);
 							trace('Received ack', topic, update.timestamp);
-							DurableSession.put(this.sessionRecord, { source: true }); // add source: true context to bypass any overloaded checks, as skipping this can lead to increased load
+							getDurableSession().put(this.sessionRecord, { source: true }); // add source: true context to bypass any overloaded checks, as skipping this can lead to increased load
 							return;
 						}
 					}
@@ -472,20 +489,20 @@ export class DurableSubscriptionsSession extends SubscriptionsSession {
 				subscription.startTime = update.timestamp;
 			}
 		}
-		DurableSession.put(this.sessionRecord, { source: true });
+		getDurableSession().put(this.sessionRecord, { source: true });
 		// TODO: Increment the timestamp for the corresponding subscription, possibly recording any interim unacked messages
 	}
 
 	async addSubscription(subscription, needsAck) {
 		await this.resumeSubscription(subscription, needsAck);
 		const { qos, startTime } = subscription;
-		if (qos > 0 && !startTime) this.saveSubscriptions();
-		return subscription.qos;
+		if (qos > 0 && !startTime) await this.saveSubscriptions();
+		return subscription;
 	}
-	removeSubscription(topic) {
+	async removeSubscription(topic) {
 		const existingSubscription = this.subscriptions.find((subscription) => subscription.topic === topic);
 		const result = super.removeSubscription(topic);
-		if (existingSubscription.qos > 0) this.saveSubscriptions();
+		if (existingSubscription.qos > 0) await this.saveSubscriptions();
 		return result;
 	}
 	saveSubscriptions() {
@@ -499,6 +516,6 @@ export class DurableSubscriptionsSession extends SubscriptionsSession {
 				startTime,
 			};
 		});
-		DurableSession.put(this.sessionRecord);
+		return getDurableSession().put(this.sessionRecord);
 	}
 }

package/server/REST.ts

@@ -1,15 +1,14 @@
 import { serialize, serializeMessage, getDeserializer } from '../server/serverHelpers/contentTypes.ts';
 import { addAnalyticsListener, recordAction, recordActionBinary } from '../resources/analytics/write.ts';
-import * as harperLogger from '../utility/logging/harper_logger.js';
-import { ServerOptions } from 'http';
-import { ServerError, ClientError } from '../utility/errors/hdbError.js';
+import * as harperLogger from '../utility/logging/harper_logger.ts';
+import { ServerError, ClientError } from '../utility/errors/hdbError.ts';
 import { Resources } from '../resources/Resources.ts';
 import { Resource, missingMethod, allowedMethods } from '../resources/Resource.ts';
 import { IterableEventQueue } from '../resources/IterableEventQueue.ts';
 import { transaction } from '../resources/transaction.ts';
 import { Headers, mergeHeaders } from '../server/serverHelpers/Headers.ts';
 import { generateJsonApi } from '../resources/openApi.ts';
-import type { Context } from '../resources/ResourceInterface.ts';
+
 import { Request } from '../server/serverHelpers/Request.ts';
 import { RequestTarget } from '../resources/RequestTarget';
 
@@ -20,7 +19,7 @@ let httpOptions = {};
 
 const OPENAPI_DOMAIN = 'openapi';
 
-async function http(request: Context & Request, nextHandler) {
+async function http(request: Request, nextHandler) {
 	const headersObject = request.headers.asObject;
 	const isSse = headersObject.accept === 'text/event-stream';
 	const method = isSse ? 'CONNECT' : request.method;
@@ -41,13 +40,13 @@ async function http(request: Context & Request, nextHandler) {
 			request.handlerPath = entry.path;
 			target = new RequestTarget(entry.relativeURL); // TODO: We don't want to have to remove the forward slash and then re-add it
 
-			target.async = true;
+			(target as any).async = true;
 			resource = entry.Resource;
 		}
-		if (resource?.isCaching) {
+		if ((resource as any)?.isCaching) {
 			const cacheControl = headersObject['cache-control'];
 			if (cacheControl) {
-				const cacheControlParts = parseHeaderValue(cacheControl);
+				const cacheControlParts = parseHeaderValue(cacheControl as any);
 				for (const part of cacheControlParts) {
 					switch (part.name) {
 						case 'max-age':
@@ -74,7 +73,7 @@ async function http(request: Context & Request, nextHandler) {
 		}
 		const replicateTo = headersObject['x-replicate-to'];
 		if (replicateTo) {
-			const parsed = parseHeaderValue(replicateTo).map((node: { name: string }) => {
+			const parsed = parseHeaderValue(replicateTo as any).map((node: any) => {
 				// we can use a component argument to indicate that number that should be confirmed
 				// for example, to replicate to three nodes and wait for confirmation from two: X-Replicate-To: 3;confirm=2
 				// or to specify nodes with confirm: X-Replicate-To: node-1, node-2, node-3;confirm=2
@@ -94,7 +93,10 @@ async function http(request: Context & Request, nextHandler) {
 			if (headersObject['content-length'] || headersObject['transfer-encoding']) {
 				// TODO: Support cancellation (if the request otherwise fails or takes too many bytes)
 				try {
-					request.data = getDeserializer(headersObject['content-type'], true)(request.body, request.headers);
+					request.data = (getDeserializer(headersObject['content-type'] as any, true) as any)(
+						request.body,
+						request.headers
+					);
 				} catch (error) {
 					throw new ClientError(error, 400);
 				}
@@ -102,7 +104,7 @@ async function http(request: Context & Request, nextHandler) {
 			request.authorize = true;
 
 			if (url === OPENAPI_DOMAIN && method === 'GET') {
-				target = {};
+				target = {} as any;
 				if (request?.user?.role?.permission?.super_user) {
 					return generateJsonApi(resources, `${request.protocol}://${request.hostname}`);
 				} else {
@@ -157,7 +159,7 @@ async function http(request: Context & Request, nextHandler) {
 		if (responseData == undefined) {
 			status ??= method === 'GET' || method === 'HEAD' ? 404 : 204;
 			// deleted entries can have a timestamp of when they were deleted
-			if (httpOptions.lastModified && isFinite(lastModification))
+			if ((httpOptions as any).lastModified && isFinite(lastModification))
 				headers.setIfNone('Last-Modified', new Date(lastModification).toUTCString());
 		} else if (responseData.headers) {
 			// if response is a Response object, use it as the response
@@ -214,7 +216,8 @@ async function http(request: Context & Request, nextHandler) {
 			} else {
 				headers.setIfNone('ETag', etag);
 			}
-			if (httpOptions.lastModified) headers.setIfNone('Last-Modified', new Date(lastModification).toUTCString());
+			if ((httpOptions as any).lastModified)
+				headers.setIfNone('Last-Modified', new Date(lastModification).toUTCString());
 		}
 		if (request.createdResource) status = 201;
 		if (request.newLocation) headers.setIfNone('Location', request.newLocation);
@@ -227,7 +230,7 @@ async function http(request: Context & Request, nextHandler) {
 		const loadedFromSource = target.loadedFromSource;
 		if (loadedFromSource !== undefined) {
 			// this appears to be a caching table with a source
-			responseObject.wasCacheMiss = loadedFromSource; // indicate if it was a missed cache
+			(responseObject as any).wasCacheMiss = loadedFromSource; // indicate if it was a missed cache
 			if (!loadedFromSource && isFinite(lastModification)) {
 				headers.setIfNone('Age', Math.round((Date.now() - (request.lastRefreshed || lastModification)) / 1000));
 			}
@@ -277,112 +280,122 @@ async function http(request: Context & Request, nextHandler) {
 	}
 }
 
-let started;
+let started = false;
 let resources: Resources;
 let addedMetrics;
 let connectionCount = 0;
 
-export function start(options: ServerOptions & { path: string; port: number; server: any; resources: Resources }) {
-	httpOptions = options;
-	if (options.includeExpensiveRecordCountEstimates) {
+export function handleApplication(scope: import('../components/Scope.ts').Scope) {
+	httpOptions = scope.options.getAll();
+	if ((httpOptions as any).includeExpensiveRecordCountEstimates) {
 		// If they really want to enable expensive record count estimates
-		Request.prototype.includeExpensiveRecordCountEstimates = true;
+		(Request.prototype as any).includeExpensiveRecordCountEstimates = true;
 	}
+	resources = scope.resources;
 	if (started) return;
 	started = true;
-	resources = options.resources;
-	options.server.http(async (request: Request, nextHandler) => {
-		if (request.isWebSocket) return;
-		return http(request, nextHandler);
-	}, options);
-	if (options.webSocket === false) return;
-	options.server.ws(async (ws, request, chainCompletion) => {
-		connectionCount++;
-		const incomingMessages = new IterableEventQueue();
-		if (!addedMetrics) {
-			addedMetrics = true;
-			addAnalyticsListener((metrics) => {
-				if (connectionCount > 0)
-					metrics.push({
-						metric: 'ws-connections',
-						connections: connectionCount,
-						byThread: true,
-					});
-			});
-		}
-		// TODO: We should set a lower keep-alive ws.socket.setKeepAlive(600000);
-		let hasError;
-		ws.on('error', (error) => {
-			hasError = true;
-			harperLogger.warn(error);
-		});
-		let deserializer;
-		ws.on('message', function message(body) {
-			if (!deserializer)
-				deserializer = getDeserializer(request.requestedContentType ?? request.headers.asObject['content-type'], false);
-			const data = deserializer(body);
-			recordAction(body.length, 'bytes-received', request.handlerPath, 'message', 'ws');
-			incomingMessages.push(data);
-		});
-		let iterator;
-		ws.on('close', () => {
-			connectionCount--;
-			recordActionBinary(!hasError, 'connection', 'ws', 'disconnect');
-			incomingMessages.emit('close');
-			if (iterator) iterator.return();
-		});
-		try {
-			await chainCompletion;
-			const url = request.url.slice(1);
-			const entry = resources.getMatch(url, 'ws');
-			recordActionBinary(Boolean(entry), 'connection', 'ws', 'connect');
-			if (!entry) {
-				// TODO: Ideally we would like to have a 404 response before upgrading to WebSocket protocol, probably
-				return ws.close(1011, `No resource was found to handle ${request.pathname}`);
-			} else {
-				request.handlerPath = entry.path;
-				recordAction(
-					(action) => ({
-						count: action.count,
-						total: connectionCount,
-					}),
-					'connections',
-					request.handlerPath,
-					'connect',
-					'ws'
-				);
-				request.authorize = true;
-				const resourceRequest = new RequestTarget(entry.relativeURL); // TODO: We don't want to have to remove the forward slash and then re-add it
-				resourceRequest.checkPermission = request.user?.role?.permission ?? {};
-				const resource = entry.Resource;
-				const responseStream = await transaction(request, () => {
-					return resource.connect(resourceRequest, incomingMessages, request);
+	scope.server.http(
+		async (request: any, nextHandler) => {
+			if (request.isWebSocket) return;
+			return http(request, nextHandler);
+		},
+		{ after: 'authentication', ...(httpOptions as any) }
+	);
+	if ((httpOptions as any).webSocket === false) return;
+	scope.server.ws(
+		async (ws, request: any, chainCompletion) => {
+			connectionCount++;
+			const incomingMessages = new IterableEventQueue();
+			if (!addedMetrics) {
+				addedMetrics = true;
+				addAnalyticsListener((metrics) => {
+					if (connectionCount > 0)
+						metrics.push({
+							metric: 'ws-connections',
+							connections: connectionCount,
+							byThread: true,
+						});
 				});
-				iterator = responseStream[Symbol.asyncIterator]();
+			}
+			// TODO: We should set a lower keep-alive ws.socket.setKeepAlive(600000);
+			let hasError;
+			(ws as any).on('error', (error) => {
+				hasError = true;
+				harperLogger.warn(error);
+			});
+			let deserializer;
+			(ws as any).on('message', function message(body) {
+				if (!deserializer)
+					deserializer = getDeserializer(
+						request.requestedContentType ?? request.headers.asObject['content-type'],
+						false
+					);
+				const data = deserializer(body);
+				recordAction(body.length, 'bytes-received', request.handlerPath, 'message', 'ws');
+				incomingMessages.push(data);
+			});
+			let iterator;
+			(ws as any).on('close', () => {
+				connectionCount--;
+				recordActionBinary(!hasError, 'connection', 'ws', 'disconnect');
+				incomingMessages.emit('close');
+				if (iterator) iterator.return();
+				request._abort?.();
+			});
+			try {
+				await chainCompletion;
+				const url = request.url.slice(1);
+				const entry = resources.getMatch(url, 'ws');
+				recordActionBinary(Boolean(entry), 'connection', 'ws', 'connect');
+				if (!entry) {
+					// TODO: Ideally we would like to have a 404 response before upgrading to WebSocket protocol, probably
+					return ws.close(1011, `No resource was found to handle ${request.pathname}`);
+				} else {
+					request.handlerPath = entry.path;
+					recordAction(
+						(action) => ({
+							count: action.count,
+							total: connectionCount,
+						}),
+						'connections',
+						request.handlerPath,
+						'connect',
+						'ws'
+					);
+					request.authorize = true;
+					const resourceRequest = new RequestTarget(entry.relativeURL); // TODO: We don't want to have to remove the forward slash and then re-add it
+					resourceRequest.checkPermission = request.user?.role?.permission ?? {};
+					const resource = entry.Resource;
+					const responseStream = await transaction(request, () => {
+						return resource.connect(resourceRequest, incomingMessages, request);
+					});
+					iterator = responseStream[Symbol.asyncIterator]();
 
-				let result;
-				while (!(result = await iterator.next()).done) {
-					const messageBinary = await serializeMessage(result.value, request);
-					ws.send(messageBinary);
-					recordAction(messageBinary.length, 'bytes-sent', request.handlerPath, 'message', 'ws');
-					if (ws._socket.writableNeedDrain) {
-						await new Promise((resolve) => ws._socket.once('drain', resolve));
+					let result;
+					while (!(result = await iterator.next()).done) {
+						const messageBinary = await serializeMessage(result.value, request);
+						ws.send(messageBinary);
+						recordAction(messageBinary.length, 'bytes-sent', request.handlerPath, 'message', 'ws');
+						if ((ws as any)._socket.writableNeedDrain) {
+							await new Promise((resolve) => (ws as any)._socket.once('drain', resolve));
+						}
 					}
 				}
+			} catch (error) {
+				if (error.statusCode) {
+					if (error.statusCode === 500) harperLogger.warn(error);
+					else harperLogger.info(error);
+				} else harperLogger.error(error);
+				ws.close(
+					HTTP_TO_WEBSOCKET_CLOSE_CODES[error.statusCode] || // try to return a helpful code
+						1011, // otherwise generic internal error
+					errorToString(error)
+				);
 			}
-		} catch (error) {
-			if (error.statusCode) {
-				if (error.statusCode === 500) harperLogger.warn(error);
-				else harperLogger.info(error);
-			} else harperLogger.error(error);
-			ws.close(
-				HTTP_TO_WEBSOCKET_CLOSE_CODES[error.statusCode] || // try to return a helpful code
-					1011, // otherwise generic internal error
-				errorToString(error)
-			);
-		}
-		ws.close();
-	}, options);
+			ws.close();
+		},
+		{ after: 'authentication', ...(httpOptions as any) }
+	);
 }
 const HTTP_TO_WEBSOCKET_CLOSE_CODES = {
 	401: 3000,

package/server/Server.ts

@@ -37,11 +37,16 @@ export interface Server {
 	shards: Map<number, string[]>;
 	hostname: string;
 	resources: Resources;
+	knownGraphQLDirectives?: string[];
+	onInvalidatedUser(callback: () => void): void;
 	replication: {
-		replicateOperation(operation: {
-			replicated: boolean;
-			[key: string]: any;
-		}): Promise<{ message: string; replicated?: unknown[] }>;
+		replicateOperation(
+			operation: {
+				replicated: boolean;
+				[key: string]: any;
+			},
+			options?: { onPeerResult?: (result: any) => void }
+		): Promise<{ message: string; replicated?: unknown[] }>;
 		monitorNodeCAs(listener: () => void): void;
 		sendOperationToNode(node: string, operation: any, options: any): Promise<any>;
 	};
@@ -56,18 +61,32 @@ export interface ServerOptions {
 	securePort?: number;
 	mtls?: boolean;
 	usageType?: string;
+	/** @deprecated Use `before` or `after` for explicit ordering instead */
+	runFirst?: boolean;
+	/** Name for this middleware entry, used by `before`/`after` in other entries. Defaults to the registering component's name. */
+	name?: string;
+	/** This middleware must run before the named middleware */
+	before?: string;
+	/** This middleware must run after the named middleware */
+	after?: string;
+	/** Only handle requests whose pathname starts with this prefix */
+	urlPath?: string;
+	/** Only handle requests for this virtual hostname */
+	host?: string;
 }
 interface WebSocketOptions extends ServerOptions {
 	subProtocol: string;
 }
-export interface UpgradeOptions {
-	port?: number;
-	securePort?: number;
-	runFirst?: boolean;
-}
+export interface UpgradeOptions extends ServerOptions {}
 
 export interface HttpOptions extends ServerOptions {
 	runFirst?: boolean;
+	logging?: {
+		id?: boolean;
+		timing?: boolean;
+		headers?: boolean;
+	};
+	lastModified?: boolean;
 }
 export interface ContentTypeHandler {
 	serialize(data: any): Buffer | string;
@@ -78,17 +97,17 @@ export interface ContentTypeHandler {
 
 export const server: Server = {
 	replication: {
-		replicateOperation(operation) {
+		replicateOperation(operation, _options) {
 			return operation.replicated
 				? Promise.reject(new Error('Replication not implemented.'))
 				: Promise.resolve({ message: '' });
 		},
-		monitorNodeCAs(_listener: () => void) {
+		monitorNodeCAs(_listener) {
 			throw new Error('Replication not implemented.');
 		},
 		sendOperationToNode() {
 			return Promise.reject(new Error('Replication not implemented.'));
 		},
 	},
-};
+} as any;
 _assignPackageExport('server', server);

package/server/fastifyRoutes/helpers/getCORSOptions.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const env = require('../../../utility/environment/environmentManager.js');
+const env = require('../../../utility/environment/environmentManager.ts');
 env.initSync();
 const { CONFIG_PARAMS } = require('../../../utility/hdbTerms.ts');
 

package/server/fastifyRoutes/helpers/getHeaderTimeoutConfig.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const env = require('../../../utility/environment/environmentManager.js');
+const env = require('../../../utility/environment/environmentManager.ts');
 env.initSync();
 const terms = require('../../../utility/hdbTerms.ts');
 

package/server/fastifyRoutes/helpers/getServerOptions.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const env = require('../../../utility/environment/environmentManager.js');
+const env = require('../../../utility/environment/environmentManager.ts');
 env.initSync();
 const { CONFIG_PARAMS } = require('../../../utility/hdbTerms.ts');