feat: refactor article and user service functions to use TypedResult for enhanced error handling

src/lib/feature/article/article.external.ts

@@ -11,92 +11,88 @@ import { getSessionData } from '@/lib/session/session-storage';
 import { TypedResult, wrap } from '@/utils/types/results';
 import { UUIDv4 } from '@/utils/types/uuid';
 
-const _getArticleByExternalId = async (
-    externalId: UUIDv4
-): Promise<ArticleModel | null> => {
-    const result = await service.getArticleByExternalId(externalId);
-    if (!result.ok) throw result.error;
-    return result.value;
-};
-
-const _getArticleBySlug = async (
-    slug: string
-): Promise<ArticleModel | null> => {
-    const result = await service.getArticleBySlug(slug);
-    if (!result.ok) throw result.error;
-    return result.value;
-};
-
-const _getArticlesPaginated = async (
-    page: number = 1,
-    pageSize: number = 10
-): Promise<PaginatedArticlesResult> => {
-    const result = await service.getArticlesPaginated(page, pageSize);
-    if (!result.ok) throw result.error;
-    return result.value;
-};
-
-const _saveArticle = async (
-    article: CreateArticleModel
-): Promise<ArticleModel> => {
-    const session = await getSessionData();
-    if (!session || !session?.user || session?.user.role !== 'admin') {
-        throw new Error('Unauthorized: Only admin users can save articles.');
-    }
-    article.authorId = session.user.id;
-
-    const result = await service.saveArticle(article);
-    if (!result.ok) throw result.error;
-    return result.value;
-};
-
-const _updateArticle = async (
-    articleId: string,
-    article: UpdateArticleModel
-): Promise<ArticleModel> => {
-    const session = await getSessionData();
-    if (!session || !session?.user || session?.user.role !== 'admin') {
-        throw new Error('Unauthorized: Only admin users can save articles.');
-    }
-
-    const result = await service.updateArticle(articleId, article);
-    if (!result.ok) throw result.error;
-    return result.value;
-};
-
-const _deleteArticle = async (articleId: string): Promise<void> => {
-    const session = await getSessionData();
-    if (!session || !session?.user || session?.user.role !== 'admin') {
-        throw new Error('Unauthorized: Only admin users can delete articles.');
-    }
-
-    const result = await service.deleteArticle(articleId);
-    if (!result.ok) throw result.error;
-};
-
 export const getArticleByExternalId: (
     externalId: UUIDv4
-) => Promise<TypedResult<ArticleModel | null>> = wrap(_getArticleByExternalId);
+) => Promise<TypedResult<ArticleModel | null>> = wrap(
+    async (externalId: UUIDv4): Promise<ArticleModel | null> => {
+        const result = await service.getArticleByExternalId(externalId);
+        if (!result.ok) throw result.error;
+        return result.value;
+    }
+);
 
 export const getArticleBySlug: (
     slug: string
-) => Promise<TypedResult<ArticleModel | null>> = wrap(_getArticleBySlug);
+) => Promise<TypedResult<ArticleModel | null>> = wrap(
+    async (slug: string): Promise<ArticleModel | null> => {
+        const result = await service.getArticleBySlug(slug);
+        if (!result.ok) throw result.error;
+        return result.value;
+    }
+);
 
 export const getArticlesPaginated: (
     page?: number,
     pageSize?: number
 ) => Promise<TypedResult<PaginatedArticlesResult>> = wrap(
-    _getArticlesPaginated
+    async (
+        page: number = 1,
+        pageSize: number = 10
+    ): Promise<PaginatedArticlesResult> => {
+        const result = await service.getArticlesPaginated(page, pageSize);
+        if (!result.ok) throw result.error;
+        return result.value;
+    }
 );
 
 export const saveArticle: (
     article: CreateArticleModel
-) => Promise<TypedResult<ArticleModel>> = wrap(_saveArticle);
+) => Promise<TypedResult<ArticleModel>> = wrap(
+    async (article: CreateArticleModel): Promise<ArticleModel> => {
+        const session = await getSessionData();
+        if (!session || !session?.user || session?.user.role !== 'admin') {
+            throw new Error(
+                'Unauthorized: Only admin users can save articles.'
+            );
+        }
+        article.authorId = session.user.id;
+
+        const result = await service.saveArticle(article);
+        if (!result.ok) throw result.error;
+        return result.value;
+    }
+);
 
 export const updateArticle: (
     articleId: string,
     article: UpdateArticleModel
-) => Promise<TypedResult<ArticleModel>> = wrap(_updateArticle);
+) => Promise<TypedResult<ArticleModel>> = wrap(
+    async (
+        articleId: string,
+        article: UpdateArticleModel
+    ): Promise<ArticleModel> => {
+        const session = await getSessionData();
+        if (!session || !session?.user || session?.user.role !== 'admin') {
+            throw new Error(
+                'Unauthorized: Only admin users can save articles.'
+            );
+        }
+
+        const result = await service.updateArticle(articleId, article);
+        if (!result.ok) throw result.error;
+        return result.value;
+    }
+);
 
 export const deleteArticle: (articleId: string) => Promise<TypedResult<void>> =
-    wrap(_deleteArticle);
+    wrap(async (articleId: string): Promise<void> => {
+        const session = await getSessionData();
+        if (!session || !session?.user || session?.user.role !== 'admin') {
+            throw new Error(
+                'Unauthorized: Only admin users can delete articles.'
+            );
+        }
+
+        const result = await service.deleteArticle(articleId);
+        if (!result.ok) throw result.error;
+    });