@jhits/plugin-blog 0.0.9 → 0.0.11

package/src/api/handler.ts

@@ -1,418 +0,0 @@
-/**
- * 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 { 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(isAdminView ? 0 : 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?.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';
-        }
-
-        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: '' },
-            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?.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 }
-                );
-            }
-        }
-
-        // 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

@@ -1,33 +0,0 @@
-/**
- * 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

@@ -1,116 +0,0 @@
-/**
- * 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

@@ -1,128 +0,0 @@
-'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';
-import { GET as ConfigGetHandler, POST as ConfigPostHandler } from './config-handler';
-
-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;
-    /** Site ID for multi-site setups */
-    siteId?: 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] : '';
-
-    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') {
-                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/config (get/save plugin config)
-        else if (route === 'config') {
-            const configApiConfig = {
-                getDb: config.getDb,
-                getUserId: config.getUserId,
-                siteId: config.siteId || 'default',
-            };
-            if (method === 'GET') {
-                return await ConfigGetHandler(req, configApiConfig);
-            }
-            if (method === 'POST') {
-                return await ConfigPostHandler(req, configApiConfig);
-            }
-        }
-        // 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 }
-        );
-    }
-}
-