kmcom-nuxt-layers 6.3.0 → 6.5.0

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

@@ -1,204 +0,0 @@
-import type {
-  MetadataProvider,
-  MetadataSearchInput,
-  MetadataSearchResult,
-} from '#layers/metadata/shared/types'
-import type * as CacheModule from './cache'
-import { beforeEach, describe, expect, it, vi } from 'vite-plus/test'
-
-// search.ts imports its sibling helpers directly. Keep the pure cache helpers real, and
-// control provider/cache lookups via mocks.
-const { providerState, getProvidersMock, getSearchCacheMock, setSearchCacheMock } = vi.hoisted(
-  () => {
-    const providerState: { mockProviders: MetadataProvider[] } = { mockProviders: [] }
-    return {
-      providerState,
-      getProvidersMock: vi.fn(() => providerState.mockProviders),
-      getSearchCacheMock: vi.fn(async () => null as MetadataSearchResult[] | null),
-      setSearchCacheMock: vi.fn(async () => undefined),
-    }
-  }
-)
-
-vi.mock('./provider-registry', () => ({ getProviders: getProvidersMock }))
-vi.mock('./cache', async (importOriginal) => ({
-  ...(await importOriginal<typeof CacheModule>()),
-  getSearchCache: getSearchCacheMock,
-  setSearchCache: setSearchCacheMock,
-}))
-
-const { searchMetadata } = await import('./search')
-
-function makeResult(overrides: Partial<MetadataSearchResult> = {}): MetadataSearchResult {
-  return {
-    id: 'comicvine:issue:1',
-    provider: 'comicvine',
-    providerId: '1',
-    mediaType: 'comic',
-    title: 'Watchmen',
-    ...overrides,
-  }
-}
-
-function makeProvider(overrides: Partial<MetadataProvider> = {}): MetadataProvider {
-  return {
-    id: 'comicvine',
-    label: 'Comic Vine',
-    mediaTypes: ['comic'],
-    search: async () => [],
-    lookup: async () => null,
-    ...overrides,
-  }
-}
-
-beforeEach(() => {
-  providerState.mockProviders = []
-  getProvidersMock.mockClear()
-  getSearchCacheMock.mockClear()
-  getSearchCacheMock.mockResolvedValue(null)
-  setSearchCacheMock.mockClear()
-})
-
-function baseInput(overrides: Partial<MetadataSearchInput> = {}): MetadataSearchInput {
-  return { query: 'watchmen', ...overrides }
-}
-
-describe('searchMetadata', () => {
-  it('targets only providers named in input.providers', async () => {
-    const a = vi.fn(async () => [makeResult({ id: 'a-1' })])
-    const b = vi.fn(async () => [makeResult({ id: 'b-1' })])
-    providerState.mockProviders = [
-      makeProvider({ id: 'comicvine', search: a }),
-      makeProvider({ id: 'openlibrary', mediaTypes: ['book'], search: b }),
-    ]
-
-    await searchMetadata(baseInput({ providers: ['comicvine'] }))
-
-    expect(a).toHaveBeenCalledTimes(1)
-    expect(b).not.toHaveBeenCalled()
-  })
-
-  it('targets providers by mediaType when providers[] is not given', async () => {
-    const comic = vi.fn(async () => [makeResult()])
-    const book = vi.fn(async () => [makeResult({ mediaType: 'book' })])
-    providerState.mockProviders = [
-      makeProvider({ id: 'comicvine', mediaTypes: ['comic'], search: comic }),
-      makeProvider({ id: 'openlibrary', mediaTypes: ['book'], search: book }),
-    ]
-
-    await searchMetadata(baseInput({ mediaType: 'comic' }))
-
-    expect(comic).toHaveBeenCalledTimes(1)
-    expect(book).not.toHaveBeenCalled()
-  })
-
-  it('targets all providers when neither providers[] nor mediaType is given', async () => {
-    const comic = vi.fn(async () => [makeResult()])
-    const book = vi.fn(async () => [makeResult({ mediaType: 'book' })])
-    providerState.mockProviders = [
-      makeProvider({ id: 'comicvine', mediaTypes: ['comic'], search: comic }),
-      makeProvider({ id: 'openlibrary', mediaTypes: ['book'], search: book }),
-    ]
-
-    await searchMetadata(baseInput())
-
-    expect(comic).toHaveBeenCalledTimes(1)
-    expect(book).toHaveBeenCalledTimes(1)
-  })
-
-  it('returns [] when no providers match the given targets', async () => {
-    providerState.mockProviders = [makeProvider({ id: 'comicvine', mediaTypes: ['comic'] })]
-
-    const result = await searchMetadata(baseInput({ mediaType: 'movie' }))
-
-    expect(result).toEqual([])
-    expect(getSearchCacheMock).not.toHaveBeenCalled()
-  })
-
-  it('returns [] when providers[] names an id with no registered provider', async () => {
-    providerState.mockProviders = [makeProvider({ id: 'comicvine' })]
-
-    const result = await searchMetadata(baseInput({ providers: ['tmdb'] }))
-
-    expect(result).toEqual([])
-  })
-
-  it('keeps results from other providers when one provider rejects', async () => {
-    const ok = vi.fn(async () => [makeResult({ id: 'ok-1', title: 'Watchmen' })])
-    const failing = vi.fn(async () => {
-      throw new Error('boom')
-    })
-    providerState.mockProviders = [
-      makeProvider({ id: 'comicvine', search: ok }),
-      makeProvider({ id: 'openlibrary', mediaTypes: ['book'], search: failing }),
-    ]
-
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined)
-
-    const result = await searchMetadata(baseInput())
-
-    expect(result).toHaveLength(1)
-    expect(result.at(0)?.id).toBe('ok-1')
-    expect(consoleErrorSpy).toHaveBeenCalled()
-
-    consoleErrorSpy.mockRestore()
-  })
-
-  it('deduplicates results by mediaType:title(lowercase):year', async () => {
-    const a = vi.fn(async () => [
-      makeResult({ id: 'a-1', title: 'Watchmen', mediaType: 'comic', publishedAt: '1986-09-01' }),
-    ])
-    const b = vi.fn(async () => [
-      makeResult({ id: 'b-1', title: 'WATCHMEN', mediaType: 'comic', publishedAt: '1986-12-25' }),
-    ])
-    providerState.mockProviders = [
-      makeProvider({ id: 'comicvine', search: a }),
-      makeProvider({ id: 'openlibrary', mediaTypes: ['comic'], search: b }),
-    ]
-
-    const result = await searchMetadata(baseInput())
-
-    expect(result).toHaveLength(1)
-    expect(result.at(0)?.id).toBe('a-1')
-  })
-
-  it('does not dedupe results with different years', async () => {
-    const a = vi.fn(async () => [
-      makeResult({ id: 'a-1', title: 'Watchmen', publishedAt: '1986-09-01' }),
-    ])
-    const b = vi.fn(async () => [
-      makeResult({ id: 'b-1', title: 'Watchmen', publishedAt: '2019-10-20' }),
-    ])
-    providerState.mockProviders = [
-      makeProvider({ id: 'comicvine', search: a }),
-      makeProvider({ id: 'openlibrary', mediaTypes: ['comic'], search: b }),
-    ]
-
-    const result = await searchMetadata(baseInput())
-
-    expect(result).toHaveLength(2)
-  })
-
-  it('short-circuits on a cache hit without calling provider search functions', async () => {
-    const cached = [makeResult({ id: 'cached-1' })]
-    getSearchCacheMock.mockResolvedValue(cached)
-    const search = vi.fn(async () => [makeResult({ id: 'live-1' })])
-    providerState.mockProviders = [makeProvider({ id: 'comicvine', search })]
-
-    const result = await searchMetadata(baseInput())
-
-    expect(result).toBe(cached)
-    expect(search).not.toHaveBeenCalled()
-    expect(setSearchCacheMock).not.toHaveBeenCalled()
-  })
-
-  it('writes deduped results to the cache after a live search', async () => {
-    const search = vi.fn(async () => [makeResult({ id: 'live-1' })])
-    providerState.mockProviders = [makeProvider({ id: 'comicvine', search })]
-
-    const result = await searchMetadata(baseInput())
-
-    expect(setSearchCacheMock).toHaveBeenCalledTimes(1)
-    expect(setSearchCacheMock).toHaveBeenCalledWith(expect.any(String), result)
-  })
-})

