kmcom-nuxt-layers 2.3.1 → 2.5.0

package/layers/metadata/server/api/metadata/sync.post.ts

@@ -0,0 +1,40 @@
+import type { MetadataSyncInput, MetadataProviderId } from '#layers/metadata/shared/types'
+
+// fallow-ignore-next-line complexity
+export default defineEventHandler(async (event) => {
+  const body = await readBody<MetadataSyncInput>(event)
+
+  const { provider: providerName, providerId, resourceType, force } = body ?? {}
+  if (!providerName || !providerId) {
+    throw createError({ statusCode: 400, message: 'provider and providerId are required' })
+  }
+
+  const provider = getProvider(providerName as MetadataProviderId)
+  if (!provider) throw createError({ statusCode: 404, message: `Provider '${providerName}' not registered` })
+  if (!provider.sync) throw createError({ statusCode: 400, message: `Provider '${providerName}' does not support sync` })
+
+  const cacheKey = makeCacheKey('metadata', providerName, resourceType ?? 'item', providerId)
+
+  if (!force) {
+    const cached = await getCacheRecord(cacheKey)
+    if (cached) return { synced: false, record: cached.normalised }
+  }
+
+  const result = await provider.sync({ provider: providerName as MetadataProviderId, providerId, resourceType, force })
+  const now = new Date().toISOString()
+
+  await setCacheRecord(cacheKey, {
+    id: result.id,
+    provider: providerName as MetadataProviderId,
+    providerId,
+    resourceType: resourceType ?? 'item',
+    mediaType: result.mediaType,
+    normalised: result,
+    raw: result.raw ?? null,
+    createdAt: now,
+    updatedAt: now,
+    lastSyncedAt: now,
+  })
+
+  return { synced: true, record: result }
+})

package/layers/metadata/server/utils/metadata/cache.ts

@@ -0,0 +1,36 @@
+import type { MetadataCacheRecord } from '#layers/metadata/shared/types'
+
+// Cache keys: metadata:{provider}:{resourceType}:{providerId}
+//             metadata-search:{provider}:{mediaType}:{queryHash}
+
+export function makeCacheKey(...parts: string[]): string {
+  return parts.join(':')
+}
+
+export async function getCacheRecord(key: string): Promise<MetadataCacheRecord | null> {
+  const storage = useStorage('metadata')
+  return (await storage.getItem<MetadataCacheRecord>(key)) ?? null
+}
+
+export async function setCacheRecord(key: string, record: MetadataCacheRecord, ttl?: number): Promise<void> {
+  const storage = useStorage('metadata')
+  await storage.setItem(key, record, ttl ? { ttl } : undefined)
+}
+
+export async function getSearchCache<T>(key: string): Promise<T | null> {
+  const storage = useStorage('metadata')
+  return (await storage.getItem<T>(key)) ?? null
+}
+
+export async function setSearchCache<T>(key: string, value: T, ttl = 3600): Promise<void> {
+  const storage = useStorage('metadata')
+  await storage.setItem(key, value, { ttl })
+}
+
+export function hashQuery(query: string): string {
+  let h = 0
+  for (let i = 0; i < query.length; i++) {
+    h = (Math.imul(31, h) + query.charCodeAt(i)) | 0
+  }
+  return Math.abs(h).toString(36)
+}

package/layers/metadata/server/utils/metadata/errors.ts

@@ -0,0 +1,24 @@
+export class MetadataProviderError extends Error {
+  constructor(
+    public readonly provider: string,
+    message: string,
+    public readonly cause?: unknown,
+  ) {
+    super(`[metadata:${provider}] ${message}`)
+    this.name = 'MetadataProviderError'
+  }
+}
+
+export class MetadataNotFoundError extends Error {
+  constructor(provider: string, id: string) {
+    super(`[metadata:${provider}] Not found: ${id}`)
+    this.name = 'MetadataNotFoundError'
+  }
+}
+
+export class MetadataRateLimitError extends Error {
+  constructor(provider: string) {
+    super(`[metadata:${provider}] Rate limit exceeded`)
+    this.name = 'MetadataRateLimitError'
+  }
+}

package/layers/metadata/server/utils/metadata/provider-registry.ts

