@contentgrowth/content-emailing 0.4.1 → 0.6.0

package/src/backend/routes/tracking.js

@@ -1,215 +0,0 @@
-/**
- * Email Tracking Routes Factory
- * Creates a Hono router with tracking endpoints for the email system.
- */
-import { Hono } from 'hono';
-
-// 1x1 transparent GIF pixel
-const TRACKING_PIXEL = new Uint8Array([
-    0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x01, 0x00, 0x01, 0x00,
-    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x21,
-    0xF9, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00,
-    0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x02, 0x01, 0x44,
-    0x00, 0x3B
-]);
-
-/**
- * Create email tracking routes
- * @param {Object} env - Environment bindings
- * @param {Object} config - Configuration
- * @param {string} [config.emailTablePrefix='system_email_'] - Prefix for D1 tables
- * @returns {Hono} Hono router
- */
-export function createTrackingRoutes(env, config = {}) {
-    const app = new Hono();
-    const db = env.DB;
-    const tablePrefix = config.emailTablePrefix || config.tableNamePrefix || 'system_email_';
-
-    /**
-     * GET /track/open/:token
-     * Track email opens via a 1x1 pixel
-     */
-    app.get('/track/open/:token', async (c) => {
-        const token = c.req.param('token');
-
-        try {
-            const sendId = token;
-
-            // Look up the send record
-            const send = await db
-                .prepare(`SELECT * FROM ${tablePrefix}sends WHERE send_id = ?`)
-                .bind(sendId)
-                .first();
-
-            if (send) {
-                // Log the open event
-                const eventId = crypto.randomUUID();
-                const now = Math.floor(Date.now() / 1000);
-
-                await db
-                    .prepare(
-                        `INSERT INTO ${tablePrefix}events (
-              event_id, send_id, user_id, tenant_id, email_kind, event_type, metadata, created_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
-                    )
-                    .bind(
-                        eventId,
-                        sendId,
-                        send.user_id,
-                        send.tenant_id,
-                        send.email_kind,
-                        'opened',
-                        JSON.stringify({
-                            user_agent: c.req.header('user-agent'),
-                            referer: c.req.header('referer'),
-                        }),
-                        now
-                    )
-                    .run();
-            }
-        } catch (error) {
-            console.error('[EmailTracking] Error tracking email open:', error);
-            // Don't fail the request - just serve the pixel
-        }
-
-        // Always return the tracking pixel
-        return new Response(TRACKING_PIXEL, {
-            headers: {
-                'Content-Type': 'image/gif',
-                'Cache-Control': 'no-cache, no-store, must-revalidate',
-                'Pragma': 'no-cache',
-                'Expires': '0',
-            },
-        });
-    });
-
-    /**
-     * POST /track/click/:token
-     * Track email clicks
-     */
-    app.post('/track/click/:token', async (c) => {
-        const token = c.req.param('token');
-
-        let url;
-        try {
-            const body = await c.req.json();
-            url = body.url;
-        } catch {
-            return c.json({ success: false, error: 'Invalid request body' }, 400);
-        }
-
-        if (!url) {
-            return c.json({ success: false, error: 'Missing URL' }, 400);
-        }
-
-        try {
-            const sendId = token;
-
-            // Look up the send record
-            const send = await db
-                .prepare(`SELECT * FROM ${tablePrefix}sends WHERE send_id = ?`)
-                .bind(sendId)
-                .first();
-
-            if (send) {
-                // Log the click event
-                const eventId = crypto.randomUUID();
-                const now = Math.floor(Date.now() / 1000);
-
-                await db
-                    .prepare(
-                        `INSERT INTO ${tablePrefix}events (
-              event_id, send_id, user_id, tenant_id, email_kind, event_type, metadata, created_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
-                    )
-                    .bind(
-                        eventId,
-                        sendId,
-                        send.user_id,
-                        send.tenant_id,
-                        send.email_kind,
-                        'clicked',
-                        JSON.stringify({
-                            url: url,
-                            user_agent: c.req.header('user-agent'),
-                            referer: c.req.header('referer'),
-                        }),
-                        now
-                    )
-                    .run();
-            }
-
-            return c.json({ success: true, tracked: !!send });
-        } catch (error) {
-            console.error('[EmailTracking] Error tracking email click:', error);
-            return c.json({ success: false, error: 'Failed to track click' }, 500);
-        }
-    });
-
-    /**
-     * GET /unsubscribe/:token
-     * Unsubscribe a user from all email notifications
-     */
-    app.get('/unsubscribe/:token', async (c) => {
-        const unsubToken = c.req.param('token');
-
-        try {
-            // Find the user by their unsubscribe token
-            const prefs = await db
-                .prepare(`SELECT * FROM ${tablePrefix}preferences WHERE unsub_token = ?`)
-                .bind(unsubToken)
-                .first();
-
-            if (!prefs) {
-                return c.json({ success: false, error: 'Invalid unsubscribe link' }, 404);
-            }
-
-            // Check if already unsubscribed
-            const currentSettings = JSON.parse(prefs.email_settings || '{}');
-            const alreadyUnsubscribed = Object.keys(currentSettings).length === 0;
-
-            if (!alreadyUnsubscribed) {
-                // Disable all email types by setting email_settings to empty object
-                const now = Math.floor(Date.now() / 1000);
-                await db
-                    .prepare(
-                        `UPDATE ${tablePrefix}preferences 
-             SET email_settings = '{}',
-                 updated_at = ?
-             WHERE unsub_token = ?`
-                    )
-                    .bind(now, unsubToken)
-                    .run();
-
-                // Log the unsubscribe event
-                const eventId = crypto.randomUUID();
-                await db
-                    .prepare(
-                        `INSERT INTO ${tablePrefix}events (
-              event_id, send_id, user_id, tenant_id, email_kind, event_type, metadata, created_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
-                    )
-                    .bind(
-                        eventId,
-                        'unsubscribe',
-                        prefs.user_id,
-                        prefs.tenant_id,
-                        'all',
-                        'unsubscribed',
-                        JSON.stringify({
-                            user_agent: c.req.header('user-agent'),
-                        }),
-                        now
-                    )
-                    .run();
-            }
-
-            return c.json({ success: true, alreadyUnsubscribed });
-        } catch (error) {
-            console.error('[EmailTracking] Error processing unsubscribe:', error);
-            return c.json({ success: false, error: 'An error occurred' }, 500);
-        }
-    });
-
-    return app;
-}

package/src/backend/routes.js

@@ -1,98 +0,0 @@
-/**
- * Email Routes Factory
- * Creates a Hono router with admin endpoints for the email system.
- */
-import { Hono } from 'hono';
-import { EmailService } from './EmailService';
-
-/**
- * Create email admin routes
- * @param {Object} env - Environment bindings
- * @param {Object} config - Configuration
- * @param {Object} cacheProvider - Optional cache provider
- * @returns {Hono} Hono router
- */
-export function createEmailRoutes(env, config = {}, cacheProvider = null) {
-    const app = new Hono();
-    const emailService = new EmailService(env, config, cacheProvider);
-
-    // List all templates
-    app.get('/templates', async (c) => {
-        try {
-            const templates = await emailService.getAllTemplates();
-            return c.json({ success: true, templates });
-        } catch (err) {
-            return c.json({ success: false, error: err.message }, 500);
-        }
-    });
-
-    // Get single template
-    app.get('/templates/:id', async (c) => {
-        try {
-            const template = await emailService.getTemplate(c.req.param('id'));
-            if (!template) return c.json({ success: false, error: 'Template not found' }, 404);
-            return c.json({ success: true, template });
-        } catch (err) {
-            return c.json({ success: false, error: err.message }, 500);
-        }
-    });
-
-    // Create/Update template
-    app.post('/templates', async (c) => {
-        try {
-            const data = await c.req.json();
-            await emailService.saveTemplate(data, 'admin'); // TODO: Pass real user ID
-            return c.json({ success: true, message: 'Template saved' });
-        } catch (err) {
-            return c.json({ success: false, error: err.message }, 500);
-        }
-    });
-
-    // Delete template
-    app.delete('/templates/:id', async (c) => {
-        try {
-            await emailService.deleteTemplate(c.req.param('id'));
-            return c.json({ success: true, message: 'Template deleted' });
-        } catch (err) {
-            return c.json({ success: false, error: err.message }, 500);
-        }
-    });
-
-    // Preview template
-    app.post('/templates/:id/preview', async (c) => {
-        try {
-            const id = c.req.param('id');
-            const data = await c.req.json(); // Variables
-            const result = await emailService.renderTemplate(id, data);
-            return c.json({ success: true, preview: result });
-        } catch (err) {
-            return c.json({ success: false, error: err.message }, 500);
-        }
-    });
-
-    // Send test email
-    app.post('/templates/:id/test', async (c) => {
-        try {
-            const id = c.req.param('id');
-            const { to, data } = await c.req.json();
-
-            const { subject, html, plainText } = await emailService.renderTemplate(id, data);
-            const result = await emailService.sendEmail({
-                to,
-                subject: `[TEST] ${subject}`,
-                html,
-                text: plainText
-            });
-
-            if (result.success) {
-                return c.json({ success: true, message: 'Test email sent' });
-            } else {
-                return c.json({ success: false, error: result.error }, 500);
-            }
-        } catch (err) {
-            return c.json({ success: false, error: err.message }, 500);
-        }
-    });
-
-    return app;
-}

package/src/common/index.js

@@ -1,11 +0,0 @@
-/**
- * Common exports
- */
-export { wrapInEmailTemplate } from './htmlWrapper.js';
-export {
-    getWebsiteUrl,
-    resetWebsiteUrlCache,
-    encodeTrackingLinks,
-    markdownToPlainText,
-    extractVariables
-} from './utils.js';

package/src/common/utils.js

@@ -1,141 +0,0 @@
-/**
- * Email Utility Functions
- * Common helpers for email processing
- */
-
-import mustache from 'mustache';
-
-// Module-level cache for website URL
-let cachedWebsiteUrl = null;
-
-/**
- * Build website URL based on environment configuration (with caching)
- * @param {Object} env - Environment bindings
- * @returns {string} Website URL (e.g., 'https://www.x0start.com')
- */
-export function getWebsiteUrl(env) {
-    if (cachedWebsiteUrl) {
-        return cachedWebsiteUrl;
-    }
-
-    const domain = env.DOMAIN || 'x0start.com';
-    const isDev = env.ENVIRONMENT === 'development' || !env.ENVIRONMENT;
-    const protocol = isDev ? 'http' : 'https';
-
-    cachedWebsiteUrl = `${protocol}://www.${domain}`;
-
-    return cachedWebsiteUrl;
-}
-
-/**
- * Reset the cached website URL (for testing or config changes)
- */
-export function resetWebsiteUrlCache() {
-    cachedWebsiteUrl = null;
-}
-
-/**
- * Encode all links in HTML to go through tracking redirect
- * @param {string} html - HTML content with links
- * @param {string} sendId - Unique send ID for tracking
- * @param {Object} env - Environment bindings (optional, for auto-detecting URL)
- * @param {string} websiteUrl - Base website URL (optional, overrides env detection)
- * @returns {string} HTML with encoded tracking links
- */
-export function encodeTrackingLinks(html, sendId, env = null, websiteUrl = null) {
-    const baseUrl = websiteUrl || (env ? getWebsiteUrl(env) : 'https://www.x0start.com');
-
-    // Helper to decode HTML entities
-    const decodeHtmlEntities = (text) => {
-        return text
-            .replace(///g, '/')
-            .replace(/:/g, ':')
-            .replace(/&/g, '&')
-            .replace(/&lt;/g, '<')
-            .replace(/&gt;/g, '>')
-            .replace(/&quot;/g, '"')
-            .replace(/&#39;/g, "'");
-    };
-
-    // Replace all href attributes with tracking URLs
-    return html.replace(/href="([^"]+)"/g, (match, url) => {
-        // Skip certain URLs that shouldn't be tracked
-        if (
-            url.startsWith('mailto:') ||
-            url.startsWith('tel:') ||
-            url.startsWith('#') ||
-            url.includes('{{') || // Skip template variables
-            url.includes('/email/unsubscribe/') ||
-            url.includes('/email/track/')
-        ) {
-            return match;
-        }
-
-        // Decode HTML entities first (marked encodes URLs with HTML entities)
-        const decodedUrl = decodeHtmlEntities(url);
-
-        // Encode the decoded URL in base64
-        const encodedUrl = Buffer.from(decodedUrl).toString('base64');
-
-        // Create tracking redirect URL
-        const trackingUrl = `${baseUrl}/r/${sendId}?url=${encodedUrl}`;
-
-        return `href="${trackingUrl}"`;
-    });
-}
-
-/**
- * Convert markdown to plain text
- * @param {string} markdown - Markdown content
- * @returns {string} Plain text version
- */
-export function markdownToPlainText(markdown) {
-    return markdown
-        .replace(/#{1,6}\s+/g, '') // Remove headers
-        .replace(/\*\*(.+?)\*\*/g, '$1') // Remove bold
-        .replace(/\*(.+?)\*/g, '$1') // Remove italic
-        .replace(/\[(.+?)\]\((.+?)\)/g, '$1: $2') // Keep both link text and URL
-        .replace(/`(.+?)`/g, '$1') // Remove code
-        .replace(/>\s+/g, '') // Remove blockquotes
-        .replace(/\n{3,}/g, '\n\n') // Normalize line breaks
-        .trim();
-}
-
-/**
- * Extract variables from a Mustache template string
- * @param {string} templateString - The mustache template string
- * @returns {string[]} Array of unique variable names
- */
-export function extractVariables(templateString) {
-    if (!templateString) return [];
-
-    try {
-        // Parse the template to get tokens
-        const tokens = mustache.parse(templateString);
-        const variables = new Set();
-
-        // Recursively extract variables from tokens
-        const collectVariables = (tokenList) => {
-            tokenList.forEach(token => {
-                const type = token[0];
-                const value = token[1];
-
-                // Types: 'name' ({{var}}), '#' (section), '^' (inverted section), '&' (unescaped)
-                if (type === 'name' || type === '#' || type === '^' || type === '&') {
-                    variables.add(value);
-                }
-
-                // Variable is in token[4] for sections
-                if ((type === '#' || type === '^') && token[4]) {
-                    collectVariables(token[4]);
-                }
-            });
-        };
-
-        collectVariables(tokens);
-        return Array.from(variables);
-    } catch (error) {
-        console.error('Error parsing template variables:', error);
-        return [];
-    }
-}

package/src/frontend/TemplateEditor.jsx

@@ -1,117 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { Save, X, Eye, AlertCircle } from 'lucide-react';
-
-export const TemplateEditor = ({
-    initialData,
-    onSave,
-    onCancel,
-    onPreview,
-    variablesHelpText = 'Supports {{variable}}'
-}) => {
-    const [formData, setFormData] = useState({
-        template_id: '',
-        template_name: '',
-        template_type: 'daily_reminder',
-        subject_template: '',
-        body_markdown: '',
-        variables: '[]',
-        description: '',
-        is_active: 1,
-        ...initialData
-    });
-
-    const handleSubmit = (e) => {
-        e.preventDefault();
-        onSave(formData);
-    };
-
-    return (
-        <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 p-4">
-            <div className="bg-white rounded-lg shadow-xl max-w-4xl w-full max-h-[90vh] overflow-hidden flex flex-col">
-                <div className="p-6 border-b border-gray-200 flex justify-between items-center">
-                    <h2 className="text-xl font-bold text-gray-900">
-                        {initialData ? 'Edit Template' : 'New Template'}
-                    </h2>
-                    <button onClick={onCancel} className="p-2 hover:bg-gray-100 rounded-lg">
-                        <X className="h-5 w-5" />
-                    </button>
-                </div>
-
-                <form onSubmit={handleSubmit} className="flex-1 overflow-y-auto p-6 space-y-4">
-                    <div className="grid grid-cols-2 gap-4">
-                        <div>
-                            <label className="block text-sm font-medium text-gray-700 mb-1">Template ID *</label>
-                            <input
-                                type="text"
-                                required
-                                disabled={!!initialData}
-                                value={formData.template_id}
-                                onChange={e => setFormData({ ...formData, template_id: e.target.value })}
-                                className="w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 disabled:bg-gray-100"
-                            />
-                        </div>
-                        <div>
-                            <label className="block text-sm font-medium text-gray-700 mb-1">Name *</label>
-                            <input
-                                type="text"
-                                required
-                                value={formData.template_name}
-                                onChange={e => setFormData({ ...formData, template_name: e.target.value })}
-                                className="w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500"
-                            />
-                        </div>
-                    </div>
-
-                    <div>
-                        <label className="block text-sm font-medium text-gray-700 mb-1">Subject *</label>
-                        <input
-                            type="text"
-                            required
-                            value={formData.subject_template}
-                            onChange={e => setFormData({ ...formData, subject_template: e.target.value })}
-                            className="w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500"
-                        />
-                        <p className="text-xs text-gray-500 mt-1">{variablesHelpText}</p>
-                    </div>
-
-                    <div>
-                        <label className="block text-sm font-medium text-gray-700 mb-1">Body (Markdown) *</label>
-                        <textarea
-                            required
-                            rows={12}
-                            value={formData.body_markdown}
-                            onChange={e => setFormData({ ...formData, body_markdown: e.target.value })}
-                            className="w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 font-mono text-sm"
-                        />
-                    </div>
-
-                    <div className="flex justify-between pt-4">
-                        <button
-                            type="button"
-                            onClick={() => onPreview && onPreview(formData)}
-                            className="flex items-center gap-2 px-4 py-2 bg-gray-100 text-gray-700 rounded-lg hover:bg-gray-200"
-                        >
-                            <Eye className="h-4 w-4" /> Preview
-                        </button>
-
-                        <div className="flex gap-2">
-                            <button
-                                type="button"
-                                onClick={onCancel}
-                                className="px-4 py-2 border border-gray-300 text-gray-700 rounded-lg hover:bg-gray-50"
-                            >
-                                Cancel
-                            </button>
-                            <button
-                                type="submit"
-                                className="flex items-center gap-2 px-4 py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700"
-                            >
-                                <Save className="h-4 w-4" /> Save
-                            </button>
-                        </div>
-                    </div>
-                </form>
-            </div>
-        </div>
-    );
-};