Implement blog content parser for repository

packages/applications/turbo-blog/src/build/model/blog/blog.entity.ts

@@ -7,17 +7,16 @@ export interface BlogMetadata {
 	description: string[];
 	publishedAt: string;
 	updatedAt: string;
+	path: string;
 }
 
 export class BlogContent extends Content {
 	public metadata: BlogMetadata;
 	public language: Language;
-	public body: string;
 
 	constructor(metadata: BlogMetadata, body: string, language: Language) {
 		super(body);
 		this.metadata = metadata;
-		this.body = body;
 		this.language = language;
 	}
 }

packages/applications/turbo-blog/src/build/model/blog/blog.repository.ts

@@ -1,7 +1,16 @@
 import type fs from "node:fs/promises";
 import type path from "node:path";
+import {
+	type Result,
+	createErr,
+	createOk,
+	isErr,
+	unwrapErr,
+	unwrapOk,
+} from "option-t/esm/PlainResult";
 import { Language } from "../language/language.entity";
 import { BlogContent } from "./blog.entity";
+import { parseBlogContent } from "./parse-blog-content";
 
 export class BlogRepository {
 	private _fs: typeof fs;
@@ -12,7 +21,10 @@ export class BlogRepository {
 		this._path = injectedPath;
 	}
 
-	public async getBlog(slug: string, language: Language): Promise<BlogContent> {
+	public async getBlog(
+		slug: string,
+		language: Language,
+	): Promise<Result<BlogContent, Error>> {
 		const blogPath = this._path.resolve(
 			process.cwd(),
 			"packages/applications/turbo-blog/src/articles/",
@@ -21,12 +33,18 @@ export class BlogRepository {
 		);
 		const blogContent = await this._fs.readFile(blogPath, "utf-8");
 
-		const [title, ...body] = blogContent.split("\n");
+		const parseBlogContentResult = await parseBlogContent(blogContent);
 
-		return new BlogContent(title, body.join("\n"), language);
+		if (isErr(parseBlogContentResult)) {
+			return parseBlogContentResult;
+		}
+
+		const { metadata, body } = unwrapOk(parseBlogContentResult);
+
+		return createOk(new BlogContent(metadata, body, language));
 	}
 
-	public async getBlogs(): Promise<BlogContent[]> {
+	public async getBlogs(): Promise<Result<BlogContent[], Error>> {
 		const blogPaths = await this._fs.readdir(
 			this._path.resolve(
 				process.cwd(),
@@ -40,40 +58,26 @@ export class BlogRepository {
 			),
 		);
 
-		const blogs = await Promise.all(
+		const blogsJa = await Promise.all(
 			blogPaths.map(async (blogPath) => {
-				const blogContent = await this._fs.readFile(
-					this._path.resolve(
-						process.cwd(),
-						"packages/applications/turbo-blog/src/articles/public",
-						blogPath,
-					),
-					"utf-8",
-				);
-
-				const [title, ...body] = blogContent.split("\n");
-
-				return new BlogContent(title, body.join("\n"), Language.ja);
+				return this.getBlog(blogPath, Language.ja);
 			}),
 		);
 
 		const blogsEn = await Promise.all(
 			blogEnPaths.map(async (blogPath) => {
-				const blogContent = await this._fs.readFile(
-					this._path.resolve(
-						process.cwd(),
-						"packages/applications/turbo-blog/src/articles/en",
-						blogPath,
-					),
-					"utf-8",
-				);
-
-				const [title, ...body] = blogContent.split("\n");
-
-				return new BlogContent(title, body.join("\n"), Language.en);
+				return this.getBlog(blogPath, Language.en);
 			}),
 		);
 
-		return [...blogs, ...blogsEn];
+		const blogResults = [...blogsJa, ...blogsEn];
+
+		const blogErrs = blogResults.filter(isErr);
+
+		if (blogErrs.length > 0) {
+			return createErr(AggregateError(blogErrs.map(unwrapErr)));
+		}
+
+		return createOk(blogResults.map(unwrapOk));
 	}
 }

packages/applications/turbo-blog/src/build/model/blog/parse-blog-content.ts

@@ -1,13 +1,34 @@
-import { type Result, isErr } from "option-t/esm/PlainResult";
-import type { BlogContent } from "./blog.entity";
+import {
+	type Result,
+	createOk,
+	isErr,
+	unwrapOk,
+} from "option-t/esm/PlainResult";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+import type { BlogMetadata } from "./blog.entity";
 import { extractBlogMetadata } from "./extract-blog-metadata";
 
+interface ParseBlogContentResult {
+	metadata: BlogMetadata;
+	body: string;
+}
+
 export const parseBlogContent: (
 	blogContent: string,
-) => Result<BlogContent, Error> = (blogContent) => {
+) => Promise<Result<ParseBlogContentResult, Error>> = async (blogContent) => {
 	const extractBlogMetadataResult = extractBlogMetadata(blogContent);
 
 	if (isErr(extractBlogMetadataResult)) {
 		return extractBlogMetadataResult;
 	}
+
+	const { content, metadata } = unwrapOk(extractBlogMetadataResult);
+
+	const parsed = await unified().use(remarkParse).process(content);
+
+	return createOk({
+		metadata,
+		body: parsed.toString(),
+	});
 };