@resolveio/server-lib 22.3.219 → 22.3.221

package/src/managers/ai-run-evidence.manager.ts

@@ -0,0 +1,264 @@
+import { createHash } from 'crypto';
+import { AIRuns } from '../collections/ai-run.collection';
+import { AIRunModel } from '../models/ai-run.model';
+import { objectIdHexString } from '../util/common';
+import {
+	AIRun,
+	AIRunOutcomeLabel,
+	AIRunSource
+} from '../util/ai-run-evidence';
+import {
+	AIRunDatasetExport,
+	AIRunDatasetExportOptions,
+	buildAIRunDatasetExport,
+	classifyAIRunFailureClass
+} from '../util/ai-run-evidence-eval';
+
+export interface AIRunPersistenceResult {
+	requested: number;
+	upsertedCount: number;
+	matchedCount: number;
+	modifiedCount: number;
+	ids: string[];
+}
+
+export interface AIRunQuery {
+	source?: AIRunSource;
+	outcome?: AIRunOutcomeLabel;
+	sourceIds?: Record<string, string>;
+	updatedAfter?: Date | string;
+	updatedBefore?: Date | string;
+	limit?: number;
+	skip?: number;
+	includeTrainingExamples?: boolean;
+}
+
+export interface AIRunSummary {
+	total: number;
+	bySource: Record<string, number>;
+	byOutcome: Record<string, number>;
+	byFailureClass: Record<string, number>;
+	estimatedUsd: number;
+	totalTokens: number;
+}
+
+function cleanText(value: any, max = 1000): string {
+	return String(value || '').replace(/\s+/g, ' ').trim().slice(0, max);
+}
+
+function safeKey(value: string): string {
+	const cleaned = cleanText(value, 300).toLowerCase().replace(/[^a-z0-9_.:-]+/g, '-').replace(/^-+|-+$/g, '');
+	return cleaned || createHash('sha1').update(value || objectIdHexString()).digest('hex').slice(0, 24);
+}
+
+function normalizeDate(value: any): Date | undefined {
+	if (value instanceof Date && Number.isFinite(value.getTime())) {
+		return value;
+	}
+	if (value) {
+		const parsed = new Date(value);
+		if (Number.isFinite(parsed.getTime())) {
+			return parsed;
+		}
+	}
+	return undefined;
+}
+
+function countBy(values: string[]): Record<string, number> {
+	const result: Record<string, number> = {};
+	for (const value of values) {
+		result[value] = (result[value] || 0) + 1;
+	}
+	return result;
+}
+
+function stripUndefined<T extends Record<string, any>>(value: T): T {
+	const next: Record<string, any> = {};
+	for (const key of Object.keys(value)) {
+		if (value[key] !== undefined) {
+			next[key] = value[key];
+		}
+	}
+	return next as T;
+}
+
+function resolveSourceKey(run: AIRun): string {
+	const sourceIds = run.sourceIds || {};
+	const priorityKeys = [
+		'ticketNumber',
+		'ticketId',
+		'appId',
+		'jobId',
+		'conversationId',
+		'domain',
+		'userId'
+	];
+	for (const key of priorityKeys) {
+		if (sourceIds[key]) {
+			return `${key}:${sourceIds[key]}`;
+		}
+	}
+	const sortedSourceIds: Record<string, string> = {};
+	for (const key of Object.keys(sourceIds).sort()) {
+		const value = cleanText(sourceIds[key], 300);
+		if (value) {
+			sortedSourceIds[key] = value;
+		}
+	}
+	if (Object.keys(sortedSourceIds).length) {
+		return JSON.stringify(sortedSourceIds);
+	}
+	return [
+		run.title || '',
+		run.status || '',
+		run.phase || '',
+		run.startedAt || '',
+		run.completedAt || ''
+	].join('|');
+}
+
+export function resolveAIRunStableId(run: AIRun): string {
+	if (run.id) {
+		return cleanText(run.id, 240);
+	}
+	const source = cleanText(run.source, 80) || 'unknown';
+	const sourceKey = resolveSourceKey(run);
+	const compactSourceKey = safeKey(sourceKey);
+	if (compactSourceKey.length <= 160) {
+		return `ai-run:${source}:${compactSourceKey}`;
+	}
+	const digest = createHash('sha1').update(`${source}:${sourceKey}`).digest('hex').slice(0, 32);
+	return `ai-run:${source}:${digest}`;
+}
+
+export function normalizeAIRunForPersistence(run: AIRun): AIRunModel {
+	const _id = resolveAIRunStableId(run);
+	return stripUndefined({
+		_id,
+		source: run.source || 'unknown',
+		sourceIds: run.sourceIds || {},
+		title: cleanText(run.title, 500),
+		status: cleanText(run.status, 160),
+		phase: cleanText(run.phase, 160),
+		startedAt: normalizeDate(run.startedAt),
+		completedAt: normalizeDate(run.completedAt),
+		outcome: run.outcome || 'unknown',
+		events: Array.isArray(run.events) ? run.events : [],
+		gates: Array.isArray(run.gates) ? run.gates : [],
+		qa: run.qa,
+		cost: run.cost,
+		nextAction: cleanText(run.nextAction, 2000),
+		warnings: Array.isArray(run.warnings) ? run.warnings.map((warning) => cleanText(warning, 300)).filter(Boolean) : [],
+		metadata: {
+			...(run.metadata || {}),
+			failureClass: classifyAIRunFailureClass(run),
+			sourceRunId: run.id || ''
+		}
+	});
+}
+
+function buildAIRunFindQuery(query: AIRunQuery = {}): Record<string, any> {
+	const selector: Record<string, any> = {};
+	if (query.source) {
+		selector.source = query.source;
+	}
+	if (query.outcome) {
+		selector.outcome = query.outcome;
+	}
+	for (const key of Object.keys(query.sourceIds || {})) {
+		const value = cleanText(query.sourceIds?.[key], 300);
+		if (value) {
+			selector[`sourceIds.${key}`] = value;
+		}
+	}
+	const updatedAt: Record<string, Date> = {};
+	const updatedAfter = normalizeDate(query.updatedAfter);
+	const updatedBefore = normalizeDate(query.updatedBefore);
+	if (updatedAfter) {
+		updatedAt.$gte = updatedAfter;
+	}
+	if (updatedBefore) {
+		updatedAt.$lte = updatedBefore;
+	}
+	if (Object.keys(updatedAt).length) {
+		selector.updatedAt = updatedAt;
+	}
+	return selector;
+}
+
+export class AIRunEvidenceManager {
+	static async upsertRuns(runs: AIRun[]): Promise<AIRunPersistenceResult> {
+		const docs = runs.map((run) => normalizeAIRunForPersistence(run));
+		const operations = docs.map((doc) => {
+			const { _id, createdAt, ...setDoc } = doc;
+			return {
+				updateOne: {
+					filter: { _id },
+					update: {
+						$set: {
+							...setDoc,
+							updatedAt: new Date()
+						},
+						$setOnInsert: {
+							_id,
+							createdAt: createdAt || new Date()
+						}
+					},
+					upsert: true
+				}
+			};
+		});
+		if (!operations.length) {
+			return {
+				requested: 0,
+				upsertedCount: 0,
+				matchedCount: 0,
+				modifiedCount: 0,
+				ids: []
+			};
+		}
+		const result = await AIRuns.bulkWrite(operations, { ordered: false }, false, true, true);
+		return {
+			requested: docs.length,
+			upsertedCount: Number(result?.upsertedCount || 0),
+			matchedCount: Number(result?.matchedCount || 0),
+			modifiedCount: Number(result?.modifiedCount || 0),
+			ids: docs.map((doc) => String(doc._id || '')).filter(Boolean)
+		};
+	}
+
+	static async findRuns(query: AIRunQuery = {}): Promise<AIRunModel[]> {
+		const limit = Math.min(Math.max(Number(query.limit || 100), 1), 1000);
+		const skip = Math.max(Number(query.skip || 0), 0);
+		return await AIRuns.find(buildAIRunFindQuery(query), {
+			sort: { updatedAt: -1 },
+			limit,
+			skip
+		});
+	}
+
+	static async summarizeRuns(query: AIRunQuery = {}): Promise<AIRunSummary> {
+		const runs = await this.findRuns({
+			...query,
+			limit: Math.min(Math.max(Number(query.limit || 1000), 1), 5000)
+		});
+		const estimatedUsd = runs.reduce((sum, run) => sum + (Number(run.cost?.estimatedUsd) || 0), 0);
+		const totalTokens = runs.reduce((sum, run) => sum + (Number(run.cost?.totalTokens) || 0), 0);
+		return {
+			total: runs.length,
+			bySource: countBy(runs.map((run) => run.source || 'unknown')),
+			byOutcome: countBy(runs.map((run) => run.outcome || 'unknown')),
+			byFailureClass: countBy(runs.map((run) => String(run.metadata?.failureClass || 'unknown'))),
+			estimatedUsd: Number(estimatedUsd.toFixed(6)),
+			totalTokens
+		};
+	}
+
+	static async exportRuns(query: AIRunQuery = {}, options: AIRunDatasetExportOptions = {}): Promise<AIRunDatasetExport> {
+		const runs = await this.findRuns({
+			...query,
+			limit: Math.min(Math.max(Number(query.limit || 1000), 1), 5000)
+		});
+		return buildAIRunDatasetExport(runs as AIRun[], options);
+	}
+}

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