@resolveio/server-lib 22.2.34 → 22.2.36

package/src/http/health.ts

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

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

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

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

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

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

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