@jhits/plugin-newsletter 0.0.10 → 0.0.11

package/src/api/handlers/subscribers.ts

@@ -0,0 +1,152 @@
+/**
+ * Subscribers API Handler
+ */
+
+'use server';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { NewsletterApiConfig } from '../../types/newsletter';
+import { sendWelcomeEmail } from '../email-utils';
+
+export async function GET_SUBSCRIBERS(
+    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 subscribers = db.collection('subscribers');
+
+        const subscriberList = await subscribers
+            .find({})
+            .sort({ subscribedAt: -1 })
+            .toArray();
+
+        return NextResponse.json(subscriberList);
+    } catch (error: any) {
+        console.error('[NewsletterAPI] GET_SUBSCRIBERS error:', error);
+        return NextResponse.json(
+            { error: 'Failed to fetch subscribers', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+export async function POST_SUBSCRIBE(
+    req: NextRequest,
+    config: NewsletterApiConfig
+): Promise<NextResponse> {
+    try {
+        const body = await req.json();
+        const { email, language } = body;
+
+        if (!email || !email.includes('@')) {
+            return NextResponse.json(
+                { error: 'Invalid email address' },
+                { status: 400 }
+            );
+        }
+
+        const dbConnection = await config.getDb();
+        const db = dbConnection.db();
+        const subscribers = db.collection('subscribers');
+
+        const existing = await subscribers.findOne({ email: email.toLowerCase() });
+        if (existing) {
+            return NextResponse.json(
+                { error: 'You are already subscribed!' },
+                { status: 409 }
+            );
+        }
+
+        await subscribers.insertOne({
+            email: email.toLowerCase(),
+            language: language || 'en',
+            subscribedAt: new Date(),
+            status: 'active',
+        });
+
+        const headers = await req.headers;
+        const host = headers.get('host') || undefined;
+        await sendWelcomeEmail(config, email, language || 'en', host);
+
+        return NextResponse.json({ message: 'Successfully subscribed' }, { status: 201 });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] POST_SUBSCRIBE error:', error);
+        return NextResponse.json(
+            { error: 'Failed to subscribe', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+export async function GET_SUBSCRIBER(
+    req: NextRequest,
+    email: 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 subscribers = db.collection('subscribers');
+
+        const subscriber = await subscribers.findOne({ email: email.toLowerCase() });
+        if (!subscriber) {
+            return NextResponse.json(
+                { error: 'Subscriber not found' },
+                { status: 404 }
+            );
+        }
+
+        return NextResponse.json(subscriber);
+    } catch (error: any) {
+        console.error('[NewsletterAPI] GET_SUBSCRIBER error:', error);
+        return NextResponse.json(
+            { error: 'Failed to fetch subscriber', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+export async function DELETE_SUBSCRIBER(
+    req: NextRequest,
+    email: 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 subscribers = db.collection('subscribers');
+
+        const result = await subscribers.deleteOne({ email: email.toLowerCase() });
+        if (result.deletedCount === 0) {
+            return NextResponse.json(
+                { error: 'Subscriber not found' },
+                { status: 404 }
+            );
+        }
+
+        return NextResponse.json({ message: 'Subscriber successfully removed' });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] DELETE_SUBSCRIBER error:', error);
+        return NextResponse.json(
+            { error: 'Failed to delete subscriber', detail: error.message },
+            { status: 500 }
+        );
+    }
+}

package/src/api/handlers/upload.ts

@@ -0,0 +1,47 @@
+/**
+ * Logo Upload Handler
+ */
+
+'use server';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { NewsletterApiConfig } from '../../types/newsletter';
+
+export async function POST_LOGO_UPLOAD(
+    req: NextRequest,
+    config: NewsletterApiConfig
+): Promise<NextResponse> {
+    try {
+        const userId = await config.getUserId?.(req);
+        if (!userId) {
+            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        }
+
+        const formData = await req.formData();
+        const file = formData.get('file') as File | null;
+        
+        if (!file) {
+            return NextResponse.json({ error: 'No file provided' }, { status: 400 });
+        }
+
+        const allowedTypes = ['image/png', 'image/jpeg'];
+        if (!allowedTypes.includes(file.type)) {
+            return NextResponse.json({ error: 'Invalid file type. Only PNG and JPEG are allowed.' }, { status: 400 });
+        }
+
+        const bytes = await file.arrayBuffer();
+        const buffer = Buffer.from(bytes);
+        const base64 = buffer.toString('base64');
+        const mimeType = file.type;
+        
+        const dataUrl = `data:${mimeType};base64,${base64}`;
+
+        return NextResponse.json({ url: dataUrl, success: true });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] POST_LOGO_UPLOAD error:', error);
+        return NextResponse.json(
+            { error: 'Failed to upload logo', detail: error.message },
+            { status: 500 }
+        );
+    }
+}

package/src/api/handlers/welcome-email.ts

@@ -0,0 +1,210 @@
+/**
+ * Welcome Email API Handler
+ */
+
+'use server';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { NewsletterApiConfig, NewsletterMetadata } from '../../types/newsletter';
+
+interface LanguageContent {
+    blocks: any[];
+    metadata: NewsletterMetadata;
+}
+
+interface WelcomeEmailLanguages {
+    en?: LanguageContent;
+    nl?: LanguageContent;
+    sv?: LanguageContent;
+}
+
+export async function GET_WELCOME_EMAIL_STATUS(
+    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 = db.collection('settings');
+
+        const welcomeEmail = await newsletters.findOne({ 
+            type: 'welcome_email',
+            id: 'welcome_automation'
+        });
+
+        const smtpConfig = await settings.findOne({ key: 'smtp' });
+        const primaryLanguage = smtpConfig?.primaryLanguage || 'en';
+
+        const languages = (welcomeEmail?.languages as WelcomeEmailLanguages) || {};
+        const availableLanguages = Object.keys(languages).filter(
+            lang => languages[lang as keyof WelcomeEmailLanguages]?.blocks?.length
+        );
+
+        return NextResponse.json({
+            configured: availableLanguages.length > 0,
+            lastUpdated: welcomeEmail?.updatedAt || null,
+            availableLanguages,
+            primaryLanguage,
+        });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] GET_WELCOME_EMAIL_STATUS error:', error);
+        return NextResponse.json(
+            { error: 'Failed to fetch welcome email status', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+export async function GET_WELCOME_EMAIL(
+    req: NextRequest,
+    config: NewsletterApiConfig
+): Promise<NextResponse> {
+    try {
+        const userId = await config.getUserId?.(req);
+        if (!userId) {
+            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+
+        }
+
+        const { searchParams } = new URL(req.url);
+        const language = searchParams.get('language') || 'en';
+
+        const dbConnection = await config.getDb();
+        const db = dbConnection.db();
+        const newsletters = db.collection('newsletters');
+        const settings = db.collection('settings');
+
+        const welcomeEmail = await newsletters.findOne({ 
+            type: 'welcome_email',
+            id: 'welcome_automation'
+        });
+
+        const smtpConfig = await settings.findOne({ key: 'smtp' });
+        const primaryLanguage = smtpConfig?.primaryLanguage || 'en';
+        
+        const languages = (welcomeEmail?.languages as WelcomeEmailLanguages) || {};
+        
+        // Get primary language content as fallback
+        const primaryContent = languages[primaryLanguage as keyof WelcomeEmailLanguages] || languages.en || { blocks: [], metadata: { subject: '', previewText: '' } };
+        
+        // If requested language doesn't exist, copy from primary language
+        if (!languages[language as keyof WelcomeEmailLanguages]) {
+            return NextResponse.json({
+                id: 'welcome_automation',
+                type: 'welcome_email',
+                title: 'Welcome Email',
+                language,
+                blocks: primaryContent.blocks,
+                metadata: primaryContent.metadata,
+                languages,
+                isCopy: true,
+                copyFrom: primaryLanguage,
+            });
+        }
+
+        return NextResponse.json({
+            id: 'welcome_automation',
+            type: 'welcome_email',
+            title: 'Welcome Email',
+            language,
+            blocks: languages[language as keyof WelcomeEmailLanguages]?.blocks || primaryContent.blocks,
+            metadata: languages[language as keyof WelcomeEmailLanguages]?.metadata || primaryContent.metadata,
+            languages,
+            isCopy: false,
+        });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] GET_WELCOME_EMAIL error:', error);
+        return NextResponse.json(
+            { error: 'Failed to fetch welcome email', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+export async function POST_WELCOME_EMAIL(
+    req: NextRequest,
+    config: NewsletterApiConfig
+): Promise<NextResponse> {
+    try {
+        const userId = await config.getUserId?.(req);
+        if (!userId) {
+            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        }
+
+        // Get language from query params first (for welcome email saves)
+        const { searchParams } = new URL(req.url);
+        const queryLanguage = searchParams.get('language');
+        
+        const body = await req.json();
+        const { blocks, metadata } = body;
+        // Use query param language, fallback to body language, then 'en'
+        const language = queryLanguage || body.language || 'en';
+        
+        const dbConnection = await config.getDb();
+        const db = dbConnection.db();
+        const newsletters = db.collection('newsletters');
+
+        const existing = await newsletters.findOne({ 
+            type: 'welcome_email',
+            id: 'welcome_automation'
+        });
+
+        const existingLanguages = (existing?.languages as WelcomeEmailLanguages) || {};
+        
+        const updatedLanguages: WelcomeEmailLanguages = {
+            ...existingLanguages,
+            [language]: {
+                blocks: blocks || [],
+                metadata: metadata || { subject: '', previewText: '' },
+            },
+        };
+
+        await newsletters.updateOne(
+            { type: 'welcome_email', id: 'welcome_automation' },
+            { 
+                $set: {
+                    type: 'welcome_email',
+                    id: 'welcome_automation',
+                    title: 'Welcome Email',
+                    languages: updatedLanguages,
+                    updatedAt: new Date().toISOString(),
+                }
+            },
+            { upsert: true }
+        );
+
+        return NextResponse.json({ success: true, message: 'Welcome email saved successfully' });
+    } catch (error: any) {
+        console.error('[NewsletterAPI] POST_WELCOME_EMAIL error:', error);
+        return NextResponse.json(
+            { error: 'Failed to save welcome email', detail: error.message },
+            { status: 500 }
+        );
+    }
+}
+
+export async function GET_WELCOME_EMAIL_CONTENT(
+    req: NextRequest,
+    config: NewsletterApiConfig,
+    language: string
+): Promise<{ blocks: any[]; metadata: NewsletterMetadata }> {
+    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 WelcomeEmailLanguages) || {};
+    const defaultContent = languages.en || { blocks: [], metadata: { subject: '', previewText: '' } };
+
+    return languages[language as keyof WelcomeEmailLanguages] || defaultContent;
+}

package/src/api/router.ts

@@ -0,0 +1,166 @@
+/**
+ * Newsletter Plugin API Router
+ * Routes API requests to appropriate handlers
+ */
+
+'use server';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { NewsletterApiConfig } from '../types/newsletter';
+import {
+    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,
+} from './handler';
+
+/**
+ * Handle newsletter API requests
+ */
+export async function handleNewsletterApi(
+    req: NextRequest,
+    path: string[],
+    config: NewsletterApiConfig
+): Promise<NextResponse> {
+    const method = req.method;
+    const route = path[0] || '';
+
+    try {
+        // Route: /api/plugin-newsletter/subscribers
+        if (route === 'subscribers') {
+            if (path[1]) {
+                // /api/plugin-newsletter/subscribers/[email]
+                const email = decodeURIComponent(path[1]).toLowerCase();
+                if (method === 'GET') {
+                    return await GET_SUBSCRIBER(req, email, config);
+                }
+                if (method === 'DELETE') {
+                    return await DELETE_SUBSCRIBER(req, email, config);
+                }
+            } else {
+                // /api/plugin-newsletter/subscribers
+                if (method === 'GET') {
+                    return await GET_SUBSCRIBERS(req, config);
+                }
+                if (method === 'POST') {
+                    return await POST_SUBSCRIBE(req, config);
+                }
+            }
+        }
+
+        // Route: /api/plugin-newsletter/settings
+        if (route === 'settings') {
+            if (method === 'GET') {
+                return await GET_SETTINGS(req, config);
+            }
+            if (method === 'POST' || method === 'PUT') {
+                return await POST_SETTINGS(req, config);
+            }
+        }
+
+        // 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]) {
+                const newsletterIdOrSlug = decodeURIComponent(path[1]);
+                
+                // Special route: /api/plugin-newsletter/newsletters/[id]/send
+                if (path[2] === 'send' && method === 'POST') {
+                    return await POST_SEND_NEWSLETTER(req, newsletterIdOrSlug, config);
+                }
+                
+                // Special route: /api/plugin-newsletter/newsletters/[id]/send (GET for info)
+                if (path[2] === 'send' && method === 'GET') {
+                    return await GET_NEWSLETTER_FOR_SEND(req, newsletterIdOrSlug, config);
+                }
+                
+                // /api/plugin-newsletter/newsletters/[id-or-slug]
+                if (method === 'GET') {
+                    return await GET_NEWSLETTER(req, newsletterIdOrSlug, config);
+                }
+                if (method === 'PUT') {
+                    return await PUT_NEWSLETTER(req, newsletterIdOrSlug, config);
+                }
+                if (method === 'DELETE') {
+                    return await DELETE_NEWSLETTER(req, newsletterIdOrSlug, config);
+                }
+            } else {
+                // /api/plugin-newsletter/newsletters
+                if (method === 'GET') {
+                    return await GET_NEWSLETTERS(req, config);
+                }
+                if (method === 'POST') {
+                    return await POST_NEWSLETTER(req, config);
+                }
+            }
+        }
+
+        // Route: /api/plugin-newsletter/welcome-email
+        if (route === 'welcome-email') {
+            // Status endpoint: /api/plugin-newsletter/welcome-email/status
+            if (path[1] === 'status' && method === 'GET') {
+                return await GET_WELCOME_EMAIL_STATUS(req, config);
+            }
+            
+            // Welcome email content: /api/plugin-newsletter/welcome-email
+            if (method === 'GET') {
+                return await GET_WELCOME_EMAIL(req, config);
+            }
+            if (method === 'POST' || method === 'PUT') {
+                return await POST_WELCOME_EMAIL(req, config);
+            }
+        }
+
+        // Route: /api/plugin-newsletter/smtp
+        if (route === 'smtp') {
+            // Test email endpoint: /api/plugin-newsletter/smtp/test
+            if (path[1] === 'test' && method === 'POST') {
+                return await POST_TEST_EMAIL(req, config);
+            }
+            if (method === 'GET') {
+                return await GET_SMTP_SETTINGS(req, config);
+            }
+            if (method === 'POST' || method === 'PUT') {
+                return await POST_SMTP_SETTINGS(req, config);
+            }
+        }
+
+        // Route: /api/plugin-newsletter/upload
+        if (route === 'upload' && method === 'POST') {
+            return await POST_LOGO_UPLOAD(req, config);
+        }
+
+        // Method not allowed
+        return NextResponse.json(
+            { error: `Method ${method} not allowed for route: ${route || '/'}` },
+            { status: 405 }
+        );
+    } catch (error: any) {
+        console.error('[NewsletterApiRouter] Error:', error);
+        return NextResponse.json(
+            { error: error.message || 'Internal server error' },
+            { status: 500 }
+        );
+    }
+}
+

package/src/index.server.ts

@@ -0,0 +1,12 @@
+import 'server-only';
+
+/**
+ * Plugin Newsletter - Server-Only Entry Point
+ * This file exports only server-side API handlers
+ * Used by the dynamic plugin router via @jhits/plugin-newsletter/server
+ */
+
+export { handleNewsletterApi as handleApi } from './api/router';
+export { handleNewsletterApi } from './api/router'; // Keep original export for backward compatibility
+export type { NewsletterApiConfig } from './types/newsletter';
+