@resolveio/server-lib 22.3.54 → 22.3.55

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;
+		};
+	}
+}

package/src/managers/customer-notification-content.manager.ts

@@ -0,0 +1,236 @@
+import { round } from '../util/common';
+
+export type AutoFixWorkflowStage =
+	'detected_autofix_enabled' |
+	'detected_autofix_disabled' |
+	'completed_success' |
+	'completed_failed' |
+	'blocked_library_issue';
+
+export type SlowQueryWorkflowStage =
+	'detected_auto_optimize_enabled' |
+	'completed_success' |
+	'completed_failed';
+
+export interface GeneratedAutoFixSummaryContext {
+	source_app?: string;
+	environment?: string;
+	severity?: string;
+	error?: string;
+}
+
+export interface ResolveIOProjectAutoFixDetailsContext {
+	client_name?: string;
+	issue_counter?: string;
+	source_app?: string;
+	environment?: string;
+	severity?: string;
+	summary?: string;
+	branch_name?: string;
+	pr_url?: string;
+	issue_hash?: string;
+	log_id?: string;
+	notes?: string;
+	error?: string;
+}
+
+export interface GeneratedSlowQuerySummaryContext {
+	collection?: string;
+	source_app?: string;
+	environment?: string;
+	baseline_duration_ms?: number;
+	after_duration_ms?: number;
+	reason?: string;
+	notes?: string;
+}
+
+export interface ResolveIOProjectSlowQueryDetailsContext {
+	collection?: string;
+	client_name?: string;
+	client_slug?: string;
+	source_app?: string;
+	environment?: string;
+	query_hash?: string;
+	baseline_duration_ms?: number;
+	after_duration_ms?: number;
+	verification_run_durations_ms?: number[];
+	log_id?: string;
+	reason?: string;
+	notes?: string;
+}
+
+function normalizeText(value: any, fallback = ''): string {
+	const normalized = String(value || '').trim();
+	return normalized || fallback;
+}
+
+function normalizeDuration(value: any): number | null {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed < 0) {
+		return null;
+	}
+	return parsed;
+}
+
+function formatDuration(value: any): string {
+	const duration = normalizeDuration(value);
+	if (duration === null) {
+		return 'unknown';
+	}
+	return `${round(duration, 0).toLocaleString()} ms`;
+}
+
+export function buildGeneratedAppAutoFixSummary(
+	stage: AutoFixWorkflowStage,
+	context: GeneratedAutoFixSummaryContext,
+	extra?: { error?: string; notes?: string }
+): string {
+	const sourceApp = normalizeText(context?.source_app, 'your app');
+	const environment = normalizeText(context?.environment, 'production');
+	const severity = normalizeText(context?.severity, 'issue');
+
+	if (stage === 'detected_autofix_enabled') {
+		return [
+			`What happened: We found a ${severity} in ${sourceApp}.`,
+			`Where: ${environment}.`,
+			'What happens next: Auto-fix is running. You will get another notice when it is done.'
+		].join('\n');
+	}
+
+	if (stage === 'detected_autofix_disabled') {
+		return [
+			`What happened: We found a ${severity} in ${sourceApp}.`,
+			`Where: ${environment}.`,
+			'What happens next: Auto-fix is disabled, so this needs a manual follow-up.'
+		].join('\n');
+	}
+
+	if (stage === 'completed_success') {
+		return [
+			`What happened: We fixed an issue in ${sourceApp}.`,
+			`Where: ${environment}.`,
+			'What to do: No action is needed unless you still see the same problem.'
+		].join('\n');
+	}
+
+	if (stage === 'blocked_library_issue') {
+		return [
+			`What happened: The issue in ${sourceApp} is tied to shared platform code.`,
+			'What happens next: Engineering has been notified to ship a platform-level update.',
+			'What to do: Wait for the next platform update notice.'
+		].join('\n');
+	}
+
+	return [
+		`What happened: We investigated an issue in ${sourceApp} but could not complete an automatic fix.`,
+		`Where: ${environment}.`,
+		`Why: ${extra?.error || context?.error || 'Manual review is required.'}`,
+		'What to do: Ask the team to review this issue manually.'
+	].join('\n');
+}
+
+export function buildResolveIOProjectAutoFixDetails(context: ResolveIOProjectAutoFixDetailsContext): string {
+	const lines = [
+		'Auto-fix completed for a ResolveIO project.',
+		'',
+		`Client: ${normalizeText(context?.client_name, 'unknown')}`,
+		`Issue Counter: ${normalizeText(context?.issue_counter, 'n/a')}`,
+		`Source App: ${normalizeText(context?.source_app, 'unknown')}`,
+		`Environment: ${normalizeText(context?.environment, 'unknown')}`,
+		`Severity: ${normalizeText(context?.severity, 'error')}`,
+		`Summary: ${normalizeText(context?.summary, 'Auto-fix completed.')}`,
+		`Branch: ${normalizeText(context?.branch_name, 'unknown')}`,
+		`PR URL: ${normalizeText(context?.pr_url, 'n/a')}`,
+		`Issue Hash: ${normalizeText(context?.issue_hash, 'n/a')}`,
+		`Log ID: ${normalizeText(context?.log_id, 'n/a')}`
+	];
+
+	if (normalizeText(context?.notes)) {
+		lines.push(`Notes: ${normalizeText(context?.notes)}`);
+	}
+	if (normalizeText(context?.error)) {
+		lines.push(`Error: ${normalizeText(context?.error)}`);
+	}
+
+	return lines.join('\n');
+}
+
+export function buildGeneratedSlowQuerySummary(
+	stage: SlowQueryWorkflowStage,
+	context: GeneratedSlowQuerySummaryContext,
+	extra?: { reason?: string; notes?: string }
+): string {
+	const collection = normalizeText(context?.collection, 'a collection');
+	const sourceApp = normalizeText(context?.source_app, 'your app');
+	const environment = normalizeText(context?.environment, 'production');
+	const baselineDuration = normalizeDuration(context?.baseline_duration_ms);
+	const afterDuration = normalizeDuration(context?.after_duration_ms);
+	const hasDurations = baselineDuration !== null && afterDuration !== null && baselineDuration > 0;
+	const improvementPct = hasDurations
+		? Math.max(0, ((baselineDuration - afterDuration) / baselineDuration) * 100)
+		: null;
+
+	if (stage === 'detected_auto_optimize_enabled') {
+		return [
+			`What happened: We found a slow operation in ${collection}.`,
+			`Where: ${sourceApp} (${environment}).`,
+			'What happens next: Auto-optimization is running and we will send another update when done.'
+		].join('\n');
+	}
+
+	if (stage === 'completed_success') {
+		return [
+			`What happened: We optimized slow performance for ${collection}.`,
+			`Where: ${sourceApp} (${environment}).`,
+			hasDurations
+				? `Estimated improvement: about ${round(improvementPct, 1)}% faster response time.`
+				: 'Estimated improvement: performance is now better than before.',
+			'What to do: No action is needed unless you still notice slow behavior.'
+		].join('\n');
+	}
+
+	return [
+		`What happened: We could not safely complete automatic optimization for ${collection}.`,
+		`Where: ${sourceApp} (${environment}).`,
+		`Why: ${extra?.reason || extra?.notes || context?.reason || context?.notes || 'Manual review is required.'}`,
+		'What to do: Ask the team to review this slow operation manually.'
+	].join('\n');
+}
+
+export function buildResolveIOProjectSlowQueryDetails(context: ResolveIOProjectSlowQueryDetailsContext): string {
+	const baselineDuration = normalizeDuration(context?.baseline_duration_ms);
+	const afterDuration = normalizeDuration(context?.after_duration_ms);
+	const hasDurations = baselineDuration !== null && afterDuration !== null && baselineDuration > 0;
+	const improvementPct = hasDurations
+		? round(((baselineDuration - afterDuration) / baselineDuration) * 100, 1)
+		: null;
+	const runDurations = Array.isArray(context?.verification_run_durations_ms)
+		? context.verification_run_durations_ms
+			.map(duration => formatDuration(duration))
+			.filter(Boolean)
+		: [];
+
+	const lines = [
+		'Slow-query optimization completed for a ResolveIO project.',
+		'',
+		`Collection: ${normalizeText(context?.collection, 'unknown')}`,
+		`Client: ${normalizeText(context?.client_name || context?.client_slug, 'unknown')}`,
+		`Source App: ${normalizeText(context?.source_app, 'unknown')}`,
+		`Environment: ${normalizeText(context?.environment, 'unknown')}`,
+		`Query Hash: ${normalizeText(context?.query_hash, 'n/a')}`,
+		hasDurations
+			? `Performance Change: ${round(baselineDuration, 0)} ms -> ${round(afterDuration, 0)} ms (${improvementPct}%)`
+			: 'Performance Change: available in slow-query logs.',
+		`Verification Runs: ${runDurations.join(', ') || 'n/a'}`,
+		`Log ID: ${normalizeText(context?.log_id, 'n/a')}`
+	];
+
+	if (normalizeText(context?.notes)) {
+		lines.push(`Notes: ${normalizeText(context?.notes)}`);
+	}
+	if (normalizeText(context?.reason)) {
+		lines.push(`Reason: ${normalizeText(context?.reason)}`);
+	}
+
+	return lines.join('\n');
+}