@resolveio/server-lib 22.3.221 → 22.3.222

package/src/publications/report-builder-reports.ts

@@ -1,47 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ReportBuilderReports } from '../collections/report-builder-report.collection';
-import { SubscriptionManager } from '../managers/subscription.manager';
-
-export function loadReportBuilderReportPublications(subscriptionManager: SubscriptionManager) {
-	subscriptionManager.publications({
-		reportbuilderreports: {
-			function: function() {
-				return ReportBuilderReports.find({}, {sort: {report_name: 1}});
-			},
-			collections: ['report-builder-reports']
-		},
-		reportbuilderreportsWithIdUser: {
-			check: new SimpleSchema({
-				id_user: {
-					type: String
-				}
-			}),
-			function: function(id_user: string) {
-				return ReportBuilderReports.find({id_user : id_user});
-			},
-			collections: ['report-builder-reports']
-		},
-		reportbuilderreportWithId: {
-			check: new SimpleSchema({
-				id: {
-					type: String
-				}
-			}),
-			function: function(id: string) {
-				return ReportBuilderReports.findOne({_id: id});
-			},
-			collections: ['report-builder-reports']
-		},
-		reportbuilderreportsWithCustomerId: {
-			check: new SimpleSchema({
-				id: {
-					type: String
-				}
-			}),
-			function: function(id: string) {
-				return ReportBuilderReports.find({shared_users: {$in: [id]}});
-			},
-			collections: ['report-builder-reports']
-		}
-	});
-}

package/src/publications/super-admin.ts

@@ -1,13 +0,0 @@
-import { SubscriptionManager } from '../managers/subscription.manager';
-import { LoggedInUsers } from '../collections/logged-in-users.collection';
-
-export function loadSuperAdminPublications(subscriptionManager: SubscriptionManager) {
-	subscriptionManager.publications({
-		loggedInUsers: {
-			function: function() {
-				return LoggedInUsers.find({}, {sort: {user: 1}});
-			},
-			collections: ['logged-in-users']
-		}
-	});
-}

package/src/publications/user-groups.ts

@@ -1,12 +0,0 @@
-import { UserGroups } from '../collections/user-group.collection';
-
-export function loadUserGroupPublications(subscriptionManager) {
-	subscriptionManager.publications({
-		usergroups: {
-			function: function() {
-				return UserGroups.find({}, {sort: {name: 1}});
-			},
-			collections: ['user-groups']
-		}
-	});
-}

package/src/publications/user-guides.ts

@@ -1,12 +0,0 @@
-import { UserGuides } from '../collections/user-guide.collection';
-
-export function loadUserGuidePublications(subscriptionManager) {
-	subscriptionManager.publications({
-		userGuides: {
-			function: function() {
-				return UserGuides.find({}, {sort: {name: 1}});
-			},
-			collections: ['user-guides']
-		}
-	});
-}

package/src/resolveio-server-app.ts