package/layers/delivery/feeds/server/utils/content-adapter.test.ts

@@ -1,67 +0,0 @@
-import type { H3Event } from 'h3'
-import { beforeEach, describe, expect, it, vi } from 'vite-plus/test'
-
-import { getContentFeedItems } from './content-adapter'
-
-const queryCollectionMock = vi.hoisted(() => vi.fn())
-
-vi.mock('@nuxt/content/nitro', () => ({
-  queryCollection: queryCollectionMock,
-}))
-
-describe('getContentFeedItems', () => {
-  beforeEach(() => {
-    queryCollectionMock.mockReset()
-  })
-
-  it('filters drafts, sorts by date, and maps feed items', async () => {
-    queryCollectionMock.mockReturnValue({
-      all: vi.fn().mockResolvedValue([
-        {
-          draft: true,
-          title: 'Draft post',
-          path: '/draft',
-          date: '2026-01-04T00:00:00.000Z',
-        },
-        {
-          title: 'Latest post',
-          description: 'Newest content',
-          path: '/latest',
-          date: '2026-01-03T00:00:00.000Z',
-          authors: [{ name: 'Ada Lovelace' }],
-          tags: ['nuxt'],
-        },
-        {
-          stem: 'Older post',
-          _path: '/older',
-          createdAt: '2026-01-01T00:00:00.000Z',
-          author: { name: 'Grace Hopper' },
-        },
-      ]),
-    })
-
-    const items = await getContentFeedItems({} as H3Event, 'articles', 2)
-
-    expect(queryCollectionMock).toHaveBeenCalledWith({}, 'articles')
-    expect(items).toEqual([
-      {
-        title: 'Latest post',
-        description: 'Newest content',
-        link: '/latest',
-        id: '/latest',
-        date: new Date('2026-01-03T00:00:00.000Z'),
-        author: 'Ada Lovelace',
-        tags: ['nuxt'],
-      },
-      {
-        title: 'Older post',
-        description: undefined,
-        link: '/older',
-        id: '/older',
-        date: new Date('2026-01-01T00:00:00.000Z'),
-        author: 'Grace Hopper',
-        tags: undefined,
-      },
-    ])
-  })
-})

