@resolveio/server-lib 22.3.221 → 22.3.222

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

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

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