feat(github_loader): allow retrieving posts from any branch

Author: montyclt

src/content/EntriesGitHubLoader.ts

@@ -8,31 +8,31 @@ import {
 } from "../helpers/github.ts";
 import matter from "gray-matter";
 
-export function entriesGitHubLoader(repository: string, directory: string): Loader {
+export function entriesGitHubLoader(repository: string, branch: string, directory: string): Loader {
     return {
         name: 'github-entries-loader',
         load: async (context: LoaderContext): Promise<void> => {
             const regex = new RegExp(`^${directory}/[^/]+/entry\.mdx?$`);
-            await loadFilesWithRegex(repository, regex, context);
+            await loadFilesWithRegex(repository, branch, regex, context);
         }
     };
 }
 
-export function simpleGitHubLoader(repository: string, directory: string): Loader {
+export function simpleGitHubLoader(repository: string, branch: string, directory: string): Loader {
     return {
         name: 'github-simple-loader',
         load: async (context: LoaderContext): Promise<void> => {
             const regex = new RegExp(`^${directory}/[^/]+\.mdx?$`);
-            await loadSimpleFilesWithRegex(repository, directory, regex, context);
+            await loadSimpleFilesWithRegex(repository, branch, directory, regex, context);
         }
     };
 }
 
-export function kvpGitHubLoader(repository: string, file: string, idKey: string, valueKey: string): Loader {
+export function kvpGitHubLoader(repository: string, branch: string, file: string, idKey: string, valueKey: string): Loader {
     return {
         name: 'github-kvp-loader',
         load: async (context: LoaderContext): Promise<void> => {
-            let kvp = await getKeyValueList(repository, file);
+            let kvp = await getKeyValueList(repository, branch, file);
 
             let toStore = Object.entries(kvp).map(([key, value]) => ({
                 id: key,
@@ -47,14 +47,14 @@ export function kvpGitHubLoader(repository: string, file: string, idKey: string,
     };
 }
 
-async function loadFilesWithRegex(repository: string, regex: RegExp, context: LoaderContext): Promise<void> {
-    const tree = await fetchRepoTree(repository);
+async function loadFilesWithRegex(repository: string, branch: string, regex: RegExp, context: LoaderContext): Promise<void> {
+    const tree = await fetchRepoTree(repository, branch);
     const entryFiles = tree.filter(file =>
         file.type === 'blob' && regex.test(file.path)
     );
 
     for (const file of entryFiles) {
-        const rawContent = await fetchFileContent(repository, file.path);
+        const rawContent = await fetchFileContent(repository, branch, file.path);
         const {data, content} = matter(rawContent);
         const id = file.path.replace('/entry.mdx', '').replace('entry.md', '')
 
@@ -74,14 +74,14 @@ async function loadFilesWithRegex(repository: string, regex: RegExp, context: Lo
     }
 }
 
-async function loadSimpleFilesWithRegex(repository: string, directory: string, regex: RegExp, context: LoaderContext): Promise<void> {
-    const tree = await fetchRepoTree(repository);
+async function loadSimpleFilesWithRegex(repository: string, branch: string, directory: string, regex: RegExp, context: LoaderContext): Promise<void> {
+    const tree = await fetchRepoTree(repository, branch);
     const entryFiles = tree.filter(file =>
         file.type === 'blob' && regex.test(file.path)
     );
 
     for (const file of entryFiles) {
-        const rawContent = await fetchFileContent(repository, file.path);
+        const rawContent = await fetchFileContent(repository, branch, file.path);
         const {data, content} = matter(rawContent);
         const id = file.path.replace('.mdx', '').replace('.md', '').replace('/entry.mdx', '').replace(`${directory}/`, '')
 

src/content/config.ts

@@ -3,6 +3,7 @@ import {entriesGitHubLoader, kvpGitHubLoader, simpleGitHubLoader} from "./Entrie
 import {isDevelopment} from "../helpers/environment.ts";
 
 export const repository: string = isDevelopment() ? 'iokode/blog-dev' : 'iokode/blog';
+export const branch: string = 'master';
 
 export const defaultLicense = {
     code: 'CC BY 4.0',
@@ -11,7 +12,7 @@ export const defaultLicense = {
 
 export const collections = {
     posts: defineCollection({
-        loader: entriesGitHubLoader(repository, 'posts'),
+        loader: entriesGitHubLoader(repository, branch, 'posts'),
         schema: z.object({
             title: z.string(),
             slug: z.string(),
@@ -26,38 +27,38 @@ export const collections = {
     }),
 
     pages: defineCollection({
-        loader: simpleGitHubLoader(repository, 'pages'),
+        loader: simpleGitHubLoader(repository, branch, 'pages'),
         schema: z.object({
             title: z.string(),
             slug: z.string(),
         }),
     }),
 
     licenses: defineCollection({
-        loader: kvpGitHubLoader(repository, 'licenses.json', 'code', 'url'),
+        loader: kvpGitHubLoader(repository, branch, 'licenses.json', 'code', 'url'),
         schema: z.object({
             code: z.string(),
             url: z.string().url(),
         }),
     }),
 
     recommendedSites: defineCollection({
-        loader: kvpGitHubLoader(repository, 'recommended-sites.json', 'name', 'url'),
+        loader: kvpGitHubLoader(repository, branch, 'recommended-sites.json', 'name', 'url'),
         schema: z.object({
             name: z.string(),
             url: z.string().url()
         })
     }),
 
     tags: defineCollection({
-        loader: simpleGitHubLoader(repository, 'tags'),
+        loader: simpleGitHubLoader(repository, branch, 'tags'),
         schema: z.object({
             name: z.string(),
             description: z.string(),
         }),
     }),
 
     authors: defineCollection({
-        loader: simpleGitHubLoader(repository, 'authors')
+        loader: simpleGitHubLoader(repository, branch, 'authors')
     })
 }

src/helpers/github.ts

@@ -58,28 +58,30 @@ export async function getGithubAvatar(username: string): Promise<GetImageResult>
     });
 }
 
-export async function fetchRepoTree(repository: string): Promise<{
+export async function fetchRepoTree(repository: string, branch: string): Promise<{
     path: string;
     mode: string;
     type: string;
     sha: string;
     size: number;
     url: string;
 }[]> {
-    const response = await authenticatedFetch(`https://api.github.com/repos/${repository}/git/trees/main?recursive=1`);
+    const response = await authenticatedFetch(`https://api.github.com/repos/${repository}/git/trees/${branch}?recursive=1`);
     if (!response.ok) {
         throw new Error(`Failed to fetch repository tree: ${response.statusText}`);
     }
     const data = await response.json();
     return data.tree; // Array of all files and directories in the repo
 }
 
-export async function fetchFileContent(repository: string, filePath: string): Promise<string> {
-    const rawUrl = `https://raw.githubusercontent.com/${repository}/main/${filePath}`;
+export async function fetchFileContent(repository: string, branch: string, filePath: string): Promise<string> {
+    const rawUrl = `https://raw.githubusercontent.com/${repository}/${branch}/${filePath}`;
     const response = await authenticatedFetch(rawUrl);
     if (!response.ok) {
         throw new Error(`Failed to fetch file ${filePath}: ${response.statusText}`);
     }
+
+    console.log(filePath);
     return await response.text();
 }
 
@@ -138,8 +140,8 @@ export async function getRawContent(repository: string, filePath: string): Promi
     return Buffer.from(data.content, 'base64');
 }
 
-export async function getKeyValueList(repository: string, file: string): Promise<Record<string, string>> {
-    let response = await authenticatedFetch(`https://raw.githubusercontent.com/${repository}/refs/heads/main/${file}`);
+export async function getKeyValueList(repository: string, branch: string, file: string): Promise<Record<string, string>> {
+    let response = await authenticatedFetch(`https://raw.githubusercontent.com/${repository}/refs/heads/${branch}/${file}`);
     return await response.json();
 }
 

src/pages/posts/assets/[slug]/[file].ts

@@ -1,10 +1,10 @@
 import {getCollection} from "astro:content";
 import {fetchRepoTree, getRawContent} from "../../../../helpers/github.ts";
-import {repository} from "../../../../content/config.ts";
+import {branch, repository} from "../../../../content/config.ts";
 
 export async function getStaticPaths() {
     const posts = await getCollection('posts');
-    const tree = await fetchRepoTree(repository);
+    const tree = await fetchRepoTree(repository, branch);
 
     const paths: { params: { slug: string; file: string }; props: { filePath: string } }[] = [];