🛠 graphql changes

models/graphql/resolvers.ts

@@ -0,0 +1,813 @@
+import Comic, { MetadataSource } from "../comic.model";
+import UserPreferences, {
+	ConflictResolutionStrategy,
+} from "../userpreferences.model";
+import {
+	resolveMetadataField,
+	buildCanonicalMetadata,
+	MetadataField,
+	ResolutionPreferences,
+} from "../../utils/metadata.resolution.utils";
+
+/**
+ * GraphQL Resolvers for canonical metadata queries and mutations
+ */
+export const resolvers = {
+	Query: {
+		/**
+		 * Get a single comic by ID
+		 */
+		comic: async (_: any, { id }: { id: string }) => {
+			try {
+				const comic = await Comic.findById(id);
+				return comic;
+			} catch (error) {
+				console.error("Error fetching comic:", error);
+				throw new Error("Failed to fetch comic");
+			}
+		},
+
+		/**
+		 * List comics with pagination and filtering
+		 */
+		comics: async (
+			_: any,
+			{
+				limit = 10,
+				page = 1,
+				search,
+				publisher,
+				series,
+			}: {
+				limit?: number;
+				page?: number;
+				search?: string;
+				publisher?: string;
+				series?: string;
+			}
+		) => {
+			try {
+				const query: any = {};
+
+				// Build search query
+				if (search) {
+					query.$or = [
+						{ "canonicalMetadata.title.value": new RegExp(search, "i") },
+						{ "canonicalMetadata.series.value": new RegExp(search, "i") },
+						{ "rawFileDetails.name": new RegExp(search, "i") },
+					];
+				}
+
+				if (publisher) {
+					query["canonicalMetadata.publisher.value"] = new RegExp(
+						publisher,
+						"i"
+					);
+				}
+
+				if (series) {
+					query["canonicalMetadata.series.value"] = new RegExp(series, "i");
+				}
+
+				const options = {
+					page,
+					limit,
+					sort: { createdAt: -1 },
+				};
+
+				const result = await Comic.paginate(query, options);
+
+				return {
+					comics: result.docs,
+					totalCount: result.totalDocs,
+					pageInfo: {
+						hasNextPage: result.hasNextPage,
+						hasPreviousPage: result.hasPrevPage,
+						currentPage: result.page,
+						totalPages: result.totalPages,
+					},
+				};
+			} catch (error) {
+				console.error("Error fetching comics:", error);
+				throw new Error("Failed to fetch comics");
+			}
+		},
+
+		/**
+		 * Get user preferences
+		 */
+		userPreferences: async (
+			_: any,
+			{ userId = "default" }: { userId?: string }
+		) => {
+			try {
+				let preferences = await UserPreferences.findOne({ userId });
+
+				// Create default preferences if none exist
+				if (!preferences) {
+					preferences = await UserPreferences.create({ userId });
+				}
+
+				return preferences;
+			} catch (error) {
+				console.error("Error fetching user preferences:", error);
+				throw new Error("Failed to fetch user preferences");
+			}
+		},
+
+		/**
+		 * Analyze metadata conflicts for a comic
+		 */
+		analyzeMetadataConflicts: async (
+			_: any,
+			{ comicId }: { comicId: string }
+		) => {
+			try {
+				const comic = await Comic.findById(comicId);
+				if (!comic) {
+					throw new Error("Comic not found");
+				}
+
+				const preferences = await UserPreferences.findOne({
+					userId: "default",
+				});
+				if (!preferences) {
+					throw new Error("User preferences not found");
+				}
+
+				const conflicts: any[] = [];
+
+				// Analyze each field for conflicts
+				const fields = [
+					"title",
+					"series",
+					"issueNumber",
+					"description",
+					"publisher",
+				];
+
+				for (const field of fields) {
+					const candidates = extractCandidatesForField(
+						field,
+						comic.sourcedMetadata
+					);
+
+					if (candidates.length > 1) {
+						const resolved = resolveMetadataField(
+							field,
+							candidates,
+							convertPreferences(preferences)
+						);
+
+						conflicts.push({
+							field,
+							candidates,
+							resolved,
+							resolutionReason: getResolutionReason(
+								resolved,
+								candidates,
+								preferences
+							),
+						});
+					}
+				}
+
+				return conflicts;
+			} catch (error) {
+				console.error("Error analyzing metadata conflicts:", error);
+				throw new Error("Failed to analyze metadata conflicts");
+			}
+		},
+
+		/**
+		 * Preview canonical metadata resolution without saving
+		 */
+		previewCanonicalMetadata: async (
+			_: any,
+			{
+				comicId,
+				preferences: preferencesInput,
+			}: { comicId: string; preferences?: any }
+		) => {
+			try {
+				const comic = await Comic.findById(comicId);
+				if (!comic) {
+					throw new Error("Comic not found");
+				}
+
+				let preferences = await UserPreferences.findOne({
+					userId: "default",
+				});
+
+				// Use provided preferences or default
+				if (preferencesInput) {
+					preferences = applyPreferencesInput(preferences, preferencesInput);
+				}
+
+				if (!preferences) {
+					throw new Error("User preferences not found");
+				}
+
+				const canonical = buildCanonicalMetadata(
+					comic.sourcedMetadata,
+					convertPreferences(preferences)
+				);
+
+				return canonical;
+			} catch (error) {
+				console.error("Error previewing canonical metadata:", error);
+				throw new Error("Failed to preview canonical metadata");
+			}
+		},
+	},
+
+	Mutation: {
+		/**
+		 * Update user preferences
+		 */
+		updateUserPreferences: async (
+			_: any,
+			{
+				userId = "default",
+				preferences: preferencesInput,
+			}: { userId?: string; preferences: any }
+		) => {
+			try {
+				let preferences = await UserPreferences.findOne({ userId });
+
+				if (!preferences) {
+					preferences = new UserPreferences({ userId });
+				}
+
+				// Update preferences
+				if (preferencesInput.sourcePriorities) {
+					preferences.sourcePriorities = preferencesInput.sourcePriorities.map(
+						(sp: any) => ({
+							source: sp.source,
+							priority: sp.priority,
+							enabled: sp.enabled,
+							fieldOverrides: sp.fieldOverrides
+								? new Map(
+										sp.fieldOverrides.map((fo: any) => [fo.field, fo.priority])
+								  )
+								: new Map(),
+						})
+					);
+				}
+
+				if (preferencesInput.conflictResolution) {
+					preferences.conflictResolution = preferencesInput.conflictResolution;
+				}
+
+				if (preferencesInput.minConfidenceThreshold !== undefined) {
+					preferences.minConfidenceThreshold =
+						preferencesInput.minConfidenceThreshold;
+				}
+
+				if (preferencesInput.preferRecent !== undefined) {
+					preferences.preferRecent = preferencesInput.preferRecent;
+				}
+
+				if (preferencesInput.fieldPreferences) {
+					preferences.fieldPreferences = new Map(
+						preferencesInput.fieldPreferences.map((fp: any) => [
+							fp.field,
+							fp.preferredSource,
+						])
+					);
+				}
+
+				if (preferencesInput.autoMerge) {
+					preferences.autoMerge = {
+						...preferences.autoMerge,
+						...preferencesInput.autoMerge,
+					};
+				}
+
+				await preferences.save();
+				return preferences;
+			} catch (error) {
+				console.error("Error updating user preferences:", error);
+				throw new Error("Failed to update user preferences");
+			}
+		},
+
+		/**
+		 * Manually set a metadata field (creates user override)
+		 */
+		setMetadataField: async (
+			_: any,
+			{ comicId, field, value }: { comicId: string; field: string; value: any }
+		) => {
+			try {
+				const comic = await Comic.findById(comicId);
+				if (!comic) {
+					throw new Error("Comic not found");
+				}
+
+				// Set the field with user override
+				const fieldPath = `canonicalMetadata.${field}`;
+				const update = {
+					[fieldPath]: {
+						value,
+						provenance: {
+							source: MetadataSource.MANUAL,
+							confidence: 1.0,
+							fetchedAt: new Date(),
+						},
+						userOverride: true,
+					},
+				};
+
+				const updatedComic = await Comic.findByIdAndUpdate(
+					comicId,
+					{ $set: update },
+					{ new: true }
+				);
+
+				return updatedComic;
+			} catch (error) {
+				console.error("Error setting metadata field:", error);
+				throw new Error("Failed to set metadata field");
+			}
+		},
+
+		/**
+		 * Trigger metadata resolution for a comic
+		 */
+		resolveMetadata: async (_: any, { comicId }: { comicId: string }) => {
+			try {
+				const comic = await Comic.findById(comicId);
+				if (!comic) {
+					throw new Error("Comic not found");
+				}
+
+				const preferences = await UserPreferences.findOne({
+					userId: "default",
+				});
+				if (!preferences) {
+					throw new Error("User preferences not found");
+				}
+
+				// Build canonical metadata
+				const canonical = buildCanonicalMetadata(
+					comic.sourcedMetadata,
+					convertPreferences(preferences)
+				);
+
+				// Update comic with canonical metadata
+				comic.canonicalMetadata = canonical;
+				await comic.save();
+
+				return comic;
+			} catch (error) {
+				console.error("Error resolving metadata:", error);
+				throw new Error("Failed to resolve metadata");
+			}
+		},
+
+		/**
+		 * Bulk resolve metadata for multiple comics
+		 */
+		bulkResolveMetadata: async (
+			_: any,
+			{ comicIds }: { comicIds: string[] }
+		) => {
+			try {
+				const preferences = await UserPreferences.findOne({
+					userId: "default",
+				});
+				if (!preferences) {
+					throw new Error("User preferences not found");
+				}
+
+				const resolvedComics = [];
+
+				for (const comicId of comicIds) {
+					const comic = await Comic.findById(comicId);
+					if (comic) {
+						const canonical = buildCanonicalMetadata(
+							comic.sourcedMetadata,
+							convertPreferences(preferences)
+						);
+
+						comic.canonicalMetadata = canonical;
+						await comic.save();
+						resolvedComics.push(comic);
+					}
+				}
+
+				return resolvedComics;
+			} catch (error) {
+				console.error("Error bulk resolving metadata:", error);
+				throw new Error("Failed to bulk resolve metadata");
+			}
+		},
+
+		/**
+		 * Remove user override for a field
+		 */
+		removeMetadataOverride: async (
+			_: any,
+			{ comicId, field }: { comicId: string; field: string }
+		) => {
+			try {
+				const comic = await Comic.findById(comicId);
+				if (!comic) {
+					throw new Error("Comic not found");
+				}
+
+				const preferences = await UserPreferences.findOne({
+					userId: "default",
+				});
+				if (!preferences) {
+					throw new Error("User preferences not found");
+				}
+
+				// Re-resolve the field without user override
+				const candidates = extractCandidatesForField(
+					field,
+					comic.sourcedMetadata
+				).filter((c) => !c.userOverride);
+
+				const resolved = resolveMetadataField(
+					field,
+					candidates,
+					convertPreferences(preferences)
+				);
+
+				if (resolved) {
+					const fieldPath = `canonicalMetadata.${field}`;
+					await Comic.findByIdAndUpdate(comicId, {
+						$set: { [fieldPath]: resolved },
+					});
+				}
+
+				const updatedComic = await Comic.findById(comicId);
+				return updatedComic;
+			} catch (error) {
+				console.error("Error removing metadata override:", error);
+				throw new Error("Failed to remove metadata override");
+			}
+		},
+
+		/**
+		 * Refresh metadata from a specific source
+		 */
+		refreshMetadataFromSource: async (
+			_: any,
+			{ comicId, source }: { comicId: string; source: MetadataSource }
+		) => {
+			try {
+				// This would trigger a re-fetch from the external source
+				// Implementation depends on your existing metadata fetching services
+				throw new Error("Not implemented - requires integration with metadata services");
+			} catch (error) {
+				console.error("Error refreshing metadata from source:", error);
+				throw new Error("Failed to refresh metadata from source");
+			}
+		},
+
+		/**
+		 * Import a new comic with automatic metadata resolution
+		 */
+		importComic: async (_: any, { input }: { input: any }) => {
+			try {
+				console.log("Importing comic via GraphQL:", input.filePath);
+
+				// 1. Check if comic already exists
+				const existingComic = await Comic.findOne({
+					"rawFileDetails.name": input.rawFileDetails?.name,
+				});
+
+				if (existingComic) {
+					return {
+						success: false,
+						comic: existingComic,
+						message: "Comic already exists in the library",
+						canonicalMetadataResolved: false,
+					};
+				}
+
+				// 2. Prepare comic data
+				const comicData: any = {
+					importStatus: {
+						isImported: true,
+						tagged: false,
+					},
+				};
+
+				// Add raw file details
+				if (input.rawFileDetails) {
+					comicData.rawFileDetails = input.rawFileDetails;
+				}
+
+				// Add inferred metadata
+				if (input.inferredMetadata) {
+					comicData.inferredMetadata = input.inferredMetadata;
+				}
+
+				// Add sourced metadata
+				if (input.sourcedMetadata) {
+					comicData.sourcedMetadata = {};
+					
+					if (input.sourcedMetadata.comicInfo) {
+						comicData.sourcedMetadata.comicInfo = JSON.parse(
+							input.sourcedMetadata.comicInfo
+						);
+					}
+					if (input.sourcedMetadata.comicvine) {
+						comicData.sourcedMetadata.comicvine = JSON.parse(
+							input.sourcedMetadata.comicvine
+						);
+					}
+					if (input.sourcedMetadata.metron) {
+						comicData.sourcedMetadata.metron = JSON.parse(
+							input.sourcedMetadata.metron
+						);
+					}
+					if (input.sourcedMetadata.gcd) {
+						comicData.sourcedMetadata.gcd = JSON.parse(
+							input.sourcedMetadata.gcd
+						);
+					}
+					if (input.sourcedMetadata.locg) {
+						comicData.sourcedMetadata.locg = input.sourcedMetadata.locg;
+					}
+				}
+
+				// Add wanted information
+				if (input.wanted) {
+					comicData.wanted = input.wanted;
+				}
+
+				// Add acquisition information
+				if (input.acquisition) {
+					comicData.acquisition = input.acquisition;
+				}
+
+				// 3. Create the comic document
+				const comic = await Comic.create(comicData);
+				console.log(`Comic created with ID: ${comic._id}`);
+
+				// 4. Check if auto-resolution is enabled
+				const preferences = await UserPreferences.findOne({
+					userId: "default",
+				});
+
+				let canonicalMetadataResolved = false;
+
+				if (
+					preferences?.autoMerge?.enabled &&
+					preferences?.autoMerge?.onImport
+				) {
+					console.log("Auto-resolving canonical metadata...");
+
+					// Build canonical metadata
+					const canonical = buildCanonicalMetadata(
+						comic.sourcedMetadata,
+						convertPreferences(preferences)
+					);
+
+					// Update comic with canonical metadata
+					comic.canonicalMetadata = canonical;
+					await comic.save();
+
+					canonicalMetadataResolved = true;
+					console.log("Canonical metadata resolved successfully");
+				}
+
+				return {
+					success: true,
+					comic,
+					message: "Comic imported successfully",
+					canonicalMetadataResolved,
+				};
+			} catch (error) {
+				console.error("Error importing comic:", error);
+				throw new Error(`Failed to import comic: ${error.message}`);
+			}
+		},
+
+		/**
+		 * Update sourced metadata and trigger resolution
+		 */
+		updateSourcedMetadata: async (
+			_: any,
+			{
+				comicId,
+				source,
+				metadata,
+			}: { comicId: string; source: MetadataSource; metadata: string }
+		) => {
+			try {
+				const comic = await Comic.findById(comicId);
+				if (!comic) {
+					throw new Error("Comic not found");
+				}
+
+				// Parse and update the sourced metadata
+				const parsedMetadata = JSON.parse(metadata);
+				const sourceKey = source.toLowerCase();
+
+				if (!comic.sourcedMetadata) {
+					comic.sourcedMetadata = {};
+				}
+
+				comic.sourcedMetadata[sourceKey] = parsedMetadata;
+				await comic.save();
+
+				console.log(
+					`Updated ${source} metadata for comic ${comicId}`
+				);
+
+				// Check if auto-resolution is enabled
+				const preferences = await UserPreferences.findOne({
+					userId: "default",
+				});
+
+				if (
+					preferences?.autoMerge?.enabled &&
+					preferences?.autoMerge?.onMetadataUpdate
+				) {
+					console.log("Auto-resolving canonical metadata after update...");
+
+					// Build canonical metadata
+					const canonical = buildCanonicalMetadata(
+						comic.sourcedMetadata,
+						convertPreferences(preferences)
+					);
+
+					// Update comic with canonical metadata
+					comic.canonicalMetadata = canonical;
+					await comic.save();
+
+					console.log("Canonical metadata resolved after update");
+				}
+
+				return comic;
+			} catch (error) {
+				console.error("Error updating sourced metadata:", error);
+				throw new Error(`Failed to update sourced metadata: ${error.message}`);
+			}
+		},
+	},
+
+	// Field resolvers
+	Comic: {
+		id: (comic: any) => comic._id.toString(),
+		sourcedMetadata: (comic: any) => ({
+			comicInfo: JSON.stringify(comic.sourcedMetadata?.comicInfo || {}),
+			comicvine: JSON.stringify(comic.sourcedMetadata?.comicvine || {}),
+			metron: JSON.stringify(comic.sourcedMetadata?.metron || {}),
+			gcd: JSON.stringify(comic.sourcedMetadata?.gcd || {}),
+			locg: comic.sourcedMetadata?.locg || null,
+		}),
+	},
+
+	UserPreferences: {
+		id: (prefs: any) => prefs._id.toString(),
+		fieldPreferences: (prefs: any) => {
+			if (!prefs.fieldPreferences) return [];
+			return Array.from(prefs.fieldPreferences.entries()).map(
+				([field, preferredSource]) => ({
+					field,
+					preferredSource,
+				})
+			);
+		},
+		sourcePriorities: (prefs: any) => {
+			return prefs.sourcePriorities.map((sp: any) => ({
+				...sp,
+				fieldOverrides: sp.fieldOverrides
+					? Array.from(sp.fieldOverrides.entries()).map(([field, priority]) => ({
+							field,
+							priority,
+					  }))
+					: [],
+			}));
+		},
+	},
+};
+
+/**
+ * Helper: Extract candidates for a field from sourced metadata
+ */
+function extractCandidatesForField(
+	field: string,
+	sourcedMetadata: any
+): MetadataField[] {
+	const candidates: MetadataField[] = [];
+
+	// Map field names to source paths
+	const mappings: Record<string, any> = {
+		title: [
+			{ source: MetadataSource.COMICVINE, path: "name", data: sourcedMetadata.comicvine },
+			{ source: MetadataSource.COMICINFO_XML, path: "Title", data: sourcedMetadata.comicInfo },
+			{ source: MetadataSource.LOCG, path: "name", data: sourcedMetadata.locg },
+		],
+		series: [
+			{ source: MetadataSource.COMICVINE, path: "volumeInformation.name", data: sourcedMetadata.comicvine },
+			{ source: MetadataSource.COMICINFO_XML, path: "Series", data: sourcedMetadata.comicInfo },
+		],
+		issueNumber: [
+			{ source: MetadataSource.COMICVINE, path: "issue_number", data: sourcedMetadata.comicvine },
+			{ source: MetadataSource.COMICINFO_XML, path: "Number", data: sourcedMetadata.comicInfo },
+		],
+		description: [
+			{ source: MetadataSource.COMICVINE, path: "description", data: sourcedMetadata.comicvine },
+			{ source: MetadataSource.LOCG, path: "description", data: sourcedMetadata.locg },
+			{ source: MetadataSource.COMICINFO_XML, path: "Summary", data: sourcedMetadata.comicInfo },
+		],
+		publisher: [
+			{ source: MetadataSource.COMICVINE, path: "volumeInformation.publisher.name", data: sourcedMetadata.comicvine },
+			{ source: MetadataSource.LOCG, path: "publisher", data: sourcedMetadata.locg },
+			{ source: MetadataSource.COMICINFO_XML, path: "Publisher", data: sourcedMetadata.comicInfo },
+		],
+	};
+
+	const fieldMappings = mappings[field] || [];
+
+	for (const mapping of fieldMappings) {
+		if (!mapping.data) continue;
+
+		const value = getNestedValue(mapping.data, mapping.path);
+		if (value !== null && value !== undefined) {
+			candidates.push({
+				value,
+				provenance: {
+					source: mapping.source,
+					confidence: 0.9,
+					fetchedAt: new Date(),
+				},
+			});
+		}
+	}
+
+	return candidates;
+}
+
+/**
+ * Helper: Get nested value from object
+ */
+function getNestedValue(obj: any, path: string): any {
+	return path.split(".").reduce((current, key) => current?.[key], obj);
+}
+
+/**
+ * Helper: Convert UserPreferences model to ResolutionPreferences
+ */
+function convertPreferences(prefs: any): ResolutionPreferences {
+	return {
+		sourcePriorities: prefs.sourcePriorities.map((sp: any) => ({
+			source: sp.source,
+			priority: sp.priority,
+			enabled: sp.enabled,
+			fieldOverrides: sp.fieldOverrides,
+		})),
+		conflictResolution: prefs.conflictResolution,
+		minConfidenceThreshold: prefs.minConfidenceThreshold,
+		preferRecent: prefs.preferRecent,
+		fieldPreferences: prefs.fieldPreferences,
+	};
+}
+
+/**
+ * Helper: Get resolution reason for display
+ */
+function getResolutionReason(
+	resolved: MetadataField | null,
+	candidates: MetadataField[],
+	preferences: any
+): string {
+	if (!resolved) return "No valid candidates";
+
+	if (resolved.userOverride) {
+		return "User override";
+	}
+
+	const priority = preferences.getSourcePriority(resolved.provenance.source);
+	return `Resolved using ${resolved.provenance.source} (priority: ${priority}, confidence: ${resolved.provenance.confidence})`;
+}
+
+/**
+ * Helper: Apply preferences input to existing preferences
+ */
+function applyPreferencesInput(prefs: any, input: any): any {
+	const updated = { ...prefs.toObject() };
+
+	if (input.sourcePriorities) {
+		updated.sourcePriorities = input.sourcePriorities;
+	}
+	if (input.conflictResolution) {
+		updated.conflictResolution = input.conflictResolution;
+	}
+	if (input.minConfidenceThreshold !== undefined) {
+		updated.minConfidenceThreshold = input.minConfidenceThreshold;
+	}
+	if (input.preferRecent !== undefined) {
+		updated.preferRecent = input.preferRecent;
+	}
+
+	return updated;
+}