kmcom-nuxt-layers 5.0.8 → 6.1.0

package/layers/core/app/utils/resolveElementStyle.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from 'vite-plus/test'
+
+import { resolveElementStyle } from './resolveElementStyle'
+
+describe('resolveElementStyle display mode', () => {
+  it('returns no display when no mode prop is set', () => {
+    expect(resolveElementStyle({}).display).toBeUndefined()
+  })
+
+  it.each([
+    ['block', 'block'],
+    ['flex', 'flex'],
+    ['grid', 'grid'],
+    ['hidden', 'none'],
+  ] as const)('resolves %s to display: %s', (prop, display) => {
+    expect(resolveElementStyle({ [prop]: true }).display).toBe(display)
+  })
+
+  it('prioritizes hidden > grid > flex > block', () => {
+    expect(resolveElementStyle({ hidden: true, grid: true, flex: true, block: true }).display).toBe(
+      'none'
+    )
+    expect(resolveElementStyle({ grid: true, flex: true, block: true }).display).toBe('grid')
+    expect(resolveElementStyle({ flex: true, block: true }).display).toBe('flex')
+  })
+})
+
+describe('resolveElementStyle grid container axis', () => {
+  it('returns no grid-template properties when grid is not set', () => {
+    const style = resolveElementStyle({ cols: 12 })
+    expect(style.gridTemplateColumns).toBeUndefined()
+    expect(style.gridTemplateRows).toBeUndefined()
+  })
+
+  it('converts numeric cols/rows to repeat() tracks when grid is set', () => {
+    const style = resolveElementStyle({ grid: true, cols: 12, rows: 4 })
+    expect(style.gridTemplateColumns).toBe('repeat(12, 1fr)')
+    expect(style.gridTemplateRows).toBe('repeat(4, 1fr)')
+  })
+
+  it('passes a string track through unchanged', () => {
+    expect(resolveElementStyle({ grid: true, cols: '1fr 2fr 1fr' }).gridTemplateColumns).toBe(
+      '1fr 2fr 1fr'
+    )
+  })
+})
+
+describe('resolveElementStyle prop mapping', () => {
+  it('maps sizing, surface and interaction props to their CSS properties 1:1', () => {
+    expect(
+      resolveElementStyle({
+        w: '10px',
+        h: '20px',
+        minW: '1px',
+        maxW: '2px',
+        minH: '3px',
+        maxH: '4px',
+        aspect: '16 / 9',
+        bg: 'red',
+        color: 'blue',
+        border: '1px solid',
+        radius: '4px',
+        shadow: '0 0 1px black',
+        cursor: 'pointer',
+        select: 'none',
+        pointer: 'none',
+      })
+    ).toMatchObject({
+      width: '10px',
+      height: '20px',
+      minWidth: '1px',
+      maxWidth: '2px',
+      minHeight: '3px',
+      maxHeight: '4px',
+      aspectRatio: '16 / 9',
+      background: 'red',
+      color: 'blue',
+      border: '1px solid',
+      borderRadius: '4px',
+      boxShadow: '0 0 1px black',
+      cursor: 'pointer',
+      userSelect: 'none',
+      pointerEvents: 'none',
+    })
+  })
+
+  it('merges layout attrs (gap/align/padding) into the same object', () => {
+    expect(resolveElementStyle({ flex: true, gap: 'md', align: 'center', p: 'sm' })).toMatchObject({
+      display: 'flex',
+      gap: 'var(--space-md)',
+      alignItems: 'center',
+      padding: 'var(--space-sm)',
+    })
+  })
+
+  it('leaves every property undefined when no props are set', () => {
+    expect(Object.values(resolveElementStyle({})).every((v) => v === undefined)).toBe(true)
+  })
+})

package/layers/core/app/utils/resolveElementStyle.ts

