webspresso 0.0.97 → 0.0.98

package/plugins/dashboard/index.js

@@ -1,29 +1,92 @@
+'use strict';
+
 /**
  * Webspresso Dashboard Plugin
- * Development dashboard for monitoring routes, plugins, and configuration
+ * Development dashboard for monitoring routes, ORM models, services, plugins, and configuration
  * Uses Mithril.js for the SPA interface
+ * @module plugins/dashboard
  */
 
 const styles = require('./styles');
 const appScript = require('./app');
+const { getAllModels } = require('../../core/orm/model');
+const { getServiceRegistry, hasServiceRegistry, hasDb, getDb } = require('../../src/app-context');
 
 /**
  * Filter sensitive environment variables
+ * @param {Object} env
+ * @returns {Object}
  */
 function filterSensitiveEnv(env) {
   const sensitiveKeys = ['SECRET', 'PASSWORD', 'KEY', 'TOKEN', 'CREDENTIAL', 'PRIVATE'];
   const filtered = {};
-  
+
   for (const [key, value] of Object.entries(env)) {
-    const isSensitive = sensitiveKeys.some(s => key.toUpperCase().includes(s));
+    const isSensitive = sensitiveKeys.some((s) => key.toUpperCase().includes(s));
     filtered[key] = isSensitive ? '••••••••' : value;
   }
-  
+
   return filtered;
 }
 