@@ -0,0 +1,15 @@
+import type { MetadataProvider, MetadataProviderId } from '#layers/metadata/shared/types'
+
+const _registry = new Map<MetadataProviderId, MetadataProvider>()
+
+export function registerProvider(provider: MetadataProvider) {
+  _registry.set(provider.id, provider)
+}
+
+export function getProvider(id: MetadataProviderId): MetadataProvider | null {
+  return _registry.get(id) ?? null
+}
+
+export function getProviders(): MetadataProvider[] {
+  return [..._registry.values()]
+}

package/layers/metadata/server/utils/metadata/search.ts

@@ -0,0 +1,42 @@
+import type { MetadataSearchInput, MetadataSearchResult } from '#layers/metadata/shared/types'
+
+// fallow-ignore-next-line complexity
+export async function searchMetadata(input: MetadataSearchInput): Promise<MetadataSearchResult[]> {
+  const all = getProviders()
+  const targets = input.providers?.length
+    ? all.filter((p) => input.providers!.includes(p.id))
+    : all.filter((p) => !input.mediaType || p.mediaTypes.includes(input.mediaType))
+
+  if (!targets.length) return []
+
+  const cacheKey = makeCacheKey(
+    'metadata-search',
+    targets.map((p) => p.id).join('+'),
+    input.mediaType ?? 'any',
+    hashQuery(`${input.query}:${input.limit ?? 10}`),
+  )
+
+  const cached = await getSearchCache<MetadataSearchResult[]>(cacheKey)
+  if (cached) return cached
+
+  const settled = await Promise.allSettled(targets.map((p) => p.search(input)))
+
+  const results: MetadataSearchResult[] = []
+  for (const outcome of settled) {
+    if (outcome.status === 'fulfilled') results.push(...outcome.value)
+  }
+
+  const deduped = deduplicateResults(results)
+  await setSearchCache(cacheKey, deduped)
+  return deduped
+}
+
+function deduplicateResults(results: MetadataSearchResult[]): MetadataSearchResult[] {
+  const seen = new Set<string>()
+  return results.filter((r) => {
+    const key = `${r.title.toLowerCase()}:${r.publishedAt?.slice(0, 4) ?? ''}`
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}

package/layers/metadata/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../apps/playground/tsconfig.json",
+  "compilerOptions": {
+    "strict": true
+  },
+  "exclude": ["node_modules"]
+}

package/layers/metadata-comicvine/nuxt.config.ts

@@ -0,0 +1,36 @@
+export default defineNuxtConfig({
+  $meta: {
+    name: 'metadata-comicvine',
+  },
+
+  extends: ['../metadata'],
+
+  alias: {
+    '#layers/metadata-comicvine': import.meta.dirname,
+  },
+
+  compatibilityDate: '2026-06-30',
+
+  runtimeConfig: {
+    metadataComicvine: {
+      apiKey: '', // env: NUXT_METADATA_COMICVINE_API_KEY
+      baseUrl: 'https://comicvine.gamespot.com/api',
+      cacheTtl: 60 * 60 * 24 * 30,
+    },
+  },
+
+  typescript: {
+    typeCheck: false,
+    strict: true,
+  },
+})
+
+declare module '@nuxt/schema' {
+  interface RuntimeConfig {
+    metadataComicvine: {
+      apiKey: string
+      baseUrl: string
+      cacheTtl: number
+    }
+  }
+}

package/layers/metadata-comicvine/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "kmcom-layer-metadata-comicvine",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./nuxt.config.ts",
+  "scripts": {
+    "dev": "nuxi dev",
+    "dev:playground": "PLAYGROUND_LAYERS=core,metadata,metadata-comicvine pnpm -F playground dev",
+    "typecheck": "vue-tsc --noEmit -p ../../tsconfig.typecheck.json",
+    "lint": "eslint ."
+  }
+}

package/layers/metadata-comicvine/server/plugins/comicvine-register.ts

@@ -0,0 +1,3 @@
+export default defineNitroPlugin(() => {
+  registerProvider(comicVineProvider)
+})

package/layers/metadata-comicvine/server/utils/metadata-comicvine/client.ts