@@ -0,0 +1,52 @@
+import type { CSSProperties } from 'vue'
+
+import { resolveLayoutAttrsStyle } from '../composables/useLayoutAttrs'
+import type { ElementProps } from '../types/element'
+
+export type ElementStyleInput = Omit<ElementProps, 'as' | 'componentProps'>
+
+const DISPLAY_FOR = {
+  hidden: 'none',
+  grid: 'grid',
+  flex: 'flex',
+  block: 'block',
+} as const
+
+function track(value: number | string | undefined): string | undefined {
+  return typeof value === 'number' ? `repeat(${value}, 1fr)` : value
+}
+
+/**
+ * Element's whole prop vocabulary → one CSSProperties object. Pure: shared by Element
+ * (inline :style) and ElementTw (Tailwind arbitrary-property classes).
+ *
+ * Grid is container axis only ("I am a grid"). Item placement lives in the layout layer
+ * (buildGridPlacementStyle); Element is in core and can't depend on layout.
+ */
+export function resolveElementStyle(props: ElementStyleInput): CSSProperties {
+  // hidden > grid > flex > block
+  const mode = (['hidden', 'grid', 'flex', 'block'] as const).find((m) => props[m])
+  return {
+    display: mode && DISPLAY_FOR[mode],
+    ...resolveLayoutAttrsStyle(props),
+    ...(props.grid && {
+      gridTemplateColumns: track(props.cols),
+      gridTemplateRows: track(props.rows),
+    }),
+    width: props.w,
+    height: props.h,
+    minWidth: props.minW,
+    maxWidth: props.maxW,
+    minHeight: props.minH,
+    maxHeight: props.maxH,
+    aspectRatio: props.aspect,
+    background: props.bg,
+    color: props.color,
+    border: props.border,
+    borderRadius: props.radius,
+    boxShadow: props.shadow,
+    cursor: props.cursor,
+    userSelect: props.select,
+    pointerEvents: props.pointer,
+  }
+}

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

@@ -1,3 +1,4 @@
+import { MetadataProviderError } from '#layers/metadata/server/utils/metadata/errors'
 import { useRuntimeConfig } from 'nitropack/runtime'
 import type { ComicVineApiResponse, ComicVineIssue, ComicVineVolume } from './types'
 

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

@@ -58,14 +58,4 @@ export const comicVineProvider: MetadataProvider = {
     const res = await fetchComicVineIssue(providerId)
     return normaliseComicVineIssue(res.results as ComicVineIssue)
   },
-
-  async sync({ providerId, resourceType = 'issue' }) {
-    const record = await comicVineProvider.lookup({
-      provider: 'comicvine',
-      providerId,
-      resourceType,
-    })
-    if (!record) throw new MetadataProviderError('comicvine', `No record found for ${providerId}`)
-    return record
-  },
 }

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

@@ -1,3 +1,4 @@
+import { providerFetch } from '#layers/metadata/server/utils/metadata/provider-fetch'
 import { useRuntimeConfig } from 'nitropack/runtime'
 import type { MetadataMediaType } from '#layers/metadata/shared/types'
 
@@ -29,15 +30,17 @@ export async function searchGoogleBooks(
   query: string,
   limit = 10
 ): Promise<GoogleBooksSearchResponse> {
-  const params: Record<string, string> = { q: query, maxResults: String(limit), langRestrict: 'en' }
+  const params: Record<string, string> = {
+    q: query,
+    maxResults: String(limit),
+    langRestrict: 'en',
+  }
   const apiKey = getApiKey()
   if (apiKey) params.key = apiKey
 
-  try {
-    return await $fetch<GoogleBooksSearchResponse>(`${BASE}/volumes`, { query: params })
-  } catch (err) {
-    throw new MetadataProviderError('google-books', `API error: ${String(err)}`)
-  }
+  return providerFetch<GoogleBooksSearchResponse>('google-books', `${BASE}/volumes`, {
+    query: params,
+  })
 }
 
 export async function fetchGoogleBooksVolume(id: string): Promise<GoogleBooksVolume> {
@@ -45,9 +48,7 @@ export async function fetchGoogleBooksVolume(id: string): Promise<GoogleBooksVol
   const apiKey = getApiKey()
   if (apiKey) params.key = apiKey
 
-  try {
-    return await $fetch<GoogleBooksVolume>(`${BASE}/volumes/${id}`, { query: params })
-  } catch (err) {
-    throw new MetadataProviderError('google-books', `API error: ${String(err)}`)
-  }
+  return providerFetch<GoogleBooksVolume>('google-books', `${BASE}/volumes/${id}`, {
+    query: params,
+  })
 }

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

