@jhits/plugin-newsletter 0.0.8 → 0.0.10

package/dist/api/handlers/newsletters.js

@@ -0,0 +1,250 @@
+/**
+ * Newsletter API Handler
+ */
+'use server';
+import { NextResponse } from 'next/server';
+import { generateSlugFromTitle } from '../../lib/utils/slugify';
+const ObjectId = require('mongodb').ObjectId;
+function getNewsletterFilter(idOrSlug) {
+    // 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, config) {
+    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 = {};
+        if (status) {
+            query['publication.status'] = status;
+        }
+        const filter = {
+            ...query,
+            $or: [
+                { hidden: { $exists: false } },
+                { hidden: { $eq: false } }
+            ]
+        };
+        const sort = {};
+        sort[sortBy] = sortOrder === 'asc' ? 1 : -1;
+        const newsletterList = await newsletters
+            .find(filter)
+            .sort(sort)
+            .limit(limit)
+            .skip(skip)
+            .toArray();
+        const listItems = newsletterList.map((newsletter) => ({
+            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) {
+        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, idOrSlug, config) {
+    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 = {
+            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) {
+        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, config) {
+    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 = [];
+        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) => 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) {
+        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, idOrSlug, config) {
+    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 = [];
+        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 = {
+            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) {
+        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, idOrSlug, config) {
+    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) {
+        console.error('[NewsletterAPI] DELETE_NEWSLETTER error:', error);
+        return NextResponse.json({ error: 'Failed to delete newsletter', detail: error.message }, { status: 500 });
+    }
+}

package/dist/api/handlers/send-newsletter.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Send Newsletter API Handler
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import { NewsletterApiConfig } from '../../types/newsletter';
+export declare function POST_SEND_NEWSLETTER(req: NextRequest, idOrSlug: string, config: NewsletterApiConfig): Promise<NextResponse>;
+export declare function GET_NEWSLETTER_FOR_SEND(req: NextRequest, idOrSlug: string, config: NewsletterApiConfig): Promise<NextResponse>;
+//# sourceMappingURL=send-newsletter.d.ts.map

package/dist/api/handlers/send-newsletter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-newsletter.d.ts","sourceRoot":"","sources":["../../../src/api/handlers/send-newsletter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AA4C7D,wBAAsB,oBAAoB,CACtC,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CA2LvB;AAED,wBAAsB,uBAAuB,CACzC,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAuCvB"}

package/dist/api/handlers/send-newsletter.js

@@ -0,0 +1,206 @@
+/**
+ * Send Newsletter API Handler
+ */
+'use server';
+import { NextResponse } from 'next/server';
+import nodemailer from 'nodemailer';
+const ObjectId = require('mongodb').ObjectId;
+async function getSmtpConfig(config) {
+    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) {
+    if (ObjectId.isValid(idOrSlug) && new ObjectId(idOrSlug).toString() === idOrSlug) {
+        return { _id: new ObjectId(idOrSlug) };
+    }
+    return { slug: idOrSlug };
+}
+export async function POST_SEND_NEWSLETTER(req, idOrSlug, config) {
+    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 = 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 = {
+            sv: '/avmälla',
+            nl: '/afmelden',
+            en: '/unsubscribe',
+        };
+        const slug = slugs[language] || slugs.en;
+        let recipientEmails = [];
+        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) => 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) {
+        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, idOrSlug, config) {
+    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) {
+        console.error('[NewsletterAPI] GET_NEWSLETTER_FOR_SEND error:', error);
+        return NextResponse.json({ error: 'Failed to fetch newsletter', detail: error.message }, { status: 500 });
+    }
+}

package/dist/api/handlers/settings.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Settings API Handler
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import { NewsletterApiConfig } from '../../types/newsletter';
+export declare function GET_SETTINGS(req: NextRequest, config: NewsletterApiConfig): Promise<NextResponse>;
+export declare function POST_SETTINGS(req: NextRequest, config: NewsletterApiConfig): Promise<NextResponse>;
+export declare function GET_SMTP_SETTINGS(req: NextRequest, config: NewsletterApiConfig): Promise<NextResponse>;
+export declare function POST_SMTP_SETTINGS(req: NextRequest, config: NewsletterApiConfig): Promise<NextResponse>;
+export declare function POST_TEST_EMAIL(req: NextRequest, config: NewsletterApiConfig): Promise<NextResponse>;
+//# sourceMappingURL=settings.d.ts.map

package/dist/api/handlers/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../../src/api/handlers/settings.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAsB,MAAM,wBAAwB,CAAC;AAoBjF,wBAAsB,YAAY,CAC9B,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CA2BvB;AAED,wBAAsB,aAAa,CAC/B,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAgCvB;AAED,wBAAsB,iBAAiB,CACnC,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CA2CvB;AAED,wBAAsB,kBAAkB,CACpC,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAgDvB;AAwBD,wBAAsB,eAAe,CACjC,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAoLvB"}