@@ -0,0 +1,52 @@
+import type { ComicVineApiResponse } from './types'
+
+const FIELD_LIST_ISSUE = 'id,name,issue_number,description,deck,cover_date,store_date,site_detail_url,image,volume,person_credits,publisher'
+const FIELD_LIST_VOLUME = 'id,name,description,deck,start_year,site_detail_url,image,publisher,people'
+
+function getConfig() {
+  const config = useRuntimeConfig()
+  return config.metadataComicvine
+}
+
+async function comicVineFetch<T>(path: string, params: Record<string, string>): Promise<ComicVineApiResponse<T>> {
+  const { apiKey, baseUrl } = getConfig()
+
+  const url = new URL(`${baseUrl}${path}`)
+  url.searchParams.set('api_key', apiKey)
+  url.searchParams.set('format', 'json')
+  for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v)
+
+  const res = await $fetch<ComicVineApiResponse<T>>(url.toString())
+  if (res.status_code !== 1) throw new MetadataProviderError('comicvine', `API error: ${res.error}`)
+  return res
+}
+
+export async function searchComicVineIssues(query: string, limit = 10) {
+  return comicVineFetch<import('./types').ComicVineIssue[]>('/search/', {
+    query,
+    resources: 'issue',
+    limit: String(limit),
+    field_list: FIELD_LIST_ISSUE,
+  })
+}
+
+export async function searchComicVineVolumes(query: string, limit = 10) {
+  return comicVineFetch<import('./types').ComicVineVolume[]>('/search/', {
+    query,
+    resources: 'volume',
+    limit: String(limit),
+    field_list: FIELD_LIST_VOLUME,
+  })
+}
+
+export async function fetchComicVineIssue(id: string) {
+  return comicVineFetch<import('./types').ComicVineIssue>(`/issue/4000-${id}/`, {
+    field_list: FIELD_LIST_ISSUE,
+  })
+}
+
+export async function fetchComicVineVolume(id: string) {
+  return comicVineFetch<import('./types').ComicVineVolume>(`/volume/4050-${id}/`, {
+    field_list: FIELD_LIST_VOLUME,
+  })
+}

package/layers/metadata-comicvine/server/utils/metadata-comicvine/normalise.ts

