@resolveio/server-lib 22.2.33 → 22.2.34

package/src/http/health.ts

@@ -0,0 +1,7 @@
+import * as express from 'express';
+
+export function setupHealthRoutes(app) {
+	app.get('/health', express.json(), function (request, response) {
+		response.sendStatus(200);
+	});
+}

package/src/http/home.ts

@@ -0,0 +1,90 @@
+import * as express from 'express';
+import SimpleSchema from 'simpl-schema';
+import { ResolveIOServer } from '../resolveio-server-app';
+import { isAllowedOrigin, objectIdHexString } from '../util/common';
+import { ErrorReporter } from '../util/error-reporter';
+
+export function setupHomeRoutes(mainServer, app, serverConfig) {
+	app.post('/resolveioContactUs', express.json(), async (request, response) => {
+		if (!isAllowedOrigin(request.headers.origin, serverConfig)) {
+			response.send(JSON.stringify({
+				error: true,
+				result: 'Invalid header'
+			}));
+		}
+		else {
+			let body = request.body;
+
+			let schema = new SimpleSchema({
+				form: {
+					type: Object
+				},
+				'form.name': {
+					type: String
+				},
+				'form.email': {
+					type: String
+				},
+				'form.phone': {
+					type: String
+				},
+				'form.subject': {
+					type: String
+				},
+				'form.message': {
+					type: String
+				}
+			});
+	
+			try {
+				schema.validate(body);
+			}
+			catch (errors) {
+				if (errors) {
+					console.error(new Date(), 'Error in HTTP Check (/resolveioContactUs)', errors);
+
+					const correlationId = objectIdHexString();
+					await ErrorReporter.report({
+						sourceApp: 'http-home',
+						message: 'HTTP Validation Error - /resolveioContactUs',
+						environment: serverConfig?.ROOT_URL,
+						clientSlug: ResolveIOServer.getClientName(),
+						clientName: serverConfig?.CLIENT_NAME,
+						context: {
+							route: '/resolveioContactUs',
+							body,
+							errors
+						},
+						metadata: {
+							context: 'http-validation',
+							route: '/resolveioContactUs',
+							correlationId
+						},
+						correlationId
+					});
+	
+					response.send(JSON.stringify({
+						error: true,
+						result: 'Invalid Parameters'
+					}));
+		
+					return;
+				}
+			}
+
+            let form = request.body.form;
+            
+            mainServer.getMethodManager().sendEmail('dustin@resolveio.com', 'ResolveIO - Contact Us', '', 
+            'Name: ' + form.name + '<br>' + 
+            'Email: ' + form.email + '<br>' + 
+            'Phone: ' + form.phone + '<br>' + 
+            'Subject: ' + form.subject + '<br>' + 
+            'Message: ' + form.message + '<br>');
+
+            response.send(JSON.stringify({
+				error: false,
+				result: null
+			}));
+		}
+	});
+}

package/src/http/slow-query-publication.ts