+/**
+ * Safely collects all registered ORM models
+ * @returns {Array<Object>}
+ */
+function collectModels() {
+  try {
+    const models = getAllModels();
+    const result = [];
+    for (const [name, model] of models.entries()) {
+      result.push({
+        name,
+        table: model.table || name.toLowerCase(),
+        primaryKey: model.primaryKey || 'id',
+        columns: model.schema && model.schema.shape ? Object.keys(model.schema.shape) : [],
+        columnCount: model.schema && model.schema.shape ? Object.keys(model.schema.shape).length : 0,
+        relations: Object.keys(model.relations || {}),
+        scopes: Object.keys(model.scopes || {}),
+        softDelete: Boolean(model.scopes?.softDelete || model.scopes?.notDeleted || model.softDelete || model.paranoid),
+        cache: model.cache || false,
+      });
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Safely collects all registered business services
+ * @returns {Array<Object>}
+ */
+function collectServices() {
+  try {
+    if (!hasServiceRegistry()) return [];
+    const registry = getServiceRegistry();
+    const result = [];
+    if (registry && registry.services) {
+      for (const [name, def] of registry.services.entries()) {
+        result.push({
+          name,
+          transaction: Boolean(def.transaction),
+          auth: def.auth !== undefined ? def.auth : false,
+          timeout: def.timeout || null,
+          hasSchema: Boolean(def.schema),
+          cache: def.cache ? true : false,
+        });
+      }
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+
 /**
  * Generate the dashboard HTML
+ * @param {Object} data
+ * @returns {string}
  */
 function generateDashboardHtml(data) {
   return `<!DOCTYPE html>
@@ -48,25 +111,25 @@ function generateDashboardHtml(data) {
 /**
  * Create the dashboard plugin
  * @param {Object} options - Plugin options
- * @param {string} options.path - Dashboard path (default: '/_webspresso')
- * @param {boolean} options.enabled - Force enable/disable (default: auto based on NODE_ENV)
+ * @param {string} [options.path='/_webspresso'] - Dashboard path
+ * @param {boolean} [options.enabled] - Force enable/disable (default: auto based on NODE_ENV)
  */
 function dashboardPlugin(options = {}) {
   const {
     path: dashboardPath = '/_webspresso',
-    enabled
+    enabled,
   } = options;
-  
+
   // Determine if enabled (default: only in development)
-  const isEnabled = enabled !== undefined 
-    ? enabled 
+  const isEnabled = enabled !== undefined
+    ? enabled
     : process.env.NODE_ENV !== 'production';
-  
+
   return {
     name: 'dashboard',
     version: '1.0.0',
-    description: 'Development dashboard for monitoring routes and configuration',
-    
+    description: 'Development dashboard for monitoring routes, models, services, and configuration',
+
     /**
      * Called after routes are mounted
      */
@@ -75,68 +138,109 @@ function dashboardPlugin(options = {}) {
       if (!isEnabled) {
         return;
       }
-      
-      const { app, routes, options: appOptions } = ctx;
-      
+
+      const { app, routes = [], options: appOptions = {} } = ctx;
+
       // Collect plugin info
-      const pluginManager = ctx.pluginManager || (appOptions && appOptions.pluginManager);
+      const pluginManager = ctx.pluginManager || appOptions.pluginManager;
       const plugins = [];
-      
+
       // Get plugins from plugin manager if available
       if (pluginManager && pluginManager.plugins) {
         for (const [name, plugin] of pluginManager.plugins) {
           plugins.push({
             name: plugin.name || name,
             version: plugin.version || '0.0.0',
-            description: plugin.description || ''
+            description: plugin.description || '',
           });
         }
       }
-      
+
+      // Collect models and services
+      const models = collectModels();
+      const services = collectServices();
+
       // Build config data
       const config = {
         env: filterSensitiveEnv({
           NODE_ENV: process.env.NODE_ENV || 'development',
           PORT: process.env.PORT || '3000',
-          BASE_URL: process.env.BASE_URL || 'http://localhost:3000'
+          BASE_URL: process.env.BASE_URL || 'http://localhost:3000',
         }),
         i18n: {
           defaultLocale: process.env.DEFAULT_LOCALE || 'en',
-          supportedLocales: (process.env.SUPPORTED_LOCALES || 'en').split(',')
+          supportedLocales: (process.env.SUPPORTED_LOCALES || 'en').split(','),
         },
         server: {
           port: process.env.PORT || '3000',
-          baseUrl: process.env.BASE_URL || 'http://localhost:3000'
-        }
+          baseUrl: process.env.BASE_URL || 'http://localhost:3000',
+        },
+        database: {
+          connected: hasDb(),
+          dialect: hasDb() ? (getDb().client || getDb().knex?.client?.config?.client || 'knex') : 'none',
+        },
       };
-      
-      // Dashboard HTML endpoint
+
+      const overview = {
+        routesCount: routes.length,
+        modelsCount: models.length,
+        servicesCount: services.length,
+        pluginsCount: plugins.length,
+        uptime: process.uptime(),
+        memoryUsage: process.memoryUsage(),
+      };
+
+      // 1. Dashboard HTML endpoint
       ctx.addRoute('get', dashboardPath, (req, res) => {
-        const data = { routes, plugins, config };
+        const data = { routes, plugins, config, models, services, overview };
         res.type('text/html');
         res.send(generateDashboardHtml(data));
       });
-      
-      // JSON API endpoints
-      ctx.addRoute('get', dashboardPath + '/api/routes', (req, res) => {
+
+      // 2. JSON API endpoints
+      ctx.addRoute('get', `${dashboardPath}/api/routes`, (req, res) => {
         res.json(routes);
       });
-      
-      ctx.addRoute('get', dashboardPath + '/api/plugins', (req, res) => {
+
+      ctx.addRoute('get', `${dashboardPath}/api/plugins`, (req, res) => {
         res.json(plugins);
       });
-      
-      ctx.addRoute('get', dashboardPath + '/api/config', (req, res) => {
+
+      ctx.addRoute('get', `${dashboardPath}/api/config`, (req, res) => {
         res.json(config);
       });
-      
+
+      ctx.addRoute('get', `${dashboardPath}/api/models`, (req, res) => {
+        res.json(collectModels());
+      });
+
+      ctx.addRoute('get', `${dashboardPath}/api/services`, (req, res) => {
+        res.json(collectServices());
+      });
+
+      ctx.addRoute('get', `${dashboardPath}/api/overview`, (req, res) => {
+        res.json({
+          routesCount: (ctx.routes || []).length,
+          modelsCount: collectModels().length,
+          servicesCount: collectServices().length,
+          pluginsCount: plugins.length,
+          nodeVersion: process.version,
+          platform: process.platform,
+          uptime: process.uptime(),
+          memoryUsage: process.memoryUsage(),
+        });
+      });
+
       // Log dashboard URL
       console.log(`\n📊 Dashboard available at: http://localhost:${process.env.PORT || 3000}${dashboardPath}\n`);
-    }
+    },
   };
 }
 
 module.exports = dashboardPlugin;
-
-
-
+module.exports.dashboardPlugin = dashboardPlugin;
+module.exports.devToolbarPlugin = dashboardPlugin;
+module.exports.devtoolsPlugin = dashboardPlugin;
+module.exports.generateDashboardHtml = generateDashboardHtml;
+module.exports.collectModels = collectModels;
+module.exports.collectServices = collectServices;

package/plugins/dashboard/styles.js

@@ -378,6 +378,84 @@ tr:hover td {
   animation: spin 0.8s linear infinite;
   margin-right: 12px;
 }
+
+/* Header Actions */
+.header-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.action-link {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 6px 12px;
+  border-radius: 6px;
+  font-size: 13px;
+  font-weight: 500;
+  text-decoration: none;
+  background: var(--bg-tertiary);
+  border: 1px solid var(--border);
+  color: var(--text-primary);
+  transition: all 0.15s ease;
+}
+
+.action-link:hover {
+  background: var(--border);
+  border-color: var(--accent);
+  color: var(--text-primary);
+}
+
+/* Badges */
+.badge {
+  display: inline-block;
+  padding: 2px 8px;
+  border-radius: 10px;
+  font-size: 11px;
+  font-weight: 600;
+  text-transform: uppercase;
+}
+
+.badge-green {
+  background: rgba(63, 185, 80, 0.15);
+  color: var(--green);
+  border: 1px solid rgba(63, 185, 80, 0.3);
+}
+
+.badge-blue {
+  background: rgba(88, 166, 255, 0.15);
+  color: var(--accent);
+  border: 1px solid rgba(88, 166, 255, 0.3);
+}
+
+.badge-purple {
+  background: rgba(163, 113, 247, 0.15);
+  color: var(--purple);
+  border: 1px solid rgba(163, 113, 247, 0.3);
+}
+
+.badge-orange {
+  background: rgba(210, 153, 34, 0.15);
+  color: var(--orange);
+  border: 1px solid rgba(210, 153, 34, 0.3);
+}
+
+.badge-gray {
+  background: rgba(110, 118, 129, 0.15);
+  color: var(--text-muted);
+  border: 1px solid rgba(110, 118, 129, 0.3);
+}
+
+.code-badge {
+  font-family: 'SF Mono', SFMono-Regular, ui-monospace, monospace;
+  font-size: 12px;
+  background: var(--bg-tertiary);
+  padding: 2px 6px;
+  border-radius: 4px;
+  border: 1px solid var(--border);
+  color: var(--accent);
+}
 `;
 
 

package/plugins/data-exchange/export-xlsx.js

@@ -3,7 +3,13 @@
  * @module plugins/data-exchange/export-xlsx
  */
 
-const ExcelJS = require('exceljs');
+let ExcelJS = null;
+function getExcelJS() {
+  if (!ExcelJS) {
+    ExcelJS = require('exceljs');
+  }
+  return ExcelJS;
+}
 const { sanitizeForOutput } = require('../../core/orm/utils');
 const { resolveExportRecords } = require('./record-selection');
 
@@ -42,7 +48,8 @@ async function buildXlsxBuffer(model, records) {
   const clean = sanitizeForOutput(records, model);
   const columns = getModelExportColumns(model, clean);
 
-  const wb = new ExcelJS.Workbook();
+  const ExcelLib = getExcelJS();
+  const wb = new ExcelLib.Workbook();
   const ws = wb.addWorksheet('Export', {
     views: [{ state: 'frozen', ySplit: 1 }],
   });

package/plugins/data-exchange/import.js

@@ -4,7 +4,13 @@
  */
 
 const multer = require('multer');
-const ExcelJS = require('exceljs');
+let ExcelJS = null;
+function getExcelJS() {
+  if (!ExcelJS) {
+    ExcelJS = require('exceljs');
+  }
+  return ExcelJS;
+}
 const { parse: parseCsv } = require('csv-parse/sync');
 const { buildHeaderMapping, dataRowsToObjects } = require('./parse-table');
 
@@ -132,7 +138,8 @@ function parseCsvToRows(buffer) {
 }
 
 async function parseXlsxToRows(buffer) {
-  const wb = new ExcelJS.Workbook();
+  const ExcelLib = getExcelJS();
+  const wb = new ExcelLib.Workbook();
   await wb.xlsx.load(buffer);
   const ws = wb.worksheets[0];
   if (!ws) return [];

package/plugins/data-exchange/index.js

@@ -76,14 +76,17 @@ function dataExchangePlugin(options = {}) {
           models: '*',
           confirm: false,
           handler: async (records, modelName, { db: d }) => {
+            const targetModel = typeof modelName === 'object' && modelName !== null
+              ? (modelName.name || modelName.modelName || modelName.model || String(modelName))
+              : String(modelName);
             const { getModel } = require('../../core/orm/model');
-            const model = d.getModel ? d.getModel(modelName) : getModel(modelName);
+            const model = d.getModel ? d.getModel(targetModel) : getModel(targetModel);
             const pk = model?.primaryKey || 'id';
             const ids = records.map((r) => r[pk]).join(',');
             return {
               download: true,
-              url: `${adminPath}/api/data-exchange/export/${modelName}?ids=${encodeURIComponent(ids)}`,
-              filename: `${modelName}_export.xlsx`,
+              url: `${adminPath}/api/data-exchange/export/${targetModel}?ids=${encodeURIComponent(ids)}`,
+              filename: `${targetModel}_export.xlsx`,
             };
           },
         });

package/plugins/email/index.js

@@ -29,10 +29,21 @@ const { emailPluginOptionsFromManifest } = require('./manifest');
  * @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)
+ * @param {Object|boolean} [options.retention] - Retention policy configuration (set false to disable)
+ * @param {number} [options.retention.days=90] - Days to retain email logs
+ * @param {number} [options.retention.intervalMs=86400000] - Auto-cleanup timer frequency (24h)
+ * @param {boolean} [options.retention.runOnStart=true] - Run initial purge shortly after startup
+ * @param {number} [options.retentionDays=90] - Shorthand for retention.days
+ * @param {number} [options.cleanupIntervalMs=86400000] - Shorthand for retention.intervalMs
+ * @param {boolean} [options.autoCleanup=true] - Enable automatic background cleanup
+ * @param {boolean} [options.cleanupOnStart=true] - Run initial purge on start
+ * @param {number} [options.cleanupStartDelayMs] - Delay in ms before start purge
  */
 function emailPlugin(options = {}) {
   const {
     db,
+    title,
+    adminTitle,
     transport,
     smtp,
     defaults = {},
@@ -48,6 +59,8 @@ function emailPlugin(options = {}) {
     manifest,
   } = options;
 
+  const pageTitle = title || adminTitle || 'Email';
+
   const logToDb = options.logToDb !== undefined ? options.logToDb : !!db;
   const knex = db ? (db.knex || db) : null;
 
@@ -55,6 +68,90 @@ function emailPlugin(options = {}) {
     console.warn('[email] logToDb is enabled but no db was passed — logging disabled');
   }
 
+  // Retention configuration
+  const retentionOption = options.retention;
+  const isRetentionDisabled =
+    retentionOption === false ||
+    (typeof retentionOption === 'object' && retentionOption.enabled === false) ||
+    options.retentionDays === null ||
+    options.retentionDays === 0 ||
+    !logToDb ||
+    !knex;
+
+  const autoCleanupEnabled =
+    !isRetentionDisabled &&
+    options.autoCleanup !== false &&
+    (typeof retentionOption !== 'object' || retentionOption.autoCleanup !== false);
+
+  const retentionConfig = {
+    enabled: !isRetentionDisabled,
+    autoCleanup: autoCleanupEnabled,
+    days: (typeof options.retentionDays === 'number' && options.retentionDays > 0)
+      ? options.retentionDays
+      : (typeof retentionOption === 'object' && retentionOption?.days ? retentionOption.days : 90),
+    intervalMs: (typeof options.cleanupIntervalMs === 'number' && options.cleanupIntervalMs > 0)
+      ? options.cleanupIntervalMs
+      : (typeof retentionOption === 'object' && retentionOption?.intervalMs ? retentionOption.intervalMs : 24 * 60 * 60 * 1000),
+    runOnStart: (typeof retentionOption === 'object' && retentionOption?.runOnStart !== undefined)
+      ? !!retentionOption.runOnStart
+      : (options.cleanupOnStart !== undefined ? !!options.cleanupOnStart : true),
+  };
+
+  let cleanupInterval = null;
+  let cleanupStartTimeout = null;
+
+  async function runCleanup() {
+    if (!knex) return 0;
+    try {
+      return await purgeEmailLogs(knex, {
+        tableName,
+        days: retentionConfig.days,
+      });
+    } catch (err) {
+      if (process.env.NODE_ENV !== 'test') {
+        console.warn('[email] Failed to run retention cleanup:', err.message);
+      }
+    }
+  }
+
+  function startCleanup(customIntervalMs) {
+    stopCleanup();
+    if (!retentionConfig.enabled || !knex) return;
+    if (typeof customIntervalMs === 'number' && customIntervalMs > 0) {
+      retentionConfig.intervalMs = customIntervalMs;
+    }
+
+    if (retentionConfig.runOnStart) {
+      const delayMs = typeof options.cleanupStartDelayMs === 'number'
+        ? options.cleanupStartDelayMs
+        : (process.env.NODE_ENV === 'test' ? 50 : 5000);
+      cleanupStartTimeout = setTimeout(() => {
+        runCleanup();
+      }, delayMs);
+      if (cleanupStartTimeout && cleanupStartTimeout.unref) {
+        cleanupStartTimeout.unref();
+      }
+    }
+
+    cleanupInterval = setInterval(() => {
+      runCleanup();
+    }, retentionConfig.intervalMs);
+    if (cleanupInterval && cleanupInterval.unref) {
+      cleanupInterval.unref();
+    }
+  }
+
+  function stopCleanup() {
+    if (cleanupStartTimeout) {
+      clearTimeout(cleanupStartTimeout);
+      cleanupStartTimeout = null;
+    }
+    if (cleanupInterval) {
+      clearInterval(cleanupInterval);
+      cleanupInterval = null;
+    }
+  }
+
   const registry = new TemplateRegistry();
 
   const manifestChunks = emailTemplatesOpt
@@ -81,7 +178,7 @@ function emailPlugin(options = {}) {
   return {
     name: 'email',
     version: '1.0.0',
-    description: 'MJML + Nodemailer email sending with optional admin UI and auth integration',
+    description: 'MJML + Nodemailer email sending with optional admin UI, auth integration, and retention cleanup',
     dependencies: includeAdminPage ? { 'admin-panel': '*' } : {},
 
     api: {
@@ -92,13 +189,29 @@ function emailPlugin(options = {}) {
       listTemplates: () => registry.list(),
       verifyConnection: () => emailService.verifyConnection(),
       queryLogs: (filters) => emailService.queryLogs(filters),
+      purge: (opts = {}) => {
+        if (!knex) throw new Error('Database is required for purge');
+        return purgeEmailLogs(knex, {
+          tableName: opts.tableName || tableName,
+          days: opts.days !== undefined ? opts.days : (opts.retentionDays !== undefined ? opts.retentionDays : retentionConfig.days),
+          olderThan: opts.olderThan,
+          ...opts,
+        });
+      },
       purgeLogs: (opts = {}) => {
         if (!knex) throw new Error('Database is required for purgeLogs');
         return purgeEmailLogs(knex, {
           tableName: opts.tableName || tableName,
           olderThan: opts.olderThan,
+          days: opts.days !== undefined ? opts.days : (opts.retentionDays !== undefined ? opts.retentionDays : retentionConfig.days),
+          ...opts,
         });
       },
+      startCleanup,
+      stopCleanup,
+      getRetentionConfig() {
+        return { ...retentionConfig };
+      },
       getMigrationTemplate: (name) => generateEmailLogsMigration(name || tableName),
       isTransportReady: () => emailService.isTransportReady(),
       loadFromManifest: (chunks) => registry.loadFromManifest(chunks),
@@ -120,6 +233,22 @@ function emailPlugin(options = {}) {
           }
         }
       }
+
+      if (retentionConfig.enabled && autoCleanupEnabled) {
+        startCleanup();
+      }
+
+      return () => {
+        stopCleanup();
+      };
+    },
+
+    dispose() {
+      stopCleanup();
+    },
+
+    shutdown() {
+      stopCleanup();
     },
 
     onRoutesReady(ctx) {
@@ -159,10 +288,11 @@ function emailPlugin(options = {}) {
 
       adminApi.registerModule({
         id: 'email',
+        title: pageTitle,
 
         pages: [{
           id: 'email',
-          title: 'Email',
+          title: pageTitle,
           path: '/email',
           icon: 'mail',
           component: generateEmailComponent({ apiPrefix }),