@@ -0,0 +1,55 @@
+import type { MetadataRecord, MetadataCreator } from '#layers/metadata/shared/types'
+import type { ComicVineIssue, ComicVineVolume } from './types'
+
+// fallow-ignore-next-line complexity
+export function normaliseComicVineIssue(issue: ComicVineIssue): MetadataRecord {
+  const creators: MetadataCreator[] = (issue.person_credits ?? []).map((p) => ({
+    name: p.name,
+    role: p.role,
+    providerId: String(p.id),
+  }))
+
+  return {
+    id: `comicvine:issue:${issue.id}`,
+    provider: 'comicvine',
+    providerId: String(issue.id),
+    mediaType: 'comic',
+    title: issue.volume?.name ? `${issue.volume.name} #${issue.issue_number}` : (issue.name ?? `Issue #${issue.issue_number}`),
+    subtitle: issue.name ?? undefined,
+    description: issue.deck ?? issue.description ?? undefined,
+    creators: creators.length ? creators : undefined,
+    publisher: issue.publisher?.name ?? undefined,
+    publishedAt: issue.cover_date ?? issue.store_date ?? undefined,
+    coverUrl: issue.image?.medium_url ?? issue.image?.original_url ?? undefined,
+    identifiers: { comicVineId: String(issue.id) },
+    sourceUrl: issue.site_detail_url,
+    raw: issue,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}
+
+// fallow-ignore-next-line complexity
+export function normaliseComicVineVolume(volume: ComicVineVolume): MetadataRecord {
+  const creators: MetadataCreator[] = (volume.people ?? []).map((p) => ({
+    name: p.name,
+    role: p.role,
+    providerId: String(p.id),
+  }))
+
+  return {
+    id: `comicvine:volume:${volume.id}`,
+    provider: 'comicvine',
+    providerId: String(volume.id),
+    mediaType: 'comic',
+    title: volume.name,
+    description: volume.deck ?? volume.description ?? undefined,
+    creators: creators.length ? creators : undefined,
+    publisher: volume.publisher?.name ?? undefined,
+    publishedAt: volume.start_year ?? undefined,
+    coverUrl: volume.image?.medium_url ?? volume.image?.original_url ?? undefined,
+    identifiers: { comicVineId: String(volume.id) },
+    sourceUrl: volume.site_detail_url,
+    raw: volume,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}

package/layers/metadata-comicvine/server/utils/metadata-comicvine/provider.ts

@@ -0,0 +1,39 @@
+import type { MetadataProvider } from '#layers/metadata/shared/types'
+
+export const comicVineProvider: MetadataProvider = {
+  id: 'comicvine',
+  label: 'Comic Vine',
+  mediaTypes: ['comic', 'graphic-novel', 'collected-edition'],
+
+  // fallow-ignore-next-line complexity
+  async search({ query, mediaType, limit = 10 }) {
+    const resourceType = mediaType === 'collected-edition' || mediaType === 'graphic-novel' ? 'volume' : 'issue'
+
+    if (resourceType === 'volume') {
+      const res = await searchComicVineVolumes(query, limit)
+      return (Array.isArray(res.results) ? res.results : []).map(normaliseComicVineVolume)
+    }
+
+    const [issueRes, volumeRes] = await Promise.all([
+      searchComicVineIssues(query, Math.ceil(limit / 2)),
+      searchComicVineVolumes(query, Math.floor(limit / 2)),
+    ])
+
+    const issues = (Array.isArray(issueRes.results) ? issueRes.results : []).map(normaliseComicVineIssue)
+    const volumes = (Array.isArray(volumeRes.results) ? volumeRes.results : []).map(normaliseComicVineVolume)
+    return [...issues, ...volumes]
+  },
+
+  async lookup({ providerId, resourceType = 'issue' }) {
+    if (resourceType === 'volume') {
+      const res = await fetchComicVineVolume(providerId)
+      return normaliseComicVineVolume(res.results as import('./types').ComicVineVolume)
+    }
+    const res = await fetchComicVineIssue(providerId)
+    return normaliseComicVineIssue(res.results as import('./types').ComicVineIssue)
+  },
+
+  async sync({ providerId, resourceType = 'issue' }) {
+    return (await comicVineProvider.lookup!({ provider: 'comicvine', providerId, resourceType }))!
+  },
+}

package/layers/metadata-comicvine/server/utils/metadata-comicvine/types.ts

@@ -0,0 +1,36 @@
+export type ComicVineApiResponse<T> = {
+  error: string
+  limit: number
+  offset: number
+  number_of_page_results: number
+  number_of_total_results: number
+  status_code: number
+  results: T
+}
+
+export type ComicVineIssue = {
+  id: number
+  name: string | null
+  issue_number: string
+  description: string | null
+  deck: string | null
+  cover_date: string | null
+  store_date: string | null
+  site_detail_url: string
+  image: { original_url: string; medium_url: string } | null
+  volume: { id: number; name: string } | null
+  person_credits: Array<{ id: number; name: string; role: string }> | null
+  publisher: { id: number; name: string } | null
+}
+
+export type ComicVineVolume = {
+  id: number
+  name: string
+  description: string | null
+  deck: string | null
+  start_year: string | null
+  site_detail_url: string
+  image: { original_url: string; medium_url: string } | null
+  publisher: { id: number; name: string } | null
+  people: Array<{ id: number; name: string; role: string }> | null
+}

package/layers/metadata-comicvine/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../apps/playground/tsconfig.json",
+  "compilerOptions": {
+    "strict": true
+  },
+  "exclude": ["node_modules"]
+}

package/layers/metadata-google-books/nuxt.config.ts

@@ -0,0 +1,32 @@
+export default defineNuxtConfig({
+  $meta: {
+    name: 'metadata-google-books',
+  },
+
+  extends: ['../metadata'],
+
+  alias: {
+    '#layers/metadata-google-books': import.meta.dirname,
+  },
+
+  compatibilityDate: '2026-06-30',
+
+  runtimeConfig: {
+    metadataGoogleBooks: {
+      apiKey: '', // env: NUXT_METADATA_GOOGLE_BOOKS_API_KEY (optional — anonymous quota is limited)
+    },
+  },
+
+  typescript: {
+    typeCheck: false,
+    strict: true,
+  },
+})
+
+declare module '@nuxt/schema' {
+  interface RuntimeConfig {
+    metadataGoogleBooks: {
+      apiKey: string
+    }
+  }
+}

package/layers/metadata-google-books/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "kmcom-layer-metadata-google-books",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./nuxt.config.ts",
+  "scripts": {
+    "dev": "nuxi dev",
+    "dev:playground": "PLAYGROUND_LAYERS=core,metadata,metadata-google-books pnpm -F playground dev",
+    "typecheck": "vue-tsc --noEmit -p ../../tsconfig.typecheck.json",
+    "lint": "eslint ."
+  }
+}

