@resolveio/server-lib 22.2.32 → 22.2.34

package/src/methods/diagnostics.ts

@@ -0,0 +1,447 @@
+import SimpleSchema from 'simpl-schema';
+import { Users } from '../collections/user.collection';
+import { MethodManager } from '../managers/method.manager';
+import { ResolveIOServer } from '../resolveio-server-app';
+
+const MAX_LIST_LIMIT = 250;
+const DEFAULT_LIST_LIMIT = 50;
+
+type SortDirection = 1 | -1;
+
+function normalizeString(value: any, maxLength = 500): string {
+	const normalized = String(value || '').trim();
+	if (!normalized) {
+		return '';
+	}
+	if (normalized.length <= maxLength) {
+		return normalized;
+	}
+	return normalized.slice(0, maxLength);
+}
+
+function normalizeBoolean(value: any): boolean | undefined {
+	if (typeof value === 'boolean') {
+		return value;
+	}
+	if (typeof value === 'string') {
+		const normalized = value.trim().toLowerCase();
+		if (['true', '1', 'yes', 'y'].includes(normalized)) {
+			return true;
+		}
+		if (['false', '0', 'no', 'n'].includes(normalized)) {
+			return false;
+		}
+	}
+	return undefined;
+}
+
+function normalizeLimit(value: any): number {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed <= 0) {
+		return DEFAULT_LIST_LIMIT;
+	}
+	return Math.min(Math.floor(parsed), MAX_LIST_LIMIT);
+}
+
+function normalizeSkip(value: any): number {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed < 0) {
+		return 0;
+	}
+	return Math.floor(parsed);
+}
+
+function normalizeSortDirection(value: any): SortDirection {
+	const normalized = normalizeString(value, 10).toLowerCase();
+	return normalized === 'asc' ? 1 : -1;
+}
+
+function escapeRegex(value: string): string {
+	return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+async function assertSuperAdmin(context: any): Promise<void> {
+	if (context?.user === 'Internal System') {
+		return;
+	}
+
+	if (context?.user?.roles?.super_admin) {
+		return;
+	}
+
+	const idUser = normalizeString(
+		context?.id_user
+			|| context?.idUser
+			|| context?.user?._id
+			|| context?.user?.id_user
+	);
+
+	if (!idUser) {
+		throw new Error('Only super admins can access diagnostics.');
+	}
+
+	const user = await Users.findById(idUser, {
+		projection: {
+			_id: 1,
+			roles: 1
+		}
+	});
+
+	if (!user?.roles?.super_admin) {
+		throw new Error('Only super admins can access diagnostics.');
+	}
+}
+
+function resolveSortField(value: string, allowedFields: string[], fallback: string): string {
+	const normalized = normalizeString(value, 80);
+	if (!normalized) {
+		return fallback;
+	}
+	if (allowedFields.includes(normalized)) {
+		return normalized;
+	}
+	return fallback;
+}
+
+function buildAutoFixSearchQuery(payload: Record<string, any>): Record<string, any> {
+	const query: Record<string, any> = {};
+	const andClauses: Record<string, any>[] = [];
+	const status = normalizeString(payload?.status, 40).toLowerCase();
+	const sourceType = normalizeString(payload?.sourceType, 40).toLowerCase();
+	const ignored = normalizeBoolean(payload?.ignored);
+	const hasPr = normalizeBoolean(payload?.hasPr);
+
+	if (status && status !== 'all') {
+		andClauses.push({status});
+	}
+
+	if (sourceType && sourceType !== 'all') {
+		andClauses.push({source_type: sourceType});
+	}
+
+	if (typeof ignored === 'boolean') {
+		andClauses.push({ignored});
+	}
+
+	if (typeof hasPr === 'boolean') {
+		if (hasPr) {
+			andClauses.push({pr_url: {$exists: true, $nin: ['', null]}});
+		}
+		else {
+			andClauses.push({
+				$or: [
+					{pr_url: {$exists: false}},
+					{pr_url: ''},
+					{pr_url: null}
+				]
+			});
+		}
+	}
+
+	const search = normalizeString(payload?.search, 160);
+	if (search) {
+		const searchRegex = {
+			$regex: escapeRegex(search),
+			$options: 'i'
+		};
+
+		andClauses.push({
+			$or: [
+				{subject: searchRegex},
+				{status: searchRegex},
+				{client_name: searchRegex},
+				{source_type: searchRegex},
+				{source_app: searchRegex},
+				{source_environment: searchRegex},
+				{severity: searchRegex},
+				{branch_name: searchRegex},
+				{pr_url: searchRegex},
+				{openai_task_id: searchRegex},
+				{plan_summary: searchRegex},
+				{last_error: searchRegex},
+				{autofix_error_count_string: searchRegex}
+			]
+		});
+	}
+
+	if (!andClauses.length) {
+		return query;
+	}
+
+	if (andClauses.length === 1) {
+		return andClauses[0];
+	}
+
+	query.$and = andClauses;
+	return query;
+}
+
+function buildSlowQuerySearchQuery(payload: Record<string, any>): Record<string, any> {
+	const query: Record<string, any> = {};
+	const andClauses: Record<string, any>[] = [];
+	const status = normalizeString(payload?.status, 40).toLowerCase();
+	const verificationStatus = normalizeString(payload?.verificationStatus, 40).toLowerCase();
+	const ignored = normalizeBoolean(payload?.ignored);
+	const collection = normalizeString(payload?.collection, 120);
+	const environment = normalizeString(payload?.environment, 120);
+	const clientSlug = normalizeString(payload?.clientSlug, 120);
+	const minDurationMs = Number(payload?.minDurationMs);
+
+	if (status && status !== 'all') {
+		andClauses.push({status});
+	}
+
+	if (verificationStatus && verificationStatus !== 'all') {
+		andClauses.push({verification_status: verificationStatus});
+	}
+
+	if (typeof ignored === 'boolean') {
+		andClauses.push({ignored});
+	}
+
+	if (collection) {
+		andClauses.push({collection});
+	}
+
+	if (environment) {
+		andClauses.push({environment});
+	}
+
+	if (clientSlug) {
+		andClauses.push({client_slug: clientSlug});
+	}
+
+	if (Number.isFinite(minDurationMs) && minDurationMs > 0) {
+		andClauses.push({
+			duration_ms: {
+				$gte: Math.floor(minDurationMs)
+			}
+		});
+	}
+
+	const search = normalizeString(payload?.search, 160);
+	if (search) {
+		const searchRegex = {
+			$regex: escapeRegex(search),
+			$options: 'i'
+		};
+
+		andClauses.push({
+			$or: [
+				{query_hash: searchRegex},
+				{collection: searchRegex},
+				{client_slug: searchRegex},
+				{client_name: searchRegex},
+				{source_app: searchRegex},
+				{environment: searchRegex},
+				{node_hostname: searchRegex},
+				{verification_notes: searchRegex},
+				{openai_task_id: searchRegex},
+				{slow_query_count_string: searchRegex}
+			]
+		});
+	}
+
+	if (!andClauses.length) {
+		return query;
+	}
+
+	if (andClauses.length === 1) {
+		return andClauses[0];
+	}
+
+	query.$and = andClauses;
+	return query;
+}
+
+function getCollection(name: string) {
+	const db = ResolveIOServer.getMainDB();
+	if (!db) {
+		throw new Error('Main DB is not available.');
+	}
+
+	return db.collection(name);
+}
+
+export function loadDiagnosticMethods(methodManager: MethodManager) {
+	methodManager.methods({
+		superAdminListAutoFixLogs: {
+			check: new SimpleSchema({
+				payload: {
+					type: Object,
+					optional: true,
+					blackbox: true
+				}
+			}),
+			function: async function(payload: Record<string, any> = {}) {
+				await assertSuperAdmin(this);
+
+				const query = buildAutoFixSearchQuery(payload);
+				const limit = normalizeLimit(payload?.limit);
+				const skip = normalizeSkip(payload?.skip);
+				const sortField = resolveSortField(
+					payload?.sortField,
+					[
+						'createdAt',
+						'updatedAt',
+						'status',
+						'duplicate_count',
+						'attempt_count',
+						'last_attempt_at',
+						'last_result_at',
+						'last_reported_at',
+						'autofix_error_count'
+					],
+					'last_reported_at'
+				);
+				const sortDirection = normalizeSortDirection(payload?.sortDirection);
+				const sort = {
+					[sortField]: sortDirection,
+					updatedAt: -1
+				};
+
+				const collection = getCollection('error-autofix-logs');
+				const [items, total] = await Promise.all([
+					collection.find(query).sort(sort as any).skip(skip).limit(limit).toArray(),
+					collection.countDocuments(query)
+				]);
+
+				return {
+					items,
+					total,
+					limit,
+					skip
+				};
+			}
+		},
+		superAdminRunAutoFixLog: {
+			check: new SimpleSchema({
+				logId: {
+					type: String
+				}
+			}),
+			function: async function(logId: string) {
+				await assertSuperAdmin(this);
+
+				const manager = ResolveIOServer['AutoFixManager'];
+				if (!manager || typeof manager.runLog !== 'function') {
+					throw new Error('Auto-fix manager is not available.');
+				}
+
+				const result = await manager.runLog(logId);
+				return {
+					status: result?.status || 'unknown',
+					reason: result?.reason || '',
+					error: result?.error || '',
+					logId: result?.log?._id || logId,
+					branchName: result?.branchName || result?.log?.branch_name || '',
+					prUrl: result?.prUrl || result?.log?.pr_url || '',
+					taskId: result?.log?.openai_task_id || ''
+				};
+			}
+		},
+		superAdminListSlowQueryLogs: {
+			check: new SimpleSchema({
+				payload: {
+					type: Object,
+					optional: true,
+					blackbox: true
+				}
+			}),
+			function: async function(payload: Record<string, any> = {}) {
+				await assertSuperAdmin(this);
+
+				const query = buildSlowQuerySearchQuery(payload);
+				const limit = normalizeLimit(payload?.limit);
+				const skip = normalizeSkip(payload?.skip);
+				const sortField = resolveSortField(
+					payload?.sortField,
+						[
+							'createdAt',
+							'updatedAt',
+							'collection',
+							'status',
+							'verification_status',
+							'duration_ms',
+						'avg_duration_ms',
+						'max_duration_ms',
+						'occurrences',
+						'last_seen_at',
+						'slow_query_count'
+					],
+					'last_seen_at'
+				);
+				const sortDirection = normalizeSortDirection(payload?.sortDirection);
+				const sort = {
+					[sortField]: sortDirection,
+					updatedAt: -1
+				};
+
+				const collection = getCollection('slow-query-logs');
+				const [items, total] = await Promise.all([
+					collection.find(query).sort(sort as any).skip(skip).limit(limit).toArray(),
+					collection.countDocuments(query)
+				]);
+
+				return {
+					items,
+					total,
+					limit,
+					skip
+				};
+			}
+		},
+		superAdminRunSlowQueryLog: {
+			check: new SimpleSchema({
+				logId: {
+					type: String
+				}
+			}),
+			function: async function(logId: string) {
+				await assertSuperAdmin(this);
+
+				const verifier = ResolveIOServer['SlowQueryVerifier'];
+				if (!verifier || typeof verifier.queueLogRun !== 'function') {
+					throw new Error('Slow query verifier is not available.');
+				}
+
+				const result = await verifier.queueLogRun(logId, {
+					force: true
+				});
+				return {
+					status: result?.status || 'unknown',
+					reason: result?.reason || '',
+					logId: result?.log?._id || logId,
+					taskId: result?.log?.openai_task_id || '',
+					notes: result?.log?.verification_notes || result?.reason || ''
+				};
+			}
+		},
+		superAdminDeploySlowQueryLog: {
+			check: new SimpleSchema({
+				logId: {
+					type: String
+				}
+			}),
+			function: async function(logId: string) {
+				await assertSuperAdmin(this);
+
+				const verifier = ResolveIOServer['SlowQueryVerifier'];
+				if (!verifier || typeof verifier.deployLog !== 'function') {
+					throw new Error('Slow query verifier is not available.');
+				}
+
+				const result = await verifier.deployLog(logId);
+				return {
+					status: result?.status || 'unknown',
+					reason: result?.reason || '',
+					logId: result?.log?._id || logId,
+					taskId: result?.log?.openai_task_id || '',
+					notes: result?.log?.verification_notes || result?.reason || '',
+					branchName: result?.log?.auto_fix_result?.publish_branch || '',
+					publishMessage: result?.log?.auto_fix_result?.publish_message || ''
+				};
+			}
+		}
+	});
+}

package/src/methods/flag-updates.ts

@@ -0,0 +1,7 @@
+import { MethodManager } from '../managers/method.manager';
+
+export function loadFlagUpdatesMethods(methodManager: MethodManager) {
+	methodManager.methods({
+		
+	});
+}

package/src/methods/flags.ts

@@ -0,0 +1,7 @@
+import { MethodManager } from '../managers/method.manager';
+
+export function loadFlagMethods(methodManager: MethodManager) {
+	methodManager.methods({
+		
+	});
+}