@resolveio/server-lib 22.3.220 → 22.3.221

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

package/src/managers/diagnostic-manager-bootstrap.ts

@@ -0,0 +1,165 @@
+import { ResolveIOServer } from '../resolveio-server-app';
+import { ErrorAutoFixManagerDependencies, registerErrorAutoFixManagerDependencies } from './error-auto-fix.manager';
+import { registerSlowQueryManagerDependencies } from './slow-query.manager';
+import {
+	CheckAICoderTokenEligibilityFn,
+	registerSlowQueryVerifierDependencies,
+	SlowQueryVerifierDependencies
+} from './slow-query-verifier.manager';
+
+interface CollectionAdapter {
+	findOne: Function;
+	find: Function;
+	insertOne: Function;
+	updateOne: Function;
+	findOneAndUpdate: Function;
+	findById?: Function;
+	createIndex?: Function;
+}
+
+export interface DiagnosticManagerBootstrapDependencies {
+	ErrorAutoFixLogs?: any;
+	SlowQueryLogs?: any;
+	AICoderApps?: any;
+	AIDashboardJobs?: any;
+	checkAICoderTokenEligibility?: CheckAICoderTokenEligibilityFn;
+}
+
+let indexesEnsured = false;
+
+function resolveMainCollection(collectionName: string): any {
+	const mainDb = ResolveIOServer.getMainDB();
+	if (!mainDb) {
+		throw new Error(`Cannot resolve collection ${collectionName} before MongoDB main DB is initialized.`);
+	}
+
+	return mainDb.collection(collectionName);
+}
+
+function createCollectionAdapter(collectionName: string): CollectionAdapter {
+	const collection = resolveMainCollection(collectionName);
+
+	return {
+		findOne: (query = {}, options = {}) => {
+			return collection.findOne(query, options);
+		},
+		find: (query = {}, options = {}) => {
+			const findOptions: Record<string, any> = {...(options || {})};
+			const sort = findOptions.sort;
+			const skip = findOptions.skip;
+			const limit = findOptions.limit;
+			delete findOptions.sort;
+			delete findOptions.skip;
+			delete findOptions.limit;
+
+			let cursor = collection.find(query, findOptions);
+			if (sort) {
+				cursor = cursor.sort(sort);
+			}
+			if (typeof skip === 'number') {
+				cursor = cursor.skip(skip);
+			}
+			if (typeof limit === 'number') {
+				cursor = cursor.limit(limit);
+			}
+
+			return cursor.toArray();
+		},
+		insertOne: (document, options = {}) => {
+			return collection.insertOne(document, options);
+		},
+		updateOne: (query, update, options = {}) => {
+			return collection.updateOne(query, update, options);
+		},
+		findOneAndUpdate: async (query, update, options = {}) => {
+			const result = await collection.findOneAndUpdate(query, update, options);
+			if (result && typeof result === 'object' && Object.prototype.hasOwnProperty.call(result, 'value')) {
+				return result.value;
+			}
+			return result;
+		},
+		findById: (id: string, options = {}) => {
+			return collection.findOne({_id: id}, options);
+		},
+		createIndex: (spec, options = {}) => {
+			return collection.createIndex(spec, options);
+		}
+	};
+}
+
+function ensureCollectionIndexes(collections: {
+	ErrorAutoFixLogs: CollectionAdapter;
+	SlowQueryLogs: CollectionAdapter;
+}): void {
+	if (indexesEnsured) {
+		return;
+	}
+	indexesEnsured = true;
+
+	setTimeout(async () => {
+		try {
+			if (typeof collections.ErrorAutoFixLogs.createIndex === 'function') {
+				await collections.ErrorAutoFixLogs.createIndex({email_hash: 1});
+				await collections.ErrorAutoFixLogs.createIndex({issue_hash: 1});
+				await collections.ErrorAutoFixLogs.createIndex({status: 1});
+				await collections.ErrorAutoFixLogs.createIndex({ignored: 1});
+			}
+		}
+		catch (error) {
+			console.error('Failed to ensure error auto-fix indexes', error);
+		}
+
+		try {
+			if (typeof collections.SlowQueryLogs.createIndex === 'function') {
+				await collections.SlowQueryLogs.createIndex({query_hash: 1});
+				await collections.SlowQueryLogs.createIndex({collection: 1});
+				await collections.SlowQueryLogs.createIndex({client_slug: 1});
+				await collections.SlowQueryLogs.createIndex({status: 1});
+				await collections.SlowQueryLogs.createIndex({ignored: 1});
+				await collections.SlowQueryLogs.createIndex({last_seen_at: -1});
+				await collections.SlowQueryLogs.createIndex({collection: 1, duration_ms: -1});
+				await collections.SlowQueryLogs.createIndex({publication: 1});
+				await collections.SlowQueryLogs.createIndex({server_url: 1});
+			}
+		}
+		catch (error) {
+			console.error('Failed to ensure slow query indexes', error);
+		}
+	}, 5000);
+}
+
+export function registerDiagnosticManagerDependencies(
+	dependencies: DiagnosticManagerBootstrapDependencies = {}
+): void {
+	const errorAutoFixLogs = dependencies.ErrorAutoFixLogs || createCollectionAdapter('error-autofix-logs');
+	const slowQueryLogs = dependencies.SlowQueryLogs || createCollectionAdapter('slow-query-logs');
+	const aiCoderApps = dependencies.AICoderApps;
+	const aiDashboardJobs = dependencies.AIDashboardJobs;
+
+	const errorAutoFixDependencies: ErrorAutoFixManagerDependencies = {
+		ErrorAutoFixLogs: errorAutoFixLogs,
+		AICoderApps: aiCoderApps,
+		AIDashboardJobs: aiDashboardJobs
+	};
+	registerErrorAutoFixManagerDependencies(errorAutoFixDependencies);
+
+	registerSlowQueryManagerDependencies({
+		SlowQueryLogs: slowQueryLogs
+	});
+
+	const slowQueryVerifierDependencies: SlowQueryVerifierDependencies = {
+		SlowQueryLogs: slowQueryLogs,
+		AICoderApps: aiCoderApps,
+		AIDashboardJobs: aiDashboardJobs
+	};
+
+	if (dependencies.checkAICoderTokenEligibility) {
+		slowQueryVerifierDependencies.checkAICoderTokenEligibility = dependencies.checkAICoderTokenEligibility;
+	}
+	registerSlowQueryVerifierDependencies(slowQueryVerifierDependencies);
+
+	ensureCollectionIndexes({
+		ErrorAutoFixLogs: errorAutoFixLogs,
+		SlowQueryLogs: slowQueryLogs
+	});
+}