@@ -23,11 +23,4 @@ export const googleBooksProvider: MetadataProvider = {
     const volume = await fetchGoogleBooksVolume(providerId)
     return normaliseGoogleBooksVolume(volume)
   },
-
-  async sync({ providerId }) {
-    const record = await googleBooksProvider.lookup({ provider: 'google-books', providerId })
-    if (!record)
-      throw new MetadataProviderError('google-books', `No record found for ${providerId}`)
-    return record
-  },
 }

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

@@ -1,3 +1,4 @@
+import { providerFetch } from '#layers/metadata/server/utils/metadata/provider-fetch'
 import type { OpenLibraryEdition, OpenLibrarySearchResponse, OpenLibraryWork } from './types'
 
 const BASE = 'https://openlibrary.org'
@@ -10,35 +11,23 @@ export async function searchOpenLibrary(
   query: string,
   limit = 10
 ): Promise<OpenLibrarySearchResponse> {
-  try {
-    return await $fetch<OpenLibrarySearchResponse>(`${BASE}/search.json`, {
-      timeout: 10000,
-      query: {
-        q: query,
-        limit,
-        fields:
-          'key,title,subtitle,author_name,author_key,publisher,first_publish_year,isbn,cover_i,number_of_pages_median',
-      },
-    })
-  } catch (err) {
-    throw new MetadataProviderError('openlibrary', `API error: ${String(err)}`)
-  }
+  return providerFetch<OpenLibrarySearchResponse>('openlibrary', `${BASE}/search.json`, {
+    timeout: 10000,
+    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> {
-  try {
-    return await $fetch<OpenLibraryWork>(`${BASE}/works/${workId}.json`)
-  } catch (err) {
-    throw new MetadataProviderError('openlibrary', `API error: ${String(err)}`)
-  }
+  return providerFetch<OpenLibraryWork>('openlibrary', `${BASE}/works/${workId}.json`)
 }
 
 export async function lookupOpenLibraryEdition(editionId: string): Promise<OpenLibraryEdition> {
-  try {
-    return await $fetch<OpenLibraryEdition>(`${BASE}/books/${editionId}.json`)
-  } catch (err) {
-    throw new MetadataProviderError('openlibrary', `API error: ${String(err)}`)
-  }
+  return providerFetch<OpenLibraryEdition>('openlibrary', `${BASE}/books/${editionId}.json`)
 }
 
 export async function lookupByIsbn(isbn: string): Promise<OpenLibraryEdition | null> {

package/layers/data/metadata/providers/openlibrary/server/utils/metadata-openlibrary/provider.ts

@@ -24,14 +24,4 @@ export const openLibraryProvider: MetadataProvider = {
     const work = await lookupOpenLibraryWork(providerId)
     return normaliseOpenLibraryWork(work)
   },
-
-  async sync({ providerId, resourceType = 'work' }) {
-    const record = await openLibraryProvider.lookup({
-      provider: 'openlibrary',
-      providerId,
-      resourceType,
-    })
-    if (!record) throw new MetadataProviderError('openlibrary', `No record found for ${providerId}`)
-    return record
-  },
 }

package/layers/data/metadata/providers/themoviedb/server/utils/metadata-tmdb/client.ts

@@ -1,3 +1,4 @@
+import { providerFetch } from '#layers/metadata/server/utils/metadata/provider-fetch'
 import { useRuntimeConfig } from 'nitropack/runtime'
 import type { TMDBFindResponse, TMDBMovie, TMDBSearchResponse, TMDBTVShow } from './types'
 
@@ -22,13 +23,9 @@ async function tmdbFetch<T>(path: string, params: Record<string, string> = {}):
   if (!isJwt) url.searchParams.set('api_key', apiKey)
   for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v)
 
-  try {
-    return await $fetch<T>(url.toString(), {
-      ...(isJwt && { headers: { Authorization: `Bearer ${apiKey}` } }),
-    })
-  } catch (err) {
-    throw new MetadataProviderError('tmdb', `API error: ${String(err)}`)
-  }
+  return providerFetch<T>('tmdb', url.toString(), {
+    ...(isJwt && { headers: { Authorization: `Bearer ${apiKey}` } }),
+  })
 }
 
 export async function searchTmdb(query: string, limit = 10): Promise<TMDBSearchResponse> {

package/layers/data/metadata/providers/themoviedb/server/utils/metadata-tmdb/provider.ts

@@ -32,10 +32,4 @@ export const tmdbProvider: MetadataProvider = {
     if (resourceType === 'tv-show') return normaliseTmdbTV(await fetchTmdbTV(providerId))
     return normaliseTmdbMovie(await fetchTmdbMovie(providerId))
   },
-
-  async sync(input) {
-    const record = await tmdbProvider.lookup(input)
-    if (!record) throw new MetadataProviderError('tmdb', `No record found for ${input.providerId}`)
-    return record
-  },
 }

package/layers/data/metadata/server/api/metadata/lookup.get.ts

@@ -1,48 +1,13 @@
-import { getCacheRecord, makeCacheKey, setCacheRecord } from '../../utils/metadata/cache'
-import { getProvider } from '../../utils/metadata/provider-registry'
-import { createError, defineEventHandler, getQuery } from 'h3'
-import type { MetadataProviderId } from '#layers/metadata/shared/types'
+import { resolveRecord } from '../../utils/metadata/resolve-record'
+import { defineEventHandler, getQuery } from 'h3'
 
-// fallow-ignore-next-line complexity
 export default defineEventHandler(async (event) => {
   const query = getQuery(event)
 
-  const providerId = String(query.providerId ?? '').trim()
-  const providerName = String(query.provider ?? '').trim() as MetadataProviderId
-  const resourceType = query.resourceType ? String(query.resourceType) : undefined
-
-  if (!providerName || !providerId) {
-    throw createError({ statusCode: 400, message: 'provider and providerId are required' })
-  }
-
-  const provider = getProvider(providerName)
-  if (!provider)
-    throw createError({ statusCode: 404, message: `Provider '${providerName}' not registered` })
-
-  const cacheKey = makeCacheKey('metadata', providerName, resourceType ?? 'item', providerId)
-  const cached = await getCacheRecord(cacheKey)
-  if (cached) return cached.normalised
-
-  const result = await provider.lookup({
-    provider: providerName,
-    providerId,
-    ...(resourceType && { resourceType }),
+  const { record } = await resolveRecord({
+    provider: String(query.provider ?? '').trim(),
+    providerId: String(query.providerId ?? '').trim(),
+    ...(query.resourceType && { resourceType: String(query.resourceType) }),
   })
-  if (!result) throw createError({ statusCode: 404, message: 'Not found' })
-
-  const now = new Date().toISOString()
-  await setCacheRecord(cacheKey, {
-    id: result.id,
-    provider: providerName,
-    providerId,
-    resourceType: resourceType ?? 'item',
-    mediaType: result.mediaType,
-    normalised: result,
-    raw: result.raw ?? null,
-    createdAt: now,
-    updatedAt: now,
-    lastSyncedAt: now,
-  })
-
-  return result
+  return record
 })

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

@@ -1,53 +1,8 @@
-import { getCacheRecord, makeCacheKey, setCacheRecord } from '../../utils/metadata/cache'
-import { getProvider } from '../../utils/metadata/provider-registry'
-import { createError, defineEventHandler, readBody } from 'h3'
-import type { MetadataProviderId, MetadataSyncInput } from '#layers/metadata/shared/types'
+import { resolveRecord } from '../../utils/metadata/resolve-record'
+import { defineEventHandler, readBody } from 'h3'
+import type { MetadataSyncInput } 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 && { resourceType }),
-    ...(force !== undefined && { 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 }
+  return resolveRecord({ ...body })
 })

package/layers/data/metadata/server/utils/metadata/provider-fetch.test.ts

@@ -0,0 +1,27 @@
+import { afterEach, describe, expect, it, vi } from 'vite-plus/test'
+
+import { MetadataProviderError } from './errors'
+import { providerFetch } from './provider-fetch'
+
+afterEach(() => vi.unstubAllGlobals())
+
+describe('providerFetch', () => {
+  it('returns the fetched body', async () => {
+    vi.stubGlobal(
+      '$fetch',
+      vi.fn(async () => ({ ok: true }))
+    )
+    await expect(providerFetch('tmdb', 'https://x.test')).resolves.toEqual({ ok: true })
+  })
+
+  it('wraps failures in a MetadataProviderError for the provider', async () => {
+    vi.stubGlobal(
+      '$fetch',
+      vi.fn(async () => Promise.reject(new Error('boom')))
+    )
+    const err = await providerFetch('tmdb', 'https://x.test').catch((e) => e)
+    expect(err).toBeInstanceOf(MetadataProviderError)
+    expect(err.provider).toBe('tmdb')
+    expect(err.message).toContain('API error')
+  })
+})

package/layers/data/metadata/server/utils/metadata/provider-fetch.ts

@@ -0,0 +1,14 @@
+import { MetadataProviderError } from './errors'
+
+/** `$fetch` that reports any failure as a MetadataProviderError for `provider`. */
+export async function providerFetch<T>(
+  provider: string,
+  url: string,
+  opts?: { query?: Record<string, unknown>; headers?: Record<string, string>; timeout?: number }
+): Promise<T> {
+  try {
+    return (await $fetch(url, opts)) as T
+  } catch (err) {
+    throw new MetadataProviderError(provider, `API error: ${String(err)}`, err)
+  }
+}

package/layers/data/metadata/server/utils/metadata/resolve-record.test.ts

@@ -0,0 +1,87 @@
+import type { MetadataProvider, MetadataRecord } from '#layers/metadata/shared/types'
+import type * as CacheModule from './cache'
+import { beforeEach, describe, expect, it, vi } from 'vite-plus/test'
+
+const { providerState, getCacheRecordMock, setCacheRecordMock } = vi.hoisted(() => ({
+  providerState: { provider: null as MetadataProvider | null },
+  getCacheRecordMock: vi.fn(async () => null as { normalised: MetadataRecord } | null),
+  setCacheRecordMock: vi.fn(async () => undefined),
+}))
+
+vi.mock('./provider-registry', () => ({ getProvider: () => providerState.provider }))
+vi.mock('./cache', async (importOriginal) => ({
+  ...(await importOriginal<typeof CacheModule>()),
+  getCacheRecord: getCacheRecordMock,
+  setCacheRecord: setCacheRecordMock,
+}))
+
+import { resolveRecord } from './resolve-record'
+
+const record = {
+  id: 'r1',
+  provider: 'comicvine',
+  providerId: '42',
+  mediaType: 'comic',
+  title: 'Watchmen',
+} as MetadataRecord
+
+const lookup = vi.fn(async () => record as MetadataRecord | null)
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  getCacheRecordMock.mockResolvedValue(null)
+  lookup.mockResolvedValue(record)
+  providerState.provider = {
+    id: 'comicvine',
+    label: 'Comic Vine',
+    mediaTypes: ['comic'],
+    search: async () => [],
+    lookup,
+  }
+})
+
+describe('resolveRecord', () => {
+  it('400s without provider or providerId', async () => {
+    await expect(resolveRecord({ provider: 'comicvine' })).rejects.toMatchObject({
+      statusCode: 400,
+    })
+  })
+
+  it('404s for an unregistered provider', async () => {
+    providerState.provider = null
+    await expect(resolveRecord({ provider: 'nope', providerId: '1' })).rejects.toMatchObject({
+      statusCode: 404,
+    })
+  })
+
+  it('fetches, caches and reports synced on a miss', async () => {
+    const out = await resolveRecord({ provider: 'comicvine', providerId: '42' })
+    expect(out).toEqual({ record, synced: true })
+    expect(setCacheRecordMock).toHaveBeenCalledWith(
+      'metadata:comicvine:item:42',
+      expect.objectContaining({ id: 'r1', providerId: '42', resourceType: 'item' })
+    )
+  })
+
+  it('returns the cached record without calling the provider', async () => {
+    getCacheRecordMock.mockResolvedValue({ normalised: record })
+    const out = await resolveRecord({ provider: 'comicvine', providerId: '42' })
+    expect(out).toEqual({ record, synced: false })
+    expect(lookup).not.toHaveBeenCalled()
+  })
+
+  it('force skips the cache read', async () => {
+    getCacheRecordMock.mockResolvedValue({ normalised: record })
+    const out = await resolveRecord({ provider: 'comicvine', providerId: '42', force: true })
+    expect(out.synced).toBe(true)
+    expect(lookup).toHaveBeenCalledOnce()
+  })
+
+  it('404s when the provider finds nothing and does not cache', async () => {
+    lookup.mockResolvedValue(null)
+    await expect(resolveRecord({ provider: 'comicvine', providerId: '42' })).rejects.toMatchObject({
+      statusCode: 404,
+    })
+    expect(setCacheRecordMock).not.toHaveBeenCalled()
+  })
+})

