@fullstackdatasolutions/articles 1.2.2 → 1.3.0

package/src/__tests__/ArticleSchemas.test.tsx

@@ -5,7 +5,10 @@ import {
   BreadcrumbSchema,
   CollectionPageSchema,
   FAQPageSchema,
+  OrganizationSchema,
+  WebSiteSchema,
 } from '../ArticleSchemas'
+import type { ArticlesConfig } from '../articlesConfig'
 import { Breadcrumb } from '../Breadcrumb'
 
 function parseSchemaScript(container: HTMLElement) {
@@ -230,6 +233,7 @@ describe('ArticleSEO', () => {
     const article = schemas.find((s) => s['@type'] === 'Article')
     expect(article.author[0]).toEqual({
       '@type': 'Person',
+      '@id': 'https://example.com/articles/authors/andrew-blase#person',
       name: 'Andrew Blase',
       url: 'https://example.com/articles/authors/andrew-blase',
       sameAs: ['https://github.com/blazestudios23'],
@@ -262,6 +266,7 @@ describe('ArticleSEO', () => {
     const article = schemas.find((s) => s['@type'] === 'Article')
     expect(article.author[0]).toEqual({
       '@type': 'Person',
+      '@id': 'https://example.com/articles/authors/andrew-blase#person',
       name: 'Andrew Blase',
       url: 'https://example.com/articles/authors/andrew-blase',
     })
@@ -486,3 +491,514 @@ describe('ArticleSEO', () => {
     )
   })
 })
+
+describe('OrganizationSchema', () => {
+  const config: ArticlesConfig = {
+    siteUrl: 'https://example.com/',
+    siteName: 'Example Site',
+    description: 'Site description.',
+    organization: {
+      logo: '/logo.png',
+      sameAs: ['https://linkedin.com/company/example'],
+    },
+  }
+
+  it('renders nothing when organization is unset', () => {
+    const { container } = render(
+      <OrganizationSchema config={{ siteUrl: 'https://example.com', siteName: 'Example Site' }} />
+    )
+    expect(container.querySelector('script')).toBeNull()
+  })
+
+  it('emits a stable @id, resolved logo, and falls back to siteName/siteUrl/description', () => {
+    const { container } = render(<OrganizationSchema config={config} />)
+    const schema = parseSchemaScript(container)
+    expect(schema).toEqual({
+      '@context': 'https://schema.org',
+      '@type': 'Organization',
+      '@id': 'https://example.com/#organization',
+      name: 'Example Site',
+      url: 'https://example.com',
+      logo: { '@type': 'ImageObject', url: 'https://example.com/logo.png' },
+      description: 'Site description.',
+      sameAs: ['https://linkedin.com/company/example'],
+    })
+  })
+
+  it('honors explicit type, name, url, description, and an absolute logo', () => {
+    const { container } = render(
+      <OrganizationSchema
+        config={{
+          siteUrl: 'https://example.com',
+          siteName: 'Example Site',
+          organization: {
+            type: 'Person',
+            name: 'Andrew Blase',
+            url: 'https://andrew.example',
+            description: 'Personal brand.',
+            logo: 'https://cdn.example.com/logo.png',
+          },
+        }}
+      />
+    )
+    const schema = parseSchemaScript(container)
+    expect(schema['@type']).toBe('Person')
+    expect(schema.name).toBe('Andrew Blase')
+    expect(schema.url).toBe('https://andrew.example')
+    expect(schema.description).toBe('Personal brand.')
+    expect(schema.logo.url).toBe('https://cdn.example.com/logo.png')
+    expect(schema.sameAs).toBeUndefined()
+  })
+})
+
+describe('WebSiteSchema', () => {
+  const baseConfig: ArticlesConfig = {
+    siteUrl: 'https://example.com/',
+    siteName: 'Example Site',
+    description: 'Site description.',
+    organization: {},
+  }
+
+  it('renders nothing when organization is unset', () => {
+    const { container } = render(
+      <WebSiteSchema config={{ siteUrl: 'https://example.com', siteName: 'Example Site' }} />
+    )
+    expect(container.querySelector('script')).toBeNull()
+  })
+
+  it('references the organization @id and omits SearchAction by default', () => {
+    const { container } = render(<WebSiteSchema config={baseConfig} />)
+    const schema = parseSchemaScript(container)
+    expect(schema).toEqual({
+      '@context': 'https://schema.org',
+      '@type': 'WebSite',
+      '@id': 'https://example.com/#website',
+      name: 'Example Site',
+      url: 'https://example.com',
+      publisher: { '@id': 'https://example.com/#organization' },
+      description: 'Site description.',
+    })
+  })
+
+  it('emits SearchAction only when searchUrlTemplate is configured', () => {
+    const { container } = render(
+      <WebSiteSchema
+        config={{
+          ...baseConfig,
+          organization: { searchUrlTemplate: '/search?q={search_term_string}' },
+        }}
+      />
+    )
+    const schema = parseSchemaScript(container)
+    expect(schema.potentialAction).toEqual({
+      '@type': 'SearchAction',
+      target: {
+        '@type': 'EntryPoint',
+        urlTemplate: 'https://example.com/search?q={search_term_string}',
+      },
+      'query-input': 'required name=search_term_string',
+    })
+  })
+})
+
+describe('ArticleSEO publisher reference', () => {
+  const article = {
+    slug: 'test-article',
+    title: 'Test Article',
+    excerpt: 'Excerpt.',
+    date: '2025-01-01',
+    author: 'Jane Doe',
+    category: 'Campaigns',
+    categories: ['Campaigns'],
+    readTime: '3 min read',
+    featuredImage: '/image.jpg',
+  } as Article
+
+  it('references the organization @id when organization is configured', () => {
+    const { container } = render(
+      <ArticleSEO
+        article={article}
+        articleUrl="https://example.com/articles/test-article"
+        siteName="Example Site"
+        config={{
+          siteUrl: 'https://example.com',
+          siteName: 'Example Site',
+          organization: {},
+        }}
+      />
+    )
+    const schema = parseAllSchemaScripts(container).find((s) => s['@type'] === 'Article')
+    expect(schema.publisher).toEqual({ '@id': 'https://example.com/#organization' })
+  })
+
+  it('keeps the inline Organization stub when organization is unset', () => {
+    const { container } = render(
+      <ArticleSEO
+        article={article}
+        articleUrl="https://example.com/articles/test-article"
+        siteName="Example Site"
+        siteLogo="https://example.com/logo.png"
+      />
+    )
+    const schema = parseAllSchemaScripts(container).find((s) => s['@type'] === 'Article')
+    expect(schema.publisher).toEqual({
+      '@type': 'Organization',
+      name: 'Example Site',
+      logo: { '@type': 'ImageObject', url: 'https://example.com/logo.png' },
+    })
+  })
+})
+
+describe('ArticleSEO entity and access fields', () => {
+  const article = {
+    slug: 'test-article',
+    title: 'Test Article',
+    excerpt: 'Excerpt.',
+    date: '2025-01-01',
+    author: 'Jane Doe',
+    category: 'Campaigns',
+    categories: ['Campaigns'],
+    readTime: '3 min read',
+    featuredImage: '/image.jpg',
+  } as Article
+
+  function renderArticle(overrides: Partial<Article>, config?: ArticlesConfig) {
+    const { container } = render(
+      <ArticleSEO
+        article={{ ...article, ...overrides }}
+        articleUrl="https://example.com/articles/test-article"
+        siteName="Example Site"
+        config={config}
+      />
+    )
+    return parseAllSchemaScripts(container)
+  }
+
+  it('defaults inLanguage to en and isAccessibleForFree to true', () => {
+    const schema = renderArticle({}).find((s) => s['@type'] === 'Article')
+    expect(schema.inLanguage).toBe('en')
+    expect(schema.isAccessibleForFree).toBe(true)
+    expect(schema.about).toBeUndefined()
+    expect(schema.citation).toBeUndefined()
+    expect(schema.speakable).toBeUndefined()
+    expect(schema.abstract).toBeUndefined()
+  })
+
+  it('honors configured language and paywalled content', () => {
+    const schema = renderArticle(
+      {},
+      {
+        siteUrl: 'https://example.com',
+        siteName: 'Example Site',
+        language: 'es',
+        isAccessibleForFree: false,
+      }
+    ).find((s) => s['@type'] === 'Article')
+    expect(schema.inLanguage).toBe('es')
+    expect(schema.isAccessibleForFree).toBe(false)
+  })
+
+  it('emits abstract, about, and citation from the article', () => {
+    const schema = renderArticle({
+      answer: 'Roll a d20 and add your modifier.',
+      about: [
+        { name: 'Pathfinder', sameAs: 'https://www.wikidata.org/wiki/Q1194077' },
+        { name: 'Combat' },
+      ],
+      citation: [{ name: 'Core Rulebook', url: 'https://example.com/crb' }, { name: 'Errata' }],
+    }).find((s) => s['@type'] === 'Article')
+
+    expect(schema.abstract).toBe('Roll a d20 and add your modifier.')
+    expect(schema.about).toEqual([
+      { '@type': 'Thing', name: 'Pathfinder', sameAs: 'https://www.wikidata.org/wiki/Q1194077' },
+      { '@type': 'Thing', name: 'Combat' },
+    ])
+    expect(schema.citation).toEqual([
+      { '@type': 'CreativeWork', name: 'Core Rulebook', url: 'https://example.com/crb' },
+      { '@type': 'CreativeWork', name: 'Errata' },
+    ])
+  })
+
+  it('emits speakable only when selectors are configured', () => {
+    const schema = renderArticle(
+      {},
+      {
+        siteUrl: 'https://example.com',
+        siteName: 'Example Site',
+        speakableSelectors: ['.article-answer', 'h1'],
+      }
+    ).find((s) => s['@type'] === 'Article')
+    expect(schema.speakable).toEqual({
+      '@type': 'SpeakableSpecification',
+      cssSelector: ['.article-answer', 'h1'],
+    })
+  })
+
+  it('adds a mainEntity Question only for a QAPage articleType with an answer', () => {
+    expect(
+      renderArticle({ answer: 'Yes.' }).find((s) => s['@type'] === 'Article').mainEntity
+    ).toBeUndefined()
+    expect(
+      renderArticle({ articleType: 'QAPage' }).find((s) => s['@type'] === 'QAPage').mainEntity
+    ).toBeUndefined()
+
+    const qa = renderArticle({ articleType: 'QAPage', answer: 'Yes, always.' }).find(
+      (s) => s['@type'] === 'QAPage'
+    )
+    expect(qa.mainEntity).toEqual({
+      '@type': 'Question',
+      name: 'Test Article',
+      text: 'Excerpt.',
+      dateCreated: new Date('2025-01-01').toISOString(),
+      answerCount: 1,
+      acceptedAnswer: {
+        '@type': 'Answer',
+        text: 'Yes, always.',
+        url: 'https://example.com/articles/test-article',
+      },
+    })
+  })
+})
+
+describe('ArticleSEO comments and freshness', () => {
+  const article = {
+    slug: 'test-article',
+    title: 'Test Article',
+    excerpt: 'Excerpt.',
+    date: '2025-01-01',
+    author: 'Jane Doe',
+    category: 'Campaigns',
+    categories: ['Campaigns'],
+    readTime: '3 min read',
+    featuredImage: '/image.jpg',
+  } as Article
+
+  function renderArticle(overrides: Partial<Article>, extra?: Record<string, unknown>) {
+    const { container } = render(
+      <ArticleSEO
+        article={{ ...article, ...overrides }}
+        articleUrl="https://example.com/articles/test-article"
+        siteName="Example Site"
+        {...extra}
+      />
+    )
+    return parseAllSchemaScripts(container).find((s) => s['@type'] === 'Article')
+  }
+
+  it('emits commentCount and comment entries for visible top-level comments', () => {
+    const schema = renderArticle(
+      {},
+      {
+        comments: [
+          {
+            id: '1',
+            articleSlug: 'test-article',
+            body: 'Great post.',
+            isDeleted: false,
+            createdAt: '2025-02-01T00:00:00.000Z',
+            authorId: 'u1',
+            authorName: 'Reader One',
+            parentId: null,
+          },
+          {
+            id: '2',
+            articleSlug: 'test-article',
+            body: 'A reply.',
+            isDeleted: false,
+            createdAt: '2025-02-02T00:00:00.000Z',
+            authorId: 'u2',
+            authorName: 'Reader Two',
+            parentId: '1',
+          },
+          {
+            id: '3',
+            articleSlug: 'test-article',
+            body: 'Removed.',
+            isDeleted: true,
+            createdAt: '2025-02-03T00:00:00.000Z',
+            authorId: 'u3',
+            authorName: 'Reader Three',
+            parentId: null,
+          },
+        ],
+      }
+    )
+
+    expect(schema.commentCount).toBe(1)
+    expect(schema.comment).toEqual([
+      {
+        '@type': 'Comment',
+        text: 'Great post.',
+        dateCreated: '2025-02-01T00:00:00.000Z',
+        author: { '@type': 'Person', name: 'Reader One' },
+      },
+    ])
+  })
+
+  it('omits comment fields when there are none to show', () => {
+    expect(renderArticle({}).commentCount).toBeUndefined()
+    expect(renderArticle({}, { comments: [] }).comment).toBeUndefined()
+  })
+
+  it('reuses datePublished for dateModified by default', () => {
+    expect(renderArticle({}).dateModified).toBe(new Date('2025-01-01').toISOString())
+  })
+
+  it('omits dateModified entirely when lastmodFallback is none', () => {
+    const schema = renderArticle(
+      {},
+      {
+        config: {
+          siteUrl: 'https://example.com',
+          siteName: 'Example Site',
+          lastmodFallback: 'none',
+        },
+      }
+    )
+    expect(schema.dateModified).toBeUndefined()
+    expect(schema.datePublished).toBe(new Date('2025-01-01').toISOString())
+  })
+
+  it('still uses an explicit lastmod under lastmodFallback none', () => {
+    const schema = renderArticle(
+      { lastmod: '2026-01-01' },
+      {
+        config: {
+          siteUrl: 'https://example.com',
+          siteName: 'Example Site',
+          lastmodFallback: 'none',
+        },
+      }
+    )
+    expect(schema.dateModified).toBe(new Date('2026-01-01').toISOString())
+  })
+})
+
+describe('OrganizationSchema parentOrganization', () => {
+  it('links the site to its umbrella entity when configured', () => {
+    const { container } = render(
+      <OrganizationSchema
+        config={{
+          siteUrl: 'https://example.com',
+          siteName: 'Example Site',
+          organization: {
+            parentOrganization: { name: 'Example Network', url: 'https://network.example' },
+          },
+        }}
+      />
+    )
+    expect(parseSchemaScript(container).parentOrganization).toEqual({
+      '@type': 'Organization',
+      name: 'Example Network',
+      url: 'https://network.example',
+    })
+  })
+})
+
+describe('ArticleSEO cross-site author identity', () => {
+  const article = {
+    slug: 'test-article',
+    title: 'Test Article',
+    excerpt: 'Excerpt.',
+    date: '2025-01-01',
+    author: 'andrew-blase',
+    category: 'Campaigns',
+    categories: ['Campaigns'],
+    readTime: '3 min read',
+    featuredImage: '/image.jpg',
+  } as Article
+
+  it('derives @id from identityUrl while url stays this site profile', () => {
+    const { container } = render(
+      <ArticleSEO
+        article={article}
+        articleUrl="https://vox.example/articles/test-article"
+        siteName="Vox"
+        authors={[
+          {
+            name: 'Andrew Blase',
+            slug: 'andrew-blase',
+            bio: '',
+            url: 'https://vox.example/articles/authors/andrew-blase',
+            identityUrl: 'https://hub.example/about',
+            sameAs: ['https://other.example/articles/authors/andrew-blase'],
+          },
+        ]}
+      />
+    )
+    const person = parseAllSchemaScripts(container).find((s) => s['@type'] === 'Article').author[0]
+    expect(person['@id']).toBe('https://hub.example/about#person')
+    expect(person.url).toBe('https://vox.example/articles/authors/andrew-blase')
+    expect(person.sameAs).toEqual(['https://other.example/articles/authors/andrew-blase'])
+  })
+
+  it('falls back to the site author page for @id when nothing is configured', () => {
+    const { container } = render(
+      <ArticleSEO
+        article={article}
+        articleUrl="https://vox.example/articles/test-article"
+        siteName="Vox"
+        config={{ siteUrl: 'https://vox.example', siteName: 'Vox' }}
+        authors={[{ name: 'Andrew Blase', slug: 'andrew-blase', bio: '' }]}
+      />
+    )
+    const person = parseAllSchemaScripts(container).find((s) => s['@type'] === 'Article').author[0]
+    expect(person['@id']).toBe('https://vox.example/articles/authors/andrew-blase#person')
+  })
+})
+
+describe('ArticleSEO image absolutization', () => {
+  const article = {
+    slug: 'test-article',
+    title: 'Test Article',
+    excerpt: 'Excerpt.',
+    date: '2025-01-01',
+    author: 'Jane Doe',
+    category: 'Campaigns',
+    categories: ['Campaigns'],
+    readTime: '3 min read',
+    featuredImage: '/articles/test-article/hero.jpg',
+  } as Article
+
+  function imageOf(overrides: Partial<Article>, config?: ArticlesConfig) {
+    const { container } = render(
+      <ArticleSEO
+        article={{ ...article, ...overrides }}
+        articleUrl="https://example.com/articles/test-article"
+        siteName="Example Site"
+        config={config}
+      />
+    )
+    return parseAllSchemaScripts(container).find((s) => s['@type'] === 'Article').image
+  }
+
+  it('absolutizes a site-relative image against config.siteUrl', () => {
+    expect(imageOf({}, { siteUrl: 'https://example.com/', siteName: 'Example Site' })).toEqual({
+      '@type': 'ImageObject',
+      url: 'https://example.com/articles/test-article/hero.jpg',
+    })
+  })
+
+  it('falls back to the articleUrl origin when no config is passed', () => {
+    expect(imageOf({}).url).toBe('https://example.com/articles/test-article/hero.jpg')
+  })
+
+  it('leaves an already-absolute image untouched', () => {
+    expect(imageOf({ featuredImage: 'https://cdn.example.com/hero.jpg' }).url).toBe(
+      'https://cdn.example.com/hero.jpg'
+    )
+  })
+
+  it('returns the raw value when articleUrl is unparseable and no config is given', () => {
+    const { container } = render(
+      <ArticleSEO article={article} articleUrl="not-a-url" siteName="Example Site" />
+    )
+    expect(parseAllSchemaScripts(container).find((s) => s['@type'] === 'Article').image.url).toBe(
+      '/articles/test-article/hero.jpg'
+    )
+  })
+
+  it('omits image entirely when the article has none', () => {
+    expect(imageOf({ featuredImage: '' })).toBeUndefined()
+  })
+})

package/src/__tests__/AuthorArticlesPage.test.tsx

@@ -352,6 +352,82 @@ describe('AuthorArticlesPage', () => {
       expect(screen.getByText('Custom block')).toBeInTheDocument()
     })
 
+    it("derives knowsAbout from the author's own article categories", () => {
+      const { container } = render(
+        <AuthorArticlesPage
+          author={author}
+          articles={[
+            ...articles,
+            { ...articles[0], slug: 'second', categories: ['Volunteers', 'Campaigns'] },
+          ]}
+          config={config}
+        />
+      )
+      const person = parseSchemaScript(container).find((schema) => schema['@type'] === 'Person')
+      expect(person.knowsAbout).toEqual(['Campaigns', 'Volunteers'])
+      expect(person['@id']).toBe('https://example.com/articles/authors/andrew-blase#person')
+    })
+
+    it('prefers an explicit AuthorProfile.knowsAbout over derived categories', () => {
+      const { container } = render(
+        <AuthorArticlesPage
+          author={{ ...author, knowsAbout: ['Civic technology'] }}
+          articles={articles}
+          config={config}
+        />
+      )
+      const person = parseSchemaScript(container).find((schema) => schema['@type'] === 'Person')
+      expect(person.knowsAbout).toEqual(['Civic technology'])
+    })
+
+    it('omits knowsAbout when there are no categories to derive it from', () => {
+      const { container } = render(
+        <AuthorArticlesPage author={author} articles={[]} config={config} />
+      )
+      const person = parseSchemaScript(container).find((schema) => schema['@type'] === 'Person')
+      expect(person.knowsAbout).toBeUndefined()
+      expect(person.worksFor).toBeUndefined()
+    })
+
+    it('links the author to the organization @id when one is configured', () => {
+      const { container } = render(
+        <AuthorArticlesPage
+          author={author}
+          articles={articles}
+          config={{ ...config, organization: {} }}
+        />
+      )
+      const person = parseSchemaScript(container).find((schema) => schema['@type'] === 'Person')
+      expect(person.worksFor).toEqual({ '@id': 'https://example.com/#organization' })
+    })
+
+    it('uses identityUrl for @id while keeping url and mainEntityOfPage on this site', () => {
+      const { container } = render(
+        <AuthorArticlesPage
+          author={{ ...author, identityUrl: 'https://hub.example/about' }}
+          articles={articles}
+          config={config}
+        />
+      )
+      const person = parseSchemaScript(container).find((schema) => schema['@type'] === 'Person')
+      expect(person['@id']).toBe('https://hub.example/about#person')
+      expect(person.url).toBe('https://example.com/articles/authors/andrew-blase')
+      expect(person.mainEntityOfPage).toBe('https://example.com/articles/authors/andrew-blase')
+    })
+
+    it('keeps mainEntityOfPage on this site even when url points elsewhere', () => {
+      const { container } = render(
+        <AuthorArticlesPage
+          author={{ ...author, url: 'https://elsewhere.example/profile' }}
+          articles={articles}
+          config={config}
+        />
+      )
+      const person = parseSchemaScript(container).find((schema) => schema['@type'] === 'Person')
+      expect(person.url).toBe('https://elsewhere.example/profile')
+      expect(person.mainEntityOfPage).toBe('https://example.com/articles/authors/andrew-blase')
+    })
+
     it('excludes credentials, servesWho, principles, proof, and promise from the Person JSON-LD', () => {
       const { container } = render(
         <AuthorArticlesPage author={richAuthor} articles={articles} config={config} />

package/src/__tests__/authorUtils.test.ts

@@ -1,4 +1,5 @@
 import {
+  getAuthorIdentityUrl,
   getAuthorAvatar,
   getAuthorSameAs,
   getAuthorSocialLinks,
@@ -87,3 +88,52 @@ describe('authorUtils', () => {
     expect(getAuthorSocialLinks(author)).toEqual([])
   })
 })
+
+describe('getAuthorSameAs cross-site profiles', () => {
+  it('merges explicit sameAs with derived social links and dedupes', () => {
+    const result = getAuthorSameAs({
+      name: 'Jane Doe',
+      slug: 'jane-doe',
+      bio: '',
+      social: { website: 'https://a.example' },
+      sameAs: ['https://b.example/authors/jane', 'https://a.example', ''],
+    })
+    expect(result).toEqual(['https://a.example', 'https://b.example/authors/jane'])
+  })
+
+  it('returns derived links only when sameAs is unset', () => {
+    expect(
+      getAuthorSameAs({
+        name: 'Jane Doe',
+        slug: 'jane-doe',
+        bio: '',
+        social: { website: 'https://a.example' },
+      })
+    ).toEqual(['https://a.example'])
+  })
+})
+
+describe('getAuthorIdentityUrl', () => {
+  const config = { siteUrl: 'https://vox.example/' }
+  const base = { name: 'Jane Doe', slug: 'jane-doe', bio: '' }
+
+  it('prefers identityUrl over url and the site author page', () => {
+    expect(
+      getAuthorIdentityUrl(
+        { ...base, identityUrl: 'https://hub.example/about', url: 'https://vox.example/x' },
+        config
+      )
+    ).toBe('https://hub.example/about')
+  })
+
+  it('falls back to url, then to this site author page', () => {
+    expect(getAuthorIdentityUrl({ ...base, url: 'https://vox.example/x' }, config)).toBe(
+      'https://vox.example/x'
+    )
+    expect(getAuthorIdentityUrl(base, config)).toBe('https://vox.example/articles/authors/jane-doe')
+  })
+
+  it('returns undefined with no config and nothing configured', () => {
+    expect(getAuthorIdentityUrl(base)).toBeUndefined()
+  })
+})