-
${this.escapeHtml(campaign.title)}
${this.escapeHtml(truncatedDescription)}
${targetLevels ? `
${targetLevels}
` : ''}
diff --git a/influence/app/public/js/response-wall.js b/influence/app/public/js/response-wall.js
index 1da1a67..f8cc3bd 100644
--- a/influence/app/public/js/response-wall.js
+++ b/influence/app/public/js/response-wall.js
@@ -342,7 +342,27 @@ function renderCampaignHeader() {
// Setup social share buttons
function setupShareButtons() {
const shareUrl = window.location.href;
-
+
+ // Social menu toggle
+ const socialsToggle = document.getElementById('share-socials-toggle');
+ const socialsMenu = document.getElementById('share-socials-menu');
+
+ if (socialsToggle && socialsMenu) {
+ socialsToggle.addEventListener('click', (e) => {
+ e.stopPropagation();
+ socialsMenu.classList.toggle('show');
+ socialsToggle.classList.toggle('active');
+ });
+
+ // Close menu when clicking outside
+ document.addEventListener('click', (e) => {
+ if (!e.target.closest('.share-socials-container')) {
+ socialsMenu.classList.remove('show');
+ socialsToggle.classList.remove('active');
+ }
+ });
+ }
+
// Facebook share
document.getElementById('share-facebook')?.addEventListener('click', () => {
const url = `https://www.facebook.com/sharer/sharer.php?u=${encodeURIComponent(shareUrl)}`;
@@ -369,6 +389,93 @@ function setupShareButtons() {
window.open(url, '_blank');
});
+ // Bluesky share
+ document.getElementById('share-bluesky')?.addEventListener('click', () => {
+ const text = currentCampaign ? `Check out responses from representatives for: ${currentCampaign.title}` : 'Check out representative responses';
+ const url = `https://bsky.app/intent/compose?text=${encodeURIComponent(text + ' ' + shareUrl)}`;
+ window.open(url, '_blank', 'width=600,height=400');
+ });
+
+ // Instagram share (note: Instagram doesn't have direct web share, opens Instagram web)
+ document.getElementById('share-instagram')?.addEventListener('click', () => {
+ alert('To share on Instagram:\n1. Copy the link (use the copy button)\n2. Open Instagram app\n3. Create a post or story\n4. Paste the link in your caption');
+ // Automatically copy the link
+ navigator.clipboard.writeText(shareUrl).catch(() => {
+ console.log('Failed to copy link automatically');
+ });
+ });
+
+ // Reddit share
+ document.getElementById('share-reddit')?.addEventListener('click', () => {
+ const title = currentCampaign ? `Representative Responses: ${currentCampaign.title}` : 'Check out these representative responses';
+ const url = `https://www.reddit.com/submit?url=${encodeURIComponent(shareUrl)}&title=${encodeURIComponent(title)}`;
+ window.open(url, '_blank', 'width=800,height=600');
+ });
+
+ // Threads share
+ document.getElementById('share-threads')?.addEventListener('click', () => {
+ const text = currentCampaign ? `Check out responses from representatives for: ${currentCampaign.title}` : 'Check out representative responses';
+ const url = `https://threads.net/intent/post?text=${encodeURIComponent(text + ' ' + shareUrl)}`;
+ window.open(url, '_blank', 'width=600,height=400');
+ });
+
+ // Telegram share
+ document.getElementById('share-telegram')?.addEventListener('click', () => {
+ const text = currentCampaign ? `Check out responses from representatives for: ${currentCampaign.title}` : 'Check out representative responses';
+ const url = `https://t.me/share/url?url=${encodeURIComponent(shareUrl)}&text=${encodeURIComponent(text)}`;
+ window.open(url, '_blank', 'width=600,height=400');
+ });
+
+ // Mastodon share
+ document.getElementById('share-mastodon')?.addEventListener('click', () => {
+ const text = currentCampaign ? `Check out responses from representatives for: ${currentCampaign.title}` : 'Check out representative responses';
+ // Mastodon requires instance selection - opens a composer with text
+ const instance = prompt('Enter your Mastodon instance (e.g., mastodon.social):');
+ if (instance) {
+ const url = `https://${instance}/share?text=${encodeURIComponent(text + ' ' + shareUrl)}`;
+ window.open(url, '_blank', 'width=600,height=400');
+ }
+ });
+
+ // SMS share
+ document.getElementById('share-sms')?.addEventListener('click', () => {
+ const text = currentCampaign ? `Check out responses from representatives for: ${currentCampaign.title}` : 'Check out representative responses';
+ const body = text + ' ' + shareUrl;
+ // Use Web Share API if available, otherwise fallback to SMS protocol
+ if (navigator.share) {
+ navigator.share({
+ title: currentCampaign ? currentCampaign.title : 'Response Wall',
+ text: body
+ }).catch(() => {
+ // Fallback to SMS protocol
+ window.location.href = `sms:?&body=${encodeURIComponent(body)}`;
+ });
+ } else {
+ // SMS protocol (works on mobile)
+ window.location.href = `sms:?&body=${encodeURIComponent(body)}`;
+ }
+ });
+
+ // Slack share
+ document.getElementById('share-slack')?.addEventListener('click', () => {
+ const url = `https://slack.com/intl/en-ca/share?url=${encodeURIComponent(shareUrl)}`;
+ window.open(url, '_blank', 'width=600,height=400');
+ });
+
+ // Discord share
+ document.getElementById('share-discord')?.addEventListener('click', () => {
+ alert('To share on Discord:\n1. Copy the link (use the copy button)\n2. Open Discord\n3. Paste the link in any channel or DM\n\nDiscord will automatically create a preview!');
+ // Automatically copy the link
+ navigator.clipboard.writeText(shareUrl).catch(() => {
+ console.log('Failed to copy link automatically');
+ });
+ });
+
+ // Print/PDF share
+ document.getElementById('share-print')?.addEventListener('click', () => {
+ window.print();
+ });
+
// Email share
document.getElementById('share-email')?.addEventListener('click', () => {
const subject = currentCampaign ? `Representative Responses: ${currentCampaign.title}` : 'Check out these representative responses';
diff --git a/influence/app/public/response-wall.html b/influence/app/public/response-wall.html
index 13ea6f7..a992262 100644
--- a/influence/app/public/response-wall.html
+++ b/influence/app/public/response-wall.html
@@ -26,40 +26,80 @@
diff --git a/influence/app/server.js b/influence/app/server.js
index 311f963..e7c36ea 100644
--- a/influence/app/server.js
+++ b/influence/app/server.js
@@ -2,9 +2,16 @@ const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const session = require('express-session');
+const compression = require('compression');
+const cookieParser = require('cookie-parser');
const path = require('path');
require('dotenv').config();
+const logger = require('./utils/logger');
+const metrics = require('./utils/metrics');
+const healthCheck = require('./utils/health-check');
+const { conditionalCsrfProtection, getCsrfToken } = require('./middleware/csrf');
+
const apiRoutes = require('./routes/api');
const authRoutes = require('./routes/auth');
const { requireAdmin, requireAuth } = require('./middleware/auth');
@@ -16,6 +23,17 @@ const PORT = process.env.PORT || 3333;
// Only trust Docker internal networks for better security
app.set('trust proxy', ['127.0.0.1', '::1', '172.16.0.0/12', '192.168.0.0/16', '10.0.0.0/8']);
+// Compression middleware for better performance
+app.use(compression({
+ filter: (req, res) => {
+ if (req.headers['x-no-compression']) {
+ return false;
+ }
+ return compression.filter(req, res);
+ },
+ level: 6 // Balance between speed and compression ratio
+}));
+
// Security middleware
app.use(helmet({
contentSecurityPolicy: {
@@ -31,22 +49,89 @@ app.use(helmet({
// Middleware
app.use(cors());
-app.use(express.json());
-app.use(express.urlencoded({ extended: true }));
+app.use(express.json({ limit: '10mb' }));
+app.use(express.urlencoded({ extended: true, limit: '10mb' }));
+app.use(cookieParser());
-// Session configuration
+// Metrics middleware - track all HTTP requests
+app.use(metrics.middleware);
+
+// Request logging middleware
+app.use((req, res, next) => {
+ const start = Date.now();
+
+ res.on('finish', () => {
+ const duration = Date.now() - start;
+ logger.logRequest(req, res, duration);
+ });
+
+ next();
+});
+
+// Session configuration - PRODUCTION HARDENED
app.use(session({
secret: process.env.SESSION_SECRET || 'influence-campaign-secret-key-change-in-production',
resave: false,
saveUninitialized: false,
+ name: 'influence.sid', // Custom session name for security
cookie: {
- secure: process.env.NODE_ENV === 'production' && process.env.HTTPS === 'true',
- httpOnly: true,
- maxAge: 24 * 60 * 60 * 1000 // 24 hours
+ secure: process.env.NODE_ENV === 'production' && process.env.HTTPS === 'true', // HTTPS only in production
+ httpOnly: true, // Prevent JavaScript access
+ maxAge: 3600000, // 1 hour (reduced from 24 hours)
+ sameSite: 'strict' // CSRF protection
}
}));
-app.use(express.static(path.join(__dirname, 'public')));
+// CSRF Protection - Applied conditionally
+app.use(conditionalCsrfProtection);
+
+// Static files with proper caching
+app.use(express.static(path.join(__dirname, 'public'), {
+ maxAge: process.env.NODE_ENV === 'production' ? '1d' : 0,
+ etag: true,
+ lastModified: true,
+ setHeaders: (res, filePath) => {
+ // Cache images and assets longer
+ if (filePath.match(/\.(jpg|jpeg|png|gif|ico|svg|woff|woff2|ttf|eot)$/)) {
+ res.setHeader('Cache-Control', 'public, max-age=604800'); // 7 days
+ }
+ // Cache CSS and JS for 1 day
+ else if (filePath.match(/\.(css|js)$/)) {
+ res.setHeader('Cache-Control', 'public, max-age=86400'); // 1 day
+ }
+ }
+}));
+
+// Health check endpoint - COMPREHENSIVE
+app.get('/api/health', async (req, res) => {
+ try {
+ const health = await healthCheck.checkAll();
+ const statusCode = health.status === 'healthy' ? 200 : health.status === 'degraded' ? 200 : 503;
+ res.status(statusCode).json(health);
+ } catch (error) {
+ logger.error('Health check failed', { error: error.message });
+ res.status(503).json({
+ status: 'unhealthy',
+ error: error.message,
+ timestamp: new Date().toISOString()
+ });
+ }
+});
+
+// Metrics endpoint for Prometheus
+app.get('/api/metrics', async (req, res) => {
+ try {
+ res.set('Content-Type', metrics.getContentType());
+ const metricsData = await metrics.getMetrics();
+ res.end(metricsData);
+ } catch (error) {
+ logger.error('Metrics endpoint failed', { error: error.message });
+ res.status(500).json({ error: 'Failed to generate metrics' });
+ }
+});
+
+// CSRF token endpoint
+app.get('/api/csrf-token', getCsrfToken);
// Routes
app.use('/api/auth', authRoutes);
@@ -100,21 +185,54 @@ app.get('/campaign/:slug', (req, res) => {
// Error handling middleware
app.use((err, req, res, next) => {
- console.error(err.stack);
- res.status(500).json({
+ logger.error('Application error', {
+ error: err.message,
+ stack: err.stack,
+ path: req.path,
+ method: req.method,
+ ip: req.ip
+ });
+
+ res.status(err.status || 500).json({
error: 'Something went wrong!',
- message: process.env.NODE_ENV === 'development' ? err.message : 'Internal server error'
+ message: process.env.NODE_ENV === 'development' ? err.message : 'Internal server error',
+ ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
});
});
// 404 handler
app.use((req, res) => {
+ logger.warn('Route not found', {
+ path: req.path,
+ method: req.method,
+ ip: req.ip
+ });
res.status(404).json({ error: 'Route not found' });
});
-app.listen(PORT, () => {
- console.log(`Server running on port ${PORT}`);
- console.log(`Environment: ${process.env.NODE_ENV}`);
+// Graceful shutdown
+process.on('SIGTERM', () => {
+ logger.info('SIGTERM received, shutting down gracefully');
+ server.close(() => {
+ logger.info('Server closed');
+ process.exit(0);
+ });
+});
+
+process.on('SIGINT', () => {
+ logger.info('SIGINT received, shutting down gracefully');
+ server.close(() => {
+ logger.info('Server closed');
+ process.exit(0);
+ });
+});
+
+const server = app.listen(PORT, () => {
+ logger.info('Server started', {
+ port: PORT,
+ environment: process.env.NODE_ENV,
+ nodeVersion: process.version
+ });
});
module.exports = app;
\ No newline at end of file
diff --git a/influence/app/services/emailQueue.js b/influence/app/services/emailQueue.js
new file mode 100644
index 0000000..f6ea762
--- /dev/null
+++ b/influence/app/services/emailQueue.js
@@ -0,0 +1,368 @@
+const Queue = require('bull');
+const logger = require('./logger');
+const metrics = require('./metrics');
+const emailService = require('../services/email');
+
+// Configure Redis connection for Bull
+const redisConfig = {
+ host: process.env.REDIS_HOST || 'localhost',
+ port: parseInt(process.env.REDIS_PORT || '6379'),
+ password: process.env.REDIS_PASSWORD || undefined,
+ db: parseInt(process.env.REDIS_DB || '0'),
+ // Retry strategy for connection failures
+ retryStrategy: (times) => {
+ const delay = Math.min(times * 50, 2000);
+ return delay;
+ },
+ // Enable offline queue
+ enableOfflineQueue: true,
+ maxRetriesPerRequest: 3
+};
+
+// Create email queue
+const emailQueue = new Queue('email-queue', {
+ redis: redisConfig,
+ defaultJobOptions: {
+ attempts: 3,
+ backoff: {
+ type: 'exponential',
+ delay: 2000 // Start with 2 seconds, then 4, 8, etc.
+ },
+ removeOnComplete: {
+ age: 24 * 3600, // Keep completed jobs for 24 hours
+ count: 1000 // Keep last 1000 completed jobs
+ },
+ removeOnFail: {
+ age: 7 * 24 * 3600 // Keep failed jobs for 7 days
+ },
+ timeout: 30000 // 30 seconds timeout per job
+ }
+});
+
+// Process email jobs
+emailQueue.process(async (job) => {
+ const { type, data } = job.data;
+ const start = Date.now();
+
+ logger.info('Processing email job', {
+ jobId: job.id,
+ type,
+ attempt: job.attemptsMade + 1,
+ maxAttempts: job.opts.attempts
+ });
+
+ try {
+ let result;
+
+ switch (type) {
+ case 'campaign':
+ result = await emailService.sendCampaignEmail(data);
+ break;
+
+ case 'verification':
+ result = await emailService.sendVerificationEmail(data);
+ break;
+
+ case 'login-details':
+ result = await emailService.sendLoginDetails(data);
+ break;
+
+ case 'broadcast':
+ result = await emailService.sendBroadcast(data);
+ break;
+
+ case 'response-verification':
+ result = await emailService.sendResponseVerificationEmail(data);
+ break;
+
+ default:
+ throw new Error(`Unknown email type: ${type}`);
+ }
+
+ const duration = (Date.now() - start) / 1000;
+
+ // Record metrics
+ metrics.recordEmailSent(
+ data.campaignId || 'system',
+ data.representativeLevel || 'unknown'
+ );
+ metrics.observeEmailSendDuration(
+ data.campaignId || 'system',
+ duration
+ );
+
+ logger.logEmailSent(
+ data.to || data.email,
+ data.campaignId || type,
+ 'success'
+ );
+
+ return result;
+ } catch (error) {
+ const duration = (Date.now() - start) / 1000;
+
+ // Record failure metrics
+ metrics.recordEmailFailed(
+ data.campaignId || 'system',
+ error.code || 'unknown'
+ );
+
+ logger.logEmailFailed(
+ data.to || data.email,
+ data.campaignId || type,
+ error
+ );
+
+ // Throw error to trigger retry
+ throw error;
+ }
+});
+
+// Queue event handlers
+emailQueue.on('completed', (job, result) => {
+ logger.info('Email job completed', {
+ jobId: job.id,
+ type: job.data.type,
+ duration: Date.now() - job.timestamp
+ });
+});
+
+emailQueue.on('failed', (job, err) => {
+ logger.error('Email job failed', {
+ jobId: job.id,
+ type: job.data.type,
+ attempt: job.attemptsMade,
+ maxAttempts: job.opts.attempts,
+ error: err.message,
+ willRetry: job.attemptsMade < job.opts.attempts
+ });
+});
+
+emailQueue.on('stalled', (job) => {
+ logger.warn('Email job stalled', {
+ jobId: job.id,
+ type: job.data.type
+ });
+});
+
+emailQueue.on('error', (error) => {
+ logger.error('Email queue error', { error: error.message });
+});
+
+// Update queue size metric every 10 seconds
+setInterval(async () => {
+ try {
+ const counts = await emailQueue.getJobCounts();
+ const queueSize = counts.waiting + counts.active;
+ metrics.setEmailQueueSize(queueSize);
+ } catch (error) {
+ logger.warn('Failed to update queue metrics', { error: error.message });
+ }
+}, 10000);
+
+/**
+ * Email Queue Service
+ * Provides methods to enqueue different types of emails
+ */
+class EmailQueueService {
+ /**
+ * Send campaign email (to representative)
+ */
+ async sendCampaignEmail(emailData) {
+ const job = await emailQueue.add(
+ {
+ type: 'campaign',
+ data: emailData
+ },
+ {
+ priority: 2, // Normal priority
+ jobId: `campaign-${emailData.campaignId}-${Date.now()}`
+ }
+ );
+
+ logger.info('Campaign email queued', {
+ jobId: job.id,
+ campaignId: emailData.campaignId,
+ recipient: emailData.to
+ });
+
+ return { jobId: job.id, queued: true };
+ }
+
+ /**
+ * Send email verification
+ */
+ async sendVerificationEmail(emailData) {
+ const job = await emailQueue.add(
+ {
+ type: 'verification',
+ data: emailData
+ },
+ {
+ priority: 1, // High priority - user waiting
+ jobId: `verification-${emailData.email}-${Date.now()}`
+ }
+ );
+
+ logger.info('Verification email queued', {
+ jobId: job.id,
+ email: emailData.email
+ });
+
+ return { jobId: job.id, queued: true };
+ }
+
+ /**
+ * Send login details
+ */
+ async sendLoginDetails(emailData) {
+ const job = await emailQueue.add(
+ {
+ type: 'login-details',
+ data: emailData
+ },
+ {
+ priority: 1, // High priority
+ jobId: `login-${emailData.email}-${Date.now()}`
+ }
+ );
+
+ logger.info('Login details email queued', {
+ jobId: job.id,
+ email: emailData.email
+ });
+
+ return { jobId: job.id, queued: true };
+ }
+
+ /**
+ * Send broadcast to users
+ */
+ async sendBroadcast(emailData) {
+ const job = await emailQueue.add(
+ {
+ type: 'broadcast',
+ data: emailData
+ },
+ {
+ priority: 3, // Lower priority - batch operation
+ jobId: `broadcast-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
+ }
+ );
+
+ logger.info('Broadcast email queued', {
+ jobId: job.id,
+ recipientCount: emailData.recipients?.length || 1
+ });
+
+ return { jobId: job.id, queued: true };
+ }
+
+ /**
+ * Send response verification email
+ */
+ async sendResponseVerificationEmail(emailData) {
+ const job = await emailQueue.add(
+ {
+ type: 'response-verification',
+ data: emailData
+ },
+ {
+ priority: 2,
+ jobId: `response-verification-${emailData.email}-${Date.now()}`
+ }
+ );
+
+ logger.info('Response verification email queued', {
+ jobId: job.id,
+ email: emailData.email
+ });
+
+ return { jobId: job.id, queued: true };
+ }
+
+ /**
+ * Get job status
+ */
+ async getJobStatus(jobId) {
+ const job = await emailQueue.getJob(jobId);
+
+ if (!job) {
+ return { status: 'not_found' };
+ }
+
+ const state = await job.getState();
+ const progress = job.progress();
+
+ return {
+ jobId: job.id,
+ status: state,
+ progress,
+ attempts: job.attemptsMade,
+ data: job.data,
+ createdAt: job.timestamp,
+ processedAt: job.processedOn,
+ finishedAt: job.finishedOn,
+ failedReason: job.failedReason
+ };
+ }
+
+ /**
+ * Get queue statistics
+ */
+ async getQueueStats() {
+ const counts = await emailQueue.getJobCounts();
+ const jobs = {
+ waiting: await emailQueue.getWaiting(0, 10),
+ active: await emailQueue.getActive(0, 10),
+ completed: await emailQueue.getCompleted(0, 10),
+ failed: await emailQueue.getFailed(0, 10)
+ };
+
+ return {
+ counts,
+ samples: {
+ waiting: jobs.waiting.map(j => ({ id: j.id, type: j.data.type })),
+ active: jobs.active.map(j => ({ id: j.id, type: j.data.type })),
+ completed: jobs.completed.slice(0, 5).map(j => ({ id: j.id, type: j.data.type })),
+ failed: jobs.failed.slice(0, 5).map(j => ({ id: j.id, type: j.data.type, reason: j.failedReason }))
+ }
+ };
+ }
+
+ /**
+ * Clean old jobs
+ */
+ async cleanQueue(grace = 24 * 3600 * 1000) {
+ const cleaned = await emailQueue.clean(grace, 'completed');
+ logger.info('Queue cleaned', { removedJobs: cleaned.length });
+ return { cleaned: cleaned.length };
+ }
+
+ /**
+ * Pause queue
+ */
+ async pauseQueue() {
+ await emailQueue.pause();
+ logger.warn('Email queue paused');
+ return { paused: true };
+ }
+
+ /**
+ * Resume queue
+ */
+ async resumeQueue() {
+ await emailQueue.resume();
+ logger.info('Email queue resumed');
+ return { resumed: true };
+ }
+
+ /**
+ * Get queue instance (for advanced operations)
+ */
+ getQueue() {
+ return emailQueue;
+ }
+}
+
+module.exports = new EmailQueueService();
diff --git a/influence/app/utils/analytics.js b/influence/app/utils/analytics.js
new file mode 100644
index 0000000..f74c457
--- /dev/null
+++ b/influence/app/utils/analytics.js
@@ -0,0 +1,350 @@
+const logger = require('./logger');
+
+/**
+ * Analytics tracking utilities for the Influence application
+ * Provides helpers for tracking campaign conversion, representative response rates,
+ * user retention, and geographic participation
+ */
+class Analytics {
+ constructor() {
+ this.cache = {
+ campaignStats: new Map(),
+ userRetention: new Map(),
+ geographicData: new Map()
+ };
+ }
+
+ /**
+ * Track campaign conversion rate
+ * @param {string} campaignId - Campaign identifier
+ * @param {number} visitors - Number of unique visitors
+ * @param {number} participants - Number of participants who took action
+ */
+ trackCampaignConversion(campaignId, visitors, participants) {
+ const conversionRate = visitors > 0 ? (participants / visitors) * 100 : 0;
+
+ const stats = {
+ campaignId,
+ visitors,
+ participants,
+ conversionRate: conversionRate.toFixed(2),
+ timestamp: new Date().toISOString()
+ };
+
+ this.cache.campaignStats.set(campaignId, stats);
+
+ logger.info('Campaign conversion tracked', {
+ event: 'analytics_campaign_conversion',
+ ...stats
+ });
+
+ return stats;
+ }
+
+ /**
+ * Calculate representative response rate
+ * @param {string} representativeLevel - Level (Federal, Provincial, Municipal)
+ * @param {number} emailsSent - Total emails sent
+ * @param {number} responsesReceived - Total responses received
+ */
+ calculateRepresentativeResponseRate(representativeLevel, emailsSent, responsesReceived) {
+ const responseRate = emailsSent > 0 ? (responsesReceived / emailsSent) * 100 : 0;
+
+ const stats = {
+ representativeLevel,
+ emailsSent,
+ responsesReceived,
+ responseRate: responseRate.toFixed(2),
+ timestamp: new Date().toISOString()
+ };
+
+ logger.info('Representative response rate calculated', {
+ event: 'analytics_response_rate',
+ ...stats
+ });
+
+ return stats;
+ }
+
+ /**
+ * Track user retention
+ * @param {string} userId - User identifier
+ * @param {string} action - Action type (login, campaign_participation, etc.)
+ */
+ trackUserRetention(userId, action) {
+ let userData = this.cache.userRetention.get(userId) || {
+ userId,
+ firstSeen: new Date().toISOString(),
+ lastSeen: new Date().toISOString(),
+ actionCount: 0,
+ actions: []
+ };
+
+ userData.lastSeen = new Date().toISOString();
+ userData.actionCount += 1;
+ userData.actions.push({
+ action,
+ timestamp: new Date().toISOString()
+ });
+
+ // Keep only last 100 actions per user
+ if (userData.actions.length > 100) {
+ userData.actions = userData.actions.slice(-100);
+ }
+
+ this.cache.userRetention.set(userId, userData);
+
+ // Determine if user is one-time or repeat
+ const daysBetween = this.getDaysBetween(userData.firstSeen, userData.lastSeen);
+ const isRepeatUser = daysBetween > 0 || userData.actionCount > 1;
+
+ logger.info('User retention tracked', {
+ event: 'analytics_user_retention',
+ userId,
+ action,
+ isRepeatUser,
+ totalActions: userData.actionCount
+ });
+
+ return { ...userData, isRepeatUser };
+ }
+
+ /**
+ * Track geographic participation by postal code
+ * @param {string} postalCode - Canadian postal code
+ * @param {string} campaignId - Campaign identifier
+ */
+ trackGeographicParticipation(postalCode, campaignId) {
+ const postalPrefix = postalCode.substring(0, 3).toUpperCase();
+
+ let geoData = this.cache.geographicData.get(postalPrefix) || {
+ postalPrefix,
+ participationCount: 0,
+ campaigns: new Set()
+ };
+
+ geoData.participationCount += 1;
+ geoData.campaigns.add(campaignId);
+
+ this.cache.geographicData.set(postalPrefix, geoData);
+
+ logger.info('Geographic participation tracked', {
+ event: 'analytics_geographic_participation',
+ postalPrefix,
+ campaignId,
+ totalParticipation: geoData.participationCount
+ });
+
+ return {
+ postalPrefix,
+ participationCount: geoData.participationCount,
+ uniqueCampaigns: geoData.campaigns.size
+ };
+ }
+
+ /**
+ * Get geographic heatmap data
+ * @returns {Array} Array of postal code prefixes with participation counts
+ */
+ getGeographicHeatmap() {
+ const heatmapData = [];
+
+ for (const [postalPrefix, data] of this.cache.geographicData.entries()) {
+ heatmapData.push({
+ postalPrefix,
+ participationCount: data.participationCount,
+ uniqueCampaigns: data.campaigns.size
+ });
+ }
+
+ return heatmapData.sort((a, b) => b.participationCount - a.participationCount);
+ }
+
+ /**
+ * Analyze peak usage times
+ * @param {Array} events - Array of event objects with timestamps
+ * @returns {Object} Peak usage analysis
+ */
+ analyzePeakUsageTimes(events) {
+ const hourCounts = new Array(24).fill(0);
+ const dayOfWeekCounts = new Array(7).fill(0);
+
+ events.forEach(event => {
+ const date = new Date(event.timestamp);
+ const hour = date.getHours();
+ const dayOfWeek = date.getDay();
+
+ hourCounts[hour] += 1;
+ dayOfWeekCounts[dayOfWeek] += 1;
+ });
+
+ const peakHour = hourCounts.indexOf(Math.max(...hourCounts));
+ const peakDay = dayOfWeekCounts.indexOf(Math.max(...dayOfWeekCounts));
+
+ const dayNames = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+
+ const analysis = {
+ peakHour: `${peakHour}:00`,
+ peakDay: dayNames[peakDay],
+ hourlyDistribution: hourCounts,
+ dailyDistribution: dayOfWeekCounts,
+ totalEvents: events.length
+ };
+
+ logger.info('Peak usage times analyzed', {
+ event: 'analytics_peak_usage',
+ ...analysis
+ });
+
+ return analysis;
+ }
+
+ /**
+ * Track device breakdown
+ * @param {string} userAgent - User agent string
+ */
+ trackDeviceType(userAgent) {
+ const isMobile = /Mobile|Android|iPhone|iPad|iPod/i.test(userAgent);
+ const isTablet = /iPad|Android.*Tablet/i.test(userAgent);
+ const isDesktop = !isMobile && !isTablet;
+
+ const deviceType = isTablet ? 'tablet' : isMobile ? 'mobile' : 'desktop';
+
+ logger.info('Device type tracked', {
+ event: 'analytics_device_type',
+ deviceType,
+ userAgent: userAgent.substring(0, 100)
+ });
+
+ return deviceType;
+ }
+
+ /**
+ * Track email deliverability
+ * @param {string} status - Status (success, bounce, spam, failed)
+ * @param {string} campaignId - Campaign identifier
+ * @param {Object} details - Additional details
+ */
+ trackEmailDeliverability(status, campaignId, details = {}) {
+ const deliverabilityData = {
+ status,
+ campaignId,
+ timestamp: new Date().toISOString(),
+ ...details
+ };
+
+ logger.info('Email deliverability tracked', {
+ event: 'analytics_email_deliverability',
+ ...deliverabilityData
+ });
+
+ return deliverabilityData;
+ }
+
+ /**
+ * Generate campaign analytics report
+ * @param {string} campaignId - Campaign identifier
+ * @param {Object} data - Campaign data including visitors, participants, emails sent, etc.
+ */
+ generateCampaignReport(campaignId, data) {
+ const {
+ visitors = 0,
+ participants = 0,
+ emailsSent = 0,
+ emailsFailed = 0,
+ responsesReceived = 0,
+ shareCount = 0,
+ avgTimeOnPage = 0
+ } = data;
+
+ const conversionRate = visitors > 0 ? ((participants / visitors) * 100).toFixed(2) : 0;
+ const emailSuccessRate = emailsSent > 0 ? (((emailsSent - emailsFailed) / emailsSent) * 100).toFixed(2) : 0;
+ const responseRate = emailsSent > 0 ? ((responsesReceived / emailsSent) * 100).toFixed(2) : 0;
+ const shareRate = participants > 0 ? ((shareCount / participants) * 100).toFixed(2) : 0;
+
+ const report = {
+ campaignId,
+ metrics: {
+ visitors,
+ participants,
+ conversionRate: `${conversionRate}%`,
+ emailsSent,
+ emailsFailed,
+ emailSuccessRate: `${emailSuccessRate}%`,
+ responsesReceived,
+ responseRate: `${responseRate}%`,
+ shareCount,
+ shareRate: `${shareRate}%`,
+ avgTimeOnPage: `${avgTimeOnPage}s`
+ },
+ insights: {
+ performance: conversionRate > 5 ? 'excellent' : conversionRate > 2 ? 'good' : 'needs improvement',
+ emailHealth: emailSuccessRate > 95 ? 'excellent' : emailSuccessRate > 85 ? 'good' : 'poor',
+ engagement: responseRate > 10 ? 'high' : responseRate > 3 ? 'medium' : 'low'
+ },
+ generatedAt: new Date().toISOString()
+ };
+
+ logger.info('Campaign report generated', {
+ event: 'analytics_campaign_report',
+ campaignId,
+ ...report.metrics
+ });
+
+ return report;
+ }
+
+ /**
+ * Get user retention summary
+ * @returns {Object} User retention statistics
+ */
+ getUserRetentionSummary() {
+ let oneTimeUsers = 0;
+ let repeatUsers = 0;
+ let totalActions = 0;
+
+ for (const [userId, userData] of this.cache.userRetention.entries()) {
+ totalActions += userData.actionCount;
+
+ const daysBetween = this.getDaysBetween(userData.firstSeen, userData.lastSeen);
+ if (daysBetween > 0 || userData.actionCount > 1) {
+ repeatUsers += 1;
+ } else {
+ oneTimeUsers += 1;
+ }
+ }
+
+ const totalUsers = oneTimeUsers + repeatUsers;
+ const retentionRate = totalUsers > 0 ? ((repeatUsers / totalUsers) * 100).toFixed(2) : 0;
+
+ return {
+ totalUsers,
+ oneTimeUsers,
+ repeatUsers,
+ retentionRate: `${retentionRate}%`,
+ avgActionsPerUser: totalUsers > 0 ? (totalActions / totalUsers).toFixed(2) : 0
+ };
+ }
+
+ /**
+ * Helper: Calculate days between two dates
+ */
+ getDaysBetween(date1, date2) {
+ const d1 = new Date(date1);
+ const d2 = new Date(date2);
+ const diffTime = Math.abs(d2 - d1);
+ return Math.floor(diffTime / (1000 * 60 * 60 * 24));
+ }
+
+ /**
+ * Clear cache (for testing or memory management)
+ */
+ clearCache() {
+ this.cache.campaignStats.clear();
+ this.cache.userRetention.clear();
+ this.cache.geographicData.clear();
+ logger.info('Analytics cache cleared');
+ }
+}
+
+module.exports = new Analytics();
diff --git a/influence/app/utils/health-check.js b/influence/app/utils/health-check.js
new file mode 100644
index 0000000..29565dc
--- /dev/null
+++ b/influence/app/utils/health-check.js
@@ -0,0 +1,380 @@
+const axios = require('axios');
+const os = require('os');
+const fs = require('fs').promises;
+const path = require('path');
+const nodemailer = require('nodemailer');
+const logger = require('./logger');
+
+/**
+ * Health check utility for monitoring all system dependencies
+ */
+class HealthCheck {
+ constructor() {
+ this.services = {
+ nocodb: { name: 'NocoDB', healthy: false, lastCheck: null, details: {} },
+ smtp: { name: 'SMTP Server', healthy: false, lastCheck: null, details: {} },
+ representAPI: { name: 'Represent API', healthy: false, lastCheck: null, details: {} },
+ disk: { name: 'Disk Space', healthy: false, lastCheck: null, details: {} },
+ memory: { name: 'Memory', healthy: false, lastCheck: null, details: {} },
+ };
+ }
+
+ /**
+ * Check NocoDB connectivity and API health
+ */
+ async checkNocoDB() {
+ const start = Date.now();
+ try {
+ const response = await axios.get(`${process.env.NOCODB_API_URL}/db/meta/projects`, {
+ headers: {
+ 'xc-token': process.env.NOCODB_API_TOKEN
+ },
+ timeout: 5000
+ });
+
+ const duration = Date.now() - start;
+ this.services.nocodb = {
+ name: 'NocoDB',
+ healthy: response.status === 200,
+ lastCheck: new Date().toISOString(),
+ details: {
+ status: response.status,
+ responseTime: `${duration}ms`,
+ url: process.env.NOCODB_API_URL
+ }
+ };
+
+ logger.logHealthCheck('nocodb', 'healthy', { responseTime: duration });
+ return this.services.nocodb;
+ } catch (error) {
+ this.services.nocodb = {
+ name: 'NocoDB',
+ healthy: false,
+ lastCheck: new Date().toISOString(),
+ details: {
+ error: error.message,
+ url: process.env.NOCODB_API_URL
+ }
+ };
+
+ logger.logHealthCheck('nocodb', 'unhealthy', { error: error.message });
+ return this.services.nocodb;
+ }
+ }
+
+ /**
+ * Check SMTP server connectivity
+ */
+ async checkSMTP() {
+ const start = Date.now();
+
+ // Skip SMTP check if in test mode
+ if (process.env.EMAIL_TEST_MODE === 'true') {
+ this.services.smtp = {
+ name: 'SMTP Server',
+ healthy: true,
+ lastCheck: new Date().toISOString(),
+ details: {
+ mode: 'test',
+ message: 'SMTP test mode enabled - emails logged only'
+ }
+ };
+ return this.services.smtp;
+ }
+
+ try {
+ const transporter = nodemailer.createTransport({
+ host: process.env.SMTP_HOST,
+ port: parseInt(process.env.SMTP_PORT || '587'),
+ secure: process.env.SMTP_SECURE === 'true',
+ auth: {
+ user: process.env.SMTP_USER,
+ pass: process.env.SMTP_PASS
+ },
+ connectionTimeout: 5000
+ });
+
+ await transporter.verify();
+ const duration = Date.now() - start;
+
+ this.services.smtp = {
+ name: 'SMTP Server',
+ healthy: true,
+ lastCheck: new Date().toISOString(),
+ details: {
+ host: process.env.SMTP_HOST,
+ port: process.env.SMTP_PORT,
+ responseTime: `${duration}ms`
+ }
+ };
+
+ logger.logHealthCheck('smtp', 'healthy', { responseTime: duration });
+ return this.services.smtp;
+ } catch (error) {
+ this.services.smtp = {
+ name: 'SMTP Server',
+ healthy: false,
+ lastCheck: new Date().toISOString(),
+ details: {
+ error: error.message,
+ host: process.env.SMTP_HOST
+ }
+ };
+
+ logger.logHealthCheck('smtp', 'unhealthy', { error: error.message });
+ return this.services.smtp;
+ }
+ }
+
+ /**
+ * Check Represent API availability
+ */
+ async checkRepresentAPI() {
+ const start = Date.now();
+ const testUrl = `${process.env.REPRESENT_API_BASE || 'https://represent.opennorth.ca'}/representatives/house-of-commons/`;
+
+ try {
+ const response = await axios.get(testUrl, {
+ timeout: 5000
+ });
+
+ const duration = Date.now() - start;
+ this.services.representAPI = {
+ name: 'Represent API',
+ healthy: response.status === 200,
+ lastCheck: new Date().toISOString(),
+ details: {
+ status: response.status,
+ responseTime: `${duration}ms`,
+ url: testUrl
+ }
+ };
+
+ logger.logHealthCheck('represent-api', 'healthy', { responseTime: duration });
+ return this.services.representAPI;
+ } catch (error) {
+ this.services.representAPI = {
+ name: 'Represent API',
+ healthy: false,
+ lastCheck: new Date().toISOString(),
+ details: {
+ error: error.message,
+ url: testUrl
+ }
+ };
+
+ logger.logHealthCheck('represent-api', 'unhealthy', { error: error.message });
+ return this.services.representAPI;
+ }
+ }
+
+ /**
+ * Check disk space for uploads directory
+ */
+ async checkDiskSpace() {
+ try {
+ const uploadsDir = path.join(__dirname, '../public/uploads');
+
+ // Ensure directory exists
+ try {
+ await fs.access(uploadsDir);
+ } catch {
+ await fs.mkdir(uploadsDir, { recursive: true });
+ }
+
+ // Get directory size
+ const directorySize = await this.getDirectorySize(uploadsDir);
+
+ // Get system disk usage (platform-specific approximation)
+ const freeSpace = os.freemem();
+ const totalSpace = os.totalmem();
+ const usedPercentage = ((totalSpace - freeSpace) / totalSpace) * 100;
+
+ // Consider healthy if less than 90% full
+ const healthy = usedPercentage < 90;
+
+ this.services.disk = {
+ name: 'Disk Space',
+ healthy,
+ lastCheck: new Date().toISOString(),
+ details: {
+ uploadsSize: this.formatBytes(directorySize),
+ systemUsedPercentage: `${usedPercentage.toFixed(2)}%`,
+ freeSpace: this.formatBytes(freeSpace),
+ totalSpace: this.formatBytes(totalSpace),
+ path: uploadsDir
+ }
+ };
+
+ logger.logHealthCheck('disk', healthy ? 'healthy' : 'unhealthy', this.services.disk.details);
+ return this.services.disk;
+ } catch (error) {
+ this.services.disk = {
+ name: 'Disk Space',
+ healthy: false,
+ lastCheck: new Date().toISOString(),
+ details: {
+ error: error.message
+ }
+ };
+
+ logger.logHealthCheck('disk', 'unhealthy', { error: error.message });
+ return this.services.disk;
+ }
+ }
+
+ /**
+ * Check memory usage
+ */
+ async checkMemory() {
+ try {
+ const totalMemory = os.totalmem();
+ const freeMemory = os.freemem();
+ const usedMemory = totalMemory - freeMemory;
+ const usedPercentage = (usedMemory / totalMemory) * 100;
+
+ // Get Node.js process memory
+ const processMemory = process.memoryUsage();
+
+ // Consider healthy if less than 85% used
+ const healthy = usedPercentage < 85;
+
+ this.services.memory = {
+ name: 'Memory',
+ healthy,
+ lastCheck: new Date().toISOString(),
+ details: {
+ system: {
+ total: this.formatBytes(totalMemory),
+ used: this.formatBytes(usedMemory),
+ free: this.formatBytes(freeMemory),
+ usedPercentage: `${usedPercentage.toFixed(2)}%`
+ },
+ process: {
+ rss: this.formatBytes(processMemory.rss),
+ heapTotal: this.formatBytes(processMemory.heapTotal),
+ heapUsed: this.formatBytes(processMemory.heapUsed),
+ external: this.formatBytes(processMemory.external)
+ }
+ }
+ };
+
+ logger.logHealthCheck('memory', healthy ? 'healthy' : 'unhealthy', this.services.memory.details);
+ return this.services.memory;
+ } catch (error) {
+ this.services.memory = {
+ name: 'Memory',
+ healthy: false,
+ lastCheck: new Date().toISOString(),
+ details: {
+ error: error.message
+ }
+ };
+
+ logger.logHealthCheck('memory', 'unhealthy', { error: error.message });
+ return this.services.memory;
+ }
+ }
+
+ /**
+ * Run all health checks
+ */
+ async checkAll() {
+ const results = await Promise.allSettled([
+ this.checkNocoDB(),
+ this.checkSMTP(),
+ this.checkRepresentAPI(),
+ this.checkDiskSpace(),
+ this.checkMemory()
+ ]);
+
+ const overall = {
+ status: Object.values(this.services).every(s => s.healthy) ? 'healthy' : 'degraded',
+ timestamp: new Date().toISOString(),
+ services: this.services,
+ uptime: process.uptime(),
+ version: process.env.npm_package_version || '1.0.0',
+ environment: process.env.NODE_ENV || 'development'
+ };
+
+ // Check if any critical services are down
+ // Note: In development, NocoDB might not be available yet
+ // Only mark as unhealthy if multiple critical services fail
+ const criticalServices = ['nocodb'];
+ const criticalDown = criticalServices.filter(name => !this.services[name].healthy);
+
+ // Allow degraded state if only external services (NocoDB, Represent API) are down
+ // Only fail health check if core services (disk, memory) are unhealthy
+ const coreServicesHealthy = this.services.disk.healthy && this.services.memory.healthy;
+
+ if (!coreServicesHealthy) {
+ overall.status = 'unhealthy';
+ } else if (criticalDown.length > 0) {
+ // Mark as degraded (not unhealthy) if external services are down
+ // This allows the container to start even if NocoDB isn't ready
+ overall.status = 'degraded';
+ }
+
+ return overall;
+ }
+
+ /**
+ * Get health check for a specific service
+ */
+ async checkService(serviceName) {
+ const checkMethods = {
+ nocodb: () => this.checkNocoDB(),
+ smtp: () => this.checkSMTP(),
+ representAPI: () => this.checkRepresentAPI(),
+ disk: () => this.checkDiskSpace(),
+ memory: () => this.checkMemory()
+ };
+
+ if (checkMethods[serviceName]) {
+ return await checkMethods[serviceName]();
+ }
+
+ throw new Error(`Unknown service: ${serviceName}`);
+ }
+
+ /**
+ * Helper: Get directory size recursively
+ */
+ async getDirectorySize(directory) {
+ let size = 0;
+
+ try {
+ const files = await fs.readdir(directory);
+
+ for (const file of files) {
+ const filePath = path.join(directory, file);
+ const stats = await fs.stat(filePath);
+
+ if (stats.isDirectory()) {
+ size += await this.getDirectorySize(filePath);
+ } else {
+ size += stats.size;
+ }
+ }
+ } catch (error) {
+ logger.warn(`Error calculating directory size: ${error.message}`);
+ }
+
+ return size;
+ }
+
+ /**
+ * Helper: Format bytes to human readable
+ */
+ formatBytes(bytes) {
+ if (bytes === 0) return '0 Bytes';
+
+ const k = 1024;
+ const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+ const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+ return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+ }
+}
+
+module.exports = new HealthCheck();
diff --git a/influence/app/utils/logger.js b/influence/app/utils/logger.js
new file mode 100644
index 0000000..b82ef06
--- /dev/null
+++ b/influence/app/utils/logger.js
@@ -0,0 +1,190 @@
+const winston = require('winston');
+const DailyRotateFile = require('winston-daily-rotate-file');
+const path = require('path');
+
+// Define log levels
+const levels = {
+ error: 0,
+ warn: 1,
+ info: 2,
+ http: 3,
+ debug: 4,
+};
+
+// Define colors for each level
+const colors = {
+ error: 'red',
+ warn: 'yellow',
+ info: 'green',
+ http: 'magenta',
+ debug: 'white',
+};
+
+// Tell winston about our colors
+winston.addColors(colors);
+
+// Define which level to log based on environment
+const level = () => {
+ const env = process.env.NODE_ENV || 'development';
+ const isDevelopment = env === 'development';
+ return isDevelopment ? 'debug' : 'info';
+};
+
+// Define log format
+const logFormat = winston.format.combine(
+ winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss:ms' }),
+ winston.format.errors({ stack: true }),
+ winston.format.splat(),
+ winston.format.json()
+);
+
+// Console format for development (pretty print)
+const consoleFormat = winston.format.combine(
+ winston.format.colorize({ all: true }),
+ winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+ winston.format.printf(
+ (info) => `${info.timestamp} ${info.level}: ${info.message}${info.stack ? '\n' + info.stack : ''}`
+ )
+);
+
+// Define transports
+const transports = [
+ // Console output
+ new winston.transports.Console({
+ format: consoleFormat,
+ handleExceptions: true,
+ }),
+
+ // Error logs - rotate daily
+ new DailyRotateFile({
+ filename: path.join(__dirname, '../../logs/error-%DATE%.log'),
+ datePattern: 'YYYY-MM-DD',
+ level: 'error',
+ format: logFormat,
+ maxSize: '20m',
+ maxFiles: '14d',
+ handleExceptions: true,
+ }),
+
+ // Combined logs - rotate daily
+ new DailyRotateFile({
+ filename: path.join(__dirname, '../../logs/combined-%DATE%.log'),
+ datePattern: 'YYYY-MM-DD',
+ format: logFormat,
+ maxSize: '20m',
+ maxFiles: '14d',
+ }),
+
+ // HTTP logs - rotate daily
+ new DailyRotateFile({
+ filename: path.join(__dirname, '../../logs/http-%DATE%.log'),
+ datePattern: 'YYYY-MM-DD',
+ level: 'http',
+ format: logFormat,
+ maxSize: '20m',
+ maxFiles: '7d',
+ }),
+];
+
+// Create the logger
+const logger = winston.createLogger({
+ level: level(),
+ levels,
+ format: logFormat,
+ transports,
+ exitOnError: false,
+});
+
+// Create a stream object for Morgan HTTP logger
+logger.stream = {
+ write: (message) => {
+ logger.http(message.trim());
+ },
+};
+
+// Helper methods for common logging patterns
+logger.logRequest = (req, res, duration) => {
+ const logData = {
+ method: req.method,
+ url: req.url,
+ status: res.statusCode,
+ duration: `${duration}ms`,
+ ip: req.ip,
+ userAgent: req.get('user-agent'),
+ };
+
+ if (res.statusCode >= 500) {
+ logger.error('Request failed', logData);
+ } else if (res.statusCode >= 400) {
+ logger.warn('Request error', logData);
+ } else {
+ logger.http('Request completed', logData);
+ }
+};
+
+logger.logEmailSent = (recipient, campaign, status) => {
+ logger.info('Email sent', {
+ event: 'email_sent',
+ recipient,
+ campaign,
+ status,
+ timestamp: new Date().toISOString(),
+ });
+};
+
+logger.logEmailFailed = (recipient, campaign, error) => {
+ logger.error('Email failed', {
+ event: 'email_failed',
+ recipient,
+ campaign,
+ error: error.message,
+ stack: error.stack,
+ timestamp: new Date().toISOString(),
+ });
+};
+
+logger.logAuth = (action, username, success, ip) => {
+ const level = success ? 'info' : 'warn';
+ logger[level]('Auth action', {
+ event: 'auth',
+ action,
+ username,
+ success,
+ ip,
+ timestamp: new Date().toISOString(),
+ });
+};
+
+logger.logCampaignAction = (action, campaignId, userId, ip) => {
+ logger.info('Campaign action', {
+ event: 'campaign_action',
+ action,
+ campaignId,
+ userId,
+ ip,
+ timestamp: new Date().toISOString(),
+ });
+};
+
+logger.logRateLimitHit = (endpoint, ip, limit) => {
+ logger.warn('Rate limit hit', {
+ event: 'rate_limit',
+ endpoint,
+ ip,
+ limit,
+ timestamp: new Date().toISOString(),
+ });
+};
+
+logger.logHealthCheck = (service, status, details = {}) => {
+ const level = status === 'healthy' ? 'info' : 'error';
+ logger[level]('Health check', {
+ event: 'health_check',
+ service,
+ status,
+ ...details,
+ timestamp: new Date().toISOString(),
+ });
+};
+
+module.exports = logger;
diff --git a/influence/app/utils/metrics.js b/influence/app/utils/metrics.js
new file mode 100644
index 0000000..faa8c32
--- /dev/null
+++ b/influence/app/utils/metrics.js
@@ -0,0 +1,276 @@
+const client = require('prom-client');
+
+// Create a Registry to register the metrics
+const register = new client.Registry();
+
+// Add default metrics (CPU, memory, etc.)
+client.collectDefaultMetrics({
+ register,
+ prefix: 'influence_app_'
+});
+
+// Custom metrics for the Influence application
+
+// Email metrics
+const emailsSentTotal = new client.Counter({
+ name: 'influence_emails_sent_total',
+ help: 'Total number of emails sent successfully',
+ labelNames: ['campaign_id', 'representative_level'],
+ registers: [register]
+});
+
+const emailsFailedTotal = new client.Counter({
+ name: 'influence_emails_failed_total',
+ help: 'Total number of emails that failed to send',
+ labelNames: ['campaign_id', 'error_type'],
+ registers: [register]
+});
+
+const emailQueueSize = new client.Gauge({
+ name: 'influence_email_queue_size',
+ help: 'Current number of emails in the queue',
+ registers: [register]
+});
+
+const emailSendDuration = new client.Histogram({
+ name: 'influence_email_send_duration_seconds',
+ help: 'Time taken to send an email',
+ labelNames: ['campaign_id'],
+ buckets: [0.1, 0.5, 1, 2, 5, 10],
+ registers: [register]
+});
+
+// API metrics
+const httpRequestDuration = new client.Histogram({
+ name: 'influence_http_request_duration_seconds',
+ help: 'Duration of HTTP requests in seconds',
+ labelNames: ['method', 'route', 'status_code'],
+ buckets: [0.01, 0.05, 0.1, 0.5, 1, 2, 5],
+ registers: [register]
+});
+
+const httpRequestsTotal = new client.Counter({
+ name: 'influence_http_requests_total',
+ help: 'Total number of HTTP requests',
+ labelNames: ['method', 'route', 'status_code'],
+ registers: [register]
+});
+
+// User metrics
+const activeUsersGauge = new client.Gauge({
+ name: 'influence_active_users_total',
+ help: 'Number of currently active users',
+ registers: [register]
+});
+
+const userRegistrationsTotal = new client.Counter({
+ name: 'influence_user_registrations_total',
+ help: 'Total number of user registrations',
+ registers: [register]
+});
+
+const loginAttemptsTotal = new client.Counter({
+ name: 'influence_login_attempts_total',
+ help: 'Total number of login attempts',
+ labelNames: ['status'],
+ registers: [register]
+});
+
+// Campaign metrics
+const campaignCreationsTotal = new client.Counter({
+ name: 'influence_campaign_creations_total',
+ help: 'Total number of campaigns created',
+ registers: [register]
+});
+
+const campaignParticipationTotal = new client.Counter({
+ name: 'influence_campaign_participation_total',
+ help: 'Total number of campaign participations',
+ labelNames: ['campaign_id'],
+ registers: [register]
+});
+
+const activeCampaignsGauge = new client.Gauge({
+ name: 'influence_active_campaigns_total',
+ help: 'Number of currently active campaigns',
+ registers: [register]
+});
+
+const campaignConversionRate = new client.Gauge({
+ name: 'influence_campaign_conversion_rate',
+ help: 'Campaign conversion rate (participants / visitors)',
+ labelNames: ['campaign_id'],
+ registers: [register]
+});
+
+// Representative metrics
+const representativeLookupTotal = new client.Counter({
+ name: 'influence_representative_lookup_total',
+ help: 'Total number of representative lookups',
+ labelNames: ['lookup_type'],
+ registers: [register]
+});
+
+const representativeResponsesTotal = new client.Counter({
+ name: 'influence_representative_responses_total',
+ help: 'Total number of representative responses received',
+ labelNames: ['representative_level'],
+ registers: [register]
+});
+
+const representativeResponseRate = new client.Gauge({
+ name: 'influence_representative_response_rate',
+ help: 'Representative response rate (responses / emails sent)',
+ labelNames: ['representative_level'],
+ registers: [register]
+});
+
+// Rate limiting metrics
+const rateLimitHitsTotal = new client.Counter({
+ name: 'influence_rate_limit_hits_total',
+ help: 'Total number of rate limit hits',
+ labelNames: ['endpoint', 'limit_type'],
+ registers: [register]
+});
+
+// External service metrics
+const externalServiceRequestsTotal = new client.Counter({
+ name: 'influence_external_service_requests_total',
+ help: 'Total number of requests to external services',
+ labelNames: ['service', 'status'],
+ registers: [register]
+});
+
+const externalServiceLatency = new client.Histogram({
+ name: 'influence_external_service_latency_seconds',
+ help: 'Latency of external service requests',
+ labelNames: ['service'],
+ buckets: [0.1, 0.5, 1, 2, 5, 10],
+ registers: [register]
+});
+
+// Geographic metrics
+const participationByPostalCode = new client.Counter({
+ name: 'influence_participation_by_postal_code_total',
+ help: 'Participation count by postal code prefix',
+ labelNames: ['postal_prefix'],
+ registers: [register]
+});
+
+// Middleware to track HTTP requests
+const metricsMiddleware = (req, res, next) => {
+ const start = Date.now();
+
+ res.on('finish', () => {
+ const duration = (Date.now() - start) / 1000;
+ const route = req.route ? req.route.path : req.path;
+ const labels = {
+ method: req.method,
+ route: route,
+ status_code: res.statusCode
+ };
+
+ httpRequestDuration.observe(labels, duration);
+ httpRequestsTotal.inc(labels);
+ });
+
+ next();
+};
+
+// Helper functions for common metric operations
+const metrics = {
+ // Email metrics
+ recordEmailSent: (campaignId, representativeLevel) => {
+ emailsSentTotal.inc({ campaign_id: campaignId, representative_level: representativeLevel });
+ },
+
+ recordEmailFailed: (campaignId, errorType) => {
+ emailsFailedTotal.inc({ campaign_id: campaignId, error_type: errorType });
+ },
+
+ setEmailQueueSize: (size) => {
+ emailQueueSize.set(size);
+ },
+
+ observeEmailSendDuration: (campaignId, durationSeconds) => {
+ emailSendDuration.observe({ campaign_id: campaignId }, durationSeconds);
+ },
+
+ // User metrics
+ setActiveUsers: (count) => {
+ activeUsersGauge.set(count);
+ },
+
+ recordUserRegistration: () => {
+ userRegistrationsTotal.inc();
+ },
+
+ recordLoginAttempt: (success) => {
+ loginAttemptsTotal.inc({ status: success ? 'success' : 'failed' });
+ },
+
+ // Campaign metrics
+ recordCampaignCreation: () => {
+ campaignCreationsTotal.inc();
+ },
+
+ recordCampaignParticipation: (campaignId) => {
+ campaignParticipationTotal.inc({ campaign_id: campaignId });
+ },
+
+ setActiveCampaigns: (count) => {
+ activeCampaignsGauge.set(count);
+ },
+
+ setCampaignConversionRate: (campaignId, rate) => {
+ campaignConversionRate.set({ campaign_id: campaignId }, rate);
+ },
+
+ // Representative metrics
+ recordRepresentativeLookup: (lookupType) => {
+ representativeLookupTotal.inc({ lookup_type: lookupType });
+ },
+
+ recordRepresentativeResponse: (representativeLevel) => {
+ representativeResponsesTotal.inc({ representative_level: representativeLevel });
+ },
+
+ setRepresentativeResponseRate: (representativeLevel, rate) => {
+ representativeResponseRate.set({ representative_level: representativeLevel }, rate);
+ },
+
+ // Rate limiting metrics
+ recordRateLimitHit: (endpoint, limitType) => {
+ rateLimitHitsTotal.inc({ endpoint, limit_type: limitType });
+ },
+
+ // External service metrics
+ recordExternalServiceRequest: (service, success) => {
+ externalServiceRequestsTotal.inc({ service, status: success ? 'success' : 'failed' });
+ },
+
+ observeExternalServiceLatency: (service, durationSeconds) => {
+ externalServiceLatency.observe({ service }, durationSeconds);
+ },
+
+ // Geographic metrics
+ recordParticipationByPostalCode: (postalCode) => {
+ const prefix = postalCode.substring(0, 3).toUpperCase();
+ participationByPostalCode.inc({ postal_prefix: prefix });
+ },
+
+ // Get metrics endpoint handler
+ getMetrics: async () => {
+ return await register.metrics();
+ },
+
+ // Get content type for metrics
+ getContentType: () => {
+ return register.contentType;
+ },
+
+ // Middleware
+ middleware: metricsMiddleware
+};
+
+module.exports = metrics;
diff --git a/influence/app/utils/rate-limiter.js b/influence/app/utils/rate-limiter.js
index 5ea7564..5edfdec 100644
--- a/influence/app/utils/rate-limiter.js
+++ b/influence/app/utils/rate-limiter.js
@@ -16,24 +16,127 @@ function cleanupExpiredEntries() {
// Clean up expired entries every minute
setInterval(cleanupExpiredEntries, 60 * 1000);
-// General API rate limiter
-const general = rateLimit({
- windowMs: 15 * 60 * 1000, // 15 minutes
- max: 100, // limit each IP to 100 requests per windowMs
- message: {
- error: 'Too many requests from this IP, please try again later.',
- retryAfter: 15 * 60 // 15 minutes in seconds
+// Custom key generator that's safer with trust proxy
+const safeKeyGenerator = (req) => {
+ return req.ip || req.connection?.remoteAddress || 'unknown';
+};
+
+// Production-grade rate limiting configuration
+const rateLimitConfig = {
+ // Email sending - very restrictive (5 emails per hour per IP)
+ emailSend: {
+ windowMs: 60 * 60 * 1000, // 1 hour
+ max: 5,
+ message: {
+ error: 'Email rate limit exceeded',
+ message: 'Too many emails sent from this IP. Maximum 5 emails per hour allowed.',
+ retryAfter: 3600
+ }
},
- standardHeaders: true, // Return rate limit info in the `RateLimit-*` headers
- legacyHeaders: false, // Disable the `X-RateLimit-*` headers
- // Use a custom key generator that's safer with trust proxy
- keyGenerator: (req) => {
- // Fallback to connection remote address if req.ip is not available
- return req.ip || req.connection?.remoteAddress || 'unknown';
+
+ // Representative lookup - moderate (30 lookups per minute)
+ representativeLookup: {
+ windowMs: 60 * 1000, // 1 minute
+ max: 30,
+ message: {
+ error: 'Representative lookup rate limit exceeded',
+ message: 'Too many representative lookups. Maximum 30 per minute allowed.',
+ retryAfter: 60
+ }
},
+
+ // Login attempts - strict (5 attempts per 15 minutes)
+ login: {
+ windowMs: 15 * 60 * 1000, // 15 minutes
+ max: 5,
+ message: {
+ error: 'Login rate limit exceeded',
+ message: 'Too many login attempts. Please try again in 15 minutes.',
+ retryAfter: 900
+ }
+ },
+
+ // Public API - standard (100 requests per minute)
+ publicAPI: {
+ windowMs: 60 * 1000, // 1 minute
+ max: 100,
+ message: {
+ error: 'API rate limit exceeded',
+ message: 'Too many requests from this IP. Please try again later.',
+ retryAfter: 60
+ }
+ },
+
+ // Campaign creation/editing - moderate (10 per hour)
+ campaignMutation: {
+ windowMs: 60 * 60 * 1000, // 1 hour
+ max: 10,
+ message: {
+ error: 'Campaign mutation rate limit exceeded',
+ message: 'Too many campaign operations. Maximum 10 per hour allowed.',
+ retryAfter: 3600
+ }
+ },
+
+ // General fallback - legacy compatibility
+ general: {
+ windowMs: 15 * 60 * 1000, // 15 minutes
+ max: 100,
+ message: {
+ error: 'Too many requests from this IP, please try again later.',
+ retryAfter: 900
+ }
+ }
+};
+
+// Create rate limiter instances
+const emailSend = rateLimit({
+ ...rateLimitConfig.emailSend,
+ standardHeaders: true,
+ legacyHeaders: false,
+ skipSuccessfulRequests: false,
+ keyGenerator: safeKeyGenerator
});
-// Email sending rate limiter (general - keeps existing behavior)
+const representativeLookup = rateLimit({
+ ...rateLimitConfig.representativeLookup,
+ standardHeaders: true,
+ legacyHeaders: false,
+ keyGenerator: safeKeyGenerator
+});
+
+const login = rateLimit({
+ ...rateLimitConfig.login,
+ standardHeaders: true,
+ legacyHeaders: false,
+ skipSuccessfulRequests: false, // Count all attempts
+ keyGenerator: safeKeyGenerator
+});
+
+const publicAPI = rateLimit({
+ ...rateLimitConfig.publicAPI,
+ standardHeaders: true,
+ legacyHeaders: false,
+ keyGenerator: safeKeyGenerator
+});
+
+const campaignMutation = rateLimit({
+ ...rateLimitConfig.campaignMutation,
+ standardHeaders: true,
+ legacyHeaders: false,
+ skipSuccessfulRequests: false,
+ keyGenerator: safeKeyGenerator
+});
+
+// General API rate limiter (legacy - kept for backward compatibility)
+const general = rateLimit({
+ ...rateLimitConfig.general,
+ standardHeaders: true,
+ legacyHeaders: false,
+ keyGenerator: safeKeyGenerator
+});
+
+// Email sending rate limiter (legacy - kept for backward compatibility)
const email = rateLimit({
windowMs: 60 * 60 * 1000, // 1 hour
max: 10, // limit each IP to 10 emails per hour
@@ -43,12 +146,8 @@ const email = rateLimit({
},
standardHeaders: true,
legacyHeaders: false,
- skipSuccessfulRequests: false, // Don't skip counting successful requests
- // Use a custom key generator that's safer with trust proxy
- keyGenerator: (req) => {
- // Fallback to connection remote address if req.ip is not available
- return req.ip || req.connection?.remoteAddress || 'unknown';
- },
+ skipSuccessfulRequests: false,
+ keyGenerator: safeKeyGenerator
});
// Custom middleware for per-recipient email rate limiting
@@ -90,16 +189,23 @@ const representAPI = rateLimit({
},
standardHeaders: true,
legacyHeaders: false,
- // Use a custom key generator that's safer with trust proxy
- keyGenerator: (req) => {
- // Fallback to connection remote address if req.ip is not available
- return req.ip || req.connection?.remoteAddress || 'unknown';
- },
+ keyGenerator: safeKeyGenerator
});
module.exports = {
+ // Legacy exports (backward compatibility)
general,
email,
+ representAPI,
+
+ // New granular rate limiters
+ emailSend,
+ representativeLookup,
+ login,
+ publicAPI,
+ campaignMutation,
perRecipientEmailLimiter,
- representAPI
+
+ // Export config for testing/monitoring
+ rateLimitConfig
};
\ No newline at end of file
diff --git a/influence/app/utils/validators.js b/influence/app/utils/validators.js
index 8129e5c..21b11c0 100644
--- a/influence/app/utils/validators.js
+++ b/influence/app/utils/validators.js
@@ -1,7 +1,31 @@
// Validate Canadian postal code format
+// Full Canadian postal code validation with proper FSA/LDU rules
function validatePostalCode(postalCode) {
- const regex = /^[A-Za-z]\d[A-Za-z]\s?\d[A-Za-z]\d$/;
- return regex.test(postalCode);
+ // Remove whitespace and convert to uppercase
+ const cleaned = postalCode.replace(/\s/g, '').toUpperCase();
+
+ // Must be exactly 6 characters
+ if (cleaned.length !== 6) return false;
+
+ // Pattern: A1A 1A1 where A is letter and 1 is digit
+ const pattern = /^[A-Z]\d[A-Z]\d[A-Z]\d$/;
+ if (!pattern.test(cleaned)) return false;
+
+ // First character cannot be D, F, I, O, Q, U, W, or Z
+ const invalidFirstChars = ['D', 'F', 'I', 'O', 'Q', 'U', 'W', 'Z'];
+ if (invalidFirstChars.includes(cleaned[0])) return false;
+
+ // Second position (LDU) cannot be 0
+ if (cleaned[1] === '0') return false;
+
+ // Third character cannot be D, F, I, O, Q, or U
+ const invalidThirdChars = ['D', 'F', 'I', 'O', 'Q', 'U'];
+ if (invalidThirdChars.includes(cleaned[2])) return false;
+
+ // Fifth character cannot be D, F, I, O, Q, or U
+ if (invalidThirdChars.includes(cleaned[4])) return false;
+
+ return true;
}
// Validate Alberta postal code (starts with T)
@@ -10,10 +34,29 @@ function validateAlbertaPostalCode(postalCode) {
return formatted.startsWith('T') && validatePostalCode(postalCode);
}
-// Validate email format
+// Validate email format with stricter rules
function validateEmail(email) {
- const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
- return regex.test(email);
+ // RFC 5322 simplified email validation
+ const regex = /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+
+ if (!regex.test(email)) return false;
+
+ // Additional checks
+ const parts = email.split('@');
+ if (parts.length !== 2) return false;
+
+ const [localPart, domain] = parts;
+
+ // Local part max 64 characters
+ if (localPart.length > 64) return false;
+
+ // Domain must have at least one dot and valid TLD
+ if (!domain.includes('.')) return false;
+
+ // Check for consecutive dots
+ if (email.includes('..')) return false;
+
+ return true;
}
// Format postal code to standard format (A1A 1A1)
@@ -25,16 +68,57 @@ function formatPostalCode(postalCode) {
return cleaned;
}
-// Sanitize string input to prevent XSS
+// Sanitize string input to prevent XSS and injection attacks
function sanitizeString(str) {
if (typeof str !== 'string') return str;
return str
.replace(/[<>]/g, '') // Remove angle brackets
+ .replace(/javascript:/gi, '') // Remove javascript: protocol
+ .replace(/on\w+\s*=/gi, '') // Remove event handlers
+ .replace(/eval\s*\(/gi, '') // Remove eval calls
.trim()
.substring(0, 1000); // Limit length
}
+// Sanitize HTML content for email templates
+function sanitizeHtmlContent(html) {
+ if (typeof html !== 'string') return html;
+
+ // Remove dangerous tags and attributes
+ let sanitized = html
+ .replace(/
)<[^<]*)*<\/script>/gi, '')
+ .replace(/)<[^<]*)*<\/iframe>/gi, '')
+ .replace(/)<[^<]*)*<\/object>/gi, '')
+ .replace(/]*>/gi, '')
+ .replace(/javascript:/gi, '')
+ .replace(/on\w+\s*=/gi, '');
+
+ return sanitized;
+}
+
+// Validate SQL/NoSQL injection attempts in where clauses
+function validateWhereClause(whereClause) {
+ if (typeof whereClause !== 'string') return false;
+
+ // Check for SQL injection patterns
+ const suspiciousPatterns = [
+ /;\s*drop\s+/i,
+ /;\s*delete\s+/i,
+ /;\s*update\s+/i,
+ /;\s*insert\s+/i,
+ /union\s+select/i,
+ /exec\s*\(/i,
+ /execute\s*\(/i,
+ /--/,
+ /\/\*/,
+ /xp_/i,
+ /sp_/i
+ ];
+
+ return !suspiciousPatterns.some(pattern => pattern.test(whereClause));
+}
+
// Validate required fields in request body
function validateRequiredFields(body, requiredFields) {
const errors = [];
@@ -130,6 +214,8 @@ module.exports = {
validateEmail,
formatPostalCode,
sanitizeString,
+ sanitizeHtmlContent,
+ validateWhereClause,
validateRequiredFields,
containsSuspiciousContent,
generateSlug,
diff --git a/influence/docker-compose.yml b/influence/docker-compose.yml
index 740c25d..d8cdb61 100644
--- a/influence/docker-compose.yml
+++ b/influence/docker-compose.yml
@@ -1,25 +1,53 @@
+version: '3.8'
+
services:
app:
build:
context: ./app
dockerfile: Dockerfile
+ container_name: influence-app
ports:
- "3333:3333"
env_file:
- .env
+ environment:
+ - NODE_ENV=production
+ - REDIS_HOST=redis-changemaker
+ - REDIS_PORT=6379
volumes:
- ./app:/usr/src/app
- /usr/src/app/node_modules
- restart: unless-stopped
+ - uploads-data:/usr/src/app/public/uploads
+ - logs-data:/usr/src/app/logs
+ restart: always
+ healthcheck:
+ test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:3333/api/health"]
+ interval: 30s
+ timeout: 10s
+ retries: 3
+ start_period: 40s
+ deploy:
+ resources:
+ limits:
+ cpus: '2'
+ memory: 2G
+ reservations:
+ cpus: '0.5'
+ memory: 512M
+ networks:
+ - changemakerlite_changemaker-lite
+ logging:
+ driver: "json-file"
+ options:
+ max-size: "10m"
+ max-file: "3"
- # MailHog for local email testing and development
- mailhog:
- image: mailhog/mailhog:latest
- ports:
- - "1025:1025" # SMTP server
- - "8025:8025" # Web UI
- restart: unless-stopped
+volumes:
+ uploads-data:
+ driver: local
+ logs-data:
+ driver: local
networks:
- changemaker-lite:
- external: true
\ No newline at end of file
+ changemakerlite_changemaker-lite:
+ external: true
diff --git a/influence/example.env b/influence/example.env
index fc10b11..62e4944 100644
--- a/influence/example.env
+++ b/influence/example.env
@@ -9,14 +9,14 @@ NOCODB_API_TOKEN=your_nocodb_api_token_here
NOCODB_PROJECT_ID=your_project_id
# SMTP Configuration
-# Configure your email service provider settings
-SMTP_HOST=smtp.your-provider.com
-SMTP_PORT=587
-SMTP_SECURE=false
-SMTP_USER=your-email@domain.com
-SMTP_PASS=your_email_password_or_app_password
-SMTP_FROM_EMAIL=your-sender@domain.com
-SMTP_FROM_NAME="Your Campaign Name"
+# Configure your email service provider settings. See below for development mode smtp
+# SMTP_HOST=smtp.your-provider.com
+# SMTP_PORT=587
+# SMTP_SECURE=false
+# SMTP_USER=your-email@domain.com
+# SMTP_PASS=your_email_password_or_app_password
+# SMTP_FROM_EMAIL=your-sender@domain.com
+# SMTP_FROM_NAME="Your Campaign Name"
# Admin Configuration
# Set a strong password for admin access
@@ -60,22 +60,47 @@ NOCODB_TABLE_REPRESENTATIVE_RESPONSES=
NOCODB_TABLE_RESPONSE_UPVOTES=
NOCODB_TABLE_EMAIL_VERIFICATIONS=
+# Redis Configuration (for email queue and caching)
+# Uses centralized Redis from root docker-compose.yml
+REDIS_HOST=redis-changemaker
+REDIS_PORT=6379
+REDIS_PASSWORD=
+REDIS_DB=0
+
+# Backup Configuration
+BACKUP_RETENTION_DAYS=30
+BACKUP_ENCRYPTION_KEY=generate_a_strong_encryption_key_here
+BACKUP_BASE_DIR=/path/to/backups
+USE_S3_BACKUP=false
+S3_BACKUP_BUCKET=
+S3_BACKUP_PREFIX=influence-backups
+REMOVE_LOCAL_AFTER_S3=false
+
+# Monitoring Configuration (optional)
+GRAFANA_ADMIN_PASSWORD=change_this_for_production
+
# Optional: Development Mode Settings
-# Uncomment and modify these for local development with MailHog
-# SMTP_HOST=mailhog
-# SMTP_PORT=1025
-# SMTP_SECURE=false
-# SMTP_USER=
-# SMTP_PASS=
-# SMTP_FROM_EMAIL=dev@albertainfluence.local
-# SMTP_FROM_NAME="BNKops Influence Campaign (DEV)"
+# Uncomment and modify these for local development with centralized MailHog
+# MailHog runs from root docker-compose.yml as a shared service
+SMTP_HOST=mailhog-changemaker
+SMTP_PORT=1025
+SMTP_SECURE=false
+SMTP_USER=
+SMTP_PASS=
+SMTP_FROM_EMAIL=dev@albertainfluence.local
+SMTP_FROM_NAME="BNKops Influence Campaign (DEV)"
# Security Notes:
# - Keep your .env file secure and never commit it to version control
# - Use strong, unique passwords for ADMIN_PASSWORD
-# - Generate a secure random string for SESSION_SECRET
-# - For production, ensure EMAIL_TEST_MODE=false
+# - Generate a secure random string for SESSION_SECRET (64+ characters)
+# - For production, ensure EMAIL_TEST_MODE=false and HTTPS=true
# - Use app passwords or API keys for SMTP_PASS, not your main email password
+# - Rotate all secrets regularly (every 90 days recommended)
+
+# Generate Secure Secrets:
+# SESSION_SECRET: node -e "console.log(require('crypto').randomBytes(64).toString('hex'))"
+# BACKUP_ENCRYPTION_KEY: node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
# Common SMTP Provider Examples:
#
@@ -105,4 +130,11 @@ NOCODB_TABLE_EMAIL_VERIFICATIONS=
# SMTP_PORT=587
# SMTP_SECURE=false
# SMTP_USER=apikey
-# SMTP_PASS=your_sendgrid_api_key
\ No newline at end of file
+# SMTP_PASS=your_sendgrid_api_key
+#
+# AWS SES:
+# SMTP_HOST=email-smtp.us-east-1.amazonaws.com
+# SMTP_PORT=587
+# SMTP_SECURE=false
+# SMTP_USER=your_aws_smtp_username
+# SMTP_PASS=your_aws_smtp_password
\ No newline at end of file
diff --git a/influence/scripts/backup.sh b/influence/scripts/backup.sh
new file mode 100755
index 0000000..aaea05c
--- /dev/null
+++ b/influence/scripts/backup.sh
@@ -0,0 +1,306 @@
+#!/bin/bash
+
+##############################################################################
+# Influence App Backup Script
+# Automated backup for NocoDB data, uploaded files, and configurations
+##############################################################################
+
+set -e # Exit on error
+
+# Configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+APP_DIR="$(dirname "$SCRIPT_DIR")"
+BACKUP_DIR="${BACKUP_BASE_DIR:-$APP_DIR/backups}"
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+BACKUP_NAME="influence_backup_${TIMESTAMP}"
+BACKUP_PATH="$BACKUP_DIR/$BACKUP_NAME"
+
+# Retention settings
+RETENTION_DAYS=${BACKUP_RETENTION_DAYS:-30}
+
+# S3/External storage settings (optional)
+USE_S3=${USE_S3_BACKUP:-false}
+S3_BUCKET=${S3_BACKUP_BUCKET:-""}
+S3_PREFIX=${S3_BACKUP_PREFIX:-"influence-backups"}
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Logging functions
+log_info() {
+ echo -e "${GREEN}[INFO]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1"
+}
+
+log_warn() {
+ echo -e "${YELLOW}[WARN]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1"
+}
+
+log_error() {
+ echo -e "${RED}[ERROR]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1"
+}
+
+# Check if required commands exist
+check_dependencies() {
+ local missing_deps=()
+
+ for cmd in tar gzip du; do
+ if ! command -v $cmd &> /dev/null; then
+ missing_deps+=($cmd)
+ fi
+ done
+
+ if [ "$USE_S3" = "true" ]; then
+ if ! command -v aws &> /dev/null; then
+ missing_deps+=(aws-cli)
+ fi
+ fi
+
+ if [ ${#missing_deps[@]} -ne 0 ]; then
+ log_error "Missing dependencies: ${missing_deps[*]}"
+ exit 1
+ fi
+}
+
+# Create backup directory
+create_backup_dir() {
+ log_info "Creating backup directory: $BACKUP_PATH"
+ mkdir -p "$BACKUP_PATH"
+}
+
+# Backup uploaded files
+backup_uploads() {
+ log_info "Backing up uploaded files..."
+
+ local uploads_dir="$APP_DIR/public/uploads"
+
+ if [ -d "$uploads_dir" ]; then
+ local size=$(du -sh "$uploads_dir" | cut -f1)
+ log_info "Uploads directory size: $size"
+
+ tar -czf "$BACKUP_PATH/uploads.tar.gz" -C "$APP_DIR/public" uploads
+ log_info "Uploads backed up successfully"
+ else
+ log_warn "Uploads directory not found, skipping"
+ fi
+}
+
+# Backup environment configuration (encrypted)
+backup_env_config() {
+ log_info "Backing up environment configuration..."
+
+ local env_file="$APP_DIR/.env"
+
+ if [ -f "$env_file" ]; then
+ # Copy .env file (will be encrypted later)
+ cp "$env_file" "$BACKUP_PATH/.env"
+
+ # Encrypt if encryption key is provided
+ if [ -n "${BACKUP_ENCRYPTION_KEY}" ]; then
+ log_info "Encrypting environment file..."
+ openssl enc -aes-256-cbc -salt -pbkdf2 \
+ -in "$BACKUP_PATH/.env" \
+ -out "$BACKUP_PATH/.env.encrypted" \
+ -k "${BACKUP_ENCRYPTION_KEY}"
+ rm "$BACKUP_PATH/.env" # Remove unencrypted version
+ log_info "Environment file encrypted"
+ else
+ log_warn "BACKUP_ENCRYPTION_KEY not set, .env file not encrypted"
+ fi
+ else
+ log_warn ".env file not found, skipping"
+ fi
+}
+
+# Backup NocoDB data (if accessible)
+backup_nocodb() {
+ log_info "Checking NocoDB backup capability..."
+
+ # Load environment variables
+ if [ -f "$APP_DIR/.env" ]; then
+ source "$APP_DIR/.env"
+ fi
+
+ # If NocoDB is accessible via API, export data
+ if [ -n "$NOCODB_API_URL" ] && [ -n "$NOCODB_API_TOKEN" ]; then
+ log_info "Exporting NocoDB metadata..."
+
+ # Export project metadata
+ curl -s -H "xc-token: $NOCODB_API_TOKEN" \
+ "$NOCODB_API_URL/api/v1/db/meta/projects" \
+ -o "$BACKUP_PATH/nocodb_projects.json" || log_warn "Failed to export NocoDB projects"
+
+ log_info "NocoDB metadata exported"
+ else
+ log_warn "NocoDB credentials not available, skipping data export"
+ fi
+}
+
+# Backup logs
+backup_logs() {
+ log_info "Backing up log files..."
+
+ local logs_dir="$APP_DIR/logs"
+
+ if [ -d "$logs_dir" ]; then
+ # Only backup logs from last 7 days
+ find "$logs_dir" -name "*.log" -mtime -7 -print0 | \
+ tar -czf "$BACKUP_PATH/logs.tar.gz" --null -T -
+ log_info "Logs backed up successfully"
+ else
+ log_warn "Logs directory not found, skipping"
+ fi
+}
+
+# Create backup manifest
+create_manifest() {
+ log_info "Creating backup manifest..."
+
+ cat > "$BACKUP_PATH/manifest.txt" << EOF
+Influence App Backup
+====================
+Backup Date: $(date)
+Backup Name: $BACKUP_NAME
+Server: $(hostname)
+
+Contents:
+$(ls -lh "$BACKUP_PATH")
+
+Total Size: $(du -sh "$BACKUP_PATH" | cut -f1)
+EOF
+
+ log_info "Manifest created"
+}
+
+# Compress entire backup
+compress_backup() {
+ log_info "Compressing backup..."
+
+ cd "$BACKUP_DIR"
+ tar -czf "${BACKUP_NAME}.tar.gz" "$BACKUP_NAME"
+
+ # Remove uncompressed directory
+ rm -rf "$BACKUP_NAME"
+
+ local size=$(du -sh "${BACKUP_NAME}.tar.gz" | cut -f1)
+ log_info "Backup compressed: ${BACKUP_NAME}.tar.gz ($size)"
+}
+
+# Upload to S3 (if enabled)
+upload_to_s3() {
+ if [ "$USE_S3" != "true" ]; then
+ return 0
+ fi
+
+ if [ -z "$S3_BUCKET" ]; then
+ log_error "S3_BUCKET not set, cannot upload to S3"
+ return 1
+ fi
+
+ log_info "Uploading backup to S3..."
+
+ aws s3 cp "${BACKUP_DIR}/${BACKUP_NAME}.tar.gz" \
+ "s3://${S3_BUCKET}/${S3_PREFIX}/${BACKUP_NAME}.tar.gz" \
+ --storage-class STANDARD_IA
+
+ if [ $? -eq 0 ]; then
+ log_info "Backup uploaded to S3 successfully"
+
+ # Optionally remove local backup after successful S3 upload
+ if [ "${REMOVE_LOCAL_AFTER_S3:-false}" = "true" ]; then
+ log_info "Removing local backup after S3 upload"
+ rm "${BACKUP_DIR}/${BACKUP_NAME}.tar.gz"
+ fi
+ else
+ log_error "Failed to upload backup to S3"
+ return 1
+ fi
+}
+
+# Clean old backups
+cleanup_old_backups() {
+ log_info "Cleaning up backups older than $RETENTION_DAYS days..."
+
+ # Clean local backups
+ find "$BACKUP_DIR" -name "influence_backup_*.tar.gz" -mtime +$RETENTION_DAYS -delete
+
+ # Clean S3 backups (if enabled)
+ if [ "$USE_S3" = "true" ] && [ -n "$S3_BUCKET" ]; then
+ log_info "Cleaning old S3 backups..."
+
+ # This requires AWS CLI with proper permissions
+ aws s3 ls "s3://${S3_BUCKET}/${S3_PREFIX}/" | \
+ while read -r line; do
+ createDate=$(echo $line | awk '{print $1" "$2}')
+ createDateSec=$(date -d "$createDate" +%s)
+ olderThan=$(date -d "-${RETENTION_DAYS} days" +%s)
+
+ if [ $createDateSec -lt $olderThan ]; then
+ fileName=$(echo $line | awk '{print $4}')
+ if [ -n "$fileName" ]; then
+ aws s3 rm "s3://${S3_BUCKET}/${S3_PREFIX}/${fileName}"
+ log_info "Deleted old S3 backup: $fileName"
+ fi
+ fi
+ done
+ fi
+
+ log_info "Cleanup completed"
+}
+
+# Verify backup integrity
+verify_backup() {
+ log_info "Verifying backup integrity..."
+
+ if tar -tzf "${BACKUP_DIR}/${BACKUP_NAME}.tar.gz" > /dev/null 2>&1; then
+ log_info "Backup integrity verified successfully"
+ return 0
+ else
+ log_error "Backup integrity check failed!"
+ return 1
+ fi
+}
+
+# Main backup process
+main() {
+ log_info "Starting Influence App backup..."
+ log_info "Backup path: $BACKUP_PATH"
+
+ # Check dependencies
+ check_dependencies
+
+ # Create backup directory
+ create_backup_dir
+
+ # Perform backups
+ backup_uploads
+ backup_env_config
+ backup_nocodb
+ backup_logs
+
+ # Create manifest
+ create_manifest
+
+ # Compress backup
+ compress_backup
+
+ # Verify backup
+ if ! verify_backup; then
+ log_error "Backup verification failed, aborting"
+ exit 1
+ fi
+
+ # Upload to S3
+ upload_to_s3 || log_warn "S3 upload failed or skipped"
+
+ # Cleanup old backups
+ cleanup_old_backups
+
+ log_info "Backup completed successfully: ${BACKUP_NAME}.tar.gz"
+ log_info "Backup size: $(du -sh "${BACKUP_DIR}/${BACKUP_NAME}.tar.gz" | cut -f1)"
+}
+
+# Run main function
+main "$@"
diff --git a/influence/scripts/toggle-smtp.sh b/influence/scripts/toggle-smtp.sh
new file mode 100755
index 0000000..94c13ba
--- /dev/null
+++ b/influence/scripts/toggle-smtp.sh
@@ -0,0 +1,204 @@
+#!/bin/bash
+
+# Toggle SMTP Configuration Script
+# Switches between development (MailHog) and production (ProtonMail) SMTP settings
+
+set -e
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+ENV_FILE="$SCRIPT_DIR/../.env"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}"
+cat << "EOF"
+╔══════════════════════════════════════════════════╗
+║ SMTP Configuration Toggle Tool ║
+║ Influence Campaign Application ║
+╚══════════════════════════════════════════════════╝
+EOF
+echo -e "${NC}"
+
+# Check if .env file exists
+if [ ! -f "$ENV_FILE" ]; then
+ echo -e "${RED}Error: .env file not found at $ENV_FILE${NC}"
+ exit 1
+fi
+
+# Detect current mode
+if grep -q "^SMTP_HOST=mailhog" "$ENV_FILE"; then
+ CURRENT_MODE="development"
+ CURRENT_HOST="mailhog"
+elif grep -q "^SMTP_HOST=smtp.protonmail.ch" "$ENV_FILE"; then
+ CURRENT_MODE="production"
+ CURRENT_HOST="smtp.protonmail.ch"
+else
+ CURRENT_MODE="unknown"
+ CURRENT_HOST=$(grep "^SMTP_HOST=" "$ENV_FILE" | cut -d'=' -f2)
+fi
+
+echo -e "${YELLOW}Current Configuration:${NC}"
+echo -e " Mode: ${BLUE}$CURRENT_MODE${NC}"
+echo -e " SMTP Host: ${BLUE}$CURRENT_HOST${NC}"
+echo -e " Email Test Mode: ${BLUE}$(grep "^EMAIL_TEST_MODE=" "$ENV_FILE" | cut -d'=' -f2)${NC}"
+echo -e " Node Environment: ${BLUE}$(grep "^NODE_ENV=" "$ENV_FILE" | cut -d'=' -f2)${NC}"
+echo ""
+
+# Ask user what mode they want
+echo "Select SMTP configuration mode:"
+echo " 1) Development (MailHog - emails captured locally)"
+echo " 2) Production (ProtonMail - emails sent to real recipients)"
+echo " 3) Cancel"
+echo ""
+read -p "Enter your choice (1-3): " choice
+
+case $choice in
+ 1)
+ TARGET_MODE="development"
+ ;;
+ 2)
+ TARGET_MODE="production"
+ ;;
+ 3)
+ echo -e "${YELLOW}Cancelled. No changes made.${NC}"
+ exit 0
+ ;;
+ *)
+ echo -e "${RED}Invalid choice. Exiting.${NC}"
+ exit 1
+ ;;
+esac
+
+# Confirm if already in target mode
+if [ "$CURRENT_MODE" = "$TARGET_MODE" ]; then
+ echo -e "${GREEN}Already in $TARGET_MODE mode. No changes needed.${NC}"
+ exit 0
+fi
+
+# Create backup
+BACKUP_FILE="${ENV_FILE}.backup_$(date +%Y%m%d_%H%M%S)"
+cp "$ENV_FILE" "$BACKUP_FILE"
+echo -e "${GREEN}✓ Backup created: $BACKUP_FILE${NC}"
+
+# Apply configuration based on target mode
+if [ "$TARGET_MODE" = "development" ]; then
+ echo ""
+ echo -e "${BLUE}Switching to DEVELOPMENT mode...${NC}"
+ echo ""
+
+ # Comment out production SMTP settings
+ sed -i 's/^SMTP_HOST=smtp.protonmail.ch/# SMTP_HOST=smtp.protonmail.ch/' "$ENV_FILE"
+ sed -i 's/^SMTP_PORT=587$/# SMTP_PORT=587/' "$ENV_FILE"
+ sed -i 's/^SMTP_SECURE=false$/# SMTP_SECURE=false/' "$ENV_FILE"
+ sed -i 's/^SMTP_USER=cmlite@bnkops.ca/# SMTP_USER=cmlite@bnkops.ca/' "$ENV_FILE"
+ sed -i 's/^SMTP_PASS=QMLDV1E2MWDHNJMY/# SMTP_PASS=QMLDV1E2MWDHNJMY/' "$ENV_FILE"
+ sed -i 's/^SMTP_FROM_EMAIL=cmlite@bnkops.ca/# SMTP_FROM_EMAIL=cmlite@bnkops.ca/' "$ENV_FILE"
+ sed -i 's/^SMTP_FROM_NAME="BNKops Influence Campaign"$/# SMTP_FROM_NAME="BNKops Influence Campaign"/' "$ENV_FILE"
+
+ # Uncomment development SMTP settings
+ sed -i 's/^# SMTP_HOST=mailhog-changemaker$/SMTP_HOST=mailhog-changemaker/' "$ENV_FILE"
+ sed -i 's/^# SMTP_PORT=1025$/SMTP_PORT=1025/' "$ENV_FILE"
+ sed -i 's/^# SMTP_SECURE=false$/SMTP_SECURE=false/' "$ENV_FILE"
+ sed -i 's/^# SMTP_USER=test$/SMTP_USER=test/' "$ENV_FILE"
+ sed -i 's/^# SMTP_PASS=test$/SMTP_PASS=test/' "$ENV_FILE"
+ sed -i 's/^# SMTP_FROM_EMAIL=dev@albertainfluence.local$/SMTP_FROM_EMAIL=dev@albertainfluence.local/' "$ENV_FILE"
+ sed -i 's/^# SMTP_FROM_NAME="BNKops Influence Campaign (DEV)"$/SMTP_FROM_NAME="BNKops Influence Campaign (DEV)"/' "$ENV_FILE"
+
+ # Update other settings
+ sed -i 's/^NODE_ENV=production$/NODE_ENV=development/' "$ENV_FILE"
+ sed -i 's/^EMAIL_TEST_MODE=false$/EMAIL_TEST_MODE=true/' "$ENV_FILE"
+ sed -i 's|^APP_URL=https://influence.cmlite.org$|APP_URL=http://localhost:3333|' "$ENV_FILE"
+
+ echo -e "${GREEN}✓ Configured for DEVELOPMENT mode${NC}"
+ echo ""
+ echo -e "${YELLOW}Development Configuration:${NC}"
+ echo " • SMTP: MailHog (mailhog-changemaker:1025)"
+ echo " • Web UI: http://localhost:8025"
+ echo " • Email Test Mode: Enabled"
+ echo " • Node Environment: development"
+ echo " • App URL: http://localhost:3333"
+ echo ""
+ echo -e "${YELLOW}Next Steps:${NC}"
+ echo " 1. Ensure MailHog is running (from root directory):"
+ echo -e " ${BLUE}cd .. && docker compose up -d mailhog${NC}"
+ echo ""
+ echo " 2. Start the Influence app:"
+ echo -e " ${BLUE}docker compose up -d${NC}"
+ echo ""
+ echo " 3. Access MailHog UI to view captured emails:"
+ echo -e " ${BLUE}http://localhost:8025${NC}"
+
+elif [ "$TARGET_MODE" = "production" ]; then
+ echo ""
+ echo -e "${BLUE}Switching to PRODUCTION mode...${NC}"
+ echo ""
+
+ # Confirm production switch
+ echo -e "${RED}⚠️ WARNING: Production mode will send REAL emails!${NC}"
+ read -p "Are you sure you want to switch to production? (yes/no): " confirm
+
+ if [ "$confirm" != "yes" ]; then
+ echo -e "${YELLOW}Cancelled. Restoring backup...${NC}"
+ mv "$BACKUP_FILE" "$ENV_FILE"
+ echo -e "${GREEN}✓ Original configuration restored${NC}"
+ exit 0
+ fi
+
+ # Comment out development SMTP settings
+ sed -i 's/^SMTP_HOST=mailhog-changemaker$/# SMTP_HOST=mailhog-changemaker/' "$ENV_FILE"
+ sed -i 's/^SMTP_PORT=1025$/# SMTP_PORT=1025/' "$ENV_FILE"
+ sed -i 's/^SMTP_SECURE=false$/# SMTP_SECURE=false/' "$ENV_FILE"
+ sed -i 's/^SMTP_USER=test$/# SMTP_USER=test/' "$ENV_FILE"
+ sed -i 's/^SMTP_PASS=test$/# SMTP_PASS=test/' "$ENV_FILE"
+ sed -i 's/^SMTP_FROM_EMAIL=dev@albertainfluence.local$/# SMTP_FROM_EMAIL=dev@albertainfluence.local/' "$ENV_FILE"
+ sed -i 's/^SMTP_FROM_NAME="BNKops Influence Campaign (DEV)"$/# SMTP_FROM_NAME="BNKops Influence Campaign (DEV)"/' "$ENV_FILE"
+
+ # Uncomment production SMTP settings
+ sed -i 's/^# SMTP_HOST=smtp.protonmail.ch$/SMTP_HOST=smtp.protonmail.ch/' "$ENV_FILE"
+ sed -i 's/^# SMTP_PORT=587$/SMTP_PORT=587/' "$ENV_FILE"
+ sed -i 's/^# SMTP_SECURE=false$/SMTP_SECURE=false/' "$ENV_FILE"
+ sed -i 's/^# SMTP_USER=cmlite@bnkops.ca$/SMTP_USER=cmlite@bnkops.ca/' "$ENV_FILE"
+ sed -i 's/^# SMTP_PASS=QMLDV1E2MWDHNJMY$/SMTP_PASS=QMLDV1E2MWDHNJMY/' "$ENV_FILE"
+ sed -i 's/^# SMTP_FROM_EMAIL=cmlite@bnkops.ca$/SMTP_FROM_EMAIL=cmlite@bnkops.ca/' "$ENV_FILE"
+ sed -i 's/^# SMTP_FROM_NAME="BNKops Influence Campaign"$/SMTP_FROM_NAME="BNKops Influence Campaign"/' "$ENV_FILE"
+
+ # Update other settings
+ sed -i 's/^NODE_ENV=development$/NODE_ENV=production/' "$ENV_FILE"
+ sed -i 's/^EMAIL_TEST_MODE=true$/EMAIL_TEST_MODE=false/' "$ENV_FILE"
+ sed -i 's|^APP_URL=http://localhost:3333$|APP_URL=https://influence.cmlite.org|' "$ENV_FILE"
+
+ echo -e "${GREEN}✓ Configured for PRODUCTION mode${NC}"
+ echo ""
+ echo -e "${YELLOW}Production Configuration:${NC}"
+ echo " • SMTP: ProtonMail (smtp.protonmail.ch)"
+ echo " • Email Test Mode: Disabled"
+ echo " • Node Environment: production"
+ echo " • App URL: https://influence.cmlite.org"
+ echo ""
+ echo -e "${RED}⚠️ IMPORTANT: Emails will be sent to REAL recipients!${NC}"
+ echo ""
+ echo -e "${YELLOW}Next Steps:${NC}"
+ echo " 1. Restart the application:"
+ echo -e " ${BLUE}docker compose down && docker compose up -d${NC}"
+ echo ""
+ echo " 2. Verify SMTP connection:"
+ echo -e " ${BLUE}docker compose logs -f${NC}"
+fi
+
+echo ""
+echo -e "${GREEN}════════════════════════════════════════════════${NC}"
+echo -e "${GREEN}✓ Configuration updated successfully!${NC}"
+echo -e "${GREEN}════════════════════════════════════════════════${NC}"
+echo ""
+echo "Current settings:"
+grep "^SMTP_HOST=" "$ENV_FILE"
+grep "^NODE_ENV=" "$ENV_FILE"
+grep "^EMAIL_TEST_MODE=" "$ENV_FILE"
+grep "^APP_URL=" "$ENV_FILE"
+echo ""
+echo -e "Backup saved at: ${BLUE}$BACKUP_FILE${NC}"
diff --git a/mkdocs/docs/build/influence.md b/mkdocs/docs/build/influence.md
index 3e931ab..1cc0176 100644
--- a/mkdocs/docs/build/influence.md
+++ b/mkdocs/docs/build/influence.md
@@ -35,30 +35,6 @@ cp example.env .env
Edit the `.env` file with your configuration:
-```env
-# Server Configuration
-NODE_ENV=production
-PORT=3333
-
-# NocoDB Configuration
-NOCODB_API_URL=https://your-nocodb-instance.com
-NOCODB_API_TOKEN=your_nocodb_api_token_here
-NOCODB_PROJECT_ID=your_project_id_here
-
-# Email Configuration (Production SMTP)
-SMTP_HOST=smtp.gmail.com
-SMTP_PORT=587
-SMTP_SECURE=false
-SMTP_USER=your_email@gmail.com
-SMTP_PASS=your_app_password
-SMTP_FROM_NAME=BNKops Influence Campaign
-SMTP_FROM_EMAIL=your_email@gmail.com
-
-# Rate Limiting
-RATE_LIMIT_WINDOW_MS=900000
-RATE_LIMIT_MAX_REQUESTS=100
-```
-
#### Development Mode Configuration
For development and testing, use MailHog to catch emails: