@jhits/plugin-blog 0.0.1

package/src/config.ts

@@ -0,0 +1,161 @@
+/**
+ * Plugin Blog Configuration
+ * Automatically creates required API routes in client apps
+ */
+
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Automatically creates plugin-blog API catch-all route
+ * This route forwards requests to the plugin's API router
+ */
+/**
+ * @deprecated Routes are now handled by the unified /api/[pluginId]/[...path]/route.ts
+ * This function is kept for backwards compatibility but does nothing
+ */
+export function ensureBlogRoutes() {
+    // Routes are now handled by the unified /api/[pluginId]/[...path]/route.ts
+    // No need to generate individual routes anymore
+    return;
+    try {
+        // Find the host app directory (where next.config.ts is)
+        let appDir = process.cwd();
+        const possiblePaths = [
+            appDir,
+            join(appDir, '..'),
+            join(appDir, '..', '..'),
+        ];
+
+        for (const basePath of possiblePaths) {
+            const configPath = join(basePath, 'next.config.ts');
+            if (existsSync(configPath)) {
+                appDir = basePath;
+                break;
+            }
+        }
+
+        const apiDir = join(appDir, 'src', 'app', 'api');
+        const pluginBlogApiDir = join(apiDir, 'plugin-blog', '[...path]');
+        const pluginBlogApiPath = join(pluginBlogApiDir, 'route.ts');
+
+        // Check if route already exists
+        if (existsSync(pluginBlogApiPath)) {
+            const fs = require('fs');
+            const existingContent = fs.readFileSync(pluginBlogApiPath, 'utf8');
+            if (existingContent.includes('@jhits/plugin-blog') || existingContent.includes('plugin-blog')) {
+                // Already set up, skip
+                return;
+            }
+        }
+
+        // Create plugin-blog API catch-all route
+        mkdirSync(pluginBlogApiDir, { recursive: true });
+        writeFileSync(pluginBlogApiPath, `// Auto-generated by @jhits/plugin-blog - Blog Plugin API
+// This route is automatically created for the blog plugin
+import { NextRequest } from 'next/server';
+import { handleBlogApi } from '@jhits/plugin-blog/api';
+import { MongoClient } from 'mongodb';
+import { cookies } from 'next/headers';
+import jwt from 'jsonwebtoken';
+
+const JWT_SECRET = process.env.JWT_SECRET || 'secret';
+const MONGODB_URI = process.env.MONGODB_URI || process.env.MONGO_URI || '';
+
+// MongoDB client singleton
+let client: MongoClient | null = null;
+let clientPromise: Promise<MongoClient>;
+
+if (!MONGODB_URI) {
+    throw new Error('Please add MONGODB_URI to your .env.local file');
+}
+
+if (process.env.NODE_ENV === 'development') {
+    const globalWithMongo = global as typeof globalThis & {
+        _mongoClientPromise?: Promise<MongoClient>;
+    };
+
+    if (!globalWithMongo._mongoClientPromise) {
+        client = new MongoClient(MONGODB_URI);
+        globalWithMongo._mongoClientPromise = client.connect();
+    }
+    clientPromise = globalWithMongo._mongoClientPromise;
+} else {
+    client = new MongoClient(MONGODB_URI);
+    clientPromise = client.connect();
+}
+
+async function getUserId(req: NextRequest): Promise<string | null> {
+    try {
+        const cookieStore = await cookies();
+        const token = cookieStore.get('auth_token')?.value;
+        if (!token) return null;
+        const decoded = jwt.verify(token, JWT_SECRET) as { id: string };
+        return decoded.id;
+    } catch {
+        return null;
+    }
+}
+
+// Get the API config
+function getBlogApiConfig() {
+    return {
+        getDb: async () => {
+            const client = await clientPromise;
+            return { db: () => client.db() };
+        },
+        getUserId,
+        collectionName: 'blogs',
+    };
+}
+
+export async function GET(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    const { path } = await params;
+    const config = getBlogApiConfig();
+    return handleBlogApi(req, path, config);
+}
+
+export async function POST(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    const { path } = await params;
+    const config = getBlogApiConfig();
+    return handleBlogApi(req, path, config);
+}
+
+export async function PUT(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    ensureInitialized();
+    const { path } = await params;
+    return handleBlogApi(req, path);
+}
+
+export async function DELETE(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    ensureInitialized();
+    const { path } = await params;
+    return handleBlogApi(req, path);
+}
+
+export async function PATCH(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    ensureInitialized();
+    const { path } = await params;
+    return handleBlogApi(req, path);
+}
+`);
+    } catch (error) {
+        // Ignore errors - route might already exist or app structure is different
+        console.warn('[plugin-blog] Could not ensure blog routes:', error);
+    }
+}

package/src/hooks/README.md

