@xcelsior/support-api 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xcelsior/support-api",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "files": [
     "packages/**",
@@ -26,10 +26,10 @@
     "@tsconfig/node18": "^18.2.2",
     "@types/node": "^20.11.16",
     "@xcelsior/aws": "1.0.3",
+    "@xcelsior/support-client": "1.0.1",
     "@xcelsior/lambda-http": "1.0.5",
     "@xcelsior/monitoring": "1.0.4",
-    "@xcelsior/email": "1.0.2",
-    "@xcelsior/support-client": "1.0.0"
+    "@xcelsior/email": "1.0.2"
   },
   "scripts": {
     "dev": "sst dev --stage dev --mode basic",

package/packages/functions/workers/notificationWorker.ts

@@ -0,0 +1,243 @@
+import type { SQSEvent } from 'aws-lambda';
+import { DynamoDBService } from '@xcelsior/aws/src/dynamodb';
+import { SqsService } from '@xcelsior/aws/src/sqs';
+import {
+    logger,
+    TICKETS_TABLE,
+    TICKET_EVENTS_TABLE,
+    SUPPORT_CONFIG_TABLE,
+    REMINDER_QUEUE,
+} from '../config';
+import {
+    sendReminderEmail,
+    sendAssignmentEmail,
+    isEmailConfigured,
+} from '../services/emailService';
+import { randomUUID } from 'node:crypto';
+
+interface AssignmentMessage {
+    type: 'assignment';
+    ticketId: string;
+    assigneeEmail: string;
+    ticketNumber: number;
+    subject: string;
+    priority?: string | null;
+    requesterName: string;
+    requesterEmail: string;
+}
+
+interface ReminderMessage {
+    type: 'reminder';
+    ticketId: string;
+}
+
+type NotificationMessage = AssignmentMessage | ReminderMessage;
+
+interface Ticket {
+    id: string;
+    ticketNumber: number;
+    subject: string;
+    status: string;
+    priority?: string | null;
+    assigneeUserId?: string | null;
+    assigneeEmail?: string | null;
+    requesterName: string;
+    requesterEmail: string;
+    reminderAt?: string | null;
+    reminderSentAt?: string | null;
+    createdAt: string;
+}
+
+const processAssignment = async (message: AssignmentMessage): Promise<void> => {
+    // Check if assignment notifications are enabled
+    const config = await DynamoDBService.getItem<{
+        id: string;
+        notification?: { emailOnAssignment?: boolean };
+    }>(
+        {
+            tableName: SUPPORT_CONFIG_TABLE,
+            key: 'support-config',
+        },
+        logger
+    );
+
+    if (config?.notification?.emailOnAssignment === false) {
+        logger.info('Assignment emails disabled in config, skipping', {
+            ticketId: message.ticketId,
+        });
+        return;
+    }
+
+    await sendAssignmentEmail({
+        to: message.assigneeEmail,
+        ticketNumber: message.ticketNumber,
+        ticketId: message.ticketId,
+        subject: message.subject,
+        priority: message.priority,
+        requesterName: message.requesterName,
+        requesterEmail: message.requesterEmail,
+    });
+
+    // Log the assignment notification event
+    await DynamoDBService.putItem(
+        {
+            tableName: TICKET_EVENTS_TABLE,
+            item: {
+                id: randomUUID(),
+                ticketId: message.ticketId,
+                type: 'assignment_email_sent',
+                payload: {
+                    assigneeEmail: message.assigneeEmail,
+                },
+                createdAt: new Date().toISOString(),
+            },
+        },
+        logger
+    );
+
+    logger.info('Assignment notification sent', {
+        ticketId: message.ticketId,
+        assigneeEmail: message.assigneeEmail,
+    });
+};
+
+const processReminder = async (message: ReminderMessage): Promise<void> => {
+    const ticket = await DynamoDBService.getItem<Ticket>(
+        {
+            tableName: TICKETS_TABLE,
+            key: message.ticketId,
+        },
+        logger
+    );
+
+    if (!ticket) {
+        logger.warn('Ticket not found for reminder', { ticketId: message.ticketId });
+        return;
+    }
+
+    // Skip if ticket is already resolved or archived
+    if (['Resolved', 'Archived'].includes(ticket.status)) {
+        logger.info('Ticket already resolved, skipping reminder', {
+            ticketId: ticket.id,
+            status: ticket.status,
+        });
+        return;
+    }
+
+    // Skip if no assignee email
+    if (!ticket.assigneeEmail) {
+        logger.info('No assignee email, skipping reminder', { ticketId: ticket.id });
+        return;
+    }
+
+    // Skip if reminder already sent for this reminderAt
+    if (ticket.reminderSentAt && ticket.reminderAt) {
+        const sentAt = new Date(ticket.reminderSentAt);
+        const reminderAt = new Date(ticket.reminderAt);
+        if (sentAt >= reminderAt) {
+            logger.info('Reminder already sent for this period', {
+                ticketId: ticket.id,
+                reminderSentAt: ticket.reminderSentAt,
+                reminderAt: ticket.reminderAt,
+            });
+            return;
+        }
+    }
+
+    // Check if reminder notifications are enabled
+    const config = await DynamoDBService.getItem<{
+        id: string;
+        notification?: { emailOnReminder?: boolean };
+    }>(
+        {
+            tableName: SUPPORT_CONFIG_TABLE,
+            key: 'support-config',
+        },
+        logger
+    );
+
+    if (config?.notification?.emailOnReminder === false) {
+        logger.info('Reminder emails disabled in config, skipping', { ticketId: ticket.id });
+        return;
+    }
+
+    // Send the reminder email
+    await sendReminderEmail({
+        to: ticket.assigneeEmail,
+        ticketNumber: ticket.ticketNumber,
+        ticketId: ticket.id,
+        subject: ticket.subject,
+        priority: ticket.priority,
+        status: ticket.status,
+        requesterName: ticket.requesterName,
+        requesterEmail: ticket.requesterEmail,
+        reminderAt: ticket.reminderAt!,
+        createdAt: ticket.createdAt,
+    });
+
+    // Update ticket with reminderSentAt
+    const now = new Date().toISOString();
+    await DynamoDBService.updateItem(
+        {
+            tableName: TICKETS_TABLE,
+            key: { id: ticket.id },
+            updateExpression: 'SET reminderSentAt = :reminderSentAt',
+            expressionAttributeValues: {
+                ':reminderSentAt': now,
+            },
+        },
+        logger
+    );
+
+    // Log the reminder event
+    await DynamoDBService.putItem(
+        {
+            tableName: TICKET_EVENTS_TABLE,
+            item: {
+                id: randomUUID(),
+                ticketId: ticket.id,
+                type: 'reminder_sent',
+                payload: {
+                    assigneeEmail: ticket.assigneeEmail,
+                    reminderAt: ticket.reminderAt,
+                },
+                createdAt: now,
+            },
+        },
+        logger
+    );
+
+    logger.info('Reminder processed successfully', {
+        ticketId: ticket.id,
+        ticketNumber: ticket.ticketNumber,
+        assigneeEmail: ticket.assigneeEmail,
+    });
+};
+
+const processMessage = async (message: NotificationMessage): Promise<void> => {
+    switch (message.type) {
+        case 'assignment':
+            await processAssignment(message);
+            break;
+        case 'reminder':
+            await processReminder(message);
+            break;
+        default:
+            logger.warn('Unknown message type', { message });
+    }
+};
+
+export const handler = async (event: SQSEvent) => {
+    if (!isEmailConfigured()) {
+        logger.info('Email not configured, skipping notification processing', {
+            recordCount: event.Records.length,
+        });
+        return;
+    }
+
+    logger.info('Processing notification messages', {
+        recordCount: event.Records.length,
+    });
+
+    await SqsService.handleMessages(event, REMINDER_QUEUE, processMessage);
+};

package/packages/functions/workers/reminderScanner.ts

@@ -0,0 +1,130 @@
+import { DynamoDBService } from '@xcelsior/aws/src/dynamodb';
+import { SqsService } from '@xcelsior/aws/src/sqs';
+import { logger, TICKETS_TABLE, REMINDER_QUEUE, SUPPORT_CONFIG_TABLE } from '../config';
+import { isEmailConfigured } from '../services/emailService';
+
+interface Ticket {
+    id: string;
+    status: string;
+    priority?: string | null;
+    assigneeEmail?: string | null;
+    reminderAt?: string | null;
+    reminderSentAt?: string | null;
+}
+
+interface ReminderMessage {
+    ticketId: string;
+    type: 'reminder';
+}
+
+const PRIORITIES = ['low', 'medium', 'high', 'critical'] as const;
+
+/**
+ * Scans for tickets that need reminders and queues them for processing.
+ * Runs on a schedule (cron) to find overdue tickets.
+ */
+export const handler = async () => {
+    // Check if email is configured - skip if not
+    if (!isEmailConfigured()) {
+        logger.info('Email not configured, skipping reminder scan');
+        return { processed: 0, queued: 0 };
+    }
+
+    // Check if reminder notifications are enabled in config
+    const config = await DynamoDBService.getItem<{
+        id: string;
+        notification?: { emailOnReminder?: boolean };
+    }>(
+        {
+            tableName: SUPPORT_CONFIG_TABLE,
+            key: 'support-config',
+        },
+        logger
+    );
+
+    if (config?.notification?.emailOnReminder === false) {
+        logger.info('Reminder notifications disabled in config');
+        return { processed: 0, queued: 0 };
+    }
+
+    const now = new Date().toISOString();
+    let totalProcessed = 0;
+    const messagesToQueue: ReminderMessage[] = [];
+
+    // Query each priority using the ReminderIndex GSI
+    // The GSI has priority as partition key and reminderAt as sort key
+    for (const priority of PRIORITIES) {
+        try {
+            // Query tickets where reminderAt <= now for this priority
+            const result = await DynamoDBService.queryItems<Ticket>(
+                {
+                    tableName: TICKETS_TABLE,
+                    indexName: 'ReminderIndex',
+                    keyConditionExpression: 'priority = :priority AND reminderAt <= :now',
+                    expressionAttributeValues: {
+                        ':priority': priority,
+                        ':now': now,
+                    },
+                },
+                logger
+            );
+
+            const tickets = result.items ?? [];
+            totalProcessed += tickets.length;
+
+            for (const ticket of tickets) {
+                // Skip if no assignee email
+                if (!ticket.assigneeEmail) {
+                    continue;
+                }
+
+                // Skip if ticket is resolved or archived
+                if (['Resolved', 'Archived'].includes(ticket.status)) {
+                    continue;
+                }
+
+                // Skip if reminder was already sent for this reminderAt
+                if (ticket.reminderSentAt && ticket.reminderAt) {
+                    const sentAt = new Date(ticket.reminderSentAt);
+                    const reminderAt = new Date(ticket.reminderAt);
+                    if (sentAt >= reminderAt) {
+                        continue;
+                    }
+                }
+
+                messagesToQueue.push({
+                    ticketId: ticket.id,
+                    type: 'reminder',
+                });
+            }
+        } catch (error) {
+            logger.error('Failed to scan tickets for priority', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                priority,
+            });
+        }
+    }
+
+    // Send all messages in batches
+    if (messagesToQueue.length > 0) {
+        try {
+            await SqsService.sendMessageBatch({
+                url: REMINDER_QUEUE,
+                messages: messagesToQueue,
+                id: (msg) => `reminder-${msg.ticketId}`,
+            });
+            logger.info('Queued reminder messages', { count: messagesToQueue.length });
+        } catch (error) {
+            logger.error('Failed to queue reminder messages', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    }
+
+    logger.info('Reminder scan complete', {
+        totalProcessed,
+        totalQueued: messagesToQueue.length,
+    });
+
+    return { processed: totalProcessed, queued: messagesToQueue.length };
+};

package/packages/functions/workers/reminderSweep.ts

@@ -1,11 +0,0 @@
-import type { SQSEvent } from 'aws-lambda';
-import { logger, middlewareConfig } from '../config';
-import { middyfy } from '@xcelsior/lambda-http';
-
-const reminderSweep = async (event: SQSEvent) => {
-    logger.info('Reminder sweep - stub', {
-        recordCount: event.Records.length,
-    });
-};
-
-export const handler = middyfy(reminderSweep, middlewareConfig);