1010 lines
24 KiB
TypeScript
1010 lines
24 KiB
TypeScript
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");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Get comic books with advanced pagination and filtering
|
|
*/
|
|
getComicBooks: async (
|
|
_: any,
|
|
{
|
|
paginationOptions,
|
|
predicate = {},
|
|
}: {
|
|
paginationOptions: any;
|
|
predicate?: any;
|
|
}
|
|
) => {
|
|
try {
|
|
const result = await Comic.paginate(predicate, paginationOptions);
|
|
return result;
|
|
} catch (error) {
|
|
console.error("Error fetching comic books:", error);
|
|
throw new Error("Failed to fetch comic books");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Get comic book groups (volumes with multiple issues)
|
|
*/
|
|
getComicBookGroups: async () => {
|
|
try {
|
|
const volumes = await Comic.aggregate([
|
|
{
|
|
$project: {
|
|
volumeInfo:
|
|
"$sourcedMetadata.comicvine.volumeInformation",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$volumeInfo",
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$_id",
|
|
volumes: {
|
|
$addToSet: "$volumeInfo",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$volumes",
|
|
},
|
|
{ $sort: { updatedAt: -1 } },
|
|
{ $skip: 0 },
|
|
{ $limit: 5 },
|
|
]);
|
|
|
|
return volumes.map((vol) => ({
|
|
id: vol._id.toString(),
|
|
volumes: vol.volumes,
|
|
}));
|
|
} catch (error) {
|
|
console.error("Error fetching comic book groups:", error);
|
|
throw new Error("Failed to fetch comic book groups");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Get library statistics
|
|
*/
|
|
getLibraryStatistics: async () => {
|
|
try {
|
|
const { getSizeOfDirectory } = require("../../utils/file.utils");
|
|
const { COMICS_DIRECTORY } = require("../../constants/directories");
|
|
|
|
const comicDirectorySize = await getSizeOfDirectory(
|
|
COMICS_DIRECTORY,
|
|
[".cbz", ".cbr", ".cb7"]
|
|
);
|
|
const totalCount = await Comic.countDocuments({});
|
|
const statistics = await Comic.aggregate([
|
|
{
|
|
$facet: {
|
|
fileTypes: [
|
|
{
|
|
$match: {
|
|
"rawFileDetails.extension": {
|
|
$in: [".cbr", ".cbz", ".cb7"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$rawFileDetails.extension",
|
|
data: { $push: "$$ROOT._id" },
|
|
},
|
|
},
|
|
],
|
|
issues: [
|
|
{
|
|
$match: {
|
|
"sourcedMetadata.comicvine.volumeInformation":
|
|
{
|
|
$gt: {},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$sourcedMetadata.comicvine.volumeInformation",
|
|
data: { $push: "$$ROOT._id" },
|
|
},
|
|
},
|
|
],
|
|
fileLessComics: [
|
|
{
|
|
$match: {
|
|
rawFileDetails: {
|
|
$exists: false,
|
|
},
|
|
},
|
|
},
|
|
],
|
|
issuesWithComicInfoXML: [
|
|
{
|
|
$match: {
|
|
"sourcedMetadata.comicInfo": {
|
|
$exists: true,
|
|
$gt: { $size: 0 },
|
|
},
|
|
},
|
|
},
|
|
],
|
|
publisherWithMostComicsInLibrary: [
|
|
{
|
|
$unwind:
|
|
"$sourcedMetadata.comicvine.volumeInformation.publisher",
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$sourcedMetadata.comicvine.volumeInformation.publisher.name",
|
|
count: { $sum: 1 },
|
|
},
|
|
},
|
|
{ $sort: { count: -1 } },
|
|
{ $limit: 1 },
|
|
],
|
|
},
|
|
},
|
|
]);
|
|
|
|
return {
|
|
totalDocuments: totalCount,
|
|
comicDirectorySize,
|
|
statistics,
|
|
};
|
|
} catch (error) {
|
|
console.error("Error fetching library statistics:", error);
|
|
throw new Error("Failed to fetch library statistics");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Search issues using Elasticsearch
|
|
*/
|
|
searchIssue: async (
|
|
_: any,
|
|
{
|
|
query,
|
|
pagination = { size: 10, from: 0 },
|
|
type,
|
|
}: {
|
|
query?: { volumeName?: string; issueNumber?: string };
|
|
pagination?: { size?: number; from?: number };
|
|
type: string;
|
|
},
|
|
context: any
|
|
) => {
|
|
try {
|
|
// Get broker from context (set up in GraphQL service)
|
|
const broker = context?.broker;
|
|
|
|
if (!broker) {
|
|
throw new Error("Broker not available in context");
|
|
}
|
|
|
|
// Call the search service through the broker
|
|
const result = await broker.call("search.issue", {
|
|
query: query || {},
|
|
pagination,
|
|
type,
|
|
});
|
|
|
|
return result;
|
|
} catch (error) {
|
|
console.error("Error searching issues:", error);
|
|
throw new Error(`Failed to search issues: ${error.message}`);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* 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;
|
|
}
|