@equilateral_ai/mindmeld 3.0.0

package/src/handlers/notifications/getPreferences.js

@@ -0,0 +1,84 @@
+/**
+ * Get Notification Preferences Handler
+ * Retrieves user's notification preferences
+ *
+ * GET /api/notifications/preferences
+ * Auth: Cognito JWT required
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
+
+exports.handler = wrapHandler(async ({ requestContext }) => {
+    const Request_ID = requestContext.requestId;
+    const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+    if (!email) {
+        return createErrorResponse(401, 'Authentication required');
+    }
+
+    // Get user preferences using the helper function
+    const prefsResult = await executeQuery(`
+        SELECT rapport.get_notification_preferences($1) as preferences
+    `, [email]);
+
+    const preferences = prefsResult.rows[0]?.preferences || getDefaultPreferences();
+
+    // Get notification log summary (last 30 days)
+    const logSummary = await executeQuery(`
+        SELECT
+            notification_type,
+            channel,
+            status,
+            COUNT(*) as count
+        FROM rapport.notification_log
+        WHERE email_address = $1
+            AND created_at > NOW() - INTERVAL '30 days'
+        GROUP BY notification_type, channel, status
+        ORDER BY notification_type, channel
+    `, [email]);
+
+    // Get pending digests
+    const pendingDigests = await executeQuery(`
+        SELECT
+            digest_type,
+            scheduled_for,
+            status
+        FROM rapport.digest_queue
+        WHERE email_address = $1
+            AND status = 'pending'
+        ORDER BY scheduled_for
+    `, [email]);
+
+    return createSuccessResponse(
+        {
+            preferences: preferences,
+            notification_summary: logSummary.rows,
+            pending_digests: pendingDigests.rows
+        },
+        'Preferences retrieved',
+        { Request_ID, Timestamp: new Date().toISOString() }
+    );
+});
+
+/**
+ * Get default notification preferences
+ */
+function getDefaultPreferences() {
+    return {
+        email_enabled: true,
+        slack_enabled: true,
+        notification_types: {
+            pattern_promotion: { email: true, slack: true },
+            weekly_digest: { email: true, slack: false },
+            critical_violation: { email: true, slack: true },
+            team_alert: { email: true, slack: true },
+            curation_candidate: { email: true, slack: true }
+        },
+        project_overrides: {},
+        digest_frequency: 'weekly',
+        digest_day: 1,
+        quiet_hours_enabled: false,
+        quiet_hours_timezone: 'America/New_York',
+        slack_dm_enabled: true
+    };
+}

package/src/handlers/notifications/sendNotification.js

