@jhits/plugin-blog 0.0.1

package/src/api/handler.ts

@@ -0,0 +1,419 @@
+/**
+ * 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.
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { APIBlogDocument, apiToBlogPost, editorStateToAPI } from '../lib/mappers/apiMapper';
+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
+ */
+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 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
+            query = {
+                'publicationData.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(limit)
+                .toArray(),
+            blogs.countDocuments(query),
+        ]);
+
+        const formatted = data.map((doc: any) => ({
+            ...doc,
+            _id: doc._id.toString(),
+        }));
+
+        return NextResponse.json({
+            blogs: formatted,
+            total: totalCount,
+        });
+    } catch (err: any) {
+        console.error('[BlogAPI] GET error:', err);
+        return NextResponse.json(
+            { error: 'Failed to fetch blogs', detail: err.message },
+            { status: 500 }
+        );
+    }
+}
+
+/**
+ * POST /api/blogs - Create new blog post
+ */
+export async function POST(req: NextRequest, config: BlogApiConfig): Promise<NextResponse> {
+    try {
+        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 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?.src?.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';
+        }
+
+        const blogDocument = {
+            title: title.trim(),
+            summary: (summary || '').trim(),
+            contentBlocks: contentBlocks || [],
+            content: content || [],
+            image: image || { src: '', alt: '', brightness: 100, blur: 0 },
+            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: '' },
+            slug,
+            authorId: userId,
+            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,
+        });
+    } catch (err: any) {
+        console.error('[BlogAPI] POST error:', err);
+        return NextResponse.json(
+            { error: 'Failed to create blog', 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> {
+    try {
+        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 isPublished = blog.publicationData?.status === 'published';
+        const isAuthor = userId && blog.authorId === userId;
+
+        if (!isPublished && !isAuthor) {
+            return NextResponse.json({ error: 'Access denied' }, { status: 403 });
+        }
+
+        return NextResponse.json({
+            ...blog,
+            _id: blog._id.toString(),
+        });
+    } catch (err: any) {
+        console.error('[BlogAPI] GET_BY_SLUG error:', err);
+        return NextResponse.json(
+            { error: 'Failed to fetch blog', 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> {
+    try {
+        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?.src?.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',
+                    imageSrc: image?.src?.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 }
+                );
+            }
+        }
+
+        // Slug logic
+        let finalSlug = slug;
+        if (isPublishing) {
+            finalSlug = slugify(title);
+        } else if (publicationData?.status === 'concept' && !slug.includes('-draft-')) {
+            finalSlug = `${slugify(title)}-draft-${Date.now().toString().slice(-4)}`;
+        }
+
+        // Update data
+        // 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';
+        }
+        
+        const updateData = {
+            title: title.trim(),
+            summary: (summary || '').trim(),
+            contentBlocks: contentBlocks || [],
+            content: content || [],
+            image: image || {},
+            categoryTags: {
+                category: categoryTags?.category?.trim() || '',
+                tags: categoryTags?.tags || [],
+            },
+            publicationData: {
+                ...publicationData,
+                status: finalStatus,
+                date: publicationData?.date ? new Date(publicationData.date) : new Date(),
+            },
+            seo: seo || {},
+            slug: finalSlug,
+            authorId: userId,
+            updatedAt: new Date(),
+        };
+
+        await blogs.updateOne({ slug }, { $set: updateData });
+
+        return NextResponse.json({
+            message: 'Blog updated successfully',
+            slug: finalSlug,
+        });
+    } catch (err: any) {
+        console.error('[BlogAPI] PUT_BY_SLUG error:', err);
+        return NextResponse.json(
+            { error: 'Failed to update blog', 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> {
+    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' });
+    } catch (err: any) {
+        console.error('[BlogAPI] DELETE_BY_SLUG error:', err);
+        return NextResponse.json(
+            { error: 'Failed to delete blog', detail: err.message },
+            { status: 500 }
+        );
+    }
+}
+

package/src/api/index.ts

@@ -0,0 +1,33 @@
+/**
+ * Blog API Exports
+ * RESTful API handlers for blog posts
+ */
+
+export {
+    GET,
+    POST,
+    PUT,
+    DELETE,
+    createBlogApiConfig,
+} from './route';
+
+export type { BlogApiConfig } from './handler';
+
+export {
+    GET as GET_HANDLER,
+    POST as POST_HANDLER,
+    GET_BY_SLUG,
+    PUT_BY_SLUG,
+    DELETE_BY_SLUG,
+} from './handler';
+
+// Router exports
+export { handleBlogApi } from './router';
+export type { BlogApiRouterConfig } from './router';
+
+// Categories handler
+export { GET as GET_CATEGORIES } from './categories';
+
+// Check title handler
+export { GET as GET_CHECK_TITLE } from './check-title';
+

package/src/api/route.ts

@@ -0,0 +1,116 @@
+/**
+ * Blog API Route Handler
+ * Server-only wrapper for the blog API handlers
+ * This file should ONLY be used in Next.js API routes
+ * 
+ * IMPORTANT: This file should ONLY be imported in server-side API routes.
+ * Do NOT import this in client-side code.
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import {
+    GET as handlerGET,
+    POST as handlerPOST,
+    GET_BY_SLUG,
+    PUT_BY_SLUG,
+    DELETE_BY_SLUG,
+    BlogApiConfig,
+} from './handler';
+
+/**
+ * Default configuration factory
+ * Client apps should provide their own config with MongoDB connection and auth
+ */
+export function createBlogApiConfig(config: BlogApiConfig): BlogApiConfig {
+    return config;
+}
+
+/**
+ * GET handler - List all blogs or get by slug
+ * Usage:
+ *   GET /api/blogs - List all
+ *   GET /api/blogs/[slug] - Get by slug
+ */
+export async function GET(
+    req: NextRequest,
+    context?: { params?: Promise<{ slug?: string }> },
+    config?: BlogApiConfig
+): Promise<NextResponse> {
+    if (!config) {
+        return NextResponse.json(
+            { error: 'Blog API config not provided' },
+            { status: 500 }
+        );
+    }
+
+    // Check if we have a slug parameter (single blog request)
+    if (context?.params) {
+        const { slug } = await context.params;
+        if (slug) {
+            return GET_BY_SLUG(req, slug, config);
+        }
+    }
+
+    // Otherwise, list all blogs
+    return handlerGET(req, config);
+}
+
+/**
+ * POST handler - Create new blog
+ * Usage: POST /api/blogs
+ */
+export async function POST(
+    req: NextRequest,
+    context?: any,
+    config?: BlogApiConfig
+): Promise<NextResponse> {
+    if (!config) {
+        return NextResponse.json(
+            { error: 'Blog API config not provided' },
+            { status: 500 }
+        );
+    }
+
+    return handlerPOST(req, config);
+}
+
+/**
+ * PUT handler - Update blog by slug
+ * Usage: PUT /api/blogs/[slug]
+ */
+export async function PUT(
+    req: NextRequest,
+    context: { params: Promise<{ slug: string }> },
+    config?: BlogApiConfig
+): Promise<NextResponse> {
+    if (!config) {
+        return NextResponse.json(
+            { error: 'Blog API config not provided' },
+            { status: 500 }
+        );
+    }
+
+    const { slug } = await context.params;
+    return PUT_BY_SLUG(req, slug, config);
+}
+
+/**
+ * DELETE handler - Delete blog by slug
+ * Usage: DELETE /api/blogs/[slug]
+ */
+export async function DELETE(
+    req: NextRequest,
+    context: { params: Promise<{ slug: string }> },
+    config?: BlogApiConfig
+): Promise<NextResponse> {
+    if (!config) {
+        return NextResponse.json(
+            { error: 'Blog API config not provided' },
+            { status: 500 }
+        );
+    }
+
+    const { slug } = await context.params;
+    return DELETE_BY_SLUG(req, slug, config);
+}
+

package/src/api/router.ts

@@ -0,0 +1,114 @@
+'use server';
+
+/**
+ * Plugin Blog API Router
+ * Centralized API handler for all blog plugin routes
+ * 
+ * This router handles requests to /api/plugin-blog/*
+ * and routes them to the appropriate handler
+ */
+
+import { NextRequest, NextResponse } from 'next/server';
+import { GET as BlogListHandler, POST as BlogCreateHandler } from './handler';
+import { GET as BlogGetHandler, PUT as BlogUpdateHandler, DELETE as BlogDeleteHandler, createBlogApiConfig } from './route';
+
+export interface BlogApiRouterConfig {
+    /** MongoDB client promise - 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;
+}
+
+/**
+ * Handle blog API requests
+ * Routes requests to appropriate handlers based on path
+ * Similar to plugin-dep, accepts config directly instead of requiring initialization
+ */
+export async function handleBlogApi(
+    req: NextRequest,
+    path: string[],
+    config: BlogApiRouterConfig
+): Promise<NextResponse> {
+    // Create the blog API config from the router config
+    const blogApiConfig = createBlogApiConfig({
+        getDb: config.getDb,
+        getUserId: config.getUserId,
+        collectionName: config.collectionName || 'blogs',
+    });
+    
+    const method = req.method;
+    // Handle empty path array - means we're at /api/plugin-blog
+    // Ensure path is always an array
+    const safePath = Array.isArray(path) ? path : [];
+    const route = safePath.length > 0 ? safePath[0] : '';
+
+    console.log(`[BlogApiRouter] method=${method}, path=${JSON.stringify(safePath)}, route=${route}, url=${req.url}`);
+    
+    try {
+        // Route: /api/plugin-blog (list/create) - empty path or 'list'
+        // This handles both /api/plugin-blog and /api/plugin-blog?limit=3
+        if (!route || route === 'list') {
+            if (method === 'GET') {
+                console.log('[BlogApiRouter] Routing to BlogListHandler');
+                return await BlogListHandler(req, blogApiConfig);
+            }
+            if (method === 'POST') {
+                return await BlogCreateHandler(req, blogApiConfig);
+            }
+            // Method not allowed for root route
+            return NextResponse.json(
+                { error: `Method ${method} not allowed for route: /` },
+                { status: 405 }
+            );
+        }
+        // Route: /api/plugin-blog/new (create new)
+        else if (route === 'new') {
+            if (method === 'POST') {
+                return await BlogCreateHandler(req, blogApiConfig);
+            }
+        }
+        // Route: /api/plugin-blog/categories (get categories)
+        else if (route === 'categories') {
+            if (method === 'GET') {
+                // Import categories handler
+                const categoriesModule = await import('./categories');
+                return await categoriesModule.GET(req, blogApiConfig);
+            }
+        }
+        // Route: /api/plugin-blog/check-title (check title duplicate)
+        else if (route === 'check-title') {
+            if (method === 'GET') {
+                const checkTitleModule = await import('./check-title');
+                return await checkTitleModule.GET(req, blogApiConfig);
+            }
+        }
+        // Route: /api/plugin-blog/[slug] (get/update/delete by slug)
+        else {
+            const slug = route;
+            if (method === 'GET') {
+                return await BlogGetHandler(req, { params: Promise.resolve({ slug }) }, blogApiConfig);
+            }
+            if (method === 'PUT') {
+                return await BlogUpdateHandler(req, { params: Promise.resolve({ slug }) }, blogApiConfig);
+            }
+            if (method === 'DELETE') {
+                return await BlogDeleteHandler(req, { params: Promise.resolve({ slug }) }, blogApiConfig);
+            }
+        }
+
+        // Method not allowed
+        return NextResponse.json(
+            { error: `Method ${method} not allowed for route: ${route || '/'}` },
+            { status: 405 }
+        );
+    } catch (error: any) {
+        console.error('[BlogApiRouter] Error:', error);
+        return NextResponse.json(
+            { error: error.message || 'Internal server error' },
+            { status: 500 }
+        );
+    }
+}
+

package/src/api-server.ts

@@ -0,0 +1,11 @@
+/**
+ * Plugin Blog - Server-Only API Exports
+ * This file is only imported in server-side code (API routes)
+ * 
+ * IMPORTANT: This file uses Node.js modules (fs, path, etc.) and should NEVER
+ * be imported in client-side code. Only use in server-side API routes.
+ */
+
+// Re-export everything from the API index
+export * from './api';
+