@@ -0,0 +1,49 @@
+import * as express from 'express';
+import { ResolveIOServer } from '../resolveio-server-app';
+
+export function setupSlowQueryPublicationRoutes(app: express.Application) {
+	app.post('/api/slow-queries/run-publication', express.json(), async (request, response) => {
+		const body = request.body || {};
+		const publication = typeof body.publication === 'string' ? body.publication.trim() : '';
+		const subscriptionData = Array.isArray(body.subscriptionData) ? body.subscriptionData : [];
+		const userId = typeof body.userId === 'string' ? body.userId : undefined;
+
+		if (!publication) {
+			response.status(400).send(JSON.stringify({
+				error: true,
+				result: 'Publication name is required.'
+			}));
+			return;
+		}
+
+		const manager = ResolveIOServer.getMainServer().getSubscriptionManager();
+		if (!manager) {
+			response.status(503).send(JSON.stringify({
+				error: true,
+				result: 'Subscription manager is not available.'
+			}));
+			return;
+		}
+
+	try {
+		const startTime = Date.now();
+		const execution = await manager.runPublicationOnce(publication, subscriptionData, {userId});
+		const durationMs = Date.now() - startTime;
+		response.send(JSON.stringify({
+			error: false,
+			result: {
+				durationMs,
+				data: execution?.result,
+				snapshot: execution?.snapshot
+			}
+		}));
+	}
+	catch (err) {
+		console.error('Slow query publication run failed', err);
+			response.status(500).send(JSON.stringify({
+				error: true,
+				result: err?.message || 'Failed to run publication.'
+			}));
+		}
+	});
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './public_api';

package/src/managers/communication-metric.manager.ts

@@ -0,0 +1,82 @@
+import { CommunicationMetrics } from '../collections/communication-metric.collection';
+import { CommunicationMetricChannel, CommunicationMetricStatus } from '../models/communication-metric.model';
+import { ResolveIOServer } from '../resolveio-server-app';
+
+export interface CommunicationMetricInput {
+	channel: CommunicationMetricChannel;
+	status: CommunicationMetricStatus;
+	value?: number;
+	unit?: string;
+	timestamp?: Date;
+	provider?: string;
+	clientSlug?: string;
+	clientName?: string;
+	id_client?: string;
+	metadata?: Record<string, any>;
+}
+
+const normalizeString = (value: any): string | undefined => {
+	if (typeof value !== 'string') {
+		return undefined;
+	}
+	const trimmed = value.trim();
+	return trimmed.length ? trimmed : undefined;
+};
+
+const buildMetadata = (input: CommunicationMetricInput): Record<string, any> | undefined => {
+	const config = ResolveIOServer.getServerConfig?.() || {};
+	const metadata: Record<string, any> = {
+		clientSlug: normalizeString(input.clientSlug) || normalizeString(ResolveIOServer.getClientName?.()),
+		clientName: normalizeString(input.clientName) || normalizeString(config['CLIENT_NAME']),
+		id_client: normalizeString(input.id_client),
+		channel: input.channel,
+		status: input.status,
+		provider: normalizeString(input.provider)
+	};
+
+	if (input.metadata && typeof input.metadata === 'object') {
+		Object.assign(metadata, input.metadata);
+	}
+
+	Object.keys(metadata).forEach(key => {
+		if (metadata[key] === undefined || metadata[key] === null || metadata[key] === '') {
+			delete metadata[key];
+		}
+	});
+
+	return Object.keys(metadata).length ? metadata : undefined;
+};
+
+export async function recordCommunicationMetric(input: CommunicationMetricInput): Promise<void> {
+	if (!input || !input.channel || !input.status) {
+		return;
+	}
+
+	const value = Number.isFinite(input.value) ? input.value : 1;
+	if (!value) {
+		return;
+	}
+
+	const payload = {
+		date: input.timestamp instanceof Date ? input.timestamp : new Date(),
+		type: `${input.channel}.${input.status}`,
+		value,
+		unit: input.unit || 'count',
+		metadata: buildMetadata(input)
+	};
+
+	try {
+		await ResolveIOServer.getMongoManager().runWithoutSession(() => CommunicationMetrics.insertOne(payload));
+	}
+	catch (err) {
+		console.error('Failed to record communication metric', err);
+	}
+}
+
+export async function recordEmailMetric(input: Omit<CommunicationMetricInput, 'channel'>): Promise<void> {
+	return recordCommunicationMetric({ ...input, channel: 'email' });
+}
+
+export async function recordTextMessageMetric(input: Omit<CommunicationMetricInput, 'channel'>): Promise<void> {
+	return recordCommunicationMetric({ ...input, channel: 'sms' });
+}

package/src/managers/cron.manager.ts

@@ -0,0 +1,333 @@
+import { ChangeStream, ChangeStreamDocument } from 'mongodb';
+import { CronJobHistories } from '../collections/cron-job-history.collection';
+import { CronJobs } from '../collections/cron-job.collection';
+import { CronJobManager } from '../cron/cron';
+import { CronJobHistoryModel } from '../models/cron-job-history.model';
+import { CronJobModel } from '../models/cron-job.model';
+import { ResolveIOServer } from '../resolveio-server-app';
+import { objectIdHexString } from '../util/common';
+
+export class CronManager {
+	private _cronManager: CronJobManager;
+	private _watchCrons$: ChangeStream;
+	private _jobs: CronJobModel[] = [];
+
+	constructor() {}
+
+	static create() {
+		const cronManager = new CronManager();
+		setImmediate(async () => await cronManager.initialize());
+		return cronManager;
+	}
+
+	private async initialize() {
+		this._cronManager = new CronJobManager();
+		await this.watchCrons();
+	}
+
+	private async watchCrons() {
+		if (this._watchCrons$ && !this._watchCrons$.closed) {
+			this._watchCrons$.removeAllListeners();
+			await this._watchCrons$.close();
+			this._watchCrons$ = null;
+		}
+	
+		// eslint-disable-next-line no-restricted-syntax
+		await new Promise(resolve => setTimeout(resolve, 1000));
+	
+		if (!this._watchCrons$ || this._watchCrons$.closed) {			
+			let res = await CronJobs.find();
+			this._jobs = res;
+
+			for (let job of this._jobs) {
+				await this.addCronJob(job);
+				if (job.running) {
+					await CronJobs.updateOne({_id: job._id}, {$set: {running: false}});
+				}
+			}
+
+			this._watchCrons$ = CronJobs.watchCollection([], {fullDocument: 'updateLookup'});
+
+			this._watchCrons$.on('change', async (doc: ChangeStreamDocument<CronJobModel>) => {
+				if (doc.operationType === 'insert') {
+					if (doc.fullDocument) {
+						if (!this._jobs.some(a => a._id === <any>doc.documentKey['_id'])) {
+							this._jobs.push(doc.fullDocument);
+						}
+
+						await this.addCronJob(doc.fullDocument);
+					}
+				}
+				else if (doc.operationType === 'replace' || doc.operationType === 'update') {
+					if (doc.fullDocument) {
+						let oldDoc = this._jobs.find(a => a._id === <any>doc.documentKey['_id']);
+						if (oldDoc) {
+							this._jobs.splice(this._jobs.map(a => a._id).indexOf(<any>doc.documentKey['_id']), 1, doc.fullDocument);
+
+							if (oldDoc.name !== doc.fullDocument.name) {
+								await this.removeCronJob(oldDoc.name);
+								await this.addCronJob(doc.fullDocument);
+							}
+							else if (typeof oldDoc.time_to_run !== typeof doc.fullDocument.time_to_run || (typeof oldDoc.time_to_run === 'string' && oldDoc.time_to_run !== doc.fullDocument.time_to_run) ||
+								(oldDoc.time_to_run instanceof Date && oldDoc.time_to_run.getTime() !== (<Date>doc.fullDocument.time_to_run).getTime()) || 
+								oldDoc.timezone !== doc.fullDocument.timezone
+							) {
+								await this.updateCronJob(doc.fullDocument);
+							}
+						}
+						else {
+							this._jobs.push(doc.fullDocument);
+							await this.addCronJob(doc.fullDocument);
+						}
+					}
+					else {
+						if (this._jobs.some(a => a._id === <any>doc.documentKey['_id'])) {
+							let job = this._jobs.find(a => a._id === <any>doc.documentKey['_id']);
+							await this.removeCronJob(job.name);
+							this._jobs.splice(this._jobs.map(a => a._id).indexOf(<any>doc.documentKey['_id']), 1);
+						}
+					}
+				}
+				else if (doc.operationType === 'delete') {
+					if (this._jobs.some(a => a._id === (<any>doc).documentKey['_id'])) {
+						let job = this._jobs.find(a => a._id === <any>doc.documentKey['_id']);
+						await this.removeCronJob(job.name);
+						this._jobs.splice(this._jobs.map(a => a._id).indexOf(<any>doc.documentKey['_id']), 1);
+					}
+				}
+			})
+			.on('error', async () => {
+				await this._watchCrons$.close();
+			})
+			.on('end', async () => {
+				await this._watchCrons$.close();
+			})
+			.on('close', async () => {
+				this._watchCrons$.removeAllListeners();
+				this._watchCrons$ = null;
+				await this.watchCrons();
+			});
+		}
+	}
+
+	private doesCronJobExist(cron: CronJobModel) {
+		return this._cronManager.exists(cron.name);
+	}
+
+	private doesCronJobNameExist(cron_name: string) {
+		return this._cronManager.exists(cron_name);
+	}
+
+	private async addCronJob(cron: CronJobModel) {
+		if (!this.doesCronJobExist(cron)) {
+			try {
+				await this._cronManager.add(
+					cron.name,
+					cron.time_to_run,
+					() => this.runCronJob(cron),
+					null,
+					true,
+					cron.timezone,
+					null, 
+					false
+				);
+
+				let nextDate = new Date(this._cronManager.getJob(cron.name).nextDate()['ts']);
+
+				if (cron.running || (nextDate && !cron.next_run || nextDate.getTime() !== cron.next_run.getTime())) {
+					await CronJobs.updateOne({_id: cron._id}, {$set: {running: false, next_run: nextDate || null}});
+				}
+			}
+			catch(e) {
+				console.log('Cron error', e);
+
+				if (cron.time_to_run instanceof Date) {
+					await this.runCronJob(cron);
+				}
+			}
+		}
+	}
+
+	private async updateCronJob(cron: CronJobModel) {
+		if (this.doesCronJobExist(cron)) {
+			await this._cronManager.update(cron.name, cron.time_to_run, () => this.runCronJob(cron), null, true, cron.timezone);
+
+			let nextDate = new Date(this._cronManager.getJob(cron.name).nextDate()['ts']);
+
+			if (nextDate && (!cron.next_run || nextDate.getTime() !== cron.next_run.getTime())) {
+				await CronJobs.updateOne({_id: cron._id}, {$set: {next_run: nextDate}});
+			}
+		}
+	}
+
+	private async removeCronJob(cron_name: string) {
+		if (this.doesCronJobNameExist(cron_name)) {
+			await this._cronManager.delete(cron_name);
+		}
+	}
+
+	private startCronJob(cron: CronJobModel) {
+		if (this.doesCronJobExist(cron)) {
+			this._cronManager.start(cron.name);
+		}
+	}
+
+	private async stopCronJob(cron: CronJobModel) {
+		if (this.doesCronJobExist(cron)) {
+			await this._cronManager.stop(cron.name);
+		}
+	}
+
+	private async stopAllCronJobs() {
+		await this._cronManager.stopAll();
+	}
+
+	private async runCronJob(cron: CronJobModel) {
+		let now = new Date();
+
+		let res = await CronJobs.findOneAndUpdate({
+			$and: [
+				{_id: cron._id},
+				{running: false},
+				{
+					$or: [
+						{next_run: {$exists: false}},
+						{next_run: null},
+						{next_run: {$lte: now}}
+					]
+				}
+			]
+		}, {$set: {running: true}});
+			
+		if (res) {
+			const saveHistoryOverride = !!(res.method_run_data && (<any>res.method_run_data)._cron_save_history === false);
+			const saveHistory = !saveHistoryOverride && res.save_history !== false;
+			let cronHistory: CronJobHistoryModel = null;
+			if (saveHistory) {
+				cronHistory = {
+					_id: objectIdHexString(),
+					name: res.name,
+					reoccuring: res.repeat,
+					time_to_run: res.time_to_run,
+					method_name: res.method_run,
+					id_cronjob: res._id,
+					server_restart: true,
+					passed: true,
+					error: '',
+					date_scheduled: res.next_run,
+					date_start: new Date(),
+					date_end: null,
+					date_next: null
+				};
+				
+				await CronJobHistories.create(cronHistory);
+			}
+
+			let timeoutHandle = setTimeout(async () => {
+				console.log(new Date(), 'Cron Timeout', this.safeStringify(cron));
+
+				if (res.repeat) {
+					let nextDate = new Date(this._cronManager.getJob(res.name).nextDate()['ts']);
+					if (cronHistory) {
+						cronHistory.date_next = nextDate;
+					}
+					await CronJobs.updateOne({_id: res._id}, {$set: {running: false, next_run: nextDate}});
+				} 
+				else {
+					await CronJobs.deleteOne({_id: res._id});
+				}
+			}, 5 * 60 * 1000); // 5 minutes in milliseconds
+
+			try {
+				if (res.method_run_data) {
+					await ResolveIOServer.getMainServer().getMethodManager().callMethodCron(res.method_run, res.method_run_data);	
+
+				}
+				else {
+					await ResolveIOServer.getMainServer().getMethodManager().callMethodCron(res.method_run);
+				}
+
+				if (res.method_complete) {
+					if (res.method_complete_data) {
+						await ResolveIOServer.getMainServer().getMethodManager().callMethodCron(res.method_complete, res.method_complete_data);
+					}
+					else {
+						await ResolveIOServer.getMainServer().getMethodManager().callMethodCron(res.method_complete);
+					}
+				}
+			}
+			catch (err) {
+				console.log(new Date(), 'Cron Error', this.safeStringify(err));
+				if (cronHistory) {
+					cronHistory.error = this.safeStringify(err);
+					cronHistory.passed = false;
+				}
+
+				if (res.repeat) {
+					let nextDate = new Date(this._cronManager.getJob(res.name).nextDate()['ts']);
+					if (cronHistory) {
+						cronHistory.date_next = nextDate;
+					}
+					await CronJobs.updateOne({_id: res._id}, {$set: {running: false, next_run: nextDate}});
+				}
+				else {
+					await CronJobs.deleteOne({_id: res._id});
+				}
+			}
+			finally {
+				// Clear the timeout if the job completes or fails before the timeout
+				clearTimeout(timeoutHandle);
+			}
+
+			if (res.repeat) {
+				let nextDate = new Date(this._cronManager.getJob(res.name).nextDate()['ts']);
+				if (cronHistory) {
+					cronHistory.date_next = nextDate;
+				}
+				await CronJobs.updateOne({_id: res._id}, {$set: {running: false, next_run: nextDate}});
+			} 
+			else {
+				await CronJobs.deleteOne({_id: res._id});
+			}
+
+			if (cronHistory) {
+				await CronJobHistories.updateOne({_id: cronHistory._id}, {$set: {
+					server_restart: false,
+					passed: cronHistory.passed,
+					error: cronHistory.error,
+					date_end: new Date(),
+					date_next: cronHistory.date_next
+				}});
+			}
+		}
+	}
+
+	private safeStringify(obj: unknown)
+	{
+		try
+		{
+			return JSON.stringify(obj, this.getCircularReplacer(), 2);
+		}
+		catch (e)
+		{
+			return `Error stringifying object: ${e.message}`;
+		}
+	}
+
+	private getCircularReplacer()
+	{
+		const seen = new WeakSet();
+		return (key, value) =>
+		{
+			if (typeof value === 'object' && value !== null)
+			{
+				if (seen.has(value))
+				{
+					return '[Circular]';
+				}
+				seen.add(value);
+			}
+			return value;
+		};
+	}
+}