package/layers/delivery/feeds/server/utils/feed-author.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, it } from 'vite-plus/test'
-
-import { resolveFeedAuthor, resolveFeedDate } from './feed-author'
-
-describe('resolveFeedAuthor', () => {
-  it('prefers the first entry of the authors array', () => {
-    expect(
-      resolveFeedAuthor({
-        authors: [{ name: 'Kieran Mansfield' }, { name: 'Someone Else' }],
-        author: 'Fallback Author',
-      })
-    ).toBe('Kieran Mansfield')
-  })
-
-  it('falls back to a string author when authors array is missing', () => {
-    expect(resolveFeedAuthor({ author: 'Kieran Mansfield' })).toBe('Kieran Mansfield')
-  })
-
-  it('falls back to an object author.name when author is not a string', () => {
-    expect(resolveFeedAuthor({ author: { name: 'Kieran Mansfield' } })).toBe('Kieran Mansfield')
-  })
-
-  it('returns undefined when no author information is present', () => {
-    expect(resolveFeedAuthor({})).toBeUndefined()
-  })
-
-  it('ignores an authors array entry with an empty name and falls through', () => {
-    expect(resolveFeedAuthor({ authors: [{ name: '' }], author: 'Kieran Mansfield' })).toBe(
-      'Kieran Mansfield'
-    )
-  })
-
-  it('ignores an empty string author and falls through to object author', () => {
-    expect(resolveFeedAuthor({ author: '' })).toBeUndefined()
-  })
-
-  it('returns undefined when authors array is empty and no author is set', () => {
-    expect(resolveFeedAuthor({ authors: [] })).toBeUndefined()
-  })
-})
-
-describe('resolveFeedDate', () => {
-  it('prefers item.date when present', () => {
-    const result = resolveFeedDate({ date: '2024-01-01T00:00:00.000Z' })
-    expect(result).toEqual(new Date('2024-01-01T00:00:00.000Z'))
-  })
-
-  it('falls back to item.createdAt when date is missing', () => {
-    const result = resolveFeedDate({ createdAt: '2023-06-15T00:00:00.000Z' })
-    expect(result).toEqual(new Date('2023-06-15T00:00:00.000Z'))
-  })
-
-  it('falls back to now when neither date nor createdAt is present', () => {
-    const before = Date.now()
-    const result = resolveFeedDate({})
-    const after = Date.now()
-
-    expect(result.getTime()).toBeGreaterThanOrEqual(before)
-    expect(result.getTime()).toBeLessThanOrEqual(after)
-  })
-
-  it('accepts a numeric timestamp', () => {
-    const timestamp = 1700000000000
-    expect(resolveFeedDate({ date: timestamp })).toEqual(new Date(timestamp))
-  })
-
-  it('accepts a Date instance', () => {
-    const date = new Date('2022-03-03T00:00:00.000Z')
-    expect(resolveFeedDate({ date })).toEqual(date)
-  })
-})

