@jhits/plugin-newsletter 0.0.4 → 0.0.5

package/package.json

@@ -1,29 +1,28 @@
 {
   "name": "@jhits/plugin-newsletter",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Newsletter management and email delivery plugin for the JHITS ecosystem",
   "publishConfig": {
     "access": "public"
   },
-  "main": "./src/index.tsx",
-  "types": "./src/index.tsx",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/index.tsx",
-      "default": "./src/index.tsx"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./server": {
-      "types": "./src/index.server.ts",
-      "default": "./src/index.server.ts"
+      "types": "./dist/index.server.d.ts",
+      "default": "./dist/index.server.js"
     }
   },
   "dependencies": {
-    "@jhits/plugin-core": "^0.0.1",
-    "lucide-react": "^0.562.0",
-    "mongodb": "^7.0.0",
+    "@jhits/plugin-core": "^0.0.2",
+    "lucide-react": "^0.564.0",
+    "mongodb": "^7.1.0",
     "next-auth": "^4.24.13",
-    "nodemailer": "^7.0.12",
-    "server-only": "^0.0.1"
+    "nodemailer": "^8.0.1"
   },
   "peerDependencies": {
     "next": ">=15.0.0",
@@ -31,19 +30,21 @@
     "react-dom": ">=18.0.0"
   },
   "devDependencies": {
-    "@types/node": "^20.19.27",
-    "@types/nodemailer": "^7.0.4",
-    "@types/react": "^19",
-    "@types/react-dom": "^19",
-    "next": "16.1.1",
-    "react": "19.2.3",
-    "react-dom": "19.2.3",
-    "typescript": "^5"
+    "@types/node": "^25.2.3",
+    "@types/nodemailer": "^7.0.9",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "next": "16.1.6",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "typescript": "^5.9.3"
   },
   "files": [
-    "src/**/*.{ts,tsx,json}",
-    "!src/**/*.md",
-    "!src/**/README.md",
+    "dist",
+    "src",
     "package.json"
-  ]
-}
+  ],
+  "scripts": {
+    "build": "tsc"
+  }
+}

package/src/api/handler.ts

@@ -6,7 +6,8 @@
 'use server';
 
 import { NextRequest, NextResponse } from 'next/server';