@@ -0,0 +1,91 @@
+# Blog Plugin Hooks
+
+React hooks for fetching blog data in client applications.
+
+## useBlogs
+
+Fetch a list of blog posts with automatic loading and error handling.
+
+### Usage
+
+```tsx
+import { useBlogs } from '@jhits/plugin-blog';
+
+function MyComponent() {
+    const { blogs, loading, error, total, refetch } = useBlogs({
+        limit: 10,
+        skip: 0,
+        status: 'published',
+        admin: false,
+        apiBaseUrl: '/api/blogs',
+    });
+
+    if (loading) return <div>Loading...</div>;
+    if (error) return <div>Error: {error}</div>;
+
+    return (
+        <div>
+            {blogs.map(blog => (
+                <div key={blog.id}>
+                    <h2>{blog.title}</h2>
+                    <p>{blog.excerpt}</p>
+                </div>
+            ))}
+        </div>
+    );
+}
+```
+
+### Options
+
+- `limit` (number, default: 10): Maximum number of posts to fetch
+- `skip` (number, default: 0): Number of posts to skip (for pagination)
+- `status` (string, optional): Filter by status ('published', 'draft', 'concept')
+- `admin` (boolean, default: false): Whether to fetch all posts for admin (includes drafts)
+- `apiBaseUrl` (string, default: '/api/blogs'): API base URL
+
+### Returns
+
+- `blogs` (PostListItem[]): Array of blog posts
+- `loading` (boolean): Whether data is currently loading
+- `error` (string | null): Error message if fetch failed
+- `total` (number): Total number of posts available
+- `refetch` (function): Function to manually refetch blogs
+
+## useBlog
+
+Fetch a single blog post by slug.
+
+### Usage
+
+```tsx
+import { useBlog } from '@jhits/plugin-blog';
+
+function BlogPost({ slug }: { slug: string }) {
+    const { blog, loading, error, refetch } = useBlog({ slug });
+
+    if (loading) return <div>Loading...</div>;
+    if (error) return <div>Error: {error}</div>;
+    if (!blog) return <div>Post not found</div>;
+
+    return (
+        <article>
+            <h1>{blog.title}</h1>
+            <div>{/* Render blog content */}</div>
+        </article>
+    );
+}
+```
+
+### Options
+
+- `slug` (string, required): Blog post slug
+- `apiBaseUrl` (string, default: '/api/blogs'): API base URL
+
+### Returns
+
+- `blog` (BlogPost | null): Blog post data
+- `loading` (boolean): Whether data is currently loading
+- `error` (string | null): Error message if fetch failed
+- `refetch` (function): Function to manually refetch the blog post
+

package/src/hooks/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Blog Hooks
+ * React hooks for fetching blog data in client applications
+ */
+
+export { useBlogs, type UseBlogsOptions, type UseBlogsResult } from './useBlogs';
+export { useBlog, type UseBlogOptions, type UseBlogResult } from './useBlog';
+

package/src/hooks/useBlog.ts