package/layers/delivery/feeds/server/utils/feed-config.test.ts

@@ -1,184 +0,0 @@
-import { describe, expect, it } from 'vite-plus/test'
-
-import {
-  createFeedConfig,
-  resolveFeedCollection,
-  resolveFeedLimit,
-  resolveFeedSiteConfig,
-} from './feed-config'
-
-describe('resolveFeedSiteConfig', () => {
-  it('defaults site to an empty object when appConfig.site is missing', () => {
-    const result = resolveFeedSiteConfig({}, new URL('https://example.com/feed'))
-    expect(result.site).toEqual({})
-  })
-
-  it('strips a trailing slash from a configured site url', () => {
-    const result = resolveFeedSiteConfig(
-      { site: { url: 'https://example.com/' } },
-      new URL('https://request-origin.com/feed')
-    )
-    expect(result.siteUrl).toBe('https://example.com')
-  })
-
-  it('keeps a site url without a trailing slash unchanged', () => {
-    const result = resolveFeedSiteConfig(
-      { site: { url: 'https://example.com' } },
-      new URL('https://request-origin.com/feed')
-    )
-    expect(result.siteUrl).toBe('https://example.com')
-  })
-
-  it('falls back to the request origin when no site url is configured', () => {
-    const result = resolveFeedSiteConfig({}, new URL('https://request-origin.com/feed?x=1'))
-    expect(result.siteUrl).toBe('https://request-origin.com')
-  })
-})
-
-describe('resolveFeedCollection', () => {
-  it('uses the explicit collection argument when provided', () => {
-    expect(resolveFeedCollection({ defaultCollection: 'docs' }, 'blog')).toBe('blog')
-  })
-
-  it('falls back to the configured default collection', () => {
-    expect(resolveFeedCollection({ defaultCollection: 'docs' }, undefined)).toBe('docs')
-  })
-
-  it('falls back to "blog" when neither is provided', () => {
-    expect(resolveFeedCollection(undefined, undefined)).toBe('blog')
-  })
-})
-
-describe('createFeedConfig', () => {
-  it('uses "My Site" as the title fallback with no collection label', () => {
-    const config = createFeedConfig({
-      site: {},
-      siteUrl: 'https://example.com',
-      collection: undefined,
-    })
-    expect(config.title).toBe('My Site')
-  })
-
-  it('appends a capitalized collection label to the title', () => {
-    const config = createFeedConfig({
-      site: { title: 'Nuxt Layers' },
-      siteUrl: 'https://example.com',
-      collection: 'blog',
-    })
-    expect(config.title).toBe('Nuxt Layers — Blog')
-  })
-
-  it('defaults description to an empty string', () => {
-    const config = createFeedConfig({
-      site: {},
-      siteUrl: 'https://example.com',
-      collection: undefined,
-    })
-    expect(config.description).toBe('')
-  })
-
-  it('passes description through when set', () => {
-    const config = createFeedConfig({
-      site: { description: 'A monorepo of Nuxt layers' },
-      siteUrl: 'https://example.com',
-      collection: undefined,
-    })
-    expect(config.description).toBe('A monorepo of Nuxt layers')
-  })
-
-  it('builds an author object when the site has a named author', () => {
-    const config = createFeedConfig({
-      site: {
-        author: { name: 'Kieran Mansfield', email: 'hi@example.com', link: 'https://example.com' },
-      },
-      siteUrl: 'https://example.com',
-      collection: undefined,
-    })
-    expect(config.author).toEqual({
-      name: 'Kieran Mansfield',
-      email: 'hi@example.com',
-      link: 'https://example.com',
-    })
-  })
-
-  it('omits author when the site author has no name', () => {
-    const config = createFeedConfig({
-      site: {},
-      siteUrl: 'https://example.com',
-      collection: undefined,
-    })
-    expect(config.author).toBeUndefined()
-  })
-
-  it('maps a falsy site.image to undefined', () => {
-    const config = createFeedConfig({
-      site: { image: '' },
-      siteUrl: 'https://example.com',
-      collection: undefined,
-    })
-    expect(config.image).toBeUndefined()
-  })
-
-  it('passes through a truthy site.image', () => {
-    const config = createFeedConfig({
-      site: { image: 'https://example.com/og.png' },
-      siteUrl: 'https://example.com',
-      collection: undefined,
-    })
-    expect(config.image).toBe('https://example.com/og.png')
-  })
-
-  it('defaults favicon to /favicon.ico', () => {
-    const config = createFeedConfig({
-      site: {},
-      siteUrl: 'https://example.com',
-      collection: undefined,
-    })
-    expect(config.favicon).toBe('/favicon.ico')
-  })
-
-  it('prefers an explicit copyright over a generated one', () => {
-    const config = createFeedConfig({
-      site: { copyright: 'All rights reserved', author: { name: 'Kieran Mansfield' } },
-      siteUrl: 'https://example.com',
-      collection: undefined,
-    })
-    expect(config.copyright).toBe('All rights reserved')
-  })
-
-  it('generates a copyright string from the author name and current year', () => {
-    const config = createFeedConfig({
-      site: { author: { name: 'Kieran Mansfield' } },
-      siteUrl: 'https://example.com',
-      collection: undefined,
-    })
-    expect(config.copyright).toBe(`Copyright ${new Date().getFullYear()} Kieran Mansfield`)
-  })
-
-  it('omits copyright when there is no explicit copyright and no author name', () => {
-    const config = createFeedConfig({
-      site: {},
-      siteUrl: 'https://example.com',
-      collection: undefined,
-    })
-    expect(config.copyright).toBeUndefined()
-  })
-})
-
-describe('resolveFeedLimit', () => {
-  it('defaults to 30 when no limit is configured', () => {
-    expect(resolveFeedLimit(undefined)).toBe(30)
-  })
-
-  it('uses the configured limit', () => {
-    expect(resolveFeedLimit({ limit: 10 })).toBe(10)
-  })
-
-  it('returns Infinity when unlimited is requested, ignoring the configured limit', () => {
-    expect(resolveFeedLimit({ limit: 10 }, { unlimited: true })).toBe(Infinity)
-  })
-
-  it('returns the default limit when unlimited is explicitly false', () => {
-    expect(resolveFeedLimit(undefined, { unlimited: false })).toBe(30)
-  })
-})

