@jhits/plugin-newsletter 0.0.8 → 0.0.10

package/dist/api/handlers/settings.js

@@ -0,0 +1,304 @@
+/**
+ * Settings API Handler
+ */
+'use server';
+import { NextResponse } from 'next/server';
+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) {
+    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, 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 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) {
+        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, config) {
+    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) {
+        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, 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 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) {
+        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, config) {
+    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) {
+        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) {
+    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, config) {
+    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 = 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;
+        let subject;
+        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;
+            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 = {
+                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;
+            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) {
+        console.error('[NewsletterAPI] POST_TEST_EMAIL error:', error);
+        return NextResponse.json({ error: 'Failed to send test email', detail: error.message }, { status: 500 });
+    }
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Subscribers API Handler
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import { NewsletterApiConfig } from '../../types/newsletter';
+export declare function GET_SUBSCRIBERS(req: NextRequest, config: NewsletterApiConfig): Promise<NextResponse>;
+export declare function POST_SUBSCRIBE(req: NextRequest, config: NewsletterApiConfig): Promise<NextResponse>;
+export declare function GET_SUBSCRIBER(req: NextRequest, email: string, config: NewsletterApiConfig): Promise<NextResponse>;
+export declare function DELETE_SUBSCRIBER(req: NextRequest, email: string, config: NewsletterApiConfig): Promise<NextResponse>;
+//# sourceMappingURL=subscribers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscribers.d.ts","sourceRoot":"","sources":["../../../src/api/handlers/subscribers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAG7D,wBAAsB,eAAe,CACjC,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAwBvB;AAED,wBAAsB,cAAc,CAChC,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CA2CvB;AAED,wBAAsB,cAAc,CAChC,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CA2BvB;AAED,wBAAsB,iBAAiB,CACnC,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CA2BvB"}

package/dist/api/handlers/subscribers.js

@@ -0,0 +1,96 @@
+/**
+ * Subscribers API Handler
+ */
+'use server';
+import { NextResponse } from 'next/server';
+import { sendWelcomeEmail } from '../email-utils';
+export async function GET_SUBSCRIBERS(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 subscribers = db.collection('subscribers');
+        const subscriberList = await subscribers
+            .find({})
+            .sort({ subscribedAt: -1 })
+            .toArray();
+        return NextResponse.json(subscriberList);
+    }
+    catch (error) {
+        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, config) {
+    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) {
+        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, email, 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 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) {
+        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, email, 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 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) {
+        console.error('[NewsletterAPI] DELETE_SUBSCRIBER error:', error);
+        return NextResponse.json({ error: 'Failed to delete subscriber', detail: error.message }, { status: 500 });
+    }
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Logo Upload Handler
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import { NewsletterApiConfig } from '../../types/newsletter';
+export declare function POST_LOGO_UPLOAD(req: NextRequest, config: NewsletterApiConfig): Promise<NextResponse>;
+//# sourceMappingURL=upload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../../src/api/handlers/upload.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE7D,wBAAsB,gBAAgB,CAClC,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAkCvB"}

package/dist/api/handlers/upload.js

@@ -0,0 +1,32 @@
+/**
+ * Logo Upload Handler
+ */
+'use server';
+import { NextResponse } from 'next/server';
+export async function POST_LOGO_UPLOAD(req, config) {
+    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');
+        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) {
+        console.error('[NewsletterAPI] POST_LOGO_UPLOAD error:', error);
+        return NextResponse.json({ error: 'Failed to upload logo', detail: error.message }, { status: 500 });
+    }
+}

package/dist/api/handlers/welcome-email.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Welcome Email API Handler
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import { NewsletterApiConfig, NewsletterMetadata } from '../../types/newsletter';
+export declare function GET_WELCOME_EMAIL_STATUS(req: NextRequest, config: NewsletterApiConfig): Promise<NextResponse>;
+export declare function GET_WELCOME_EMAIL(req: NextRequest, config: NewsletterApiConfig): Promise<NextResponse>;
+export declare function POST_WELCOME_EMAIL(req: NextRequest, config: NewsletterApiConfig): Promise<NextResponse>;
+export declare function GET_WELCOME_EMAIL_CONTENT(req: NextRequest, config: NewsletterApiConfig, language: string): Promise<{
+    blocks: any[];
+    metadata: NewsletterMetadata;
+}>;
+//# sourceMappingURL=welcome-email.d.ts.map

package/dist/api/handlers/welcome-email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"welcome-email.d.ts","sourceRoot":"","sources":["../../../src/api/handlers/welcome-email.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAajF,wBAAsB,wBAAwB,CAC1C,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAsCvB;AAED,wBAAsB,iBAAiB,CACnC,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CA6DvB;AAED,wBAAsB,kBAAkB,CACpC,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAyDvB;AAED,wBAAsB,yBAAyB,CAC3C,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,EAAE,MAAM,GACjB,OAAO,CAAC;IAAE,MAAM,EAAE,GAAG,EAAE,CAAC;IAAC,QAAQ,EAAE,kBAAkB,CAAA;CAAE,CAAC,CAc1D"}

package/dist/api/handlers/welcome-email.js

@@ -0,0 +1,142 @@
+/**
+ * Welcome Email API Handler
+ */
+'use server';
+import { NextResponse } from 'next/server';
+export async function GET_WELCOME_EMAIL_STATUS(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 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 || {};
+        const availableLanguages = Object.keys(languages).filter(lang => languages[lang]?.blocks?.length);
+        return NextResponse.json({
+            configured: availableLanguages.length > 0,
+            lastUpdated: welcomeEmail?.updatedAt || null,
+            availableLanguages,
+            primaryLanguage,
+        });
+    }
+    catch (error) {
+        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, config) {
+    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 || {};
+        // Get primary language content as fallback
+        const primaryContent = languages[primaryLanguage] || languages.en || { blocks: [], metadata: { subject: '', previewText: '' } };
+        // If requested language doesn't exist, copy from primary language
+        if (!languages[language]) {
+            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]?.blocks || primaryContent.blocks,
+            metadata: languages[language]?.metadata || primaryContent.metadata,
+            languages,
+            isCopy: false,
+        });
+    }
+    catch (error) {
+        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, config) {
+    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 || {};
+        const updatedLanguages = {
+            ...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) {
+        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, config, language) {
+    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 || {};
+    const defaultContent = languages.en || { blocks: [], metadata: { subject: '', previewText: '' } };
+    return languages[language] || defaultContent;
+}

package/dist/api/router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/api/router.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAe1D;;GAEG;AACH,wBAAsB,mBAAmB,CACrC,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CA+EvB"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/api/router.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAwB1D;;GAEG;AACH,wBAAsB,mBAAmB,CACrC,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CA6HvB"}