@@ -0,0 +1,85 @@
+/**
+ * useBlog Hook
+ * React hook for fetching a single blog post by slug
+ */
+
+import { useState, useEffect } from 'react';
+import { apiToBlogPost, type APIBlogDocument } from '../lib/mappers/apiMapper';
+import { BlogPost } from '../types/post';
+
+export interface UseBlogOptions {
+    /** Blog post slug */
+    slug: string;
+    /** API base URL (default: '/api/blogs') */
+    apiBaseUrl?: string;
+}
+
+export interface UseBlogResult {
+    /** Blog post data */
+    blog: BlogPost | null;
+    /** Whether data is currently loading */
+    loading: boolean;
+    /** Error message if fetch failed */
+    error: string | null;
+    /** Function to refetch the blog post */
+    refetch: () => Promise<void>;
+}
+
+/**
+ * React hook to fetch a single blog post by slug
+ * 
+ * @example
+ * ```tsx
+ * const { blog, loading, error } = useBlog({ slug: 'my-blog-post' });
+ * ```
+ */
+export function useBlog(options: UseBlogOptions): UseBlogResult {
+    const { slug, apiBaseUrl = '/api/plugin-blog' } = options;
+
+    const [blog, setBlog] = useState<BlogPost | null>(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState<string | null>(null);
+
+    const fetchBlog = async () => {
+        if (!slug) {
+            setLoading(false);
+            return;
+        }
+
+        try {
+            setLoading(true);
+            setError(null);
+
+            const response = await fetch(`${apiBaseUrl}/${slug}`);
+
+            if (!response.ok) {
+                if (response.status === 404) {
+                    throw new Error('Blog post not found');
+                }
+                throw new Error(`Failed to fetch blog: ${response.status}`);
+            }
+
+            const apiDoc: APIBlogDocument = await response.json();
+            const blogPost = apiToBlogPost(apiDoc);
+            setBlog(blogPost);
+        } catch (err: any) {
+            console.error('[useBlog] Error fetching blog:', err);
+            setError(err.message || 'Failed to fetch blog');
+            setBlog(null);
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    useEffect(() => {
+        fetchBlog();
+    }, [slug, apiBaseUrl]);
+
+    return {
+        blog,
+        loading,
+        error,
+        refetch: fetchBlog,
+    };
+}
+

package/src/hooks/useBlogs.ts

@@ -0,0 +1,123 @@
+/**
+ * useBlogs Hook
+ * React hook for fetching blog posts in client applications
+ */
+
+import { useState, useEffect } from 'react';
+import { apiToBlogPost, type APIBlogDocument } from '../lib/mappers/apiMapper';
+import { PostListItem } from '../types/post';
+
+export interface UseBlogsOptions {
+    /** Maximum number of posts to fetch (default: 10) */
+    limit?: number;
+    /** Number of posts to skip (default: 0) */
+    skip?: number;
+    /** Filter by status (published, draft, concept) */
+    status?: string;
+    /** Whether to fetch all posts for admin (includes drafts) */
+    admin?: boolean;
+    /** API base URL (default: '/api/blogs') */
+    apiBaseUrl?: string;
+}
+
+export interface UseBlogsResult {
+    /** Array of blog posts */
+    blogs: PostListItem[];
+    /** Whether data is currently loading */
+    loading: boolean;
+    /** Error message if fetch failed */
+    error: string | null;
+    /** Total number of posts available */
+    total: number;
+    /** Function to refetch blogs */
+    refetch: () => Promise<void>;
+}
+
+/**
+ * React hook to fetch blog posts
+ * 
+ * @example
+ * ```tsx
+ * const { blogs, loading, error } = useBlogs({ limit: 5 });
+ * ```
+ */
+export function useBlogs(options: UseBlogsOptions = {}): UseBlogsResult {
+    const {
+        limit = 10,
+        skip = 0,
+        status,
+        admin = false,
+        apiBaseUrl = '/api/plugin-blog',
+    } = options;
+
+    const [blogs, setBlogs] = useState<PostListItem[]>([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState<string | null>(null);
+    const [total, setTotal] = useState(0);
+
+    const fetchBlogs = async () => {
+        try {
+            setLoading(true);
+            setError(null);
+
+            const params = new URLSearchParams();
+            if (limit) params.set('limit', limit.toString());
+            if (skip) params.set('skip', skip.toString());
+            if (status) params.set('status', status);
+            if (admin) params.set('admin', 'true');
+
+            const url = `${apiBaseUrl}?${params.toString()}`;
+            const response = await fetch(url);
+
+            if (!response.ok) {
+                throw new Error(`Failed to fetch blogs: ${response.status}`);
+            }
+
+            const data = await response.json();
+            
+            // Handle error response
+            if (data.error) {
+                throw new Error(data.error || 'Failed to fetch blogs');
+            }
+            
+            // Convert API format to PostListItem format
+            const blogsArray = Array.isArray(data.blogs) ? data.blogs : [];
+            const convertedBlogs: PostListItem[] = blogsArray.map((apiDoc: APIBlogDocument) => {
+                const blogPost = apiToBlogPost(apiDoc);
+                return {
+                    id: blogPost.id,
+                    title: blogPost.title,
+                    slug: blogPost.slug,
+                    excerpt: blogPost.metadata.excerpt || '',
+                    status: blogPost.publication.status,
+                    authorId: blogPost.publication.authorId || '',
+                    updatedAt: blogPost.updatedAt,
+                    featuredImage: blogPost.metadata.featuredImage,
+                };
+            });
+
+            setBlogs(convertedBlogs);
+            setTotal(data.total || convertedBlogs.length);
+        } catch (err: any) {
+            console.error('[useBlogs] Error fetching blogs:', err);
+            setError(err.message || 'Failed to fetch blogs');
+            setBlogs([]);
+            setTotal(0);
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    useEffect(() => {
+        fetchBlogs();
+    }, [limit, skip, status, admin, apiBaseUrl]);
+
+    return {
+        blogs,
+        loading,
+        error,
+        total,
+        refetch: fetchBlogs,
+    };
+}
+

package/src/index.server.ts

@@ -0,0 +1,12 @@
+/**
+ * Plugin Blog - Server-Only Entry Point
+ * This file exports only server-side API handlers
+ * Used by the dynamic plugin router via @jhits/plugin-blog/server
+ * 
+ * Note: This file is server-only (no 'use server' needed - that's only for Server Actions)
+ */
+
+export { handleBlogApi as handleApi } from './api/router';
+export { handleBlogApi } from './api/router'; // Keep original export for backward compatibility
+export type { BlogApiRouterConfig } from './api/router';
+