@jhits/plugin-blog 0.0.18 → 0.0.20

package/src/api/handler.ts

@@ -1,673 +1,156 @@
 /**
  * Blog API Handler
- * RESTful API handler for blog posts
- * Compatible with Next.js API routes
- * 
- * IMPORTANT: This file should ONLY be imported in server-side API routes.
- * Do NOT import this in client-side code.
+ * Simplified RESTful API handler using BlogService
  */
 
 import { NextRequest, NextResponse } from 'next/server';
+import { BlogService } from './service';
 import { slugify } from '../lib/utils/slugify';
 
 export interface BlogApiConfig {
-    /** MongoDB client promise (from clientPromise) - should return { db: () => Database } */
     getDb: () => Promise<{ db: () => any }>;
-    /** Function to get authenticated user ID from request */
     getUserId: (req: NextRequest) => Promise<string | null>;
-    /** Collection name (default: 'blogs') */
     collectionName?: string;
 }
 
 /**
- * GET /api/blogs - List all blog posts
- * GET /api/blogs?admin=true - List all posts for admin (includes drafts)
- * GET /api/blogs?status=published - Filter by status
- * GET /api/blogs?language=en - Filter by language (falls back to nl if not found)
+ * Generic helper to find a blog post by slug across all languages
+ * Avoids hardcoding language codes
  */