package/layers/metadata-google-books/server/plugins/google-books-register.ts

@@ -0,0 +1,3 @@
+export default defineNitroPlugin(() => {
+  registerProvider(googleBooksProvider)
+})

package/layers/metadata-google-books/server/utils/metadata-google-books/client.ts

@@ -0,0 +1,23 @@
+import type { GoogleBooksSearchResponse, GoogleBooksVolume } from './types'
+
+const BASE = 'https://www.googleapis.com/books/v1'
+
+function getApiKey(): string | undefined {
+  return useRuntimeConfig().metadataGoogleBooks?.apiKey || undefined
+}
+
+export async function searchGoogleBooks(query: string, limit = 10): Promise<GoogleBooksSearchResponse> {
+  const params: Record<string, string> = { q: query, maxResults: String(limit) }
+  const apiKey = getApiKey()
+  if (apiKey) params.key = apiKey
+
+  return $fetch<GoogleBooksSearchResponse>(`${BASE}/volumes`, { query: params })
+}
+
+export async function fetchGoogleBooksVolume(id: string): Promise<GoogleBooksVolume> {
+  const params: Record<string, string> = {}
+  const apiKey = getApiKey()
+  if (apiKey) params.key = apiKey
+
+  return $fetch<GoogleBooksVolume>(`${BASE}/volumes/${id}`, { query: params })
+}

package/layers/metadata-google-books/server/utils/metadata-google-books/normalise.ts

@@ -0,0 +1,39 @@
+import type { MetadataRecord, MetadataCreator } from '#layers/metadata/shared/types'
+import type { GoogleBooksVolume } from './types'
+
+// fallow-ignore-next-line complexity
+export function normaliseGoogleBooksVolume(volume: GoogleBooksVolume): MetadataRecord {
+  const { volumeInfo } = volume
+
+  const creators: MetadataCreator[] = (volumeInfo.authors ?? []).map((name) => ({
+    name,
+    role: 'author',
+  }))
+
+  const isbn10 = volumeInfo.industryIdentifiers?.find((i) => i.type === 'ISBN_10')?.identifier
+  const isbn13 = volumeInfo.industryIdentifiers?.find((i) => i.type === 'ISBN_13')?.identifier
+
+  const cover = volumeInfo.imageLinks?.thumbnail ?? volumeInfo.imageLinks?.smallThumbnail
+
+  return {
+    id: `google-books:volume:${volume.id}`,
+    provider: 'google-books',
+    providerId: volume.id,
+    mediaType: 'book',
+    title: volumeInfo.title,
+    subtitle: volumeInfo.subtitle,
+    description: volumeInfo.description,
+    creators: creators.length ? creators : undefined,
+    publisher: volumeInfo.publisher,
+    publishedAt: volumeInfo.publishedDate,
+    coverUrl: cover ? cover.replace('http://', 'https://') : undefined,
+    identifiers: {
+      isbn10,
+      isbn13,
+      googleBooksId: volume.id,
+    },
+    sourceUrl: volumeInfo.canonicalVolumeLink ?? volumeInfo.infoLink,
+    raw: volume,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}

package/layers/metadata-google-books/server/utils/metadata-google-books/provider.ts

@@ -0,0 +1,21 @@
+import type { MetadataProvider } from '#layers/metadata/shared/types'
+
+export const googleBooksProvider: MetadataProvider = {
+  id: 'google-books',
+  label: 'Google Books',
+  mediaTypes: ['book', 'graphic-novel', 'collected-edition'],
+
+  async search({ query, limit = 10 }) {
+    const res = await searchGoogleBooks(query, limit)
+    return (res.items ?? []).map(normaliseGoogleBooksVolume)
+  },
+
+  async lookup({ providerId }) {
+    const volume = await fetchGoogleBooksVolume(providerId)
+    return normaliseGoogleBooksVolume(volume)
+  },
+
+  async sync({ providerId }) {
+    return (await googleBooksProvider.lookup!({ provider: 'google-books', providerId }))!
+  },
+}

package/layers/metadata-google-books/server/utils/metadata-google-books/types.ts

@@ -0,0 +1,25 @@
+export type GoogleBooksVolumeInfo = {
+  title: string
+  subtitle?: string
+  authors?: string[]
+  publisher?: string
+  publishedDate?: string
+  description?: string
+  industryIdentifiers?: Array<{ type: 'ISBN_10' | 'ISBN_13' | string; identifier: string }>
+  pageCount?: number
+  imageLinks?: { thumbnail?: string; smallThumbnail?: string }
+  previewLink?: string
+  infoLink?: string
+  canonicalVolumeLink?: string
+}
+
+export type GoogleBooksVolume = {
+  id: string
+  selfLink: string
+  volumeInfo: GoogleBooksVolumeInfo
+}
+
+export type GoogleBooksSearchResponse = {
+  totalItems: number
+  items?: GoogleBooksVolume[]
+}

package/layers/metadata-google-books/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../apps/playground/tsconfig.json",
+  "compilerOptions": {
+    "strict": true
+  },
+  "exclude": ["node_modules"]
+}