package/layers/data/metadata/server/utils/metadata/resolve-record.ts

@@ -0,0 +1,60 @@
+import { createError } from 'h3'
+import { getCacheRecord, makeCacheKey, setCacheRecord } from './cache'
+import { getProvider } from './provider-registry'
+import type { MetadataRecord } from '#layers/metadata/shared/types'
+
+export type ResolveRecordInput = {
+  provider?: string
+  providerId?: string
+  resourceType?: string
+  /** Skip the cache read and refetch from the provider. */
+  force?: boolean
+}
+
+/**
+ * Cache-through lookup of one record. `synced` is true when the provider was called,
+ * false when the cached record was returned. Throws h3 errors (400/404) for bad input.
+ */
+export async function resolveRecord(
+  input: ResolveRecordInput
+): Promise<{ record: MetadataRecord; synced: boolean }> {
+  const { provider: providerName, providerId, resourceType, force } = input
+  if (!providerName || !providerId) {
+    throw createError({ statusCode: 400, message: 'provider and providerId are required' })
+  }
+
+  const provider = getProvider(providerName)
+  if (!provider) {
+    throw createError({ statusCode: 404, message: `Provider '${providerName}' not registered` })
+  }
+
+  const cacheKey = makeCacheKey('metadata', providerName, resourceType ?? 'item', providerId)
+
+  if (!force) {
+    const cached = await getCacheRecord(cacheKey)
+    if (cached) return { record: cached.normalised, synced: false }
+  }
+
+  const record = await provider.lookup({
+    provider: providerName,
+    providerId,
+    ...(resourceType && { resourceType }),
+  })
+  if (!record) throw createError({ statusCode: 404, message: 'Not found' })
+
+  const now = new Date().toISOString()
+  await setCacheRecord(cacheKey, {
+    id: record.id,
+    provider: providerName,
+    providerId,
+    resourceType: resourceType ?? 'item',
+    mediaType: record.mediaType,
+    normalised: record,
+    raw: record.raw ?? null,
+    createdAt: now,
+    updatedAt: now,
+    lastSyncedAt: now,
+  })
+
+  return { record, synced: true }
+}

package/layers/data/metadata/shared/types/providers.ts

@@ -1,6 +1,8 @@
 import type { MetadataMediaType, MetadataRecord } from './metadata'
 
-export type MetadataProviderId = 'comicvine' | 'openlibrary' | 'google-books' | 'tmdb' | 'local'
+// Open: a provider layer registers whatever id it likes (built-ins: comicvine, openlibrary,
+// google-books, tmdb). Unknown ids are rejected at runtime by the provider registry.
+export type MetadataProviderId = string
 
 export type MetadataSearchInput = {
   query: string
@@ -32,5 +34,4 @@ export type MetadataProvider = {
   mediaTypes: MetadataMediaType[]
   search: (input: MetadataSearchInput) => Promise<MetadataSearchResult[]>
   lookup: (input: MetadataLookupInput) => Promise<MetadataRecord | null>
-  sync?: (input: MetadataSyncInput) => Promise<MetadataRecord>
 }