@levino/shipyard-blog 0.7.4 → 0.7.5

package/src/feeds.ts

@@ -0,0 +1,286 @@
+interface FeedPost {
+  id: string
+  data: {
+    date: Date
+    title: string
+    description: string
+    draft?: boolean
+    unlisted?: boolean
+    tags?: string[]
+  }
+}
+
+interface I18nConfig {
+  locales: (string | { codes: string[] })[]
+}
+
+const escapeXml = (text: string): string =>
+  text
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;')
+
+const buildUrl = (
+  baseUrl: string,
+  ...segments: (string | undefined | null)[]
+): string => {
+  const url = new URL(baseUrl)
+  const parts = [
+    url.pathname.replace(/\/$/, ''),
+    ...segments
+      .filter(Boolean)
+      .map((s) => (s as string).replace(/^\/|\/$/g, '')),
+  ]
+  url.pathname = `/${parts.filter(Boolean).join('/')}`
+  return url.toString()
+}
+
+const filterPosts = (
+  allPosts: FeedPost[],
+  includeDraftsInDev: boolean,
+  currentLocale: string | undefined,
+  i18n: I18nConfig | null | undefined | false,
+  limit: number,
+  isDev: boolean,
+): FeedPost[] =>
+  allPosts
+    .filter((post) => {
+      if (post.data.unlisted) return false
+      if (post.data.draft && !(isDev && includeDraftsInDev)) return false
+      return true
+    })
+    .filter((post) => {
+      if (i18n) {
+        const [pl] = post.id.split('/')
+        return pl === currentLocale
+      }
+      return true
+    })
+    .toSorted((a, b) => b.data.date.getTime() - a.data.date.getTime())
+    .slice(0, limit)
+
+const getPostUrl = (
+  post: FeedPost,
+  routeBasePath: string,
+  baseUrl: string,
+  currentLocale: string | undefined,
+  i18n: I18nConfig | null | undefined | false,
+): string => {
+  if (i18n && currentLocale) {
+    const slug = post.id.replace(`${currentLocale}/`, '')
+    return buildUrl(baseUrl, currentLocale, routeBasePath, slug)
+  }
+  return buildUrl(baseUrl, routeBasePath, post.id)
+}
+
+export interface FeedParams {
+  allPosts: FeedPost[]
+  blogConfig: {
+    routeBasePath: string
+    blogTitle: string
+    blogDescription?: string
+    includeDraftsInDev: boolean
+    feedOptions: {
+      limit: number
+      title?: string
+      description?: string
+    }
+  }
+  site: URL | undefined
+  currentLocale: string | undefined
+  i18n: I18nConfig | null | undefined | false
+  isDev: boolean
+}
+
+export const createRssResponse = ({
+  allPosts,
+  blogConfig,
+  site,
+  currentLocale,
+  i18n,
+  isDev,
+}: FeedParams): Response => {
+  const baseUrl = site?.toString() ?? 'https://example.com'
+  const { feedOptions, blogTitle, blogDescription, routeBasePath } = blogConfig
+  const posts = filterPosts(
+    allPosts,
+    blogConfig.includeDraftsInDev,
+    currentLocale,
+    i18n,
+    feedOptions.limit,
+    isDev,
+  )
+  const title = feedOptions.title ?? blogTitle
+  const description =
+    feedOptions.description ?? blogDescription ?? `${title} Feed`
+  const feedUrl = i18n
+    ? buildUrl(baseUrl, currentLocale ?? '', routeBasePath, 'rss.xml')
+    : buildUrl(baseUrl, routeBasePath, 'rss.xml')
+
+  const items = posts
+    .map((post) => {
+      const postUrl = getPostUrl(
+        post,
+        routeBasePath,
+        baseUrl,
+        currentLocale,
+        i18n,
+      )
+      return [
+        '    <item>',
+        `      <title>${escapeXml(post.data.title)}</title>`,
+        `      <link>${escapeXml(postUrl)}</link>`,
+        `      <description>${escapeXml(post.data.description)}</description>`,
+        `      <pubDate>${post.data.date.toUTCString()}</pubDate>`,
+        `      <guid>${escapeXml(postUrl)}</guid>`,
+        '    </item>',
+      ].join('\n')
+    })
+    .join('\n')
+
+  const xml = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">',
+    '  <channel>',
+    `    <title>${escapeXml(title)}</title>`,
+    `    <link>${escapeXml(baseUrl)}</link>`,
+    `    <description>${escapeXml(description)}</description>`,
+    `    <language>${currentLocale ?? 'en'}</language>`,
+    `    <atom:link href="${escapeXml(feedUrl)}" rel="self" type="application/rss+xml"/>`,
+    `    <lastBuildDate>${new Date().toUTCString()}</lastBuildDate>`,
+    items,
+    '  </channel>',
+    '</rss>',
+  ].join('\n')
+
+  return new Response(xml, {
+    headers: { 'Content-Type': 'application/rss+xml; charset=utf-8' },
+  })
+}
+
+export const createAtomResponse = ({
+  allPosts,
+  blogConfig,
+  site,
+  currentLocale,
+  i18n,
+  isDev,
+}: FeedParams): Response => {
+  const baseUrl = site?.toString() ?? 'https://example.com'
+  const { feedOptions, blogTitle, blogDescription, routeBasePath } = blogConfig
+  const posts = filterPosts(
+    allPosts,
+    blogConfig.includeDraftsInDev,
+    currentLocale,
+    i18n,
+    feedOptions.limit,
+    isDev,
+  )
+  const title = feedOptions.title ?? blogTitle
+  const feedUrl = i18n
+    ? buildUrl(baseUrl, currentLocale ?? '', routeBasePath, 'atom.xml')
+    : buildUrl(baseUrl, routeBasePath, 'atom.xml')
+
+  const lastUpdated =
+    posts.length > 0
+      ? posts[0].data.date.toISOString()
+      : new Date().toISOString()
+  const subtitle = feedOptions.description ?? blogDescription
+
+  const entries = posts
+    .map((post) => {
+      const postUrl = getPostUrl(
+        post,
+        routeBasePath,
+        baseUrl,
+        currentLocale,
+        i18n,
+      )
+      return [
+        '  <entry>',
+        `    <title>${escapeXml(post.data.title)}</title>`,
+        `    <link href="${escapeXml(postUrl)}"/>`,
+        `    <id>${escapeXml(postUrl)}</id>`,
+        `    <updated>${post.data.date.toISOString()}</updated>`,
+        `    <summary>${escapeXml(post.data.description)}</summary>`,
+        '  </entry>',
+      ].join('\n')
+    })
+    .join('\n')
+
+  const xml = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    `<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="${currentLocale ?? 'en'}">`,
+    `  <title>${escapeXml(title)}</title>`,
+    `  <link href="${escapeXml(baseUrl)}"/>`,
+    `  <link href="${escapeXml(feedUrl)}" rel="self" type="application/atom+xml"/>`,
+    `  <id>${escapeXml(baseUrl)}</id>`,
+    `  <updated>${lastUpdated}</updated>`,
+    ...(subtitle ? [`  <subtitle>${escapeXml(subtitle)}</subtitle>`] : []),
+    entries,
+    '</feed>',
+  ].join('\n')
+
+  return new Response(xml, {
+    headers: { 'Content-Type': 'application/atom+xml; charset=utf-8' },
+  })
+}
+
+export const createJsonFeedResponse = ({
+  allPosts,
+  blogConfig,
+  site,
+  currentLocale,
+  i18n,
+  isDev,
+}: FeedParams): Response => {
+  const baseUrl = site?.toString() ?? 'https://example.com'
+  const { feedOptions, blogTitle, blogDescription, routeBasePath } = blogConfig
+  const posts = filterPosts(
+    allPosts,
+    blogConfig.includeDraftsInDev,
+    currentLocale,
+    i18n,
+    feedOptions.limit,
+    isDev,
+  )
+  const title = feedOptions.title ?? blogTitle
+  const description = feedOptions.description ?? blogDescription
+  const feedUrl = i18n
+    ? buildUrl(baseUrl, currentLocale ?? '', routeBasePath, 'feed.json')
+    : buildUrl(baseUrl, routeBasePath, 'feed.json')
+
+  const items = posts.map((post) => {
+    const postUrl = getPostUrl(
+      post,
+      routeBasePath,
+      baseUrl,
+      currentLocale,
+      i18n,
+    )
+    return {
+      id: postUrl,
+      url: postUrl,
+      title: post.data.title,
+      summary: post.data.description,
+      date_published: post.data.date.toISOString(),
+      ...(post.data.tags?.length ? { tags: post.data.tags } : {}),
+    }
+  })
+
+  const feed = {
+    version: 'https://jsonfeed.org/version/1.1',
+    title,
+    home_page_url: baseUrl,
+    feed_url: feedUrl,
+    ...(description ? { description } : {}),
+    language: currentLocale ?? 'en',
+    items,
+  }
+
+  return new Response(JSON.stringify(feed, null, 2), {
+    headers: { 'Content-Type': 'application/feed+json; charset=utf-8' },
+  })
+}

