feat: mail pooling, refactor of notification lib and configs

Author: BolverBlitz

README.md

@@ -60,14 +60,16 @@ SMTP_SECURE=false
 SMTP_USER=notifications@example.com
 SMTP_PASSWORD=change-me
 SMTP_FROM=notifications@example.com
+SMTP_POOL_MAX_CONNECTIONS=1
+SMTP_POOL_MAX_MESSAGES=1000
 EMAIL_MAX_RETRIES=5
 ```
 
-`SMTP_SECURE=true` enables implicit TLS. Port `465` also enables it automatically. Failed sends are retried by the notification worker until `EMAIL_MAX_RETRIES` is reached.
+`SMTP_SECURE=true` enables implicit TLS. Port `465` also enables it automatically. SMTP pooling reuses authenticated connections; one connection can send up to `SMTP_POOL_MAX_MESSAGES` messages before reconnecting. Failed sends are retried by the notification worker until `EMAIL_MAX_RETRIES` is reached.
 
-Email HTML templates live in `config/templates/email/*.ejs`. Their i18next translations live in `config/templates/email/locales/<language>.json`; the recipient's saved language is used with `FALLBACKLANG` as fallback.
+Notification registrations live in `config/notifications/*.js`. Email HTML templates live in `config/templates/email/*.ejs`. Core email translations live in `config/templates/email/locales/<language>.json`; feature translations can use `config/templates/email/locales/<featureName>/<language>.json`. The recipient's saved language is used with `FALLBACKLANG` as fallback.
 
-Features can register additional queued email types while their startup module is loaded:
+Notification definitions are channel-independent. Current channel is `email`; future channels can be added without changing notification callers. Definitions use category `system` or `newsletter`. Newsletter registrations automatically appear in user settings.
 
 Place feature-owned templates inside the feature package:
 
@@ -83,36 +85,32 @@ config/templates/email/FoodOrderReady.ejs
 ```
 
 ```js
-const {
-  registerNotificationType,
-  sendNotification,
-} = require('@lib/notifications');
-
-registerNotificationType({
-  type: 'FoodOrderReady',
-  constant: 'FOOD_ORDER_READY',
-  templatePath: 'config/templates/email/FoodOrderReady.ejs',
-  translations: {
-    de: {
-      emails: {
-        FoodOrderReady: {
-          subject: 'Deine Bestellung ist fertig',
-          heading: 'Bestellung abholbereit',
-        },
+// installed_features/foodorders/config/notifications/foodorders.js
+module.exports = [
+  {
+    type: 'FoodOrderReady',
+    constant: 'FOOD_ORDER_READY',
+    category: 'newsletter',
+    preferenceKey: 'foodorder-ready',
+    translationKeyBase: 'FoodOrders.Notifications.Ready',
+    requiresMessage: true,
+    channels: {
+      email: {
+        templatePath: 'config/templates/email/FoodOrderReady.ejs',
+        buildContext: (task) => ({
+          order: JSON.parse(task.custom_message),
+        }),
+        buildText: (context) => `${context.name}, deine Bestellung ist fertig.`,
       },
     },
   },
-  requiresMessage: true,
-  buildContext: (task) => ({
-    order: JSON.parse(task.custom_message),
-  }),
-  buildText: (context) => `${context.name}, deine Bestellung ist fertig.`,
-});
+];
 
+const { sendNotification } = require('@lib/notifications');
 await sendNotification(userId, 0, 'FoodOrderReady', JSON.stringify(order));
 ```
 
-The type is stored in `email_tasks.type`. `templatePath` may be absolute or relative to the application root. Copied template files are tracked in the feature manifest and removed by the feature uninstaller. Feature API modules are loaded before the email worker starts, so their registrations are available when queued tasks are processed.
+The notification type is stored in `email_tasks.type`; the user preference channel is stored in `user_notifications.type`. `templatePath` may be absolute or relative to the application root. Copied registration, locale, and template files are tracked in the feature manifest and removed by the feature uninstaller. Notification config files are loaded before the email worker starts.
 
 ## OAuth Login
 
@@ -206,16 +204,28 @@ Each feature folder needs a `feature.json` or `config.json` manifest:
 
 On startup the app scans `installed_features/<featureName>`. Folder presence enables the feature. If the feature version is newer than `config/features/<featureName>.json`, or if the installed config does not exist yet, the feature files are copied into the application.
 
-Supported feature folders include application folders such as `api`, `lib`, `src`, `views`, `public`, and `config`. A top-level `templates` folder is installed into `config/templates`. Feature translations live in:
+Supported feature folders include application folders such as `api`, `lib`, `src`, `views`, `public`, and `config`. A top-level `templates` folder is installed into `config/templates`. Feature page translations live in:
 
 ```text
-installed_features/<featureName>/local/<language>/<featureName>.json
+installed_features/<featureName>/locales/<language>/features/<featureName>.json
 ```
 
 and are installed to:
 
 ```text
-config/features/local/<language>/<featureName>.json
+config/locales/<language>/features/<featureName>.json
+```
+
+Feature email translations live in:
+
+```text
+installed_features/<featureName>/templates/email/locales/<featureName>/<language>.json
+```
+
+and are installed to:
+
+```text
+config/templates/email/locales/<featureName>/<language>.json
 ```
 
 Feature public files can also be served from:

api/users.js

@@ -6,7 +6,13 @@ const { getUserNotifications, setUserNotificationState } = require('@lib/sqlite/
 const { getAllUserSessions, deleteAllWebtokensForUser } = require('@lib/sqlite/webtokens');
 const { checkIfSettingTrue, getSetting } = require('@lib/sqlite/settings');
 const { isEBGOAuthEnabled } = require('@lib/oauth');
-const { NOTIFICATION_TYPES, sendNotification } = require('@lib/notifications');
+const {
+    NOTIFICATION_TYPES,
+    NOTIFICATION_CHANNELS,
+    getNewsletterNotifications,
+    canSetNotificationPreference,
+    sendNotification,
+} = require('@lib/notifications');
 const Joi = require('@lib/sanitizer');
 const bcrypt = require('bcrypt');
 const express = require('ultimate-express');
@@ -53,7 +59,7 @@ const notificationStateSchema = Joi.object({
 
 const notificationParamsSchema = Joi.object({
     key: Joi.fullysanitizedString().pattern(/^[a-z0-9_-]+$/).min(1).max(64).required(),
-    type: Joi.fullysanitizedString().valid('email').required()
+    type: Joi.fullysanitizedString().valid(...Object.values(NOTIFICATION_CHANNELS)).required()
 });
 
 const validateUUID = Joi.object({
@@ -132,7 +138,14 @@ router.post('/', limiter(20), async (req, res) => {
 
 router.get('/', verifyRequest('web.user.read'), limiter(1), async (req, res) => {
     const user_data = await getUser(req.user.user_data.id);
-    user_data.notifications = getUserNotifications(req.user.user_data.id);
+    const preferences = getUserNotifications(req.user.user_data.id);
+    user_data.notifications = preferences;
+    user_data.notificationSettings = getNewsletterNotifications().map((definition) => ({
+        ...definition,
+        enabled: preferences.find((preference) =>
+            preference.key === definition.key && preference.type === definition.channel
+        )?.state !== false,
+    }));
     return res.json(user_data)
 });
 
@@ -187,6 +200,9 @@ router.put('/language', verifyRequest('app.user.settings.language.write'), limit
 router.put('/notifications/:key/:type', verifyRequest('app.user.settings.email.write'), limiter(10), async (req, res) => {
     const params = await notificationParamsSchema.validateAsync(req.params);
     const body = await notificationStateSchema.validateAsync(req.body);
+    if (!canSetNotificationPreference(params.key, params.type)) {
+        return res.status(404).json({ error: 'Notification preference not found' });
+    }
     setUserNotificationState(req.user.user_data.id, params.key, params.type, body.enabled);
     return res.json({ message: 'Notification preference updated successfully' });
 });

config/locals_map.js

@@ -119,14 +119,6 @@ module.exports = {
         "Error",
         "Page"
     ],
-    "/settings": [
-        "Settings",
-        "Error",
-        "Page",
-        "Setup",
-        "Navbar",
-        "Categories"
-    ],
     "/setup": [
         "Setup",
         "Error",

config/notifications/core.js

@@ -0,0 +1,60 @@
+const path = require('node:path');
+
+const emailTemplateDir = path.join(__dirname, '..', 'templates', 'email');
+
+module.exports = [
+    {
+        type: 'RegMail',
+        constant: 'REG_MAIL',
+        category: 'system',
+        channels: {
+            email: { templatePath: path.join(emailTemplateDir, 'RegMail.ejs') },
+        },
+    },
+    {
+        type: 'DeleteAcc',
+        constant: 'DELETE_ACCOUNT',
+        category: 'system',
+        channels: {
+            email: { templatePath: path.join(emailTemplateDir, 'DeleteAcc.ejs') },
+        },
+    },
+    {
+        type: 'Custom',
+        constant: 'CUSTOM',
+        category: 'system',
+        requiresMessage: true,
+        channels: {
+            email: { templatePath: path.join(emailTemplateDir, 'Custom.ejs') },
+        },
+    },
+    {
+        type: 'Discounts',
+        constant: 'DISCOUNTS',
+        category: 'newsletter',
+        preferenceKey: 'discount',
+        translationKeyBase: 'Settings.DiscountEmails',
+        requiresMessage: true,
+        channels: {
+            email: {
+                templatePath: path.join(emailTemplateDir, 'Discounts.ejs'),
+                buildContext: (task) => ({
+                    discountItems: JSON.parse(task.custom_message).items || [],
+                }),
+                buildText: (context) => [
+                    context.t('emails.greeting', { name: context.name }),
+                    '',
+                    context.t('emails.Discounts.body'),
+                    ...context.discountItems.map((item) =>
+                        `${item.name}: ${Number(item.discount_price).toFixed(2)} € ` +
+                        `(${context.t('emails.Discounts.until', {
+                            date: new Date(item.discount_until).toLocaleString(context.language),
+                        })})`
+                    ),
+                    '',
+                    context.domain,
+                ].join('\n'),
+            },
+        },
+    },
+];

index.js

@@ -8,11 +8,12 @@ const { log } = require('@lib/logger');
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { deepMerge } = require('@lib/utils');
 
 process.log = {};
 process.log = log;
 
-const { installFeatures, featureLocalesDir } = require('@lib/features');
+const { installFeatures } = require('@lib/features');
 installFeatures();
 
 // Render Templates
@@ -21,25 +22,44 @@ installFeatures();
 const localesDir = path.join(__dirname, 'config', 'locales');
 
 let availableLanguages = {};
-let availableFeatureLanguages = {};
 let countryConfig = {};
 
+const mergeLanguageBundles = (target, bundleDir) => {
+    fs.readdirSync(bundleDir, { withFileTypes: true }).forEach(entry => {
+        const entryPath = path.join(bundleDir, entry.name);
+        if (entry.isDirectory()) {
+            mergeLanguageBundles(target, entryPath);
+            return;
+        }
+        if (!entry.name.endsWith('.json')) return;
+
+        deepMerge(target, JSON.parse(fs.readFileSync(entryPath, 'utf8')));
+    });
+};
+
 // Recursive loader for language components
 const loadLanguageComponents = (langDir) => {
     const components = {};
     const files = fs.readdirSync(langDir);
+    const featureBundlesDir = path.join(langDir, 'features');
 
     files.forEach(file => {
         const filePath = path.join(langDir, file);
+        if (filePath === featureBundlesDir) return;
+
         if (fs.lstatSync(filePath).isDirectory()) {
-            components[file] = loadLanguageComponents(filePath); // Recurse into subdirectories
+            components[file] = loadLanguageComponents(filePath);
         } else if (file.endsWith('.json')) {
             const componentName = path.basename(file, '.json');
             const fileContents = fs.readFileSync(filePath, 'utf8');
             components[componentName] = JSON.parse(fileContents);
         }
     });
 
+    if (fs.existsSync(featureBundlesDir)) {
+        mergeLanguageBundles(components, featureBundlesDir);
+    }
+
     return components;
 }
 
@@ -49,24 +69,12 @@ languages.forEach(langCode => {
     const langDir = path.join(localesDir, langCode);
     if (fs.lstatSync(langDir).isDirectory()) {
         availableLanguages[langCode] = loadLanguageComponents(langDir);
-        const featureLangDir = path.join(featureLocalesDir, langCode);
-        availableFeatureLanguages[langCode] = {};
-        if (fs.existsSync(featureLangDir) && fs.lstatSync(featureLangDir).isDirectory()) {
-            fs.readdirSync(featureLangDir)
-                .filter(file => file.endsWith('.json'))
-                .forEach(file => {
-                    const featureName = path.basename(file, '.json');
-                    const fileContents = fs.readFileSync(path.join(featureLangDir, file), 'utf8');
-                    availableFeatureLanguages[langCode][featureName] = JSON.parse(fileContents);
-                });
-        }
         countryConfig[langCode] = availableLanguages[langCode].LocalLanguages.local;
     }
 });
 
 // Expose globals
 process.availableLanguages = availableLanguages; // Used for template rendering for different languages
-process.availableFeatureLanguages = availableFeatureLanguages; // Feature-owned translations, injected only when enabled
 process.countryConfig = countryConfig; // Used for language dropdowns
 process.localsMap = require('@config/locals_map.js'); // Used for template rendering for different languages
 process.permissions_config = require('@config/permissions.js');

lib/features.js

@@ -4,7 +4,6 @@ const path = require('node:path');
 const appRoot = path.join(__dirname, '..');
 const installedFeaturesDir = path.join(appRoot, 'installed_features');
 const featureConfigDir = path.join(appRoot, 'config', 'features');
-const featureLocalesDir = path.join(featureConfigDir, 'local');
 const featureMigrationRoot = path.join(appRoot, 'migrations', 'features');
 const featureSeedRoot = path.join(appRoot, 'seeds', 'features');
 const localsMapPath = path.join(appRoot, 'config', 'locals_map.js');
@@ -206,8 +205,8 @@ const copyRecursive = (sourcePath, targetPath, installedFiles) => {
 
 /**
  * Copies all installable files from a feature package into their application locations.
- * Special folders are routed to shared feature config locations:
- * local -> config/features/local, templates -> config/templates,
+ * Special folders are routed to shared application locations:
+ * locales -> config/locales, templates -> config/templates,
  * migrations -> migrations/features/<feature>, seeds -> seeds/features/<feature>.
  * Other top-level entries are copied relative to the app root.
  * @param {String} featureDir Source directory under installed_features.
@@ -225,8 +224,8 @@ const copyFeatureFiles = (featureDir, featureName, manifest) => {
         const sourcePath = path.join(featureDir, dirent.name);
         let targetPath;
 
-        if (dirent.name === 'local') {
-            targetPath = path.join(featureLocalesDir);
+        if (dirent.name === 'locales') {
+            targetPath = path.join(appRoot, 'config', 'locales');
         } else if (dirent.name === 'templates') {
             targetPath = path.join(appRoot, 'config', 'templates');
         } else if (dirent.name === 'migrations') {
@@ -278,7 +277,6 @@ const applyFeatureLocalsMap = (featureName, manifest) => {
 const installFeatures = () => {
     fs.mkdirSync(installedFeaturesDir, { recursive: true });
     fs.mkdirSync(featureConfigDir, { recursive: true });
-    fs.mkdirSync(featureLocalesDir, { recursive: true });
 
     const installed = [];
 
@@ -362,7 +360,6 @@ const getFeaturePublicFilePath = (featureName, publicPath) => {
 module.exports = {
     installedFeaturesDir,
     featureConfigDir,
-    featureLocalesDir,
     installFeatures,
     loadFeatureDefinitions,
     getFeaturePublicFilePath,