@resolveio/server-lib 22.2.34 → 22.2.36

package/src/methods/diagnostics.ts

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

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

package/src/methods/flags.ts

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