package/src/index.ts

@@ -166,13 +166,15 @@ export const blogConfigSchema = z.object({
   /**
    * The base path where blog routes will be mounted.
    * @default 'blog'
-   * @example 'news' will mount blog at /news/[...slug]
+   * @example 'blog' will mount at /blog/[...slug]
+   * @example 'news' will mount at /news/[...slug]
    */
   routeBasePath: z.string().default('blog'),
   /**
    * The name of the content collection to use.
    * Must match a collection defined in your content.config.ts.
-   * @default Same as routeBasePath (e.g., 'blog' or 'news')
+   * Defaults to the routeBasePath if not specified.
+   * @example 'blog' for a collection named 'blog'
    */
   collectionName: z.string().optional(),
   /**
@@ -300,26 +302,39 @@ const VIRTUAL_MODULE_ID = 'virtual:shipyard-blog/config'
 const RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID}`
 const VIRTUAL_TAGS_MODULE_ID = 'virtual:shipyard-blog/tags'
 const RESOLVED_VIRTUAL_TAGS_MODULE_ID = `\0${VIRTUAL_TAGS_MODULE_ID}`
+const VIRTUAL_REGISTRY_ID = 'virtual:shipyard-blog/registry'
+const RESOLVED_VIRTUAL_REGISTRY_ID = `\0${VIRTUAL_REGISTRY_ID}`
+
+const blogRegistry: Record<
+  string,
+  {
+    blogConfig: BlogConfig
+    tagsMap: Record<string, unknown>
+    collectionName: string
+  }
+> = {}
 
 export default (options: Partial<BlogConfig> = {}): AstroIntegration => {
-  // Parse and validate config
   const blogConfig = blogConfigSchema.parse(options)
 
-  // Load tags map if path is provided
-  let tagsMap: Record<string, unknown> = {}
-  if (blogConfig.tagsMapPath) {
-    // Defer loading to avoid issues at module parse time
-    // Tags will be loaded by the virtual module
+  let normalizedBasePath = blogConfig.routeBasePath
+  while (normalizedBasePath.startsWith('/')) {
+    normalizedBasePath = normalizedBasePath.slice(1)
   }
+  while (normalizedBasePath.endsWith('/')) {
+    normalizedBasePath = normalizedBasePath.slice(0, -1)
+  }
+
+  const resolvedCollectionName = blogConfig.collectionName ?? normalizedBasePath
+
+  let tagsMap: Record<string, unknown> = {}
 
   return {
-    name: 'shipyard-blog',
+    name: `shipyard-blog-${normalizedBasePath}`,
     hooks: {
       'astro:config:setup': ({ injectRoute, config, updateConfig }) => {
-        // Load tags map now (at config setup time)
         if (blogConfig.tagsMapPath) {
           try {
-            // Resolve relative to CWD (project root)
             const resolvedPath = blogConfig.tagsMapPath.startsWith('/')
               ? blogConfig.tagsMapPath
               : `${process.cwd()}/${blogConfig.tagsMapPath}`
@@ -329,7 +344,6 @@ export default (options: Partial<BlogConfig> = {}): AstroIntegration => {
               const rawData = parseYaml(fileContent)
 
               if (rawData && typeof rawData === 'object') {
-                // Validate each tag against the schema
                 for (const [key, value] of Object.entries(rawData)) {
                   const result = tagSchema.safeParse(value)
                   if (result.success) {
@@ -339,149 +353,145 @@ export default (options: Partial<BlogConfig> = {}): AstroIntegration => {
               }
             }
           } catch {
-            // Tags file doesn't exist or is invalid, use empty map
             tagsMap = {}
           }
         }
 
-        // Add a vite plugin to provide the config via a virtual module
+        blogRegistry[normalizedBasePath] = {
+          blogConfig,
+          tagsMap,
+          collectionName: resolvedCollectionName,
+        }
+
         updateConfig({
           vite: {
             plugins: [
               {
-                name: 'shipyard-blog-config',
+                name: `shipyard-blog-config-${normalizedBasePath}`,
                 resolveId(id) {
-                  if (id === VIRTUAL_MODULE_ID) {
+                  if (id === VIRTUAL_REGISTRY_ID)
+                    return RESOLVED_VIRTUAL_REGISTRY_ID
+                  if (id === VIRTUAL_MODULE_ID)
                     return RESOLVED_VIRTUAL_MODULE_ID
-                  }
-                  if (id === VIRTUAL_TAGS_MODULE_ID) {
+                  if (id === VIRTUAL_TAGS_MODULE_ID)
                     return RESOLVED_VIRTUAL_TAGS_MODULE_ID
-                  }
                 },
                 load(id) {
-                  if (id === RESOLVED_VIRTUAL_MODULE_ID) {
+                  if (id === RESOLVED_VIRTUAL_REGISTRY_ID)
+                    return `export default ${JSON.stringify(blogRegistry)}`
+                  if (id === RESOLVED_VIRTUAL_MODULE_ID)
                     return `export default ${JSON.stringify(blogConfig)}`
-                  }
-                  if (id === RESOLVED_VIRTUAL_TAGS_MODULE_ID) {
+                  if (id === RESOLVED_VIRTUAL_TAGS_MODULE_ID)
                     return `export default ${JSON.stringify(tagsMap)}`
-                  }
                 },
               },
             ],
           },
         })
 
-        // Use configurable routeBasePath for multi-instance support
-        const basePath = blogConfig.routeBasePath
+        const basePath = normalizedBasePath
+        const pageBase = '@levino/shipyard-blog/astro/pages'
 
         if (config.i18n) {
-          // With i18n: use locale prefix
           injectRoute({
             pattern: `/[locale]/${basePath}`,
-            entrypoint: `@levino/shipyard-blog/astro/BlogIndex.astro`,
+            entrypoint: `${pageBase}/BlogIndex.astro`,
           })
           injectRoute({
             pattern: `/[locale]/${basePath}/page/[page]`,
-            entrypoint: `@levino/shipyard-blog/astro/BlogIndexPaginated.astro`,
+            entrypoint: `${pageBase}/BlogIndexPaginated.astro`,
           })
           injectRoute({
             pattern: `/[locale]/${basePath}/tags`,
-            entrypoint: `@levino/shipyard-blog/astro/BlogTagsIndex.astro`,
+            entrypoint: `${pageBase}/BlogTagsIndex.astro`,
           })
           injectRoute({
             pattern: `/[locale]/${basePath}/tags/[tag]`,
-            entrypoint: `@levino/shipyard-blog/astro/BlogTagPage.astro`,
+            entrypoint: `${pageBase}/BlogTagPage.astro`,
           })
           if (blogConfig.archiveEnabled) {
             injectRoute({
               pattern: `/[locale]/${basePath}/archive`,
-              entrypoint: `@levino/shipyard-blog/astro/BlogArchive.astro`,
+              entrypoint: `${pageBase}/BlogArchive.astro`,
             })
           }
           if (blogConfig.authorsEnabled) {
             injectRoute({
               pattern: `/[locale]/${basePath}/authors`,
-              entrypoint: `@levino/shipyard-blog/astro/BlogAuthorsIndex.astro`,
+              entrypoint: `${pageBase}/BlogAuthorsIndex.astro`,
             })
             injectRoute({
               pattern: `/[locale]/${basePath}/authors/[author]`,
-              entrypoint: `@levino/shipyard-blog/astro/BlogAuthorPage.astro`,
+              entrypoint: `${pageBase}/BlogAuthorPage.astro`,
             })
           }
           injectRoute({
             pattern: `/[locale]/${basePath}/[...slug]`,
-            entrypoint: `@levino/shipyard-blog/astro/BlogEntry.astro`,
+            entrypoint: `${pageBase}/BlogEntry.astro`,
           })
         } else {
-          // Without i18n: direct path
           injectRoute({
             pattern: `/${basePath}`,
-            entrypoint: `@levino/shipyard-blog/astro/BlogIndex.astro`,
+            entrypoint: `${pageBase}/BlogIndex.astro`,
           })
           injectRoute({
             pattern: `/${basePath}/page/[page]`,
-            entrypoint: `@levino/shipyard-blog/astro/BlogIndexPaginated.astro`,
+            entrypoint: `${pageBase}/BlogIndexPaginated.astro`,
           })
           injectRoute({
             pattern: `/${basePath}/tags`,
-            entrypoint: `@levino/shipyard-blog/astro/BlogTagsIndex.astro`,
+            entrypoint: `${pageBase}/BlogTagsIndex.astro`,
           })
           injectRoute({
             pattern: `/${basePath}/tags/[tag]`,
-            entrypoint: `@levino/shipyard-blog/astro/BlogTagPage.astro`,
+            entrypoint: `${pageBase}/BlogTagPage.astro`,
           })
           if (blogConfig.archiveEnabled) {
             injectRoute({
               pattern: `/${basePath}/archive`,
-              entrypoint: `@levino/shipyard-blog/astro/BlogArchive.astro`,
+              entrypoint: `${pageBase}/BlogArchive.astro`,
             })
           }
           if (blogConfig.authorsEnabled) {
             injectRoute({
               pattern: `/${basePath}/authors`,
-              entrypoint: `@levino/shipyard-blog/astro/BlogAuthorsIndex.astro`,
+              entrypoint: `${pageBase}/BlogAuthorsIndex.astro`,
             })
             injectRoute({
               pattern: `/${basePath}/authors/[author]`,
-              entrypoint: `@levino/shipyard-blog/astro/BlogAuthorPage.astro`,
+              entrypoint: `${pageBase}/BlogAuthorPage.astro`,
             })
           }
           injectRoute({
             pattern: `/${basePath}/[...slug]`,
-            entrypoint: `@levino/shipyard-blog/astro/BlogEntry.astro`,
+            entrypoint: `${pageBase}/BlogEntry.astro`,
           })
         }
 
-        // Inject feed routes if enabled
         const { feedOptions } = blogConfig
-        if (feedOptions.rss || feedOptions.atom || feedOptions.json) {
-          if (config.i18n) {
-            injectRoute({
-              pattern: `/[locale]/${basePath}/rss.xml`,
-              entrypoint: `@levino/shipyard-blog/astro/feeds/rss.xml.ts`,
-            })
-            injectRoute({
-              pattern: `/[locale]/${basePath}/atom.xml`,
-              entrypoint: `@levino/shipyard-blog/astro/feeds/atom.xml.ts`,
-            })
-            injectRoute({
-              pattern: `/[locale]/${basePath}/feed.json`,
-              entrypoint: `@levino/shipyard-blog/astro/feeds/feed.json.ts`,
-            })
-          } else {
-            injectRoute({
-              pattern: `/${basePath}/rss.xml`,
-              entrypoint: `@levino/shipyard-blog/astro/feeds/rss.xml.ts`,
-            })
-            injectRoute({
-              pattern: `/${basePath}/atom.xml`,
-              entrypoint: `@levino/shipyard-blog/astro/feeds/atom.xml.ts`,
-            })
-            injectRoute({
-              pattern: `/${basePath}/feed.json`,
-              entrypoint: `@levino/shipyard-blog/astro/feeds/feed.json.ts`,
-            })
-          }
+        if (feedOptions.rss) {
+          injectRoute({
+            pattern: config.i18n
+              ? `/[locale]/${basePath}/rss.xml`
+              : `/${basePath}/rss.xml`,
+            entrypoint: `${pageBase}/feeds/rss.xml.ts`,
+          })
+        }
+        if (feedOptions.atom) {
+          injectRoute({
+            pattern: config.i18n
+              ? `/[locale]/${basePath}/atom.xml`
+              : `/${basePath}/atom.xml`,
+            entrypoint: `${pageBase}/feeds/atom.xml.ts`,
+          })
+        }
+        if (feedOptions.json) {
+          injectRoute({
+            pattern: config.i18n
+              ? `/[locale]/${basePath}/feed.json`
+              : `/${basePath}/feed.json`,
+            entrypoint: `${pageBase}/feeds/feed.json.ts`,
+          })
         }
       },
     },