@jhits/plugin-newsletter 0.0.10 → 0.0.11

package/src/api/handlers/send-newsletter.ts

@@ -0,0 +1,288 @@
+/**
+ * Send Newsletter API Handler
+ */
+
+'use server';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { NewsletterApiConfig } from '../../types/newsletter';
+import nodemailer from 'nodemailer';
+import path from 'path';
+import fs from 'fs';
+
+const ObjectId = require('mongodb').ObjectId;
+
+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;
+}
+
+function getNewsletterFilter(idOrSlug: string) {
+    if (ObjectId.isValid(idOrSlug) && new ObjectId(idOrSlug).toString() === idOrSlug) {
+        return { _id: new ObjectId(idOrSlug) };
+    }
+    return { slug: idOrSlug };
+}
+
+export async function POST_SEND_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 { testEmail, language = 'en' } = body;
+        const isTest = !!testEmail;
+
+        const dbConnection = await config.getDb();
+        const db = dbConnection.db();
+        const newsletters = db.collection('newsletters');
+        const subscribers = db.collection('subscribers');
+
+        const filter = getNewsletterFilter(idOrSlug);
+        const newsletter = await newsletters.findOne(filter);
+
+        if (!newsletter) {
+            return NextResponse.json(
+                { error: 'Newsletter not found' },
+                { status: 404 }
+            );
+        }
+
+        const blocks = newsletter.blocks || [];
+        const metadata = newsletter.metadata || {};
+
+        if (!blocks || blocks.length === 0) {
+            return NextResponse.json(
+                { error: 'Newsletter has no content' },
+                { status: 400 }
+            );
+        }
+
+        let smtpConfig = await getSmtpConfig(config);
+
+        if (!smtpConfig || !smtpConfig.host || !smtpConfig.user || !smtpConfig.from) {
+            return NextResponse.json(
+                { error: 'SMTP not configured. Please configure SMTP settings first.' },
+                { status: 400 }
+            );
+        }
+
+        const transporter = nodemailer.createTransport({
+            host: smtpConfig.host,
+            port: smtpConfig.port,
+            secure: smtpConfig.port === 465,
+            auth: {
+                user: smtpConfig.user,
+                pass: smtpConfig.password,
+            },
+            connectionTimeout: 30000,
+        });
+
+        const baseUrl = config.baseUrl || 'http://localhost:3001';
+        
+        let logoAttachment: any = undefined;
+        let logoSrc = smtpConfig.logoUrl || `${baseUrl}/logo_black.svg`;
+        
+        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';
+            }
+        }
+
+        const { generateNewsletterEmailHtml } = await import('../../lib/email/EmailRenderer');
+
+        const slugs: Record<string, string> = {
+            sv: '/avmälla',
+            nl: '/afmelden',
+            en: '/unsubscribe',
+        };
+        const slug = slugs[language] || slugs.en;
+
+        let recipientEmails: string[] = [];
+        let recipientCount = 0;
+
+        if (isTest) {
+            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+            if (!emailRegex.test(testEmail)) {
+                return NextResponse.json({ error: 'Invalid test email address' }, { status: 400 });
+            }
+            recipientEmails = [testEmail];
+            recipientCount = 1;
+        } else {
+            const subscriberList = await subscribers.find({ status: 'active' }).toArray();
+            recipientEmails = subscriberList.map((s: any) => s.email);
+            recipientCount = recipientEmails.length;
+
+            if (recipientCount === 0) {
+                return NextResponse.json(
+                    { error: 'No active subscribers found' },
+                    { status: 400 }
+                );
+            }
+        }
+
+        const subject = metadata.subject || 'Newsletter';
+        
+        const recipientsWithUrls = await Promise.all(
+            recipientEmails.map(async (email) => {
+                const subscriber = isTest ? null : await subscribers.findOne({ email });
+                const subscriberLang = subscriber?.language || language;
+                const subscriberSlug = slugs[subscriberLang] || slugs.en;
+                const unsubscribeUrl = `${baseUrl}${subscriberSlug}?email=${encodeURIComponent(email)}`;
+                
+                return { email, unsubscribeUrl };
+            })
+        );
+
+        let successCount = 0;
+        let failedCount = 0;
+
+        for (const { email, unsubscribeUrl } of recipientsWithUrls) {
+            try {
+                const html = generateNewsletterEmailHtml(
+                    blocks,
+                    { subject: metadata.subject || '', previewText: metadata.previewText || '' },
+                    {
+                        baseUrl,
+                        locale: language,
+                        logoUrl: logoSrc,
+                        unsubscribeUrl,
+                        footerText: `© ${new Date().getFullYear()} ${smtpConfig.fromName || 'Botanics & You'}`,
+                    }
+                );
+
+                await transporter.sendMail({
+                    from: smtpConfig.fromName
+                        ? `"${smtpConfig.fromName}" <${smtpConfig.from}>`
+                        : smtpConfig.from,
+                    to: email,
+                    subject,
+                    html,
+                    ...(logoAttachment && {
+                        attachments: [logoAttachment],
+                    }),
+                });
+                successCount++;
+            } catch (err) {
+                console.error(`Failed to send email to ${email}:`, err);
+                failedCount++;
+            }
+        }
+
+        if (!isTest && successCount > 0) {
+            await newsletters.updateOne(filter, {
+                $set: {
+                    'publication.status': 'sent',
+                    'publication.sentDate': new Date().toISOString(),
+                    'publication.recipientCount': successCount,
+                    updatedAt: new Date().toISOString(),
+                }
+            });
+        }
+
+        return NextResponse.json({
+            success: true,
+            message: isTest 
+                ? `Test newsletter sent to ${testEmail}`
+                : `Newsletter sent to ${successCount} subscriber${successCount !== 1 ? 's' : ''}${failedCount > 0 ? ` (${failedCount} failed)` : ''}`,
+            details: {
+                successCount,
+                failedCount,
+                totalRecipients: recipientCount,
+                isTest,
+            }
+        });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] POST_SEND_NEWSLETTER error:', error);
+        return NextResponse.json(
+            { error: 'Failed to send newsletter', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+export async function GET_NEWSLETTER_FOR_SEND(
+    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 newsletters = db.collection('newsletters');
+        const subscribers = db.collection('subscribers');
+
+        const filter = getNewsletterFilter(idOrSlug);
+        const newsletter = await newsletters.findOne(filter);
+
+        if (!newsletter) {
+            return NextResponse.json(
+                { error: 'Newsletter not found' },
+                { status: 404 }
+            );
+        }
+
+        const subscriberCount = await subscribers.countDocuments({ status: 'active' });
+
+        return NextResponse.json({
+            id: newsletter._id?.toString() || newsletter.id,
+            title: newsletter.title,
+            subject: newsletter.metadata?.subject || '',
+            status: newsletter.publication?.status || 'draft',
+            hasContent: (newsletter.blocks?.length || 0) > 0,
+            subscriberCount,
+        });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] GET_NEWSLETTER_FOR_SEND error:', error);
+        return NextResponse.json(
+            { error: 'Failed to fetch newsletter', detail: error.message },
+            { status: 500 }
+        );
+    }
+}

