feat(wikibase): handle not found errors for properties and items

backend/src/api/wikibase/entities.ts

@@ -49,10 +49,10 @@ export const wikibaseEntitiesApi = new Elysia({ prefix: '/api/wikibase/entities'
 
   .get(
     '/properties/:propertyId',
-    async ({ params: { propertyId }, query: { instance = 'wikidata' }, wikibase }) => {
+    async ({ params: { propertyId }, query: { instance = 'wikidata' }, wikibase, status }) => {
       const property = await wikibase.getProperty(instance, propertyId)
       if (!property) {
-        return ApiErrorHandler.notFoundError(`Property ${propertyId} not found`)
+        return status(404, ApiErrorHandler.notFoundError('Property', propertyId))
       }
       return { data: property }
     },
@@ -89,10 +89,10 @@ export const wikibaseEntitiesApi = new Elysia({ prefix: '/api/wikibase/entities'
 
   .get(
     '/items/:itemId',
-    async ({ params: { itemId }, query: { instance = 'wikidata' }, wikibase }) => {
+    async ({ params: { itemId }, query: { instance = 'wikidata' }, wikibase, status }) => {
       const item = await wikibase.getItem(instance, itemId)
       if (!item) {
-        return ApiErrorHandler.notFoundError(`Item ${itemId} not found`)
+        return status(404, ApiErrorHandler.notFoundError('Item', itemId))
       }
       return { data: item }
     },

backend/src/services/wikibase.service.ts

@@ -153,7 +153,7 @@ export class WikibaseService {
   /**
    * Get property details by ID
    */
-  async getProperty(instanceId: string, propertyId: PropertyId): Promise<PropertyDetails> {
+  async getProperty(instanceId: string, propertyId: PropertyId): Promise<PropertyDetails | null> {
     const client = this.getClient(instanceId)
 
     const params = {
@@ -166,12 +166,15 @@ export class WikibaseService {
     const response = (await client.get(params)) as WikibaseGetEntitiesResponse
 
     if (response.error) {
+      if (response.error.code === 'missingentity' || response.error.code === 'no-such-entity') {
+        return null
+      }
       throw new Error(`Failed to get property: ${response.error.info}`)
     }
 
     const entity = response.entities?.[propertyId]
     if (!entity || entity.missing !== undefined) {
-      throw new Error(`Property ${propertyId} not found`)
+      return null
     }
 
     const labels = entity.labels ?? {}
@@ -263,7 +266,7 @@ export class WikibaseService {
   /**
    * Get item details by ID
    */
-  async getItem(instanceId: string, itemId: ItemId): Promise<ItemDetails> {
+  async getItem(instanceId: string, itemId: ItemId): Promise<ItemDetails | null> {
     const client = this.getClient(instanceId)
 
     const params = {
@@ -276,12 +279,15 @@ export class WikibaseService {
     const response = (await client.get(params)) as WikibaseGetEntitiesResponse
 
     if (response.error) {
+      if (response.error.code === 'missingentity' || response.error.code === 'no-such-entity') {
+        return null
+      }
       throw new Error(`Failed to get item: ${response.error.info}`)
     }
 
     const entity = response.entities?.[itemId]
     if (!entity || entity.missing !== undefined) {
-      throw new Error(`Item ${itemId} not found`)
+      return null
     }
 
     const itemDetails: ItemDetails = {

backend/tests/api/wikibase/entities.test.ts

@@ -0,0 +1,120 @@
+import { wikibaseEntitiesApi } from '@backend/api/wikibase/entities'
+import { wikibaseService } from '@backend/services/wikibase.service'
+import { treaty } from '@elysiajs/eden'
+import { beforeEach, describe, expect, test } from 'bun:test'
+import Elysia from 'elysia'
+
+// Mock the wikibase service
+const mockWikibaseService = {
+  getProperty: async () => {
+    return null // Simulate not found
+  },
+  getItem: async () => {
+    return null // Simulate not found
+  },
+}
+
+// Mock the service
+Object.assign(wikibaseService, mockWikibaseService)
+
+const createTestApi = () => {
+  return treaty(new Elysia().use(wikibaseEntitiesApi)).api
+}
+
+describe('Wikibase Entities API', () => {
+  let api: ReturnType<typeof createTestApi>
+
+  beforeEach(() => {
+    api = createTestApi()
+  })
+
+  describe('Property endpoints', () => {
+    test('should return 404 for non-existent property', async () => {
+      const { data, status, error } = await api.wikibase.entities
+        .properties({ propertyId: 'P1000000' })
+        .get({
+          query: { instance: 'wikidata' },
+        })
+
+      expect(data).toBeNull()
+      expect(status).toBe(404)
+      expect(error).toHaveProperty('value', {
+        data: [],
+        errors: [
+          {
+            details: [],
+            code: 'NOT_FOUND',
+            message: "Property with identifier 'P1000000' not found",
+          },
+        ],
+      })
+    })
+  })
+
+  describe('Item endpoints', () => {
+    test('should return 404 for non-existent item', async () => {
+      const { data, status, error } = await api.wikibase.entities
+        .items({ itemId: 'Q1000000' })
+        .get({
+          query: { instance: 'wikidata' },
+        })
+
+      expect(data).toBeNull()
+      expect(status).toBe(404)
+      expect(error).toHaveProperty('value', {
+        data: [],
+        errors: [
+          {
+            details: [],
+            code: 'NOT_FOUND',
+            message: "Item with identifier 'Q1000000' not found",
+          },
+        ],
+      })
+    })
+
+    test('should return 404 when wikibase.getItem throws an error for not found', async () => {
+      const { data, status, error } = await api.wikibase.entities
+        .items({ itemId: 'Q9999999' })
+        .get({
+          query: { instance: 'wikidata' },
+        })
+
+      expect(data).toBeNull()
+      expect(status).toBe(404)
+      expect(error).toHaveProperty('value', {
+        data: [],
+        errors: [
+          {
+            details: [],
+            code: 'NOT_FOUND',
+            message: "Item with identifier 'Q9999999' not found",
+          },
+        ],
+      })
+    })
+  })
+
+  describe('Item endpoints', () => {
+    test('should return 404 for non-existent item', async () => {
+      const { data, status, error } = await api.wikibase.entities
+        .items({ itemId: 'Q1000000' })
+        .get({
+          query: { instance: 'wikidata' },
+        })
+
+      expect(data).toBeNull()
+      expect(status).toBe(404)
+      expect(error).toHaveProperty('value', {
+        data: [],
+        errors: [
+          {
+            details: [],
+            code: 'NOT_FOUND',
+            message: "Item with identifier 'Q1000000' not found",
+          },
+        ],
+      })
+    })
+  })
+})