package/layers/delivery/feeds/server/utils/formats.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, it } from 'vite-plus/test'
-
-import { toAtom } from './formats/atom'
-import { toJSONFeed } from './formats/json'
-import { toRSS } from './formats/rss'
-import type { FeedConfig, FeedItem } from './types'
-
-const config: FeedConfig = {
-  title: 'Nuxt Layers Feed',
-  description: 'Layered syndication output.',
-  siteUrl: 'https://example.com',
-  author: {
-    name: 'Kieran Mansfield',
-    link: 'https://example.com/about',
-  },
-  favicon: '/favicon.ico',
-}
-
-const items: FeedItem[] = [
-  {
-    title: 'A & B',
-    description: 'Read > write',
-    link: '/posts/a-b',
-    id: '/posts/a-b',
-    date: new Date('2026-01-03T10:00:00.000Z'),
-    author: 'Ada Lovelace',
-    tags: ['nuxt', 'feeds'],
-  },
-]
-
-describe('feed format serializers', () => {
-  it('serializes RSS output with the stylesheet and item data', () => {
-    const xml = toRSS(items, config)
-
-    expect(xml).toContain('<?xml-stylesheet type="text/xsl" href="/feed/style.xsl"?>')
-    expect(xml).toContain('<title>Nuxt Layers Feed</title>')
-    expect(xml).toContain('Ada Lovelace')
-    expect(xml).toContain('/posts/a-b')
-  })
-
-  it('serializes JSON Feed output as a structured object', () => {
-    expect(toJSONFeed(items, config)).toMatchObject({
-      version: 'https://jsonfeed.org/version/1.1',
-      title: 'Nuxt Layers Feed',
-      description: 'Layered syndication output.',
-      home_page_url: 'https://example.com',
-      feed_url: 'https://example.com/feed/json',
-      authors: [{ name: 'Kieran Mansfield', url: 'https://example.com/about' }],
-      items: [
-        {
-          id: 'https://example.com/posts/a-b',
-          url: 'https://example.com/posts/a-b',
-          title: 'A & B',
-          content_text: 'Read > write',
-          date_published: '2026-01-03T10:00:00.000Z',
-          authors: [{ name: 'Ada Lovelace' }],
-          tags: ['nuxt', 'feeds'],
-        },
-      ],
-    })
-  })
-
-  it('serializes Atom output with escaped markup', () => {
-    const xml = toAtom(items, config)
-
-    expect(xml).toContain('<?xml-stylesheet type="text/xsl" href="/feed/style.xsl"?>')
-    expect(xml).toContain('<title>Nuxt Layers Feed</title>')
-    expect(xml).toContain('<title>A &amp; B</title>')
-    expect(xml).toContain('<summary>Read &gt; write</summary>')
-  })
-})

