webspresso 0.0.80 → 0.0.82

package/plugins/email/auth-bridge.js

@@ -0,0 +1,209 @@
+/**
+ * Auth ↔ email plugin bridge
+ * @module plugins/email/auth-bridge
+ */
+
+const { createKnexAuthTokensAdapter } = require('../../core/auth/tokens');
+const { registerBundledAuthTemplates } = require('./bundled-templates');
+
+const DEFAULT_AUTH_EMAILS = {
+  passwordReset: {
+    enabled: true,
+    template: 'auth-password-reset',
+    subject: 'Reset your password',
+    path: '/reset-password',
+    tokenTtlMs: 60 * 60 * 1000,
+  },
+  emailVerification: {
+    enabled: true,
+    template: 'auth-email-verify',
+    subject: 'Verify your email',
+    path: '/verify-email',
+    tokenTtlMs: 24 * 60 * 60 * 1000,
+  },
+  welcome: {
+    enabled: false,
+    template: 'auth-welcome',
+    subject: 'Welcome',
+  },
+  registerRoutes: true,
+  routePrefix: '/api/auth',
+};
+
+/**
+ * @param {Object} authManager
+ * @param {Object} emailService
+ * @param {import('./template-registry').TemplateRegistry} registry
+ * @param {Object} config
+ * @param {Object} db
+ */
+function wireAuthEmails(authManager, emailService, registry, config, db) {
+  if (!authManager || !emailService) return null;
+
+  const merged = {
+    ...DEFAULT_AUTH_EMAILS,
+    ...config,
+    passwordReset: { ...DEFAULT_AUTH_EMAILS.passwordReset, ...config.passwordReset },
+    emailVerification: { ...DEFAULT_AUTH_EMAILS.emailVerification, ...config.emailVerification },
+    welcome: { ...DEFAULT_AUTH_EMAILS.welcome, ...config.welcome },
+  };
+
+  registerBundledAuthTemplates(registry);
+
+  if (!authManager.authTokens && db) {
+    authManager.authTokens = createKnexAuthTokensAdapter(db);
+  }
+
+  const baseUrl = (merged.baseUrl || process.env.BASE_URL || 'http://localhost:3000').replace(/\/$/, '');
+  const identifierField = authManager.identifierField || 'email';
+
+  function userDisplayName(user) {
+    return user.name || user[identifierField] || 'there';
+  }
+
+  function buildUrl(pathSegment, token) {
+    const sep = pathSegment.includes('?') ? '&' : '?';
+    return `${baseUrl}${pathSegment}${sep}token=${encodeURIComponent(token)}`;
+  }
+
+  if (merged.passwordReset?.enabled) {
+    authManager.notifications.passwordReset = async (user, { token, resetUrl }) => {
+      const url = resetUrl || buildUrl(merged.passwordReset.path, token);
+      await emailService.sendTemplate(merged.passwordReset.template, {
+        to: user[identifierField],
+        subject: merged.passwordReset.subject,
+        data: {
+          name: userDisplayName(user),
+          token,
+          resetUrl: url,
+          email: user[identifierField],
+        },
+      });
+    };
+  }
+
+  if (merged.emailVerification?.enabled) {
+    authManager.notifications.emailVerification = async (user, { token, verifyUrl }) => {
+      const url = verifyUrl || buildUrl(merged.emailVerification.path, token);
+      await emailService.sendTemplate(merged.emailVerification.template, {
+        to: user[identifierField],
+        subject: merged.emailVerification.subject,
+        data: {
+          name: userDisplayName(user),
+          token,
+          verifyUrl: url,
+          email: user[identifierField],
+        },
+      });
+    };
+  }
+
+  if (merged.welcome?.enabled) {
+    authManager.notifications.welcome = async (user) => {
+      await emailService.sendTemplate(merged.welcome.template, {
+        to: user[identifierField],
+        subject: merged.welcome.subject,
+        data: {
+          name: userDisplayName(user),
+          email: user[identifierField],
+        },
+      });
+    };
+  }
+
+  return merged;
+}
+
+/**
+ * @param {Object} options
+ * @param {Object} options.authManager
+ * @param {Object} options.ctx - RoutesReadyContext
+ * @param {Object} options.authEmailsConfig
+ */
+function registerAuthEmailRoutes(options) {
+  const { authManager, ctx, authEmailsConfig } = options;
+  if (!authEmailsConfig?.registerRoutes) return;
+
+  const prefix = authEmailsConfig.routePrefix || '/api/auth';
+  const guest = ctx.middlewares?.guest;
+  const authMw = ctx.middlewares?.auth;
+
+  const base = (authEmailsConfig.baseUrl || process.env.BASE_URL || 'http://localhost:3000').replace(/\/$/, '');
+
+  async function forgotPasswordHandler(req, res) {
+    try {
+      const email = req.body?.email || req.body?.identifier;
+      if (email) {
+        await authManager.requestPasswordReset(String(email), {
+          tokenTtlMs: authEmailsConfig.passwordReset?.tokenTtlMs,
+          buildResetUrl: (token) => {
+            const pathSeg = authEmailsConfig.passwordReset?.path || '/reset-password';
+            return `${base}${pathSeg}?token=${encodeURIComponent(token)}`;
+          },
+        });
+      }
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  }
+
+  async function resetPasswordHandler(req, res) {
+    try {
+      const { token, password } = req.body || {};
+      if (!token || !password) {
+        return res.status(400).json({ error: 'token and password are required' });
+      }
+      await authManager.completePasswordReset(String(token), String(password));
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(err.status || 400).json({ error: err.message, code: err.code });
+    }
+  }
+
+  async function verifyEmailHandler(req, res) {
+    try {
+      const { token } = req.body || {};
+      if (!token) {
+        return res.status(400).json({ error: 'token is required' });
+      }
+      const result = await authManager.verifyEmail(String(token));
+      res.json(result);
+    } catch (err) {
+      res.status(err.status || 400).json({ error: err.message, code: err.code });
+    }
+  }
+
+  async function resendVerificationHandler(req, res) {
+    try {
+      const userId = req.user?.id;
+      if (!userId) {
+        return res.status(401).json({ error: 'Authentication required' });
+      }
+      await authManager.requestEmailVerification(userId, {
+        tokenTtlMs: authEmailsConfig.emailVerification?.tokenTtlMs,
+        buildVerifyUrl: (token) => {
+          const pathSeg = authEmailsConfig.emailVerification?.path || '/verify-email';
+          return `${base}${pathSeg}?token=${encodeURIComponent(token)}`;
+        },
+      });
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  }
+
+  const forgotMw = guest ? [guest, forgotPasswordHandler] : [forgotPasswordHandler];
+  const resetMw = guest ? [guest, resetPasswordHandler] : [resetPasswordHandler];
+  const resendMw = authMw ? [authMw, resendVerificationHandler] : [resendVerificationHandler];
+
+  ctx.addRoute('post', `${prefix}/forgot-password`, ...forgotMw);
+  ctx.addRoute('post', `${prefix}/reset-password`, ...resetMw);
+  ctx.addRoute('post', `${prefix}/verify-email`, verifyEmailHandler);
+  ctx.addRoute('post', `${prefix}/resend-verification`, ...resendMw);
+}
+
+module.exports = {
+  wireAuthEmails,
+  registerAuthEmailRoutes,
+};

package/plugins/email/bundled-templates.js

@@ -0,0 +1,68 @@
+/**
+ * Built-in auth email templates (inline MJML — no filesystem reads)
+ * Source copies for editing: plugins/email/templates/*.mjml (sync to this file manually)
+ * @module plugins/email/bundled-templates
+ */
+
+/** @type {Record<string, { mjml: string }>} */
+const BUNDLED_AUTH_TEMPLATES = {
+  'auth-password-reset': {
+    mjml: `<mjml>
+  <mj-body background-color="#f4f4f5">
+    <mj-section background-color="#ffffff" padding="32px 24px">
+      <mj-column>
+        <mj-text font-size="20px" font-weight="600" color="#18181b">Reset your password</mj-text>
+        <mj-text color="#52525b">Hi {{name}},</mj-text>
+        <mj-text color="#52525b">We received a request to reset your password. Click the button below to choose a new one.</mj-text>
+        <mj-button background-color="#2563eb" href="{{resetUrl}}">Reset password</mj-button>
+        <mj-text color="#71717a" font-size="12px">If you did not request this, you can safely ignore this email.</mj-text>
+      </mj-column>
+    </mj-section>
+  </mj-body>
+</mjml>`,
+  },
+  'auth-email-verify': {
+    mjml: `<mjml>
+  <mj-body background-color="#f4f4f5">
+    <mj-section background-color="#ffffff" padding="32px 24px">
+      <mj-column>
+        <mj-text font-size="20px" font-weight="600" color="#18181b">Verify your email</mj-text>
+        <mj-text color="#52525b">Hi {{name}},</mj-text>
+        <mj-text color="#52525b">Please confirm your email address by clicking the button below.</mj-text>
+        <mj-button background-color="#2563eb" href="{{verifyUrl}}">Verify email</mj-button>
+        <mj-text color="#71717a" font-size="12px">If you did not create an account, you can ignore this message.</mj-text>
+      </mj-column>
+    </mj-section>
+  </mj-body>
+</mjml>`,
+  },
+  'auth-welcome': {
+    mjml: `<mjml>
+  <mj-body background-color="#f4f4f5">
+    <mj-section background-color="#ffffff" padding="32px 24px">
+      <mj-column>
+        <mj-text font-size="20px" font-weight="600" color="#18181b">Welcome</mj-text>
+        <mj-text color="#52525b">Hi {{name}},</mj-text>
+        <mj-text color="#52525b">Thanks for joining us. Your account is ready.</mj-text>
+      </mj-column>
+    </mj-section>
+  </mj-body>
+</mjml>`,
+  },
+};
+
+/**
+ * @param {import('./template-registry').TemplateRegistry} registry
+ */
+function registerBundledAuthTemplates(registry) {
+  for (const [id, source] of Object.entries(BUNDLED_AUTH_TEMPLATES)) {
+    if (!registry.has(id)) {
+      registry.register(id, source, 'inline');
+    }
+  }
+}
+
+module.exports = {
+  BUNDLED_AUTH_TEMPLATES,
+  registerBundledAuthTemplates,
+};

package/plugins/email/fs-env.js

@@ -0,0 +1,101 @@
+/**
+ * Optional Node.js filesystem helpers — no top-level fs import (edge/worker safe)
+ * @module plugins/email/fs-env
+ */
+
+let fsModule = null;
+let fsChecked = false;
+
+/**
+ * @returns {typeof import('fs')|null}
+ */
+function getFs() {
+  if (fsChecked) return fsModule;
+  fsChecked = true;
+  try {
+    fsModule = require('fs');
+  } catch {
+    fsModule = null;
+  }
+  return fsModule;
+}
+
+/**
+ * @returns {boolean}
+ */
+function isFilesystemAvailable() {
+  return getFs() != null;
+}
+
+/**
+ * @param {string} str
+ * @returns {boolean}
+ */
+function isInlineMarkup(str) {
+  const trimmed = String(str).trim();
+  return trimmed.startsWith('<mjml')
+    || trimmed.startsWith('<html')
+    || trimmed.startsWith('<!DOCTYPE')
+    || trimmed.startsWith('<!doctype');
+}
+
+/**
+ * @param {string} str
+ * @returns {boolean}
+ */
+function looksLikeFilePath(str) {
+  if (isInlineMarkup(str)) return false;
+  const s = String(str);
+  return s.startsWith('./')
+    || s.startsWith('../')
+    || s.startsWith('/')
+    || s.startsWith('~')
+    || /\.(mjml|html|htm|txt)$/i.test(s);
+}
+
+/**
+ * @param {string} filePath
+ * @returns {string|null}
+ */
+function readFileUtf8(filePath) {
+  const fs = getFs();
+  if (!fs) return null;
+
+  const path = require('path');
+  const resolved = path.resolve(filePath);
+
+  try {
+    if (!fs.existsSync(resolved)) return null;
+    return fs.readFileSync(resolved, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string} dir
+ * @returns {string[]|null} null when fs unavailable
+ */
+function listMjmlBasenamesInDir(dir) {
+  const fs = getFs();
+  if (!fs) return null;
+
+  const path = require('path');
+  const resolved = path.resolve(dir);
+
+  try {
+    if (!fs.existsSync(resolved)) return [];
+    return fs.readdirSync(resolved).filter((f) => f.endsWith('.mjml'));
+  } catch {
+    return [];
+  }
+}
+
+module.exports = {
+  getFs,
+  isFilesystemAvailable,
+  isInlineMarkup,
+  looksLikeFilePath,
+  readFileUtf8,
+  listMjmlBasenamesInDir,
+};

package/plugins/email/index.js

@@ -0,0 +1,186 @@
+/**
+ * Email plugin — MJML + Nodemailer
+ * @module plugins/email
+ */
+
+const { TemplateRegistry } = require('./template-registry');
+const { createEmailService } = require('./service');
+const { createEmailApiHandlers } = require('./api-handlers');
+const { generateEmailComponent } = require('./admin-component');
+const { generateEmailLogsMigration } = require('./migration-template');
+const { purgeEmailLogs } = require('./purge');
+const { wireAuthEmails, registerAuthEmailRoutes } = require('./auth-bridge');
+const { emailPluginOptionsFromManifest } = require('./manifest');
+
+/**
+ * @param {Object} options
+ * @param {Object} [options.db] - Database instance (must expose .knex)
+ * @param {Object} [options.transport] - Nodemailer transport instance
+ * @param {Object} [options.smtp] - SMTP options
+ * @param {Object} [options.defaults] - Default from/replyTo
+ * @param {string} [options.templatesDir] - Directory of *.mjml templates
+ * @param {Object} [options.templates] - Template map
+ * @param {boolean} [options.logToDb] - Log sends to DB (default true when db present)
+ * @param {string} [options.tableName='email_logs']
+ * @param {boolean} [options.includeAdminPage=true]
+ * @param {string} [options.adminPath='/_admin']
+ * @param {string} [options.apiPrefix='/email']
+ * @param {Object} [options.auth] - AuthManager instance
+ * @param {Object} [options.authEmails] - Auth email bridge config
+ * @param {Object} [options.emailTemplates] - Precompiled templates from build manifest
+ * @param {Object} [options.manifest] - Full build manifest (uses emailTemplates field)
+ */
+function emailPlugin(options = {}) {
+  const {
+    db,
+    transport,
+    smtp,
+    defaults = {},
+    templatesDir,
+    templates = {},
+    tableName = 'email_logs',
+    includeAdminPage = true,
+    adminPath: adminPathOpt,
+    apiPrefix = '/email',
+    auth: authOption,
+    authEmails,
+    emailTemplates: emailTemplatesOpt,
+    manifest,
+  } = options;
+
+  const logToDb = options.logToDb !== undefined ? options.logToDb : !!db;
+  const knex = db ? (db.knex || db) : null;
+
+  if (logToDb && !db) {
+    console.warn('[email] logToDb is enabled but no db was passed — logging disabled');
+  }
+
+  const registry = new TemplateRegistry();
+
+  const manifestChunks = emailTemplatesOpt
+    || manifest?.emailTemplates
+    || null;
+  if (manifestChunks) {
+    registry.loadFromManifest(manifestChunks);
+  }
+
+  if (templatesDir) registry.loadFromDir(templatesDir);
+  registry.loadFromMap(templates);
+
+  const emailService = createEmailService({
+    registry,
+    transportOptions: { transport, smtp },
+    defaults,
+    knex: logToDb ? knex : null,
+    logToDb: logToDb && !!knex,
+    tableName,
+  });
+
+  let wiredAuthEmailsConfig = null;
+
+  return {
+    name: 'email',
+    version: '1.0.0',
+    description: 'MJML + Nodemailer email sending with optional admin UI and auth integration',
+    dependencies: includeAdminPage ? { 'admin-panel': '*' } : {},
+
+    api: {
+      send: (opts) => emailService.send(opts),
+      sendTemplate: (name, opts) => emailService.sendTemplate(name, opts),
+      preview: (nameOrOpts, data) => emailService.preview(nameOrOpts, data),
+      registerTemplate: (id, source) => registry.register(id, source),
+      listTemplates: () => registry.list(),
+      verifyConnection: () => emailService.verifyConnection(),
+      queryLogs: (filters) => emailService.queryLogs(filters),
+      purgeLogs: (opts = {}) => {
+        if (!knex) throw new Error('Database is required for purgeLogs');
+        return purgeEmailLogs(knex, {
+          tableName: opts.tableName || tableName,
+          olderThan: opts.olderThan,
+        });
+      },
+      getMigrationTemplate: (name) => generateEmailLogsMigration(name || tableName),
+      isTransportReady: () => emailService.isTransportReady(),
+      loadFromManifest: (chunks) => registry.loadFromManifest(chunks),
+      emailPluginOptionsFromManifest,
+    },
+
+    register(ctx) {
+      // noop — templates loaded at plugin init; register available for future hot-reload
+    },
+
+    onRoutesReady(ctx) {
+      const authManager = authOption || ctx.options?.auth || null;
+
+      if (authEmails?.enabled && authManager) {
+        wiredAuthEmailsConfig = wireAuthEmails(
+          authManager,
+          emailService,
+          registry,
+          authEmails,
+          db
+        );
+        registerAuthEmailRoutes({
+          authManager,
+          ctx,
+          authEmailsConfig: wiredAuthEmailsConfig,
+        });
+      } else if (authEmails?.enabled && !authManager) {
+        console.warn('[email] authEmails.enabled but no auth manager found — pass auth to createApp or emailPlugin');
+      }
+
+      if (!includeAdminPage) return;
+
+      const adminApi = ctx.usePlugin('admin-panel');
+      if (!adminApi) {
+        console.warn('[email] admin-panel plugin not found, skipping admin page registration');
+        return;
+      }
+
+      const handlers = createEmailApiHandlers({
+        emailService,
+        registry,
+        knex: logToDb ? knex : null,
+        tableName,
+      });
+
+      adminApi.registerModule({
+        id: 'email',
+
+        pages: [{
+          id: 'email',
+          title: 'Email',
+          path: '/email',
+          icon: 'mail',
+          component: generateEmailComponent({ apiPrefix }),
+        }],
+
+        menu: [{
+          id: 'email',
+          label: 'Email',
+          path: '/email',
+          icon: 'mail',
+          order: 40,
+        }],
+
+        api: {
+          prefix: apiPrefix,
+          routes: [
+            { method: 'get', path: '/logs', handler: handlers.listLogsHandler },
+            { method: 'get', path: '/templates', handler: handlers.templatesHandler },
+            { method: 'post', path: '/send-test', handler: handlers.sendTestHandler },
+            { method: 'post', path: '/preview', handler: handlers.previewHandler },
+            { method: 'post', path: '/verify', handler: handlers.verifyHandler },
+            { method: 'post', path: '/purge', handler: handlers.purgeHandler },
+          ],
+        },
+      });
+    },
+  };
+}
+
+module.exports = emailPlugin;
+module.exports.emailPlugin = emailPlugin;
+module.exports.generateEmailLogsMigration = generateEmailLogsMigration;
+module.exports.purgeEmailLogs = purgeEmailLogs;
+module.exports.emailPluginOptionsFromManifest = emailPluginOptionsFromManifest;

package/plugins/email/manifest.js

@@ -0,0 +1,25 @@
+/**
+ * Build manifest helpers for email plugin
+ * @module plugins/email/manifest
+ */
+
+/**
+ * @param {object} manifest
+ * @returns {{ templates: Record<string, { mjml?: string, html?: string }>, emailTemplates: Record<string, object> }}
+ */
+function emailPluginOptionsFromManifest(manifest) {
+  const chunks = manifest?.emailTemplates || {};
+  /** @type {Record<string, { mjml?: string, html?: string }>} */
+  const templates = {};
+
+  for (const [id, chunk] of Object.entries(chunks)) {
+    if (chunk?.mjml) templates[id] = { mjml: chunk.mjml };
+    else if (chunk?.html) templates[id] = { html: chunk.html };
+  }
+
+  return { templates, emailTemplates: chunks };
+}
+
+module.exports = {
+  emailPluginOptionsFromManifest,
+};

package/plugins/email/migration-template.js

@@ -0,0 +1,40 @@
+/**
+ * Migration template for email_logs table
+ * @module plugins/email/migration-template
+ */
+
+/**
+ * @param {string} [tableName='email_logs']
+ * @returns {string}
+ */
+function generateEmailLogsMigration(tableName = 'email_logs') {
+  return `/**
+ * Migration: Create ${tableName} table
+ * Auto-generated by email plugin
+ */
+
+exports.up = function(knex) {
+  return knex.schema.createTable('${tableName}', (table) => {
+    table.bigIncrements('id').primary();
+    table.string('to', 1000).nullable();
+    table.string('cc', 1000).nullable();
+    table.string('bcc', 1000).nullable();
+    table.string('subject', 500).nullable();
+    table.string('template_id', 255).nullable().index();
+    table.string('from', 255).nullable();
+    table.string('status', 16).notNullable().index();
+    table.string('message_id', 255).nullable();
+    table.text('error').nullable();
+    table.timestamp('created_at').defaultTo(knex.fn.now()).notNullable().index();
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTableIfExists('${tableName}');
+};
+`;
+}
+
+module.exports = {
+  generateEmailLogsMigration,
+};

package/plugins/email/purge.js

@@ -0,0 +1,28 @@
+/**
+ * Delete email log rows older than a cutoff
+ * @module plugins/email/purge
+ */
+
+/**
+ * @param {import('knex').Knex} knex
+ * @param {Object} options
+ * @param {string} [options.tableName='email_logs']
+ * @param {Date|string} options.olderThan
+ * @returns {Promise<number>}
+ */
+async function purgeEmailLogs(knex, options) {
+  const tableName = options.tableName || 'email_logs';
+  const olderThan = options.olderThan instanceof Date
+    ? options.olderThan
+    : new Date(options.olderThan);
+
+  if (Number.isNaN(olderThan.getTime())) {
+    throw new Error('purgeEmailLogs: invalid olderThan date');
+  }
+
+  return knex(tableName).where('created_at', '<', olderThan).delete();
+}
+
+module.exports = {
+  purgeEmailLogs,
+};