feat(metadata): 'manual' metadata provider

server/api/v1/admin/import/game/index.post.ts

@@ -18,11 +18,6 @@ export default defineEventHandler(async (h3) => {
       statusCode: 400,
       statusMessage: "Path missing from body",
     });
-  if (!metadata.id || !metadata.sourceId)
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Metadata IDs missing from body",
-    });
 
   const validPath = await libraryManager.checkUnimportedGamePath(path);
   if (!validPath)
@@ -31,6 +26,9 @@ export default defineEventHandler(async (h3) => {
       statusMessage: "Invalid unimported game path",
     });
 
-  const game = await h3.context.metadataHandler.createGame(metadata, path);
-  return game;
+  if (!metadata || !metadata.id || !metadata.sourceId) {
+    return await h3.context.metadataHandler.createGameWithoutMetadata(path);
+  } else {
+    return await h3.context.metadataHandler.createGame(metadata, path);
+  }
 });

server/internal/metadata/index.ts

@@ -72,10 +72,25 @@ export class MetadataHandler {
       .filter((result) => result.status === "fulfilled")
       .map((result) => result.value)
       .flat();
-      
+
     return successfulResults;
   }
 
+  async createGameWithoutMetadata(libraryBasePath: string) {
+    return await this.createGame(
+      {
+        id: "",
+        name: libraryBasePath,
+        icon: "",
+        description: "",
+        year: 0,
+        sourceId: "manual",
+        sourceName: "Manual",
+      },
+      libraryBasePath
+    );
+  }
+
   async createGame(
     result: InternalGameMetadataResult,
     libraryBasePath: string
@@ -103,6 +118,7 @@ export class MetadataHandler {
     try {
       metadata = await provider.fetchGame({
         id: result.id,
+        name: result.name,
         // wrap in anonymous functions to keep references to this
         publisher: (name: string) => this.fetchPublisher(name),
         developer: (name: string) => this.fetchDeveloper(name),

server/internal/metadata/manual.ts

@@ -0,0 +1,63 @@
+import { MetadataSource } from "@prisma/client";
+import { MetadataProvider } from ".";
+import {
+  GameMetadataSearchResult,
+  _FetchGameMetadataParams,
+  GameMetadata,
+  _FetchPublisherMetadataParams,
+  PublisherMetadata,
+  _FetchDeveloperMetadataParams,
+  DeveloperMetadata,
+} from "./types";
+import * as jdenticon from "jdenticon";
+
+export class ManualMetadataProvider implements MetadataProvider {
+  id() {
+    return "manual";
+  }
+  name() {
+    return "Manual";
+  }
+  source() {
+    return MetadataSource.Manual;
+  }
+  async search(query: string) {
+    return [];
+  }
+  async fetchGame({
+    name,
+    publisher,
+    developer,
+    createObject,
+  }: _FetchGameMetadataParams): Promise<GameMetadata> {
+    const icon = jdenticon.toPng(name, 512);
+    const iconId = createObject(icon);
+
+    return {
+      id: "manual",
+      name,
+      shortDescription: "Default description.",
+      description: "# Default description.",
+      released: new Date(),
+      publishers: [],
+      developers: [],
+      reviewCount: 0,
+      reviewRating: 0,
+
+      icon: iconId,
+      coverId: iconId,
+      bannerId: iconId,
+      images: [iconId],
+    };
+  }
+  async fetchPublisher(
+    params: _FetchPublisherMetadataParams
+  ): Promise<PublisherMetadata> {
+    throw new Error("Method not implemented.");
+  }
+  async fetchDeveloper(
+    params: _FetchDeveloperMetadataParams
+  ): Promise<DeveloperMetadata> {
+    throw new Error("Method not implemented.");
+  }
+}

server/plugins/metadata.ts

@@ -1,22 +1,25 @@
 import { MetadataHandler, MetadataProvider } from "../internal/metadata";
 import { GiantBombProvider } from "../internal/metadata/giantbomb";
+import { ManualMetadataProvider } from "../internal/metadata/manual";
 
 export const metadataHandler = new MetadataHandler();
 
-const providerCreators: Array<() => MetadataProvider> = [() => new GiantBombProvider()];
+const providerCreators: Array<() => MetadataProvider> = [
+  () => new GiantBombProvider(),
+  () => new ManualMetadataProvider(),
+];
 
 export default defineNitroPlugin(async (nitro) => {
-    for (const creator of providerCreators) {
-        try {
-            const instance = creator();
-            metadataHandler.addProvider(instance);
-        }
-        catch (e) {
-            console.warn(e);
-        }
+  for (const creator of providerCreators) {
+    try {
+      const instance = creator();
+      metadataHandler.addProvider(instance);
+    } catch (e) {
+      console.warn(e);
     }
+  }
 
-    nitro.hooks.hook('request', (h3) => {
-        h3.context.metadataHandler = metadataHandler;
-    })
-});
+  nitro.hooks.hook("request", (h3) => {
+    h3.context.metadataHandler = metadataHandler;
+  });
+});