@@ -0,0 +1,170 @@
+/**
+ * Send Notification Handler
+ * Sends email and/or Slack notifications based on user preferences
+ *
+ * POST /api/notifications/send
+ * Auth: Cognito JWT required (Admin or internal service)
+ *
+ * Body:
+ * {
+ *   "type": "pattern_promotion|weekly_digest|critical_violation|team_alert|curation_candidate",
+ *   "recipients": ["email@example.com"] | "all_project" | "all_admins",
+ *   "projectId": "prj_xxx" (optional),
+ *   "data": { ... notification-specific data ... }
+ * }
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
+const { NotificationService } = require('../../core/NotificationService');
+
+// Initialize notification service (singleton for Lambda warm starts)
+const notificationService = new NotificationService();
+
+exports.handler = wrapHandler(async ({ requestContext, body }) => {
+    const Request_ID = requestContext.requestId;
+    const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+    if (!email) {
+        return createErrorResponse(401, 'Authentication required');
+    }
+
+    // Validate required fields
+    const { type, recipients, projectId, data } = body;
+
+    if (!type) {
+        return createErrorResponse(400, 'Notification type is required');
+    }
+
+    if (!recipients) {
+        return createErrorResponse(400, 'Recipients are required');
+    }
+
+    if (!data) {
+        return createErrorResponse(400, 'Notification data is required');
+    }
+
+    // Validate notification type
+    const validTypes = ['pattern_promotion', 'weekly_digest', 'critical_violation', 'team_alert', 'curation_candidate'];
+    if (!validTypes.includes(type)) {
+        return createErrorResponse(400, `Invalid notification type. Valid types: ${validTypes.join(', ')}`);
+    }
+
+    // Check authorization (only admins and managers can send notifications)
+    const authCheck = await executeQuery(`
+        SELECT
+            ue."Admin",
+            ue."Manager",
+            u."Super_Admin",
+            ue."Company_ID"
+        FROM "UserEntitlements" ue
+        JOIN "Users" u ON ue."Email_Address" = u."Email_Address"
+        WHERE ue."Email_Address" = $1
+    `, [email]);
+
+    if (authCheck.rowCount === 0) {
+        return createErrorResponse(403, 'Access denied');
+    }
+
+    const userRole = authCheck.rows[0];
+    const isAuthorized = userRole.Super_Admin || userRole.Admin || userRole.Manager;
+
+    if (!isAuthorized) {
+        return createErrorResponse(403, 'Only admins and managers can send notifications');
+    }
+
+    // Resolve recipients
+    let recipientEmails = [];
+
+    if (Array.isArray(recipients)) {
+        // Direct email list
+        recipientEmails = recipients;
+    } else if (recipients === 'all_project' && projectId) {
+        // All project collaborators
+        const collaborators = await executeQuery(`
+            SELECT pc.email_address
+            FROM rapport.project_collaborators pc
+            WHERE pc.project_id = $1
+        `, [projectId]);
+        recipientEmails = collaborators.rows.map(r => r.email_address);
+    } else if (recipients === 'all_admins') {
+        // All company admins
+        const admins = await executeQuery(`
+            SELECT ue."Email_Address" as email_address
+            FROM "UserEntitlements" ue
+            WHERE ue."Company_ID" = $1 AND ue."Admin" = true
+        `, [userRole.Company_ID]);
+        recipientEmails = admins.rows.map(r => r.email_address);
+    } else if (recipients === 'all_managers') {
+        // All company managers
+        const managers = await executeQuery(`
+            SELECT ue."Email_Address" as email_address
+            FROM "UserEntitlements" ue
+            WHERE ue."Company_ID" = $1 AND (ue."Manager" = true OR ue."Admin" = true)
+        `, [userRole.Company_ID]);
+        recipientEmails = managers.rows.map(r => r.email_address);
+    } else {
+        return createErrorResponse(400, 'Invalid recipients format');
+    }
+
+    if (recipientEmails.length === 0) {
+        return createSuccessResponse({
+            sent: 0,
+            skipped: 0,
+            failed: 0,
+            message: 'No recipients found'
+        }, 'No notifications sent');
+    }
+
+    // Get preferences for all recipients
+    const prefsQuery = await executeQuery(`
+        SELECT email_address, rapport.get_notification_preferences(email_address) as preferences
+        FROM "Users"
+        WHERE "Email_Address" = ANY($1)
+    `, [recipientEmails]);
+
+    const prefsMap = new Map(prefsQuery.rows.map(r => [r.email_address, r.preferences]));
+
+    // Build recipient list with preferences
+    const recipientList = recipientEmails.map(recipientEmail => ({
+        email: recipientEmail,
+        preferences: prefsMap.get(recipientEmail) || null,
+        data: data,
+        projectId: projectId
+    }));
+
+    // Send batch notifications
+    const results = await notificationService.sendBatch(recipientList, type);
+
+    // Log notifications
+    for (const recipientEmail of recipientEmails) {
+        const status = results.errors.find(e => e.email === recipientEmail) ? 'failed' : 'sent';
+        const errorMessage = results.errors.find(e => e.email === recipientEmail)?.error || null;
+
+        await executeQuery(`
+            SELECT rapport.log_notification($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+        `, [
+            recipientEmail,
+            type,
+            'email', // Primary channel
+            status,
+            projectId || null,
+            data.referenceType || null,
+            data.referenceId || null,
+            JSON.stringify(data),
+            null, // message_id populated by NotificationService if available
+            errorMessage
+        ]);
+    }
+
+    return createSuccessResponse(
+        {
+            total: results.total,
+            sent: results.sent,
+            skipped: results.skipped,
+            failed: results.failed,
+            errors: results.errors.length > 0 ? results.errors : undefined
+        },
+        'Notifications processed',
+        { Request_ID, Timestamp: new Date().toISOString() }
+    );
+});

package/src/handlers/notifications/updatePreferences.js

@@ -0,0 +1,316 @@
+/**
+ * Update Notification Preferences Handler
+ * Updates user's notification preferences
+ *
+ * PUT /api/notifications/preferences
+ * Auth: Cognito JWT required
+ *
+ * Body:
+ * {
+ *   "email_enabled": true,
+ *   "slack_enabled": true,
+ *   "notification_types": {
+ *     "pattern_promotion": { "email": true, "slack": true },
+ *     "weekly_digest": { "email": true, "slack": false },
+ *     "critical_violation": { "email": true, "slack": true },
+ *     "team_alert": { "email": true, "slack": true },
+ *     "curation_candidate": { "email": true, "slack": true }
+ *   },
+ *   "project_overrides": {
+ *     "prj_xxx": { "email_enabled": false, "notification_types": {...} }
+ *   },
+ *   "digest_frequency": "weekly",
+ *   "digest_day": 1,
+ *   "quiet_hours_enabled": false,
+ *   "quiet_hours_start": "22:00",
+ *   "quiet_hours_end": "08:00",
+ *   "quiet_hours_timezone": "America/New_York",
+ *   "slack_channel": "#my-channel",
+ *   "slack_dm_enabled": true
+ * }
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
+
+exports.handler = wrapHandler(async ({ requestContext, body }) => {
+    const Request_ID = requestContext.requestId;
+    const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+    if (!email) {
+        return createErrorResponse(401, 'Authentication required');
+    }
+
+    // Validate and sanitize input
+    const validatedPrefs = validatePreferences(body);
+    if (validatedPrefs.error) {
+        return createErrorResponse(400, validatedPrefs.error);
+    }
+
+    // Default notification types for new users
+    const defaultNotificationTypes = {
+        pattern_promotion: { email: true, slack: true },
+        weekly_digest: { email: true, slack: false },
+        critical_violation: { email: true, slack: true },
+        team_alert: { email: true, slack: true },
+        curation_candidate: { email: true, slack: true }
+    };
+
+    const {
+        email_enabled = true,
+        slack_enabled = true,
+        notification_types = defaultNotificationTypes,
+        project_overrides = {},
+        digest_frequency = 'weekly',
+        digest_day = 1,
+        quiet_hours_enabled = false,
+        quiet_hours_start,
+        quiet_hours_end,
+        quiet_hours_timezone = 'America/New_York',
+        slack_channel,
+        slack_dm_enabled = true
+    } = validatedPrefs;
+
+    // Upsert preferences
+    const result = await executeQuery(`
+        INSERT INTO rapport.notification_preferences (
+            email_address,
+            email_enabled,
+            slack_enabled,
+            notification_types,
+            project_overrides,
+            digest_frequency,
+            digest_day,
+            quiet_hours_enabled,
+            quiet_hours_start,
+            quiet_hours_end,
+            quiet_hours_timezone,
+            slack_channel,
+            slack_dm_enabled
+        ) VALUES (
+            $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13
+        )
+        ON CONFLICT (email_address) DO UPDATE SET
+            email_enabled = COALESCE($2, rapport.notification_preferences.email_enabled),
+            slack_enabled = COALESCE($3, rapport.notification_preferences.slack_enabled),
+            notification_types = COALESCE($4, rapport.notification_preferences.notification_types),
+            project_overrides = COALESCE($5, rapport.notification_preferences.project_overrides),
+            digest_frequency = COALESCE($6, rapport.notification_preferences.digest_frequency),
+            digest_day = COALESCE($7, rapport.notification_preferences.digest_day),
+            quiet_hours_enabled = COALESCE($8, rapport.notification_preferences.quiet_hours_enabled),
+            quiet_hours_start = $9,
+            quiet_hours_end = $10,
+            quiet_hours_timezone = COALESCE($11, rapport.notification_preferences.quiet_hours_timezone),
+            slack_channel = $12,
+            slack_dm_enabled = COALESCE($13, rapport.notification_preferences.slack_dm_enabled),
+            updated_at = NOW()
+        RETURNING *
+    `, [
+        email,
+        email_enabled,
+        slack_enabled,
+        notification_types ? JSON.stringify(notification_types) : null,
+        project_overrides ? JSON.stringify(project_overrides) : null,
+        digest_frequency,
+        digest_day,
+        quiet_hours_enabled,
+        quiet_hours_start,
+        quiet_hours_end,
+        quiet_hours_timezone,
+        slack_channel,
+        slack_dm_enabled
+    ]);
+
+    // If digest frequency changed, update the digest queue
+    if (digest_frequency) {
+        await updateDigestQueue(email, digest_frequency, digest_day);
+    }
+
+    return createSuccessResponse(
+        {
+            preferences: {
+                email_enabled: result.rows[0].email_enabled,
+                slack_enabled: result.rows[0].slack_enabled,
+                notification_types: result.rows[0].notification_types,
+                project_overrides: result.rows[0].project_overrides,
+                digest_frequency: result.rows[0].digest_frequency,
+                digest_day: result.rows[0].digest_day,
+                quiet_hours_enabled: result.rows[0].quiet_hours_enabled,
+                quiet_hours_start: result.rows[0].quiet_hours_start,
+                quiet_hours_end: result.rows[0].quiet_hours_end,
+                quiet_hours_timezone: result.rows[0].quiet_hours_timezone,
+                slack_channel: result.rows[0].slack_channel,
+                slack_dm_enabled: result.rows[0].slack_dm_enabled
+            },
+            updated_at: result.rows[0].updated_at
+        },
+        'Preferences updated',
+        { Request_ID, Timestamp: new Date().toISOString() }
+    );
+});
+
+/**
+ * Validate and sanitize preferences input
+ */
+function validatePreferences(body) {
+    const result = {};
+
+    // Validate boolean fields
+    if (body.email_enabled !== undefined) {
+        if (typeof body.email_enabled !== 'boolean') {
+            return { error: 'email_enabled must be a boolean' };
+        }
+        result.email_enabled = body.email_enabled;
+    }
+
+    if (body.slack_enabled !== undefined) {
+        if (typeof body.slack_enabled !== 'boolean') {
+            return { error: 'slack_enabled must be a boolean' };
+        }
+        result.slack_enabled = body.slack_enabled;
+    }
+
+    if (body.quiet_hours_enabled !== undefined) {
+        if (typeof body.quiet_hours_enabled !== 'boolean') {
+            return { error: 'quiet_hours_enabled must be a boolean' };
+        }
+        result.quiet_hours_enabled = body.quiet_hours_enabled;
+    }
+
+    if (body.slack_dm_enabled !== undefined) {
+        if (typeof body.slack_dm_enabled !== 'boolean') {
+            return { error: 'slack_dm_enabled must be a boolean' };
+        }
+        result.slack_dm_enabled = body.slack_dm_enabled;
+    }
+
+    // Validate notification_types
+    if (body.notification_types !== undefined) {
+        if (typeof body.notification_types !== 'object') {
+            return { error: 'notification_types must be an object' };
+        }
+
+        const validTypes = ['pattern_promotion', 'weekly_digest', 'critical_violation', 'team_alert', 'curation_candidate'];
+        for (const type of Object.keys(body.notification_types)) {
+            if (!validTypes.includes(type)) {
+                return { error: `Invalid notification type: ${type}` };
+            }
+            const typePrefs = body.notification_types[type];
+            if (typeof typePrefs !== 'object') {
+                return { error: `notification_types.${type} must be an object` };
+            }
+            if (typePrefs.email !== undefined && typeof typePrefs.email !== 'boolean') {
+                return { error: `notification_types.${type}.email must be a boolean` };
+            }
+            if (typePrefs.slack !== undefined && typeof typePrefs.slack !== 'boolean') {
+                return { error: `notification_types.${type}.slack must be a boolean` };
+            }
+        }
+        result.notification_types = body.notification_types;
+    }
+
+    // Validate project_overrides
+    if (body.project_overrides !== undefined) {
+        if (typeof body.project_overrides !== 'object') {
+            return { error: 'project_overrides must be an object' };
+        }
+        result.project_overrides = body.project_overrides;
+    }
+
+    // Validate digest_frequency
+    if (body.digest_frequency !== undefined) {
+        const validFrequencies = ['daily', 'weekly', 'monthly', 'never'];
+        if (!validFrequencies.includes(body.digest_frequency)) {
+            return { error: `Invalid digest_frequency. Valid values: ${validFrequencies.join(', ')}` };
+        }
+        result.digest_frequency = body.digest_frequency;
+    }
+
+    // Validate digest_day
+    if (body.digest_day !== undefined) {
+        if (typeof body.digest_day !== 'number' || body.digest_day < 0 || body.digest_day > 31) {
+            return { error: 'digest_day must be a number between 0 and 31' };
+        }
+        result.digest_day = body.digest_day;
+    }
+
+    // Validate quiet hours
+    if (body.quiet_hours_start !== undefined) {
+        if (!/^\d{2}:\d{2}$/.test(body.quiet_hours_start)) {
+            return { error: 'quiet_hours_start must be in HH:MM format' };
+        }
+        result.quiet_hours_start = body.quiet_hours_start;
+    }
+
+    if (body.quiet_hours_end !== undefined) {
+        if (!/^\d{2}:\d{2}$/.test(body.quiet_hours_end)) {
+            return { error: 'quiet_hours_end must be in HH:MM format' };
+        }
+        result.quiet_hours_end = body.quiet_hours_end;
+    }
+
+    if (body.quiet_hours_timezone !== undefined) {
+        result.quiet_hours_timezone = body.quiet_hours_timezone;
+    }
+
+    // Validate slack_channel
+    if (body.slack_channel !== undefined) {
+        if (body.slack_channel !== null && typeof body.slack_channel !== 'string') {
+            return { error: 'slack_channel must be a string or null' };
+        }
+        result.slack_channel = body.slack_channel;
+    }
+
+    return result;
+}
+
+/**
+ * Update digest queue when frequency changes
+ */
+async function updateDigestQueue(email, frequency, digestDay) {
+    // Remove existing pending digests
+    await executeQuery(`
+        DELETE FROM rapport.digest_queue
+        WHERE email_address = $1 AND status = 'pending'
+    `, [email]);
+
+    // If frequency is 'never', don't schedule anything
+    if (frequency === 'never') {
+        return;
+    }
+
+    // Calculate next scheduled time
+    const now = new Date();
+    let scheduledFor;
+
+    switch (frequency) {
+        case 'daily':
+            scheduledFor = new Date(now);
+            scheduledFor.setDate(scheduledFor.getDate() + 1);
+            scheduledFor.setHours(9, 0, 0, 0); // 9 AM next day
+            break;
+
+        case 'weekly':
+            scheduledFor = new Date(now);
+            const daysUntilNextDigestDay = (digestDay - now.getDay() + 7) % 7 || 7;
+            scheduledFor.setDate(scheduledFor.getDate() + daysUntilNextDigestDay);
+            scheduledFor.setHours(9, 0, 0, 0); // 9 AM
+            break;
+
+        case 'monthly':
+            scheduledFor = new Date(now);
+            scheduledFor.setMonth(scheduledFor.getMonth() + 1);
+            scheduledFor.setDate(digestDay || 1);
+            scheduledFor.setHours(9, 0, 0, 0); // 9 AM
+            break;
+
+        default:
+            return;
+    }
+
+    // Insert new digest into queue
+    await executeQuery(`
+        INSERT INTO rapport.digest_queue (email_address, digest_type, scheduled_for, status, digest_data)
+        VALUES ($1, $2, $3, 'pending', '{}'::jsonb)
+        ON CONFLICT (email_address, digest_type, scheduled_for) DO NOTHING
+    `, [email, frequency, scheduledFor.toISOString()]);
+}