package/layers/metadata-openlibrary/nuxt.config.ts

@@ -0,0 +1,18 @@
+export default defineNuxtConfig({
+  $meta: {
+    name: 'metadata-openlibrary',
+  },
+
+  extends: ['../metadata'],
+
+  alias: {
+    '#layers/metadata-openlibrary': import.meta.dirname,
+  },
+
+  compatibilityDate: '2026-06-30',
+
+  typescript: {
+    typeCheck: false,
+    strict: true,
+  },
+})

package/layers/metadata-openlibrary/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "kmcom-layer-metadata-openlibrary",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./nuxt.config.ts",
+  "scripts": {
+    "dev": "nuxi dev",
+    "dev:playground": "PLAYGROUND_LAYERS=core,metadata,metadata-openlibrary pnpm -F playground dev",
+    "typecheck": "vue-tsc --noEmit -p ../../tsconfig.typecheck.json",
+    "lint": "eslint ."
+  }
+}

package/layers/metadata-openlibrary/server/plugins/openlibrary-register.ts

@@ -0,0 +1,3 @@
+export default defineNitroPlugin(() => {
+  registerProvider(openLibraryProvider)
+})

package/layers/metadata-openlibrary/server/utils/metadata-openlibrary/client.ts

@@ -0,0 +1,30 @@
+import type { OpenLibrarySearchResponse, OpenLibraryWork, OpenLibraryEdition } from './types'
+
+const BASE = 'https://openlibrary.org'
+
+export function openLibraryCoverUrl(coverId: number, size: 'S' | 'M' | 'L' = 'M'): string {
+  return `https://covers.openlibrary.org/b/id/${coverId}-${size}.jpg`
+}
+
+export async function searchOpenLibrary(query: string, limit = 10): Promise<OpenLibrarySearchResponse> {
+  return $fetch<OpenLibrarySearchResponse>(`${BASE}/search.json`, {
+    query: { q: query, limit, fields: 'key,title,subtitle,author_name,author_key,publisher,first_publish_year,isbn,cover_i,number_of_pages_median' },
+  })
+}
+
+export async function lookupOpenLibraryWork(workId: string): Promise<OpenLibraryWork> {
+  return $fetch<OpenLibraryWork>(`${BASE}/works/${workId}.json`)
+}
+
+export async function lookupOpenLibraryEdition(editionId: string): Promise<OpenLibraryEdition> {
+  return $fetch<OpenLibraryEdition>(`${BASE}/books/${editionId}.json`)
+}
+
+export async function lookupByIsbn(isbn: string): Promise<OpenLibraryEdition | null> {
+  try {
+    return await $fetch<OpenLibraryEdition>(`${BASE}/isbn/${isbn}.json`)
+  }
+  catch {
+    return null
+  }
+}