package/src/api/handlers/settings.ts

@@ -0,0 +1,403 @@
+/**
+ * Settings API Handler
+ */
+
+'use server';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { NewsletterApiConfig, NewsletterSettings } from '../../types/newsletter';
+import nodemailer from 'nodemailer';
+import path from 'path';
+import fs from 'fs';
+import handlebars from 'handlebars';
+import { getTestEmailTranslations } from '../../lib/i18n';
+
+async function getWelcomeEmail(config: NewsletterApiConfig) {
+    const dbConnection = await config.getDb();
+    const db = dbConnection.db();
+    const newsletters = db.collection('newsletters');
+
+    const welcomeEmail = await newsletters.findOne({
+        type: 'welcome_email',
+        id: 'welcome_automation'
+    });
+
+    return welcomeEmail || null;
+}
+
+export async function GET_SETTINGS(
+    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 newsletters = db.collection('newsletters');
+
+        const settings = await newsletters.findOne({ id: 'welcome_automation' });
+        return NextResponse.json(settings || {
+            id: 'welcome_automation',
+            languages: {
+                nl: { title: '', message: '' },
+                en: { title: '', message: '' },
+                sv: { title: '', message: '' },
+            },
+        });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] GET_SETTINGS error:', error);
+        return NextResponse.json(
+            { error: 'Failed to fetch settings', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+export async function POST_SETTINGS(
+    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 dbConnection = await config.getDb();
+        const db = dbConnection.db();
+        const newsletters = db.collection('newsletters');
+
+        await newsletters.updateOne(
+            { id: 'welcome_automation' },
+            {
+                $set: {
+                    id: 'welcome_automation',
+                    languages: body.languages || {},
+                    updatedAt: new Date(),
+                },
+            },
+            { upsert: true }
+        );
+
+        return NextResponse.json({ success: true, message: 'Settings updated successfully' });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] POST_SETTINGS error:', error);
+        return NextResponse.json(
+            { error: 'Failed to update settings', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+export async function GET_SMTP_SETTINGS(
+    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 settings = db.collection('settings');
+
+        const smtpConfig = await settings.findOne({ key: 'smtp' });
+
+        if (!smtpConfig) {
+            return NextResponse.json({
+                host: '',
+                port: 465,
+                user: '',
+                password: '',
+                from: '',
+                fromName: '',
+                primaryLanguage: 'en',
+                logoUrl: '',
+            });
+        }
+
+        return NextResponse.json({
+            host: smtpConfig.host || '',
+            port: smtpConfig.port || 465,
+            user: smtpConfig.user || '',
+            password: smtpConfig.password || '',
+            from: smtpConfig.from || '',
+            fromName: smtpConfig.fromName || '',
+            primaryLanguage: smtpConfig.primaryLanguage || 'en',
+            logoUrl: smtpConfig.logoUrl || '',
+        });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] GET_SMTP_SETTINGS error:', error);
+        return NextResponse.json(
+            { error: 'Failed to fetch SMTP settings', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+export async function POST_SMTP_SETTINGS(
+    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();
+
+        if (!body.host || !body.user || !body.from) {
+            return NextResponse.json(
+                { error: 'Host, user, and from address are required' },
+                { status: 400 }
+            );
+        }
+
+        const dbConnection = await config.getDb();
+        const db = dbConnection.db();
+        const settings = db.collection('settings');
+
+        await settings.updateOne(
+            { key: 'smtp' },
+            {
+                $set: {
+                    key: 'smtp',
+                    host: body.host,
+                    port: body.port || 465,
+                    user: body.user,
+                    password: body.password,
+                    from: body.from,
+                    fromName: body.fromName || '',
+                    primaryLanguage: body.primaryLanguage || 'en',
+                    logoUrl: body.logoUrl || '',
+                    updatedAt: new Date(),
+                    updatedBy: userId,
+                },
+            },
+            { upsert: true }
+        );
+
+        return NextResponse.json({ success: true, message: 'SMTP settings saved successfully' });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] POST_SMTP_SETTINGS error:', error);
+        return NextResponse.json(
+            { error: 'Failed to save SMTP settings', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+function getSmtpConfigFromDb(config: NewsletterApiConfig): Promise<{ host: string; port: number; user: string; password: string; from: string; fromName: string; logoUrl: string } | null> {
+    return (async () => {
+        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 POST_TEST_EMAIL(
+    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 { email, language = 'en', emailType = 'test' } = body;
+
+        if (!email) {
+            return NextResponse.json({ error: 'Email address is required' }, { status: 400 });
+        }
+
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        if (!emailRegex.test(email)) {
+            return NextResponse.json({ error: 'Invalid email address' }, { status: 400 });
+        }
+
+        let smtpConfig = await getSmtpConfigFromDb(config);
+
+        if (!smtpConfig || !smtpConfig.host || !smtpConfig.user || !smtpConfig.from) {
+            return NextResponse.json(
+                { error: 'SMTP not configured. Please configure SMTP settings first.' },
+                { status: 400 }
+            );
+        }
+
+        const transporter = nodemailer.createTransport({
+            host: smtpConfig.host,
+            port: smtpConfig.port,
+            secure: smtpConfig.port === 465,
+            auth: {
+                user: smtpConfig.user,
+                pass: smtpConfig.password,
+            },
+            connectionTimeout: 10000,
+        });
+
+        const logoPath = path.join(process.cwd(), 'node_modules', '@jhits', 'plugin-newsletter', 'templates', 'logo.png');
+        let logoExists = fs.existsSync(logoPath);
+
+        if (!logoExists) {
+            const altPath = path.join(__dirname, '..', '..', '..', '..', 'templates', 'logo.png');
+            logoExists = fs.existsSync(altPath);
+        }
+
+        const baseUrl = config.baseUrl || 'http://localhost:3001';
+        
+        let logoAttachment: any = undefined;
+        let logoSrc = smtpConfig.logoUrl || `${baseUrl}/logo_black.svg`;
+        
+        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';
+            }
+        }
+
+        let html: string;
+        let subject: string;
+
+        if (emailType === 'welcome') {
+            const dbConnection = await config.getDb();
+            const db = dbConnection.db();
+            const newsletters = db.collection('newsletters');
+
+            const welcomeEmail = await newsletters.findOne({
+                type: 'welcome_email',
+                id: 'welcome_automation'
+            });
+
+            const languages = welcomeEmail?.languages as Record<string, { blocks: any[]; metadata: any }> | undefined;
+            const langContent = languages?.[language];
+            const defaultContent = languages?.en || { blocks: [], metadata: { subject: '' } };
+            const content = langContent || defaultContent;
+
+            const blocks = content.blocks;
+            const metadata = content.metadata;
+
+            if (!blocks || blocks.length === 0) {
+                return NextResponse.json(
+                    { error: 'Welcome email not configured for this language. Please configure it first.' },
+                    { status: 400 }
+                );
+            }
+
+            const { generateNewsletterEmailHtml } = await import('../../lib/email/EmailRenderer');
+
+            const isDutch = language === 'nl';
+            const isSwedish = language === 'sv';
+
+            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)}`;
+            
+            html = generateNewsletterEmailHtml(
+                blocks,
+                { subject: metadata?.subject || '' },
+                {
+                    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 t = getTestEmailTranslations(language);
+
+            const templatePath = path.join(process.cwd(), 'node_modules', '@jhits', 'plugin-newsletter', 'templates', 'test-email.hbs');
+            let templateContent: string;
+
+            if (fs.existsSync(templatePath)) {
+                templateContent = fs.readFileSync(templatePath, 'utf-8');
+            } else {
+                const altPath = path.join(__dirname, '..', '..', '..', '..', 'templates', 'test-email.hbs');
+                if (fs.existsSync(altPath)) {
+                    templateContent = fs.readFileSync(altPath, 'utf-8');
+                } else {
+                    return NextResponse.json({ error: 'Email template not found' }, { status: 500 });
+                }
+            }
+
+            const template = handlebars.compile(templateContent);
+
+            html = template({
+                recipientEmail: email,
+                fromName: smtpConfig.fromName || 'JHITS Newsletter',
+                currentYear: new Date().getFullYear(),
+                ...t,
+            });
+
+            subject = language === 'nl' ? 'Test e-mail - SMTP configuratie' : language === 'sv' ? 'Test e-post - SMTP-konfiguration' : 'Test Email - SMTP Configuration';
+        }
+
+        await transporter.sendMail({
+            from: smtpConfig.fromName
+                ? `"${smtpConfig.fromName}" <${smtpConfig.from}>`
+                : smtpConfig.from,
+            to: email,
+            subject,
+            html,
+            ...(emailType === 'test' && logoExists && {
+                attachments: [
+                    {
+                        filename: 'logo.png',
+                        path: logoPath,
+                        cid: 'logo',
+                    },
+                ],
+            }),
+            ...(emailType === 'welcome' && logoAttachment && {
+                attachments: [logoAttachment],
+            }),
+        });
+
+        return NextResponse.json({ success: true, message: `Test email sent to ${email}` });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] POST_TEST_EMAIL error:', error);
+        return NextResponse.json(
+            { error: 'Failed to send test email', detail: error.message },
+            { status: 500 }
+        );
+    }
+}