@resolveio/server-lib 22.2.33 → 22.2.34

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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,617 @@
+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;
+	}
+}