feat: changelog - formatted links, more git providers & copy markdown

app/components/Changelog/Markdown.vue

@@ -10,6 +10,11 @@ const route = useRoute()
 
 const { data, error, pending } = useLazyFetch(
   () => `/api/changelog/md/${info.provider}/${info.repo}/${info.path}`,
+  {
+    query: {
+      host: computed(() => info.host),
+    },
+  },
 )
 
 if (import.meta.client) {

app/components/Changelog/Releases.vue

@@ -12,7 +12,11 @@ const {
   data: releases,
   error,
   pending,
-} = useLazyFetch<ReleaseData[]>(() => `/api/changelog/releases/${info.provider}/${info.repo}`)
+} = useLazyFetch<ReleaseData[]>(() => `/api/changelog/releases/${info.provider}/${info.repo}`, {
+  query: {
+    host: computed(() => info.host),
+  },
+})
 
 const route = useRoute()
 

server/api/changelog/md/[provider]/[owner]/[repo]/[...path].get.ts

@@ -1,4 +1,5 @@
 import * as v from 'valibot'
+import { createForgejoRepoInfo, createGithubRepoInfo } from '~~/server/utils/changelog/mdRepoInfo'
 import {
   ERROR_CHANGELOG_FILE_FAILED,
   ERROR_THROW_INCOMPLETE_PARAM,
@@ -11,6 +12,9 @@ export default defineCachedEventHandler(
     const owner = getRouterParam(event, 'owner')
     const path = getRouterParam(event, 'path')
 
+    const rawQuery = getQuery(event)
+    const { host } = v.parse(v.object({ host: v.optional(v.string()) }), rawQuery)
+
     if (!repo || !provider || !owner || !path) {
       throw createError({
         status: 404,
@@ -22,6 +26,9 @@ export default defineCachedEventHandler(
       switch (provider as ProviderId) {
         case 'github':
           return await getGithubMarkDown(owner, repo, path)
+        case 'codeberg':
+        case 'forgejo':
+          return await getForgejoMarkdown(owner, repo, path, host ?? 'codeberg.org')
 
         default:
           throw createError({
@@ -55,11 +62,13 @@ async function getGithubMarkDown(owner: string, repo: string, path: string) {
 
   const markdown = v.parse(v.string(), data)
 
-  return (
-    await changelogRenderer({
-      blobBaseUrl: `https://github.com/${owner}/${repo}/blob/HEAD`,
-      rawBaseUrl: `https://raw.githubusercontent.com/${owner}/${repo}/HEAD`,
-      path,
-    })
-  )(markdown)
+  return (await changelogRenderer(createGithubRepoInfo(owner, repo, path)))(markdown)
+}
+
+async function getForgejoMarkdown(owner: string, repo: string, path: string, host: string) {
+  const data = await $fetch(`https://${host}/${owner}/${repo}/raw/branch/HEAD/${path}`)
+
+  const markdown = v.parse(v.string(), data)
+
+  return (await changelogRenderer(createForgejoRepoInfo(host, owner, repo, path)))(markdown)
 }

server/api/changelog/releases/[provider]/[owner]/[repo].get.ts

@@ -1,19 +1,27 @@
 import type { ProviderId } from '~~/shared/utils/git-providers'
 import type { ReleaseData } from '~~/shared/types/changelog'
+import * as v from 'valibot'
 import {
   ERROR_CHANGELOG_RELEASES_FAILED,
   ERROR_THROW_INCOMPLETE_PARAM,
 } from '~~/shared/utils/constants'
-import { GithubReleaseCollectionSchama } from '~~/shared/schemas/changelog/release'
+import {
+  GithubReleaseCollectionSchama,
+  ForgejoReleaseCollectionSchema,
+} from '~~/shared/schemas/changelog/release'
 import { parse } from 'valibot'
 import { changelogRenderer } from '~~/server/utils/changelog/markdown'
+import { createForgejoRepoInfo, createGithubRepoInfo } from '~~/server/utils/changelog/mdRepoInfo'
 
 export default defineCachedEventHandler(
   async event => {
     const provider = getRouterParam(event, 'provider')
     const repo = getRouterParam(event, 'repo')
     const owner = getRouterParam(event, 'owner')
 
+    const rawQuery = getQuery(event)
+    const { host } = v.parse(v.object({ host: v.optional(v.string()) }), rawQuery)
+
     if (!repo || !provider || !owner) {
       throw createError({
         status: 404,
@@ -25,6 +33,9 @@ export default defineCachedEventHandler(
       switch (provider as ProviderId) {
         case 'github':
           return await getReleasesFromGithub(owner, repo)
+        case 'codeberg':
+        case 'forgejo':
+          return await getReleasesFromForgejo(owner, repo, host ?? 'codeberg.org')
 
         default:
           throw createError({
@@ -62,10 +73,7 @@ async function getReleasesFromGithub(owner: string, repo: string) {
 
   const { releases } = parse(GithubReleaseCollectionSchama, data)
 
-  const render = await changelogRenderer({
-    blobBaseUrl: `https://github.com/${owner}/${repo}/blob/HEAD`,
-    rawBaseUrl: `https://raw.githubusercontent.com/${owner}/${repo}/HEAD`,
-  })
+  const render = await changelogRenderer(createGithubRepoInfo(owner, repo))
 
   return releases.map(r => {
     const { html, toc } = render(r.markdown, r.id)
@@ -82,3 +90,24 @@ async function getReleasesFromGithub(owner: string, repo: string) {
     } satisfies ReleaseData
   })
 }
+
+async function getReleasesFromForgejo(owner: string, repo: string, host: string) {
+  const data = await $fetch(`https://${host}/api/v1/repos/${owner}/${repo}/releases?draft=false`)
+  const releases = parse(ForgejoReleaseCollectionSchema, data)
+
+  const render = await changelogRenderer(createForgejoRepoInfo(host, owner, repo))
+
+  return releases.map(r => {
+    const { html, toc } = render(r.body, r.id)
+    return {
+      id: r.id,
+      html: html?.replace(/(?<!>)\n/g, '<br>') ?? null,
+      title: r.name || r.tag_name,
+      prerelease: r.prerelease,
+      toc,
+      link: r.html_url,
+      publishedAt: r.published_at,
+      draft: r.draft,
+    } satisfies ReleaseData
+  })
+}

server/utils/changelog/detectChangelog.ts

@@ -3,7 +3,11 @@ import { FetchError } from 'ofetch'
 import type { ExtendedPackageJson } from '~~/shared/utils/package-analysis'
 import { type RepoRef, parseRepoUrl } from '~~/shared/utils/git-providers'
 import { ERROR_CHANGELOG_NOT_FOUND, ERROR_UNGH_API_KEY_EXHAUSTED } from '~~/shared/utils/constants'
-import { GithubReleaseSchama } from '~~/shared/schemas/changelog/release'
+import {
+  GithubReleaseSchama,
+  ForgejoReleaseSchama,
+  GitlabReleaseSchame,
+} from '~~/shared/schemas/changelog/release'
 import { resolveURL } from 'ufo'
 import * as v from 'valibot'
 
@@ -56,12 +60,17 @@ async function checkReleases(
     case 'github': {
       return checkLatestGithubRelease(ref, directory)
     }
+    case 'codeberg':
+    case 'forgejo': {
+      return checkLatestForgejoRelease(ref, directory)
+    }
+    case 'gitlab': {
+      return checkLatestGitlabRelease(ref, directory)
+    }
   }
   return [false, null]
 }
 
-/// releases
-
 const MD_REGEX = /(?<=\[.*?(changelog|releases|changes|history|news)\.md.*?\]\()(.*?)(?=\))/i
 const ROOT_ONLY_REGEX = /^\/[^/]+$/
 
@@ -180,8 +189,9 @@ async function checkFiles(ref: RepoRef, baseUrl: RepoFileUrl, dir?: string) {
         type: 'md',
         provider: ref.provider,
         path: resolveURL(dir ?? '', fileName),
-        repo: `${ref.owner}/${ref.repo}`,
+        repo: `${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.repo)}`,
         link: resolveURL(baseUrl.blob, dir ?? '', fileName),
+        host: ref.host,
       } satisfies ChangelogMarkdownInfo
     }
   }
@@ -200,6 +210,154 @@ function getBaseFileUrl(ref: RepoRef): RepoFileUrl | null {
         raw: `https://raw.githubusercontent.com/${ref.owner}/${ref.repo}/HEAD`,
         blob: `https://github.com/${ref.owner}/${ref.repo}/blob/HEAD`,
       }
+    case 'codeberg':
+    case 'forgejo': {
+      const host = ref.host ?? 'codeberg.org'
+      return {
+        blob: `https://${host}/${ref.owner}/${ref.repo}/src/branch/HEAD`,
+        raw: `https://${host}/${ref.owner}/${ref.repo}/raw/branch/HEAD`,
+      }
+    }
+    case 'gitlab': {
+      const host = ref.host ?? 'gitlab.com'
+      return {
+        blob: `https://${host}/${ref.owner}/${ref.repo}/-/blob/HEAD`,
+        raw: `https://${host}/${ref.owner}/${ref.repo}/-/raw/HEAD`,
+      }
+    }
   }
   return null
 }
+
+// codeberg / forgejo
+
+async function checkLatestForgejoRelease(
+  ref: RepoRef,
+  directory?: string,
+): Promise<SafeResult<ChangelogInfo | false>> {
+  try {
+    const host = ref.host ?? 'codeberg.org'
+
+    const response = await $fetch(
+      `https://${host}/api/v1/repos/${ref.owner}/${ref.repo}/releases/latest`,
+      {
+        headers: {
+          'User-Agent': 'npmx.dev',
+          'accept': 'application/json',
+        },
+      },
+    )
+
+    const release = v.parse(ForgejoReleaseSchama, response)
+
+    const matchedChangelog = release.body?.match(MD_REGEX)?.at(0)
+
+    // /src/branch/ can be similar to /blob/
+    if (!matchedChangelog || !matchedChangelog.includes('/src/branch/')) {
+      return [
+        {
+          type: 'release',
+          link: `https://${host}/${ref.owner}/${ref.repo}/releases`,
+          provider: ref.provider,
+          repo: `${ref.owner}/${ref.repo}`,
+          host: ref.host,
+        },
+        null,
+      ]
+    }
+
+    const path = matchedChangelog.replace(/^.*\/src\/branch\/[^/]+\//i, '')
+    if (
+      directory &&
+      !(
+        path.startsWith(directory.endsWith('/') ? directory : `${directory}/`) ||
+        ROOT_ONLY_REGEX.test(path)
+      )
+    ) {
+      return [false, null] as const
+    }
+    return [
+      {
+        provider: ref.provider,
+        type: 'md',
+        path,
+        repo: `${ref.owner}/${ref.repo}`,
+        link: matchedChangelog,
+        host: ref.host,
+      },
+      null,
+    ]
+  } catch (e) {
+    if (e instanceof Error) {
+      return [null, e]
+    }
+  }
+  return [false, null]
+}
+
+// gitlab
+async function checkLatestGitlabRelease(
+  ref: RepoRef,
+  directory?: string,
+): Promise<SafeResult<ChangelogInfo | false>> {
+  try {
+    const host = ref.host ?? 'gitlab.com'
+    const repoPath = encodeURIComponent(`${ref.owner}/${ref.repo}`)
+
+    const response = await $fetch(
+      `https://${host}/api/v4/projects/${repoPath}/releases/permalink/latest`,
+      {
+        headers: {
+          'User-Agent': 'npmx.dev',
+          'accept': 'application/json',
+        },
+      },
+    )
+    const release = v.parse(GitlabReleaseSchame, response)
+
+    const matchedChangelog = release.description?.match(MD_REGEX)?.at(0)
+
+    if (!matchedChangelog || !matchedChangelog.includes('/-/blob/')) {
+      return [
+        {
+          type: 'release',
+          // I encode both just to be sure
+          link: `https://${host}/${ref.owner}/${ref.repo}/-/releases`,
+          provider: ref.provider,
+          repo: `${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.repo)}`,
+          host: ref.host,
+        },
+        null,
+      ]
+    }
+
+    const path = matchedChangelog.replace(/^.*\/-\/blob\/[^/]+\//i, '')
+
+    if (
+      directory &&
+      !(
+        path.startsWith(directory.endsWith('/') ? directory : `${directory}/`) ||
+        ROOT_ONLY_REGEX.test(path)
+      )
+    ) {
+      return [false, null] as const
+    }
+
+    return [
+      {
+        provider: ref.provider,
+        type: 'md',
+        path,
+        repo: `${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.repo)}`,
+        link: matchedChangelog,
+        host: ref.host,
+      },
+      null,
+    ]
+  } catch (e) {
+    if (e instanceof Error) {
+      return [null, e]
+    }
+  }
+  return [false, null]
+}