+async function findPostBySlug(collection: any, slug: string) {
+    // 1. Try root slug (fastest, indexed)
+    const rootMatch = await collection.findOne({ slug });
+    if (rootMatch) return rootMatch;
+
+    // 2. Generic search across all localized slugs using aggregation
+    // This works for ANY language key (nl, en, sv, de, fr, es, etc.)
+    const results = await collection.aggregate([
+        // Convert the 'languages' object into an array of { k, v } entries
+        { $addFields: { _langEntries: { $objectToArray: { $ifNull: ["$languages", {}] } } } },
+        // Match if any entry's slug matches our target
+        { $match: { "_langEntries.v.metadata.slug": slug } },
+        // Remove the temporary field
+        { $project: { _langEntries: 0 } },
+        { $limit: 1 }
+    ]).toArray();
+
+    return results[0] || null;
+}
+
 export async function GET(req: NextRequest, config: BlogApiConfig): Promise<NextResponse> {
     try {
         const url = new URL(req.url);
-        const limit = Number(url.searchParams.get('limit') ?? 10);
-        const skip = Number(url.searchParams.get('skip') ?? 0);
-        const statusFilter = url.searchParams.get('status');
-        const isAdminView = url.searchParams.get('admin') === 'true';
-        const requestedLanguage = url.searchParams.get('language') || 'nl';
-
-        const userId = await config.getUserId(req);
-        const dbConnection = await config.getDb();
-        const db = dbConnection.db();
-        const blogs = db.collection(config.collectionName || 'blogs');
-
-        // Build query
-        let query: any = {};
-
-        if (isAdminView && userId) {
-            // Admin view: show all posts owned by user
-            if (statusFilter) {
-                query = {
-                    'publicationData.status': statusFilter,
-                    authorId: userId,
-                };
-            } else {
-                query = { authorId: userId };
-            }
-        } else {
-            // Public view: only published posts in the SPECIFIC language
-            // This ensures we only fetch blogs that actually have content for this language
-            query = {
-                [`languages.${requestedLanguage}.status`]: 'published',
-                'publicationData.date': { $lte: new Date() },
-            };
-            
-            if (statusFilter && statusFilter !== 'published') {
-                // Non-admin can't filter by non-published status
-                return NextResponse.json({ error: 'Invalid status filter' }, { status: 400 });
-            }
-        }
-
-        const [data, totalCount] = await Promise.all([
-            blogs
-                .find(query)
-                .sort({ 'publicationData.date': -1 })
-                .skip(skip)
-                .limit(isAdminView ? 0 : limit)
-                .toArray(),
-            blogs.countDocuments(query),
-        ]);
-
-        // Supported languages for fallback (in order of preference)
-        const fallbackLanguages = [requestedLanguage, 'nl', 'en'];
-
-        const formatted = data.map((doc: any) => {
-            const languages = doc.languages || {};
-            
-            // Only use exact language match public views - no fallback for
-            // This ensures visitors see content in their language only
-            const hasExactLanguage = !!languages[requestedLanguage];
-            
-            // Skip this post if no exact language match (for public non-admin views)
-            if (!isAdminView && !hasExactLanguage) {
-                return null;
-            }
-            
-            const postPrimaryLang = doc.metadata?.lang || 'nl';
-            
-            // Find the best available language for this post
-            let bestLanguage = requestedLanguage;
-            let isMissingTranslation = false;
-
-            if (!languages[requestedLanguage]) {
-                // For admin view, if specific language is requested, show it as missing instead of falling back
-                // This ensures the UI is "synced" with the selected language
-                if (isAdminView) {
-                    isMissingTranslation = true;
-                } else {
-                    // Public view still uses fallback or filtering
-                    const fallbackLanguages = [postPrimaryLang, 'nl', 'en'];
-                    for (const lang of fallbackLanguages) {
-                        if (languages[lang]) {
-                            bestLanguage = lang;
-                            break;
-                        }
-                    }
-                }
-            }
-            
-            const langContent = languages[bestLanguage] || {};
-            const meta = langContent.metadata || {};
-            
-            // Ensure all languages in doc have a status and updatedAt for the dashboard
-            const enrichedLanguages = { ...languages };
-            Object.keys(enrichedLanguages).forEach(lang => {
-                if (!enrichedLanguages[lang].status) {
-                    enrichedLanguages[lang].status = doc.publicationData?.status === 'concept' ? 'draft' : (doc.publicationData?.status || 'draft');
-                }
-                if (!enrichedLanguages[lang].updatedAt) {
-                    enrichedLanguages[lang].updatedAt = doc.updatedAt;
-                }
-            });
-
-            // Language display names for placeholders
-            const langNames: Record<string, string> = {
-                nl: 'Dutch',
-                en: 'English',
-                sv: 'Swedish',
-                de: 'German',
-                fr: 'French',
-                es: 'Spanish'
-            };
-            
-            const displayTitle = isMissingTranslation 
-                ? `(No ${langNames[requestedLanguage] || requestedLanguage.toUpperCase()} translation)` 
-                : (meta.title || doc.title || '');
-
-            const displayStatus = isMissingTranslation 
-                ? 'not-translated' 
-                : (langContent.status || doc.publicationData?.status || 'concept');
-            
-            return {
-                ...doc,
-                _id: doc._id.toString(),
-                title: displayTitle,
-                summary: isMissingTranslation ? '' : (meta.excerpt || doc.summary || ''),
-                contentBlocks: isMissingTranslation ? [] : (langContent.blocks || doc.contentBlocks || doc.blocks || []),
-                image: isMissingTranslation ? null : (meta.featuredImage || doc.image),
-                categoryTags: isMissingTranslation ? { category: '', tags: [] } : (meta.categories ? {
-                    category: meta.categories[0] || '',
-                    tags: meta.tags || doc.categoryTags?.tags || []
-                } : (doc.categoryTags || { category: '', tags: [] })),
-                publicationData: {
-                    ...doc.publicationData,
-                    status: displayStatus,
-                },
-                seo: isMissingTranslation ? {} : (meta.seo || doc.seo || {}),
-                lang: bestLanguage,
-                isMissingTranslation,
-                requestedLanguage,
-                availableLanguages: Object.keys(languages),
-                languages: enrichedLanguages,
-                updatedAt: isMissingTranslation ? doc.updatedAt : (langContent.updatedAt || doc.updatedAt),
-                status: displayStatus,
-            };
-        }).filter(Boolean); // Remove null entries
-
-        // Sort by updatedAt descending so the UI order makes sense
-        formatted.sort((a: any, b: any) => {
-            const dateA = new Date(a.updatedAt).getTime();
-            const dateB = new Date(b.updatedAt).getTime();
-            return dateB - dateA;
-        });
-
-        return NextResponse.json({
-            blogs: formatted,
-            total: formatted.length,
+        const service = new BlogService(config);
+        const results = await service.listBlogs({
+            limit: Number(url.searchParams.get('limit') ?? 10),
+            skip: Number(url.searchParams.get('skip') ?? 0),
+            status: url.searchParams.get('status') || undefined,
+            isAdmin: url.searchParams.get('admin') === 'true',
+            userId: await config.getUserId(req),
+            requestedLanguage: url.searchParams.get('language') || 'nl',
         });
+        return NextResponse.json(results);
     } catch (err: any) {
-        console.error('[BlogAPI] GET error:', err);
-        return NextResponse.json(
-            { error: 'Failed to fetch blogs', detail: err.message },
-            { status: 500 }
-        );
+        return NextResponse.json({ error: 'Fetch failed', detail: err.message }, { status: 500 });
     }
 }
 
-/**
- * POST /api/blogs - Create new blog post
- */
 export async function POST(req: NextRequest, config: BlogApiConfig): Promise<NextResponse> {
     try {
         const url = new URL(req.url);
         const language = url.searchParams.get('language') || 'nl';
-        
         const userId = await config.getUserId(req);
-        if (!userId) {
-            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
-        }
+        if (!userId) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
 
         const body = await req.json();
-        const {
-            title,
-            summary,
-            content,
-            contentBlocks,
-            image,
-            categoryTags,
-            publicationData,
-            seo,
-        } = body;
-
-        const isPublishing = publicationData?.status === 'published';
-        const isConcept = publicationData?.status === 'concept' || publicationData?.status === 'draft';
-
-        // Validation
-        const errors: string[] = [];
-        if (!title?.trim()) {
-            errors.push('Title is required');
-        }
-
-        if (isPublishing) {
-            // Publishing requires all fields
-            if (!summary?.trim()) errors.push('Summary is required for publishing');
-            if (!image?.id?.trim()) errors.push('Featured image is required for publishing');
-            // Only require category if it's explicitly provided and empty
-            // If categoryTags is undefined or category is undefined, that's also missing
-            if (!categoryTags || !categoryTags.category || !categoryTags.category.trim()) {
-                errors.push('Category is required for publishing');
-            }
-            const hasContent =
-                (contentBlocks && Array.isArray(contentBlocks) && contentBlocks.length > 0) ||
-                (content && Array.isArray(content) && content.length > 0);
-            if (!hasContent) {
-                errors.push('Content is required for publishing');
-            }
-            if (!publicationData?.date) errors.push('Publication date is required');
-        }
-
-        if (errors.length > 0) {
-            return NextResponse.json({ message: errors[0], allErrors: errors }, { status: 400 });
-        }
-
-        // Create slug
-        let baseSlug = slugify(title);
-        const slug = isPublishing
-            ? baseSlug
-            : `${baseSlug}-draft-${Date.now().toString().slice(-4)}`;
-
-        const dbConnection = await config.getDb();
-        const db = dbConnection.db();
-        const blogs = db.collection(config.collectionName || 'blogs');
-
-        // Determine the final status: if publishing, set to 'published', otherwise convert draft to concept
-        let finalStatus = publicationData?.status;
-        if (isPublishing) {
-            finalStatus = 'published';
-        } else if (publicationData?.status === 'draft') {
-            finalStatus = 'concept';
-        } else {
-            finalStatus = publicationData?.status || 'concept';
-        }
+        if (!body.title?.trim()) return NextResponse.json({ message: 'Title is required' }, { status: 400 });
 
-        const blogDocument = {
-            title: title.trim(),
-            summary: (summary || '').trim(),
-            contentBlocks: contentBlocks || [],
-            content: content || [],
-            image: image || { id: '', alt: '' }, // Only store id and alt - plugin-images handles transforms
-            categoryTags: {
-                category: categoryTags?.category?.trim() || '',
-                tags: categoryTags?.tags || [],
-            },
-            publicationData: {
-                ...publicationData,
-                status: finalStatus,
-                date: publicationData?.date ? new Date(publicationData.date) : new Date(),
-            },
-            seo: seo || { title: '', description: '' },
+        const service = new BlogService(config);
+        const isPublishing = body.publicationData?.status === 'published';
+        const slug = isPublishing ? slugify(body.title) : `${slugify(body.title)}-draft-${Date.now().toString().slice(-4)}`;
+        
+        const updateData = service.prepareUpdateData(body, null, language);
+        const finalDoc = {
+            ...updateData,
             slug,
             authorId: userId,
-            languages: {
-                [language]: {
-                    blocks: contentBlocks || [],
-                    metadata: {
-                        title: title.trim(),
-                        excerpt: (summary || '').trim(),
-                        featuredImage: image,
-                        categories: categoryTags?.category ? [categoryTags.category] : [],
-                        tags: categoryTags?.tags || [],
-                        seo: seo || {},
-                    },
-                    updatedAt: new Date().toISOString(),
-                    status: finalStatus,
-                },
-            },
-            metadata: {
-                lang: language,
-            },
+            metadata: { lang: language },
             createdAt: new Date(),
-            updatedAt: new Date(),
         };
 
-        const result = await blogs.insertOne(blogDocument);
-
-        return NextResponse.json({
-            message: isPublishing ? 'Blog published successfully' : 'Draft saved successfully',
-            blogId: result.insertedId,
-            slug,
-        });
+        const dbConn = await config.getDb();
+        const result = await dbConn.db().collection(config.collectionName || 'blogs').insertOne(finalDoc);
+        return NextResponse.json({ message: 'Success', blogId: result.insertedId, slug });
     } catch (err: any) {
-        console.error('[BlogAPI] POST error:', err);
-        return NextResponse.json(
-            { error: 'Failed to create blog', detail: err.message },
-            { status: 500 }
-        );
+        return NextResponse.json({ error: 'Create failed', detail: err.message }, { status: 500 });
     }
 }
 
-/**
- * GET /api/blogs/[slug] - Get single blog post by slug
- */
-export async function GET_BY_SLUG(
-    req: NextRequest,
-    slug: string,
-    config: BlogApiConfig
-): Promise<NextResponse> {
+export async function GET_BY_SLUG(req: NextRequest, slug: string, config: BlogApiConfig): Promise<NextResponse> {
     try {
         const url = new URL(req.url);
-        const requestedLanguage = url.searchParams.get('language') || 'nl';
+        const service = new BlogService(config);
+        const lang = url.searchParams.get('language') || 'nl';
         
-        const userId = await config.getUserId(req);
-        const dbConnection = await config.getDb();
-        const db = dbConnection.db();
-        const blogs = db.collection(config.collectionName || 'blogs');
-
-        const blog = await blogs.findOne({ slug });
-
-        if (!blog) {
-            return NextResponse.json({ error: 'Blog not found' }, { status: 404 });
-        }
-
-        // Security check
-        const isAuthor = userId && blog.authorId === userId;
-        const isAdminView = url.searchParams.get('admin') === 'true';
+        const dbConn = await config.getDb();
+        const collection = dbConn.db().collection(config.collectionName || 'blogs');
         
-        // For public view, we must have a published version in the requested language
-        if (!isAdminView && !isAuthor) {
-            const langData = blog.languages?.[requestedLanguage];
-            if (!langData || langData.status !== 'published') {
-                return NextResponse.json({ error: 'Blog post not available in this language' }, { status: 404 });
-            }
-            
-            // Also check publication date
-            if (blog.publicationData?.date && new Date(blog.publicationData.date) > new Date()) {
-                return NextResponse.json({ error: 'Blog post not yet published' }, { status: 404 });
-            }
-        }
-
-        const languages = blog.languages || {};
-        const postPrimaryLang = blog.metadata?.lang || 'nl';
+        const blogDoc = await findPostBySlug(collection, slug);
         
-        // Find the best available language for this post
-        let bestLanguage = requestedLanguage;
-        let isMissingTranslation = false;
-
-        if (!languages[requestedLanguage]) {
-            if (isAdminView) {
-                isMissingTranslation = true;
-            } else {
-                // Try fallback languages in order
-                const fallbackLanguages = [requestedLanguage, 'nl', 'en'];
-                for (const lang of fallbackLanguages) {
-                    if (languages[lang]) {
-                        bestLanguage = lang;
-                        break;
-                    }
-                }
-                // If still no match, use primary language from metadata
-                if (!languages[bestLanguage] && languages[postPrimaryLang]) {
-                    bestLanguage = postPrimaryLang;
-                }
-            }
+        if (!blogDoc) {
+            return NextResponse.json({ error: 'Blog not found' }, { status: 404 });
         }
-        
-        const langContent = languages[bestLanguage] || {};
-        const meta = langContent.metadata || {};
-        
-        // Language display names for placeholders
-        const langNames: Record<string, string> = {
-            nl: 'Dutch',
-            en: 'English',
-            sv: 'Swedish',
-            de: 'German',
-            fr: 'French',
-            es: 'Spanish'
-        };
-
-        let title = isMissingTranslation 
-            ? `(No ${langNames[requestedLanguage] || requestedLanguage.toUpperCase()} translation)` 
-            : (meta.title || blog.title || '');
-        let summary = isMissingTranslation ? '' : (meta.excerpt || blog.summary || '');
-        let contentBlocks = isMissingTranslation ? [] : (langContent.blocks || blog.contentBlocks || blog.blocks || []);
-        let image = isMissingTranslation ? null : (meta.featuredImage || blog.image);
-        let categoryTags = isMissingTranslation ? { category: '', tags: [] } : (meta.categories ? {
-            category: meta.categories[0] || '',
-            tags: meta.tags || blog.categoryTags?.tags || []
-        } : (blog.categoryTags || { category: '', tags: [] }));
-        let seo = isMissingTranslation ? {} : (meta.seo || blog.seo || {});
-        let metadata = { ...blog.metadata, ...meta, lang: bestLanguage };
-
-        // Ensure all languages in doc have a status and updatedAt for the dashboard
-        const enrichedLanguages = { ...languages };
-        Object.keys(enrichedLanguages).forEach(lang => {
-            if (!enrichedLanguages[lang].status) {
-                enrichedLanguages[lang].status = blog.publicationData?.status === 'concept' ? 'draft' : (blog.publicationData?.status || 'draft');
-            }
-            if (!enrichedLanguages[lang].updatedAt) {
-                enrichedLanguages[lang].updatedAt = blog.updatedAt;
-            }
-        });
-
-        const displayStatus = isMissingTranslation 
-            ? 'not-translated' 
-            : (langContent.status || blog.publicationData?.status || 'concept');
 
-        return NextResponse.json({
-            ...blog,
-            _id: blog._id.toString(),
-            title,
-            summary,
-            contentBlocks,
-            image,
-            categoryTags,
-            publicationData: {
-                ...blog.publicationData,
-                status: displayStatus,
-            },
-            seo,
-            metadata,
-            languages: enrichedLanguages,
-            availableLanguages: Object.keys(languages),
-            lang: bestLanguage,
-            isMissingTranslation,
-            requestedLanguage,
-            updatedAt: isMissingTranslation ? blog.updatedAt : (langContent.updatedAt || blog.updatedAt),
-            status: displayStatus,
-        });
+        const formatted = (service as any).formatWithLanguage(blogDoc, lang, url.searchParams.get('admin') === 'true');
+        return NextResponse.json(formatted);
     } catch (err: any) {
         console.error('[BlogAPI] GET_BY_SLUG error:', err);
-        return NextResponse.json(
-            { error: 'Failed to fetch blog', detail: err.message },
-            { status: 500 }
-        );
+        return NextResponse.json({ error: 'Fetch failed', detail: err.message }, { status: 500 });
     }
 }
 
-/**
- * PUT /api/blogs/[slug] - Update blog post by slug
- */
-export async function PUT_BY_SLUG(
-    req: NextRequest,
-    slug: string,
-    config: BlogApiConfig
-): Promise<NextResponse> {
+export async function PUT_BY_SLUG(req: NextRequest, slug: string, config: BlogApiConfig): Promise<NextResponse> {
     try {
         const url = new URL(req.url);
         const language = url.searchParams.get('language') || 'nl';
-        
         const userId = await config.getUserId(req);
-        if (!userId) {
-            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
-        }
-
-        const body = await req.json();
-        const {
-            title,
-            summary,
-            content,
-            contentBlocks,
-            image,
-            categoryTags,
-            publicationData,
-            seo,
-        } = body;
-
-        const dbConnection = await config.getDb();
-        const db = dbConnection.db();
-        const blogs = db.collection(config.collectionName || 'blogs');
-
-        // Check if blog exists and user is author
-        const existingBlog = await blogs.findOne({ slug });
-        if (!existingBlog) {
-            return NextResponse.json({ error: 'Blog not found' }, { status: 404 });
-        }
-        if (existingBlog.authorId !== userId) {
-            return NextResponse.json({ error: 'Forbidden: Not the author' }, { status: 403 });
-        }
-
-        // Validation
-        const isPublishing = publicationData?.status === 'published';
-        if (!title?.trim()) {
-            return NextResponse.json({ message: 'Title is required' }, { status: 400 });
-        }
-
-        if (isPublishing) {
-            const hasContent =
-                (contentBlocks && Array.isArray(contentBlocks) && contentBlocks.length > 0) ||
-                (content && Array.isArray(content) && content.length > 0);
-
-            // Collect all missing fields for better error messages
-            const missingFields: string[] = [];
-            if (!summary?.trim()) missingFields.push('summary');
-            if (!image?.id?.trim()) missingFields.push('featured image');
-            // Only require category if it's explicitly provided and empty
-            // If categoryTags is undefined or category is undefined, that's also missing
-            if (!categoryTags || !categoryTags.category || !categoryTags.category.trim()) {
-                missingFields.push('category');
-            }
-            if (!hasContent) missingFields.push('content');
-
-            if (missingFields.length > 0) {
-                console.log('[BlogAPI] PUT_BY_SLUG validation failed:', {
-                    isPublishing,
-                    missingFields,
-                    summary: summary?.trim() || 'missing',
-                    imageId: image?.id?.trim() || 'missing',
-                    category: categoryTags?.category?.trim() || 'missing',
-                    hasContent,
-                    contentBlocksLength: contentBlocks?.length || 0,
-                    contentLength: content?.length || 0,
-                });
-                return NextResponse.json(
-                    {
-                        message: `Missing required fields for publishing: ${missingFields.join(', ')}`,
-                        missingFields
-                    },
-                    { status: 400 }
-                );
-            }
-        }
+        if (!userId) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
 
-        // Slug logic - DON'T change slug for existing posts, keep original
-        // The slug should remain constant across all language versions
-        const finalSlug = slug;
-
-        // Determine the final status: if publishing, set to 'published', otherwise preserve or convert draft to concept
-        let finalStatus = publicationData?.status;
-        if (isPublishing) {
-            finalStatus = 'published';
-        } else if (publicationData?.status === 'draft') {
-            finalStatus = 'concept';
-        }
-
-        // Preserve existing languages or initialize
-        const existingLanguages = existingBlog.languages || {};
-        const primaryLanguage = existingBlog.metadata?.lang || 'nl';
+        const dbConn = await config.getDb();
+        const collection = dbConn.db().collection(config.collectionName || 'blogs');
         
-        // Update the specific language content
-        // Only the language being saved gets a new updatedAt timestamp
-        const now = new Date();
-        const updatedLanguages = {
-            ...existingLanguages,
-            [language]: {
-                blocks: contentBlocks || [],
-                metadata: {
-                    title: title.trim(),
-                    excerpt: (summary || '').trim(),
-                    featuredImage: image,
-                    categories: categoryTags?.category ? [categoryTags.category] : [],
-                    tags: categoryTags?.tags || [],
-                    seo: seo || {},
-                },
-                updatedAt: now.toISOString(),
-                status: finalStatus,
-            },
-        };
-
-        // For root-level fields, only update if this is the primary language
-        // Otherwise preserve existing root values to maintain backward compatibility
-        const isPrimaryLanguage = language === primaryLanguage || !existingLanguages[primaryLanguage];
+        const existing = await findPostBySlug(collection, slug);
         
-        const updateData: any = {
-            // Only update root-level title/summary if saving in primary language
-            // This maintains backward compatibility
-            ...(isPrimaryLanguage ? {
-                title: title.trim(),
-                summary: (summary || '').trim(),
-                contentBlocks: contentBlocks || [],
-                content: content || [],
-                image: image || {},
-                categoryTags: {
-                    category: categoryTags?.category?.trim() || '',
-                    tags: categoryTags?.tags || [],
-                },
-                seo: seo || {},
-            } : {}),
-            publicationData: {
-                ...existingBlog.publicationData,
-                ...publicationData,
-                status: finalStatus,
-                date: publicationData?.date ? new Date(publicationData.date) : existingBlog.publicationData?.date || new Date(),
-            },
-            authorId: userId,
-            languages: updatedLanguages,
-            metadata: {
-                ...existingBlog.metadata,
-                lang: primaryLanguage,
-            },
-            updatedAt: new Date(),
-        };
-
-        await blogs.updateOne({ slug }, { $set: updateData });
+        if (!existing) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+        if (existing.authorId !== userId) return NextResponse.json({ error: 'Forbidden' }, { status: 403 });
 
-        return NextResponse.json({
-            message: 'Blog updated successfully',
-            slug: slug, // Return original slug, not finalSlug
-        });
+        const service = new BlogService(config);
+        const updateData = service.prepareUpdateData(await req.json(), existing, language);
+        
+        await collection.updateOne({ _id: existing._id }, { $set: updateData });
+        
+        // Return the potentially NEW localized slug so the editor can redirect if needed
+        const newSlug = updateData.languages[language].metadata.slug || existing.slug;
+        return NextResponse.json({ message: 'Updated', slug: newSlug });
     } catch (err: any) {
-        console.error('[BlogAPI] PUT_BY_SLUG error:', err);
-        return NextResponse.json(
-            { error: 'Failed to update blog', detail: err.message },
-            { status: 500 }
-        );
+        return NextResponse.json({ error: 'Update failed', detail: err.message }, { status: 500 });
     }
 }
 
-/**
- * DELETE /api/blogs/[slug] - Delete blog post by slug
- */
-export async function DELETE_BY_SLUG(
-    req: NextRequest,
-    slug: string,
-    config: BlogApiConfig
-): Promise<NextResponse> {
+export async function DELETE_BY_SLUG(req: NextRequest, slug: string, config: BlogApiConfig): Promise<NextResponse> {
     try {
         const userId = await config.getUserId(req);
-        if (!userId) {
-            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
-        }
-
-        const dbConnection = await config.getDb();
-        const db = dbConnection.db();
-        const blogs = db.collection(config.collectionName || 'blogs');
-
-        // Verify ownership
-        const blog = await blogs.findOne({ slug });
-        if (!blog) {
-            return NextResponse.json({ error: 'Blog not found' }, { status: 404 });
-        }
-        if (blog.authorId !== userId) {
-            return NextResponse.json({ error: 'Forbidden: Not the author' }, { status: 403 });
-        }
-
-        await blogs.deleteOne({ slug });
-
-        return NextResponse.json({ message: 'Blog deleted successfully' });
+        if (!userId) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        const dbConn = await config.getDb();
+        const collection = dbConn.db().collection(config.collectionName || 'blogs');
+        
+        const blog = await findPostBySlug(collection, slug);
+        
+        if (!blog) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+        if (blog.authorId !== userId) return NextResponse.json({ error: 'Forbidden' }, { status: 403 });
+        await collection.deleteOne({ _id: blog._id });
+        return NextResponse.json({ message: 'Deleted' });
     } catch (err: any) {
-        console.error('[BlogAPI] DELETE_BY_SLUG error:', err);
-        return NextResponse.json(
-            { error: 'Failed to delete blog', detail: err.message },
-            { status: 500 }
-        );
+        return NextResponse.json({ error: 'Delete failed', detail: err.message }, { status: 500 });
     }
 }
-