package/layers/delivery/seo/app/utils/seoConfig.test.ts

@@ -1,58 +0,0 @@
-import type { SiteConfig } from '#layers/core/app/types/site'
-import { describe, expect, it } from 'vite-plus/test'
-
-import { resolveSeoConfig } from './seoConfig'
-
-const site: SiteConfig = { title: 'Nuxt Layers', description: 'A composable layer system' }
-
-describe('resolveSeoConfig', () => {
-  it('applies all defaults when no seoLayer config is given', () => {
-    expect(resolveSeoConfig(site)).toEqual({
-      site,
-      ogImageComponent: 'OgImageNuxtSeo',
-      ogImageProps: {},
-      twitterCard: 'summary_large_image',
-      schemaOrgEnabled: true,
-      identity: null,
-    })
-  })
-
-  it('applies all defaults when seoLayer is an empty object', () => {
-    expect(resolveSeoConfig(site, {})).toEqual({
-      site,
-      ogImageComponent: 'OgImageNuxtSeo',
-      ogImageProps: {},
-      twitterCard: 'summary_large_image',
-      schemaOrgEnabled: true,
-      identity: null,
-    })
-  })
-
-  it('uses the configured og:image component and props when provided', () => {
-    const result = resolveSeoConfig(site, {
-      ogImage: { component: 'OgImageCustom', props: { title: 'Custom' } },
-    })
-
-    expect(result.ogImageComponent).toBe('OgImageCustom')
-    expect(result.ogImageProps).toEqual({ title: 'Custom' })
-  })
-
-  it('uses the configured twitter card type', () => {
-    expect(resolveSeoConfig(site, { twitterCard: 'summary' }).twitterCard).toBe('summary')
-  })
-
-  it('allows schemaOrg to be disabled explicitly', () => {
-    const result = resolveSeoConfig(site, { schemaOrg: { enabled: false } })
-    expect(result.schemaOrgEnabled).toBe(false)
-  })
-
-  it('passes through a configured schemaOrg identity', () => {
-    const identity = { type: 'Organization', name: 'Nuxt Layers' }
-    const result = resolveSeoConfig(site, { schemaOrg: { identity } })
-    expect(result.identity).toBe(identity)
-  })
-
-  it('preserves the site object reference in the result', () => {
-    expect(resolveSeoConfig(site).site).toBe(site)
-  })
-})