-import { NewsletterApiConfig } from '../types/newsletter';
+import { NewsletterApiConfig, Newsletter, NewsletterListItem } from '../types/newsletter';
+import { generateSlugFromTitle } from '../lib/utils/slugify';
 import nodemailer from 'nodemailer';
 
 /**
@@ -352,3 +353,341 @@ async function sendWelcomeEmail(
     }
 }
 
+/**
+ * GET /api/plugin-newsletter/newsletters - List all newsletters
+ */
+export async function GET_NEWSLETTERS(
+    req: NextRequest,
+    config: NewsletterApiConfig
+): 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 collectionName = config.collectionName || 'newsletters';
+        const newsletters = db.collection(collectionName);
+
+        // Get query parameters
+        const { searchParams } = new URL(req.url);
+        const status = searchParams.get('status');
+        const limit = parseInt(searchParams.get('limit') || '50', 10);
+        const skip = parseInt(searchParams.get('skip') || '0', 10);
+        const sortBy = searchParams.get('sortBy') || 'updatedAt';
+        const sortOrder = searchParams.get('sortOrder') || 'desc';
+
+        // Build query
+        const query: any = {};
+        if (status) {
+            query['publication.status'] = status;
+        }
+
+        // Build sort
+        const sort: any = {};
+        sort[sortBy] = sortOrder === 'asc' ? 1 : -1;
+
+        const newsletterList = await newsletters
+            .find(query)
+            .sort(sort)
+            .limit(limit)
+            .skip(skip)
+            .toArray();
+
+        // Convert to list items
+        const listItems: NewsletterListItem[] = newsletterList.map((newsletter: any) => ({
+            id: newsletter._id?.toString() || newsletter.id,
+            title: newsletter.title,
+            slug: newsletter.slug,
+            status: newsletter.publication?.status || 'draft',
+            subject: newsletter.metadata?.subject || '',
+            scheduledDate: newsletter.publication?.scheduledDate,
+            sentDate: newsletter.publication?.sentDate,
+            authorId: newsletter.publication?.authorId,
+            updatedAt: newsletter.updatedAt || newsletter.createdAt,
+            recipientCount: newsletter.recipientCount,
+        }));
+
+        return NextResponse.json(listItems);
+    } catch (error: any) {
+        console.error('[NewsletterAPI] GET_NEWSLETTERS error:', error);
+        return NextResponse.json(
+            { error: 'Failed to fetch newsletters', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+/**
+ * GET /api/plugin-newsletter/newsletters/[slug] - Get specific newsletter
+ */
+export async function GET_NEWSLETTER(
+    req: NextRequest,
+    slug: string,
+    config: NewsletterApiConfig
+): 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 collectionName = config.collectionName || 'newsletters';
+        const newsletters = db.collection(collectionName);
+
+        const newsletter = await newsletters.findOne({ slug });
+        if (!newsletter) {
+            return NextResponse.json(
+                { error: 'Newsletter not found' },
+                { status: 404 }
+            );
+        }
+
+        // Convert MongoDB document to Newsletter format
+        const result: Newsletter = {
+            id: newsletter._id?.toString() || newsletter.id,
+            title: newsletter.title,
+            slug: newsletter.slug,
+            blocks: newsletter.blocks || [],
+            metadata: newsletter.metadata || {
+                subject: '',
+                previewText: '',
+                lang: 'en',
+                recipientFilter: { type: 'all' },
+            },
+            publication: newsletter.publication || {
+                status: 'draft',
+                updatedAt: new Date().toISOString(),
+            },
+            createdAt: newsletter.createdAt || new Date().toISOString(),
+            updatedAt: newsletter.updatedAt || new Date().toISOString(),
+            version: newsletter.version,
+        };
+
+        return NextResponse.json(result);
+    } catch (error: any) {
+        console.error('[NewsletterAPI] GET_NEWSLETTER error:', error);
+        return NextResponse.json(
+            { error: 'Failed to fetch newsletter', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+/**
+ * POST /api/plugin-newsletter/newsletters/new - Create new newsletter
+ */
+export async function POST_NEWSLETTER(
+    req: NextRequest,
+    config: NewsletterApiConfig
+): 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, blocks, metadata, publication } = body;
+
+        // Validation
+        const errors: string[] = [];
+        if (!title || typeof title !== 'string' || title.trim().length === 0) {
+            errors.push('Title is required');
+        }
+        if (!metadata?.subject || typeof metadata.subject !== 'string' || metadata.subject.trim().length === 0) {
+            errors.push('Subject is required');
+        }
+
+        if (errors.length > 0) {
+            return NextResponse.json({ message: errors[0], allErrors: errors }, { status: 400 });
+        }
+
+        const dbConnection = await config.getDb();
+        const db = dbConnection.db();
+        const collectionName = config.collectionName || 'newsletters';
+        const newsletters = db.collection(collectionName);
+
+        // Get existing slugs for collision check
+        const existingNewsletters = await newsletters.find({}, { projection: { slug: 1 } }).toArray();
+        const existingSlugs = existingNewsletters.map((n: any) => n.slug).filter(Boolean);
+
+        // Use subject as title if title is empty
+        const finalTitle = (title?.trim() || metadata?.subject?.trim() || '').trim();
+        
+        // Generate slug
+        const slug = generateSlugFromTitle(finalTitle, existingSlugs);
+
+        const newsletterDocument = {
+            title: finalTitle,
+            slug,
+            blocks: blocks || [],
+            metadata: {
+                subject: metadata.subject.trim(),
+                previewText: metadata.previewText?.trim() || '',
+                lang: metadata.lang || 'en',
+                recipientFilter: metadata.recipientFilter || { type: 'all' },
+            },
+            publication: {
+                status: publication?.status || 'draft',
+                scheduledDate: publication?.scheduledDate,
+                authorId: userId,
+                updatedAt: new Date().toISOString(),
+            },
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            version: 1,
+        };
+
+        const result = await newsletters.insertOne(newsletterDocument);
+
+        return NextResponse.json({
+            message: 'Newsletter created successfully',
+            id: result.insertedId.toString(),
+            slug,
+        }, { status: 201 });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] POST_NEWSLETTER error:', error);
+        return NextResponse.json(
+            { error: 'Failed to create newsletter', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+/**
+ * PUT /api/plugin-newsletter/newsletters/[slug] - Update existing newsletter
+ */
+export async function PUT_NEWSLETTER(
+    req: NextRequest,
+    slug: string,
+    config: NewsletterApiConfig
+): 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, blocks, metadata, publication } = body;
+
+        // Validation
+        // For newsletters, subject is required and can serve as title
+        const errors: string[] = [];
+        if (!metadata?.subject || typeof metadata.subject !== 'string' || metadata.subject.trim().length === 0) {
+            errors.push('Subject is required');
+        }
+        
+        // Use subject as title if title is empty (for newsletters, subject is the primary identifier)
+        const finalTitle = (title?.trim() || metadata?.subject?.trim() || '').trim();
+        if (!finalTitle) {
+            errors.push('Title is required (use subject if no title is provided)');
+        }
+
+        if (errors.length > 0) {
+            return NextResponse.json({ message: errors[0], allErrors: errors }, { status: 400 });
+        }
+
+        const dbConnection = await config.getDb();
+        const db = dbConnection.db();
+        const collectionName = config.collectionName || 'newsletters';
+        const newsletters = db.collection(collectionName);
+
+        // Check if newsletter exists
+        const existing = await newsletters.findOne({ slug });
+        if (!existing) {
+            return NextResponse.json(
+                { error: 'Newsletter not found' },
+                { status: 404 }
+            );
+        }
+
+        // Generate new slug if title changed
+        let newSlug = slug;
+        if (finalTitle !== existing.title) {
+            const existingNewsletters = await newsletters.find({ _id: { $ne: existing._id } }, { projection: { slug: 1 } }).toArray();
+            const existingSlugs = existingNewsletters.map((n: any) => n.slug).filter(Boolean);
+            newSlug = generateSlugFromTitle(finalTitle, existingSlugs);
+        }
+
+        // Update newsletter
+        const updateData: any = {
+            title: finalTitle,
+            slug: newSlug,
+            blocks: blocks || [],
+            metadata: {
+                subject: metadata.subject.trim(),
+                previewText: metadata.previewText?.trim() || '',
+                lang: metadata.lang || 'en',
+                recipientFilter: metadata.recipientFilter || { type: 'all' },
+            },
+            publication: {
+                ...existing.publication,
+                status: publication?.status || existing.publication?.status || 'draft',
+                scheduledDate: publication?.scheduledDate,
+                authorId: userId,
+                updatedAt: new Date().toISOString(),
+            },
+            updatedAt: new Date(),
+            version: (existing.version || 1) + 1,
+        };
+
+        await newsletters.updateOne(
+            { slug },
+            { $set: updateData }
+        );
+
+        return NextResponse.json({
+            message: 'Newsletter updated successfully',
+            slug: newSlug,
+        });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] PUT_NEWSLETTER error:', error);
+        return NextResponse.json(
+            { error: 'Failed to update newsletter', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+/**
+ * DELETE /api/plugin-newsletter/newsletters/[slug] - Delete newsletter
+ */
+export async function DELETE_NEWSLETTER(
+    req: NextRequest,
+    slug: string,
+    config: NewsletterApiConfig
+): 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 collectionName = config.collectionName || 'newsletters';
+        const newsletters = db.collection(collectionName);
+
+        const result = await newsletters.deleteOne({ slug });
+        if (result.deletedCount === 0) {
+            return NextResponse.json(
+                { error: 'Newsletter not found' },
+                { status: 404 }
+            );
+        }
+
+        return NextResponse.json({ message: 'Newsletter deleted successfully' });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] DELETE_NEWSLETTER error:', error);
+        return NextResponse.json(
+            { error: 'Failed to delete newsletter', detail: error.message },
+            { status: 500 }
+        );
+    }
+}

package/src/api/router.ts

@@ -14,6 +14,11 @@ import {
     DELETE_SUBSCRIBER,
     GET_SETTINGS,
     POST_SETTINGS,
+    GET_NEWSLETTERS,
+    GET_NEWSLETTER,
+    POST_NEWSLETTER,
+    PUT_NEWSLETTER,
+    DELETE_NEWSLETTER,
 } from './handler';
 
 /**
@@ -60,6 +65,36 @@ export async function handleNewsletterApi(
             }
         }
 
+        // Route: /api/plugin-newsletter/newsletters
+        if (route === 'newsletters') {
+            // Special route: /api/plugin-newsletter/newsletters/new
+            if (path[1] === 'new' && method === 'POST') {
+                return await POST_NEWSLETTER(req, config);
+            }
+            
+            if (path[1]) {
+                // /api/plugin-newsletter/newsletters/[slug]
+                const newsletterSlug = decodeURIComponent(path[1]);
+                if (method === 'GET') {
+                    return await GET_NEWSLETTER(req, newsletterSlug, config);
+                }
+                if (method === 'PUT') {
+                    return await PUT_NEWSLETTER(req, newsletterSlug, config);
+                }
+                if (method === 'DELETE') {
+                    return await DELETE_NEWSLETTER(req, newsletterSlug, config);
+                }
+            } else {
+                // /api/plugin-newsletter/newsletters
+                if (method === 'GET') {
+                    return await GET_NEWSLETTERS(req, config);
+                }
+                if (method === 'POST') {
+                    return await POST_NEWSLETTER(req, config);
+                }
+            }
+        }
+
         // Method not allowed
         return NextResponse.json(
             { error: `Method ${method} not allowed for route: ${route || '/'}` },