@jhits/plugin-newsletter 0.0.10 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhits/plugin-newsletter",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Newsletter management and email delivery plugin for the JHITS ecosystem",
   "publishConfig": {
     "access": "public"
@@ -30,7 +30,7 @@
     "mongodb": "^7.1.0",
     "next-auth": "^4.24.13",
     "nodemailer": "^8.0.1",
-    "@jhits/plugin-core": "0.0.8"
+    "@jhits/plugin-core": "0.0.9"
   },
   "peerDependencies": {
     "next": ">=15.0.0",
@@ -49,6 +49,7 @@
     "typescript": "^5.9.3"
   },
   "files": [
+    "src",
     "dist",
     "package.json",
     "templates",

package/src/api/email-utils.ts

@@ -0,0 +1,165 @@
+/**
+ * Email Utilities
+ */
+
+'use server';
+
+import { NewsletterApiConfig, NewsletterMetadata } from '../types/newsletter';
+import nodemailer from 'nodemailer';
+import path from 'path';
+import fs from 'fs';
+import handlebars from 'handlebars';
+import { GET_WELCOME_EMAIL_CONTENT } from './handlers/welcome-email';
+
+interface SmtpConfig {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    from: string;
+    fromName: string;
+    logoUrl?: string;
+}
+
+async function getSmtpConfig(config: NewsletterApiConfig): Promise<SmtpConfig | null> {
+    const dbConnection = await config.getDb();
+    const db = dbConnection.db();
+    const settings = db.collection('settings');
+    const smtpConfig = await settings.findOne({ key: 'smtp' });
+    
+    if (smtpConfig && smtpConfig.host) {
+        return {
+            host: smtpConfig.host,
+            port: smtpConfig.port || 465,
+            user: smtpConfig.user,
+            password: smtpConfig.password,
+            from: smtpConfig.from,
+            fromName: smtpConfig.fromName || '',
+            logoUrl: smtpConfig.logoUrl || '',
+        };
+    }
+    return null;
+}
+
+export async function sendWelcomeEmail(
+    config: NewsletterApiConfig,
+    email: string,
+    language: string,
+    host?: string
+): Promise<void> {
+    const smtpConfig = await getSmtpConfig(config);
+    if (!smtpConfig) return;
+
+    const { blocks, metadata } = await GET_WELCOME_EMAIL_CONTENT(undefined as any, config, language);
+    
+    const isDutch = language === 'nl';
+    const isSwedish = language === 'sv';
+    const baseUrl = host
+        ? (host.includes('localhost') ? 'http' : 'https') + '://' + host
+        : config.baseUrl || 'https://bya.jorishummel.com';
+
+    const slugs: Record<string, string> = {
+        sv: '/avmälla',
+        nl: '/afmelden',
+        en: '/unsubscribe',
+    };
+    const slug = slugs[language] || slugs.en;
+    const unsubscribeUrl = `${baseUrl}${slug}?email=${encodeURIComponent(email)}`;
+
+    try {
+        const transporter = nodemailer.createTransport({
+            host: smtpConfig.host,
+            port: smtpConfig.port,
+            secure: smtpConfig.port === 465,
+            auth: {
+                user: smtpConfig.user,
+                pass: smtpConfig.password,
+            },
+            connectionTimeout: 10000,
+        });
+
+        let html: string;
+        let subject: string;
+        let logoAttachment = undefined;
+        let logoSrc = smtpConfig.logoUrl || `${baseUrl}/logo_black.svg`;
+        
+        // If logoUrl is a data URL (base64), embed it as CID attachment
+        if (smtpConfig.logoUrl && smtpConfig.logoUrl.startsWith('data:')) {
+            const matches = smtpConfig.logoUrl.match(/^data:([^;]+);base64,(.+)$/);
+            if (matches) {
+                const mimeType = matches[1];
+                const base64Data = matches[2];
+                const ext = mimeType === 'image/png' ? 'png' : 'jpg';
+                logoAttachment = {
+                    filename: `logo.${ext}`,
+                    content: Buffer.from(base64Data, 'base64'),
+                    cid: 'logo',
+                    contentType: mimeType,
+                };
+                logoSrc = 'cid:logo';
+            }
+        }
+
+        if (blocks && blocks.length > 0) {
+            const { generateNewsletterEmailHtml } = await import('../lib/email/EmailRenderer');
+            
+            html = generateNewsletterEmailHtml(
+                blocks,
+                { subject: metadata?.subject || '', previewText: metadata?.previewText || '' },
+                {
+                    baseUrl,
+                    locale: language,
+                    logoUrl: logoSrc,
+                    unsubscribeUrl,
+                    footerText: `© ${new Date().getFullYear()} ${smtpConfig.fromName || 'Botanics & You'}`,
+                }
+            );
+            subject = metadata?.subject || (isDutch ? 'Welkom!' : isSwedish ? 'Välkommen!' : 'Welcome!');
+        } else {
+            const legacyTemplatePath = path.join(process.cwd(), 'node_modules', '@jhits', 'plugin-newsletter', 'templates', 'welcome-email-legacy.hbs');
+            let templateContent: string;
+
+            if (fs.existsSync(legacyTemplatePath)) {
+                templateContent = fs.readFileSync(legacyTemplatePath, 'utf-8');
+            } else {
+                const altPath = path.join(__dirname, '..', '..', '..', 'templates', 'welcome-email-legacy.hbs');
+                if (fs.existsSync(altPath)) {
+                    templateContent = fs.readFileSync(altPath, 'utf-8');
+                } else {
+                    console.error('[NewsletterAPI] Legacy email template not found');
+                    return;
+                }
+            }
+
+            const template = handlebars.compile(templateContent);
+            html = template({
+                fromName: smtpConfig.fromName || 'Botanics & You',
+                title: isDutch ? 'Fijn dat je er bent' : isSwedish ? 'Tack för att du är här' : "We're glad you're here",
+                message: isDutch 
+                    ? 'Bedankt dat je deel uitmaakt van de community. Wij geloven dat de natuur alles biedt wat we werkelijk nodig hebben.'
+                    : isSwedish
+                    ? 'Tack för att du är en del av vår community. Vi tror att naturen ger oss allt vi verkligen behöver.'
+                    : 'Thank you for joining our community. We believe that nature provides everything we truly need.',
+                unsubscribeUrl,
+                unsubscribeText: isDutch ? 'Afmelden' : isSwedish ? 'Avanmälan' : 'Unsubscribe',
+                tagline: isDutch ? 'Natuurlijk verbonden' : isSwedish ? 'Naturligt ansluten' : 'Naturally connected',
+                currentYear: new Date().getFullYear(),
+            });
+            subject = isDutch ? 'Welkom bij Botanics & You' : isSwedish ? 'Välkommen till Botanics & You' : 'Welcome to Botanics & You';
+        }
+
+        await transporter.sendMail({
+            from: smtpConfig.fromName 
+                ? `"${smtpConfig.fromName}" <${smtpConfig.from}>`
+                : smtpConfig.from,
+            to: email,
+            subject,
+            html,
+            ...(logoAttachment && {
+                attachments: [logoAttachment],
+            }),
+        });
+    } catch (error) {
+        console.error('[NewsletterAPI] Failed to send welcome email:', error);
+    }
+}

package/src/api/handler.ts

@@ -0,0 +1,28 @@
+/**
+ * Newsletter API Handler
+ * Re-exports all handler functions from handlers folder
+ */
+
+export {
+    GET_SUBSCRIBERS,
+    POST_SUBSCRIBE,
+    GET_SUBSCRIBER,
+    DELETE_SUBSCRIBER,
+    GET_SETTINGS,
+    POST_SETTINGS,
+    GET_NEWSLETTERS,
+    GET_NEWSLETTER,
+    POST_NEWSLETTER,
+    PUT_NEWSLETTER,
+    DELETE_NEWSLETTER,
+    GET_WELCOME_EMAIL_STATUS,
+    GET_WELCOME_EMAIL,
+    POST_WELCOME_EMAIL,
+    GET_SMTP_SETTINGS,
+    POST_SMTP_SETTINGS,
+    POST_TEST_EMAIL,
+    POST_LOGO_UPLOAD,
+    POST_SEND_NEWSLETTER,
+    GET_NEWSLETTER_FOR_SEND,
+    sendWelcomeEmail,
+} from './handlers';

package/src/api/handlers/index.ts

@@ -0,0 +1,44 @@
+/**
+ * API Handlers Index
+ * Re-exports all handler functions
+ */
+
+export {
+    GET_SUBSCRIBERS,
+    POST_SUBSCRIBE,
+    GET_SUBSCRIBER,
+    DELETE_SUBSCRIBER,
+} from './subscribers';
+
+export {
+    GET_SETTINGS,
+    POST_SETTINGS,
+    GET_SMTP_SETTINGS,
+    POST_SMTP_SETTINGS,
+    POST_TEST_EMAIL,
+} from './settings';
+
+export {
+    POST_LOGO_UPLOAD,
+} from './upload';
+
+export {
+    GET_NEWSLETTERS,
+    GET_NEWSLETTER,
+    POST_NEWSLETTER,
+    PUT_NEWSLETTER,
+    DELETE_NEWSLETTER,
+} from './newsletters';
+
+export {
+    POST_SEND_NEWSLETTER,
+    GET_NEWSLETTER_FOR_SEND,
+} from './send-newsletter';
+
+export {
+    GET_WELCOME_EMAIL_STATUS,
+    GET_WELCOME_EMAIL,
+    POST_WELCOME_EMAIL,
+} from './welcome-email';
+
+export { sendWelcomeEmail } from '../email-utils';

package/src/api/handlers/newsletters.ts

@@ -0,0 +1,332 @@
+/**
+ * Newsletter API Handler
+ */
+
+'use server';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { NewsletterApiConfig, Newsletter, NewsletterListItem } from '../../types/newsletter';
+import { generateSlugFromTitle } from '../../lib/utils/slugify';
+
+const ObjectId = require('mongodb').ObjectId;
+
+function getNewsletterFilter(idOrSlug: string) {
+    // Check if it's a valid MongoDB ObjectId
+    if (ObjectId.isValid(idOrSlug) && new ObjectId(idOrSlug).toString() === idOrSlug) {
+        return { _id: new ObjectId(idOrSlug) };
+    }
+    // Otherwise try by slug
+    return { slug: idOrSlug };
+}
+
+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);
+
+        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';
+
+        const query: any = {};
+        if (status) {
+            query['publication.status'] = status;
+        }
+
+        const filter = {
+            ...query,
+            $or: [
+                { hidden: { $exists: false } },
+                { hidden: { $eq: false } }
+            ]
+        };
+
+        const sort: any = {};
+        sort[sortBy] = sortOrder === 'asc' ? 1 : -1;
+
+        const newsletterList = await newsletters
+            .find(filter)
+            .sort(sort)
+            .limit(limit)
+            .skip(skip)
+            .toArray();
+
+        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,
+            hidden: newsletter.hidden,
+        }));
+
+        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 }
+        );
+    }
+}
+
+export async function GET_NEWSLETTER(
+    req: NextRequest,
+    idOrSlug: 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 filter = getNewsletterFilter(idOrSlug);
+        const newsletter = await newsletters.findOne(filter);
+        
+        if (!newsletter) {
+            return NextResponse.json(
+                { error: 'Newsletter not found' },
+                { status: 404 }
+            );
+        }
+
+        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 }
+        );
+    }
+}
+
+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;
+
+        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);
+
+        const finalTitle = (title?.trim() || metadata?.subject?.trim() || '').trim();
+        
+        // Generate slug for backwards compatibility, but id is primary
+        const existingNewsletters = await newsletters.find({}, { projection: { slug: 1 } }).toArray();
+        const existingSlugs = existingNewsletters.map((n: any) => n.slug).filter(Boolean);
+        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 }
+        );
+    }
+}
+
+export async function PUT_NEWSLETTER(
+    req: NextRequest,
+    idOrSlug: 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;
+
+        const errors: string[] = [];
+        if (!metadata?.subject || typeof metadata.subject !== 'string' || metadata.subject.trim().length === 0) {
+            errors.push('Subject is required');
+        }
+        
+        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);
+
+        const filter = getNewsletterFilter(idOrSlug);
+        const existing = await newsletters.findOne(filter);
+        if (!existing) {
+            return NextResponse.json(
+                { error: 'Newsletter not found' },
+                { status: 404 }
+            );
+        }
+
+        const updateData: any = {
+            title: finalTitle,
+            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(filter, { $set: updateData });
+
+        return NextResponse.json({
+            message: 'Newsletter updated successfully',
+            id: existing._id?.toString(),
+        });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] PUT_NEWSLETTER error:', error);
+        return NextResponse.json(
+            { error: 'Failed to update newsletter', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+export async function DELETE_NEWSLETTER(
+    req: NextRequest,
+    idOrSlug: 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 filter = getNewsletterFilter(idOrSlug);
+        const result = await newsletters.deleteOne(filter);
+        
+        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 }
+        );
+    }
+}