@@ -1,617 +0,0 @@
-import { Db, MongoClient, MongoClientOptions } from 'mongodb';
-import { LocalLogManager } from './managers/local-log.manager';
-import { MongoManager } from './managers/mongo.manager';
-import { ResolveIOMainServer } from './server-app';
-
-export class ResolveIOServer {
-	private static _serverConfig = null;
-	private static _clientRoutes = [];
-	private static _mongoConnection: MongoClient = null;
-	private static _mainDB: Db = null;
-	private static _mainServer = null;
-	private static _localLogManager = null;
-	private static _mongoManager = null;
-	private static _client = '';
-	private static _clientDir = '';
-	private static _sesMail = true;
-	private static _publicProgram = false;
-
-	private static _reconnecting = false;
-	private static _mongoReconnectPromise: Promise<void> = null;
-	private static _lastMongoPoolClearedLogMs = 0;
-	private static readonly MONGO_POOL_CLEARED_DEBOUNCE_MS = 1000;
-
-	private static async connectMongo(): Promise<MongoClient> {
-		const mongoUrl = ResolveIOServer.getServerConfig()['MONGO_URL'];
-		const clientOptions = ResolveIOServer.resolveMongoClientOptions();
-		const client = await MongoClient.connect(mongoUrl, clientOptions);
-		ResolveIOServer.attachMongoListeners(client);
-		return client;
-	}
-
-	private static attachMongoListeners(client: MongoClient): void {
-		if (!client) {
-			return;
-		}
-
-		client.on('close', ResolveIOServer.handleMongoClose);
-		client.on('error', ResolveIOServer.handleMongoError);
-		client.on('connectionPoolCleared', ResolveIOServer.handleMongoPoolCleared);
-		client.on('serverClosed', ResolveIOServer.handleMongoServerClosed);
-		client.on('topologyClosed', ResolveIOServer.handleMongoTopologyClosed);
-	}
-
-	private static detachMongoListeners(client: MongoClient): void {
-		if (!client) {
-			return;
-		}
-
-		client.removeListener('close', ResolveIOServer.handleMongoClose);
-		client.removeListener('error', ResolveIOServer.handleMongoError);
-		client.removeListener('connectionPoolCleared', ResolveIOServer.handleMongoPoolCleared);
-		client.removeListener('serverClosed', ResolveIOServer.handleMongoServerClosed);
-		client.removeListener('topologyClosed', ResolveIOServer.handleMongoTopologyClosed);
-	}
-
-	private static async handleMongoClose(signal?: any): Promise<void> {
-		await ResolveIOServer.handleMongoDisconnectSignal('close', signal);
-	}
-
-	private static async handleMongoError(signal?: any): Promise<void> {
-		await ResolveIOServer.handleMongoDisconnectSignal('error', signal);
-	}
-
-	private static async handleMongoServerClosed(signal?: any): Promise<void> {
-		await ResolveIOServer.handleMongoDisconnectSignal('serverClosed', signal);
-	}
-
-	private static async handleMongoTopologyClosed(signal?: any): Promise<void> {
-		await ResolveIOServer.handleMongoDisconnectSignal('topologyClosed', signal);
-	}
-
-	private static async handleMongoPoolCleared(signal?: any): Promise<void> {
-		const now = Date.now();
-		const summary = ResolveIOServer.summarizeMongoSignal(signal);
-
-		if (!ResolveIOServer._lastMongoPoolClearedLogMs || (now - ResolveIOServer._lastMongoPoolClearedLogMs) >= ResolveIOServer.MONGO_POOL_CLEARED_DEBOUNCE_MS) {
-			ResolveIOServer._lastMongoPoolClearedLogMs = now;
-			console.warn(new Date(), 'Mongo connection pool cleared', summary);
-		}
-
-		await ResolveIOServer.handleMongoDisconnectSignal('connectionPoolCleared', signal, { verifyBeforeReconnect: true });
-	}
-
-	private static async handleMongoDisconnectSignal(reason: string, signal?: any, options: { verifyBeforeReconnect?: boolean } = {}): Promise<void> {
-		if (options.verifyBeforeReconnect) {
-			const isHealthy = await ResolveIOServer.isMongoConnectionHealthy();
-			if (isHealthy) {
-				return;
-			}
-		}
-
-		await ResolveIOServer.requestMongoReconnect(reason, signal);
-	}
-
-	private static async isMongoConnectionHealthy(timeoutMs = 2500): Promise<boolean> {
-		const client = ResolveIOServer.getMongoConnection();
-		if (!client) {
-			return false;
-		}
-
-		const pingDatabase = ResolveIOServer.getServerConfig()?.['DATABASE'] || 'admin';
-		try {
-			const timeoutPromise = (async () => {
-				await ResolveIOServer.delay(timeoutMs);
-				throw new Error('mongo-ping-timeout');
-			})();
-			await Promise.race([
-				client.db(pingDatabase).command({ ping: 1 }),
-				timeoutPromise
-			]);
-			return true;
-		}
-		catch {
-			return false;
-		}
-	}
-
-	public static async requestMongoReconnect(reason = 'unknown', signal?: any): Promise<void> {
-		const reconnectPromise = ResolveIOServer._mongoReconnectPromise;
-		if (reconnectPromise !== null) {
-			return reconnectPromise;
-		}
-
-		const signalSummary = ResolveIOServer.summarizeMongoSignal(signal);
-
-		ResolveIOServer._reconnecting = true;
-		ResolveIOServer._mongoReconnectPromise = (async () => {
-			try {
-				console.error(new Date(), 'Mongo connection lost', { reason, signal: signalSummary });
-				await ResolveIOServer.reconnectMongo(reason, signal);
-			}
-			finally {
-				ResolveIOServer._reconnecting = false;
-				ResolveIOServer._mongoReconnectPromise = null;
-			}
-		})();
-
-		return ResolveIOServer._mongoReconnectPromise;
-	}
-
-	private static summarizeMongoSignal(signal?: any): any {
-		if (!signal) {
-			return null;
-		}
-
-		if (typeof signal !== 'object') {
-			return signal;
-		}
-
-		return {
-			name: signal.name,
-			message: signal.message,
-			code: signal.code,
-			codeName: signal.codeName,
-			address: signal.address,
-			interruptInUseConnections: signal.interruptInUseConnections
-		};
-	}
-
-	private static async closeMongoClientQuietly(client: MongoClient): Promise<void> {
-		if (!client) {
-			return;
-		}
-
-		try {
-			ResolveIOServer.detachMongoListeners(client);
-			await client.close(false);
-		}
-		catch {
-			// ignore old client close errors
-		}
-	}
-
-	private static async notifyMongoReconnect(reason: string): Promise<void> {
-		try {
-			const mongoManager = ResolveIOServer.getMongoManager();
-			if (mongoManager && typeof (mongoManager as any).handleMongoReconnect === 'function') {
-				await (mongoManager as any).handleMongoReconnect(reason);
-			}
-		}
-		catch (error) {
-			console.error(new Date(), 'Mongo reconnect post-hook failed (mongo manager)', error);
-		}
-
-		try {
-			const mainServer = ResolveIOServer.getMainServer();
-			const subscriptionManager = mainServer && typeof mainServer.getSubscriptionManager === 'function'
-				? mainServer.getSubscriptionManager()
-				: null;
-			if (subscriptionManager && typeof (subscriptionManager as any).handleMongoReconnect === 'function') {
-				await (subscriptionManager as any).handleMongoReconnect(reason);
-			}
-		}
-		catch (error) {
-			console.error(new Date(), 'Mongo reconnect post-hook failed (subscription manager)', error);
-		}
-	}
-
-	private static async reconnectMongo(reason = 'unknown', signal?: any): Promise<void> {
-		const previousClient = ResolveIOServer.getMongoConnection();
-		const signalSummary = ResolveIOServer.summarizeMongoSignal(signal);
-		let attempt = 0;
-
-		while (true) {
-			try {
-				const client = await ResolveIOServer.connectMongo();
-				ResolveIOServer.setMongoConnection(client);
-				ResolveIOServer.setMainDB(client.db(ResolveIOServer.getServerConfig()['DATABASE']));
-				await ResolveIOServer.closeMongoClientQuietly(previousClient);
-				await ResolveIOServer.notifyMongoReconnect(reason);
-				console.log(new Date(), 'Mongo reconnected', { reason, attempts: attempt + 1, signal: signalSummary });
-				return;
-			}
-			catch (err) {
-				attempt++;
-				console.error(new Date(), 'Mongo reconnect failed', { reason, attempts: attempt, signal: signalSummary, error: ResolveIOServer.summarizeMongoSignal(err) });
-				await ResolveIOServer.delay(Math.min(attempt * 1000, 10000));
-			}
-		}
-	}
-
-	private static async handleMongoDisconnect(err): Promise<void> {
-		await ResolveIOServer.requestMongoReconnect('legacy-disconnect-signal', err);
-	}
-
-	private static async delay(ms: number) {
-		// eslint-disable-next-line no-restricted-syntax
-		return new Promise(resolve => setTimeout(resolve, ms));
-	}
-
-	private static resolveMongoClientOptions(): MongoClientOptions | undefined {
-		const config = ResolveIOServer.getServerConfig();
-		const options: MongoClientOptions = {};
-
-		const numericOptionKeys: Array<{ key: keyof MongoClientOptions; env: string; configKey: string }> = [
-			{ key: 'maxPoolSize', env: 'MONGO_MAX_POOL_SIZE', configKey: 'MONGO_MAX_POOL_SIZE' },
-			{ key: 'minPoolSize', env: 'MONGO_MIN_POOL_SIZE', configKey: 'MONGO_MIN_POOL_SIZE' },
-			{ key: 'waitQueueTimeoutMS', env: 'MONGO_WAIT_QUEUE_TIMEOUT_MS', configKey: 'MONGO_WAIT_QUEUE_TIMEOUT_MS' },
-			{ key: 'maxIdleTimeMS', env: 'MONGO_MAX_IDLE_TIME_MS', configKey: 'MONGO_MAX_IDLE_TIME_MS' },
-			{ key: 'serverSelectionTimeoutMS', env: 'MONGO_SERVER_SELECTION_TIMEOUT_MS', configKey: 'MONGO_SERVER_SELECTION_TIMEOUT_MS' },
-			{ key: 'connectTimeoutMS', env: 'MONGO_CONNECT_TIMEOUT_MS', configKey: 'MONGO_CONNECT_TIMEOUT_MS' },
-			{ key: 'socketTimeoutMS', env: 'MONGO_SOCKET_TIMEOUT_MS', configKey: 'MONGO_SOCKET_TIMEOUT_MS' },
-			{ key: 'heartbeatFrequencyMS', env: 'MONGO_HEARTBEAT_FREQUENCY_MS', configKey: 'MONGO_HEARTBEAT_FREQUENCY_MS' }
-		];
-
-		for (const option of numericOptionKeys) {
-			const value = ResolveIOServer.pickMongoOptionValue(option.env, option.configKey);
-			if (typeof value === 'number') {
-				Object.assign(options, { [option.key]: value });
-			}
-		}
-
-		const booleanOptionKeys: Array<{ key: keyof MongoClientOptions; env: string; configKey: string }> = [
-			{ key: 'retryWrites', env: 'MONGO_RETRY_WRITES', configKey: 'MONGO_RETRY_WRITES' }
-		];
-
-		for (const option of booleanOptionKeys) {
-			const value = ResolveIOServer.pickMongoBooleanOptionValue(option.env, option.configKey);
-			if (typeof value === 'boolean') {
-				Object.assign(options, { [option.key]: value });
-			}
-		}
-
-		const structuredOptions = config?.['MONGO_CLIENT_OPTIONS'];
-		if (structuredOptions && typeof structuredOptions === 'object' && !Array.isArray(structuredOptions)) {
-			Object.assign(options, structuredOptions);
-		}
-
-		return Object.keys(options).length ? options : undefined;
-	}
-
-	private static pickMongoOptionValue(envKey: string, configKey: string): number | undefined {
-		const rawEnv = process.env[envKey];
-		if (rawEnv && !Number.isNaN(Number(rawEnv))) {
-			const parsed = parseInt(rawEnv, 10);
-			return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
-		}
-
-		const config = ResolveIOServer.getServerConfig();
-		const configValue = config?.[configKey];
-		if (typeof configValue === 'number' && Number.isFinite(configValue) && configValue > 0) {
-			return configValue;
-		}
-
-		if (typeof configValue === 'string' && configValue.trim().length && !Number.isNaN(Number(configValue))) {
-			const parsed = parseInt(configValue, 10);
-			return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
-		}
-
-		return undefined;
-	}
-
-	private static pickMongoBooleanOptionValue(envKey: string, configKey: string): boolean | undefined {
-		const rawEnv = process.env[envKey];
-		if (typeof rawEnv === 'string' && rawEnv.length) {
-			if (['true', '1', 'yes'].includes(rawEnv.toLowerCase())) {
-				return true;
-			}
-			else if (['false', '0', 'no'].includes(rawEnv.toLowerCase())) {
-				return false;
-			}
-		}
-
-		const config = ResolveIOServer.getServerConfig();
-		const configValue = config?.[configKey];
-		if (typeof configValue === 'boolean') {
-			return configValue;
-		}
-
-		if (typeof configValue === 'string' && configValue.length) {
-			if (['true', '1', 'yes'].includes(configValue.toLowerCase())) {
-				return true;
-			}
-			else if (['false', '0', 'no'].includes(configValue.toLowerCase())) {
-				return false;
-			}
-		}
-
-		return undefined;
-	}
-
-	constructor() {}
-	
-	public static async create(serverConfig, clientRoutes: string[], client: string, clientDir, sesMail = true, publicProgram = false) {
-		const resolveioServer = new ResolveIOServer();
-		await resolveioServer.initialize(serverConfig, clientRoutes, client, clientDir, sesMail, publicProgram);
-		return resolveioServer;
-	}
-
-	private async initialize(serverConfig, clientRoutes: string[], client: string, clientDir, sesMail = true, publicProgram = false) {
-		ResolveIOServer._serverConfig = serverConfig;
-		ResolveIOServer._clientRoutes = clientRoutes;
-		ResolveIOServer._client = client;
-		ResolveIOServer._clientDir = clientDir;
-		ResolveIOServer._sesMail = sesMail;
-		ResolveIOServer._publicProgram = publicProgram;
-		
-		try {
-			let dbConnection = await ResolveIOServer.connectMongo();
-			process.removeAllListeners('unhandledRejection');
-
-			ResolveIOServer.setMongoConnection(dbConnection);
-			ResolveIOServer.setMainDB(dbConnection.db(ResolveIOServer.getServerConfig()['DATABASE']));
-
-			// dbConnection
-			// .on('error', error => {
-			// 	if (typeof error.message === 'string' && error.message.includes('ns does not exist')) {
-			// 		return;
-			// 	}
-					
-			// 	// Otherwise log normally
-			// 	throw error;
-			// })
-			// .on('close', () => process.exit(1));
-	
-			let LocalLogManager = (await import('./managers/local-log.manager')).LocalLogManager;
-			let localLogManager = LocalLogManager.create();
-			ResolveIOServer.setLocalLogManager(localLogManager);
-
-			let MongoManager = (await import('./managers/mongo.manager')).MongoManager;
-			let mongoManager = await MongoManager.create();
-			ResolveIOServer.setMongoManager(mongoManager);
-			
-			let serverApp = (await import('./server-app')).ResolveIOMainServer;
-			let app = await serverApp.create();
-			ResolveIOServer.setMainServer(app);
-			
-			return true;
-		}
-		catch (err) {
-			err.message = 'Error in ResolveIOServer (initialize): Mongo Client Connect And Run ResolveIO Server App Library - ' + err.message;
-			console.error(err.message);
-			process.exit(1);
-		}
-	}
-
-	public static getClientName() {
-		return this._client;
-	}
-
-	public static getMainServer(): ResolveIOMainServer {
-		return ResolveIOServer._mainServer;
-	}
-
-	public static setMainServer(mainServer: ResolveIOMainServer) {
-		ResolveIOServer._mainServer = mainServer;
-	}
-
-	public static setMongoConnection(mongoConnection: MongoClient) {
-		ResolveIOServer._mongoConnection = mongoConnection;
-	}
-
-	public static getMongoConnection(): MongoClient {
-		return ResolveIOServer._mongoConnection;
-	}
-
-	public static getMainDB(): Db {
-		return ResolveIOServer._mainDB;
-	}
-
-	public static setMainDB(mainDB: Db) {
-		ResolveIOServer._mainDB = mainDB
-	}
-
-	public static getMongoManager(): MongoManager {
-		return ResolveIOServer._mongoManager;
-	}
-
-	public static setMongoManager(mongoManager: MongoManager) {
-		ResolveIOServer._mongoManager = mongoManager;
-	}
-
-	public static getLocalLogManager(): LocalLogManager {
-		return ResolveIOServer._localLogManager;
-	}
-
-	public static setLocalLogManager(localLogManager: LocalLogManager) {
-		ResolveIOServer._localLogManager = localLogManager;
-	}
-
-	public static getServerConfig() {
-		return ResolveIOServer._serverConfig;
-	}
-
-	public static getLogStorageMode(): 'offline' | 'direct' {
-		const configuredMode = this.resolveConfiguredLogStorageMode();
-		if (configuredMode === 'offline' || configuredMode === 'direct') {
-			return configuredMode;
-		}
-
-		return this.resolveLegacyLogStorageMode();
-	}
-
-	public static shouldWriteLogsOffline(): boolean {
-		return this.getLogStorageMode() === 'offline';
-	}
-
-	private static resolveConfiguredLogStorageMode(): 'offline' | 'direct' | 'auto' {
-		const config = ResolveIOServer.getServerConfig() || {};
-		const configuredValue = process.env.RESOLVEIO_LOG_STORAGE_MODE
-			|| process.env.LOG_STORAGE_MODE
-			|| config['RESOLVEIO_LOG_STORAGE_MODE']
-			|| config['LOG_STORAGE_MODE']
-			|| config['LOCAL_LOG_STORAGE_MODE']
-			|| '';
-		const normalized = String(configuredValue || '').trim().toLowerCase();
-
-		if (!normalized || normalized === 'auto') {
-			return 'auto';
-		}
-
-		if (normalized === 'direct' || normalized === 'database' || normalized === 'db') {
-			return 'direct';
-		}
-
-		if (normalized === 'offline' || normalized === 'offload' || normalized === 'file' || normalized === 'local') {
-			return 'offline';
-		}
-
-		return 'auto';
-	}
-
-	private static resolveLegacyLogStorageMode(): 'offline' | 'direct' {
-		const rootUrl = ResolveIOServer.getServerConfig()?.['ROOT_URL'];
-		if (rootUrl !== 'https://resolveio.com' && rootUrl !== 'http://localhost:4200') {
-			return 'offline';
-		}
-		return 'direct';
-	}
-
-	public static getInstanceHost(): string {
-		const config = ResolveIOServer.getServerConfig() || {};
-		const explicitHost = this.findFirstNonEmptyString([
-			process.env.RESOLVEIO_INSTANCE_HOST,
-			process.env.INSTANCE_HOST,
-			config['RESOLVEIO_INSTANCE_HOST'],
-			config['INSTANCE_HOST'],
-			config['SERVER_HOST']
-		]);
-		if (explicitHost) {
-			return explicitHost;
-		}
-
-		const hostFromUrl = this.extractHostName(this.findFirstNonEmptyString([
-			process.env.RESOLVEIO_SERVER_URL,
-			process.env.SERVER_URL,
-			config['RESOLVEIO_SERVER_URL'],
-			config['SERVER_URL'],
-			process.env.ROOT_URL,
-			config['ROOT_URL']
-		]));
-		if (hostFromUrl) {
-			return hostFromUrl;
-		}
-
-		const envHostName = this.findFirstNonEmptyString([
-			process.env.EC2_PUBLIC_HOSTNAME,
-			process.env.HOSTNAME
-		]);
-		if (envHostName) {
-			return envHostName;
-		}
-
-		return 'local-instance';
-	}
-
-	public static getServerApiBaseUrl(): string {
-		const config = ResolveIOServer.getServerConfig() || {};
-		const explicitBaseUrl = this.normalizeBaseUrl(this.findFirstNonEmptyString([
-			process.env.RESOLVEIO_SERVER_URL,
-			process.env.SERVER_URL,
-			config['RESOLVEIO_SERVER_URL'],
-			config['SERVER_URL']
-		]));
-		if (explicitBaseUrl) {
-			return explicitBaseUrl;
-		}
-
-		const normalizedRootUrl = this.normalizeBaseUrl(this.findFirstNonEmptyString([
-			process.env.ROOT_URL,
-			config['ROOT_URL']
-		]));
-		if (normalizedRootUrl) {
-			try {
-				const parsedRootUrl = new URL(normalizedRootUrl);
-				if (parsedRootUrl.port === '4200') {
-					parsedRootUrl.port = '8080';
-				}
-
-				parsedRootUrl.pathname = '';
-				parsedRootUrl.search = '';
-				parsedRootUrl.hash = '';
-				return parsedRootUrl.toString().replace(/\/$/, '');
-			}
-			catch {
-				return normalizedRootUrl;
-			}
-		}
-
-		const defaultPort = this.findFirstNonEmptyString([
-			process.env.PORT,
-			config['PORT']
-		]) || '8080';
-		return `http://127.0.0.1:${defaultPort}`;
-	}
-
-	public static buildServerApiUrl(pathname: string): string {
-		const normalizedPath = pathname && pathname.startsWith('/')
-			? pathname
-			: `/${pathname || ''}`;
-		return this.getServerApiBaseUrl().replace(/\/$/, '') + normalizedPath;
-	}
-
-	private static findFirstNonEmptyString(values: any[]): string | null {
-		for (const value of values || []) {
-			if (typeof value === 'string' && value.trim().length) {
-				return value.trim();
-			}
-		}
-
-		return null;
-	}
-
-	private static normalizeBaseUrl(value?: string | null): string | null {
-		if (!value || typeof value !== 'string') {
-			return null;
-		}
-
-		const trimmedValue = value.trim();
-		if (!trimmedValue) {
-			return null;
-		}
-
-		const hasScheme = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(trimmedValue);
-		const candidate = hasScheme ? trimmedValue : `http://${trimmedValue}`;
-		try {
-			const parsed = new URL(candidate);
-			parsed.pathname = '';
-			parsed.search = '';
-			parsed.hash = '';
-			return parsed.toString().replace(/\/$/, '');
-		}
-		catch {
-			return null;
-		}
-	}
-
-	private static extractHostName(value?: string | null): string | null {
-		const normalizedBase = this.normalizeBaseUrl(value || '');
-		if (!normalizedBase) {
-			return null;
-		}
-
-		try {
-			return new URL(normalizedBase).hostname || null;
-		}
-		catch {
-			return null;
-		}
-	}
-
-	public static getClientRoutes() {
-		return ResolveIOServer._clientRoutes;
-	}
-
-	public static getClientDir(): string {
-		return ResolveIOServer._clientDir;
-	}
-
-	public static getSESMail(): boolean {
-		return ResolveIOServer._sesMail;
-	}
-
-	public static getpublicProgram(): boolean {
-		return ResolveIOServer._publicProgram;
-	}
-}