@xcelsior/support-api 0.1.9 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xcelsior/support-api",
-  "version": "0.1.9",
+  "version": "0.1.13",
   "type": "module",
   "files": [
     "packages/**",
@@ -25,11 +25,11 @@
     "typescript": "^5.3.3",
     "@tsconfig/node18": "^18.2.2",
     "@types/node": "^20.11.16",
-    "@xcelsior/lambda-http": "1.0.5",
+    "@xcelsior/aws": "1.0.5",
+    "@xcelsior/support-client": "1.0.6",
     "@xcelsior/email": "1.0.2",
-    "@xcelsior/aws": "1.0.4",
-    "@xcelsior/monitoring": "1.0.4",
-    "@xcelsior/support-client": "1.0.3"
+    "@xcelsior/lambda-http": "1.0.5",
+    "@xcelsior/monitoring": "1.0.4"
   },
   "scripts": {
     "dev": "sst dev --stage dev --mode basic",

package/packages/functions/events/list.ts

@@ -46,3 +46,4 @@ const listTicketEvents = async (event: APIGatewayProxyEventV2) => {
 };
 
 export const handler = middyfy(listTicketEvents, middlewareConfig);
+

package/packages/functions/search/ticketSearch.ts

@@ -11,6 +11,7 @@ export type TicketSearchDocument = {
     categoryId: string | null;
     teamId: string | null;
     assigneeUserId: string | null;
+    assigneeEmail: string | null;
     requesterName: string;
     requesterEmail: string;
     attachments: string[];
@@ -119,6 +120,7 @@ export const mapTicketToDocument = (ticket: any): TicketSearchDocument => ({
     categoryId: ticket.categoryId ?? null,
     teamId: ticket.teamId ?? null,
     assigneeUserId: ticket.assigneeUserId ?? null,
+    assigneeEmail: ticket.assigneeEmail ?? null,
     requesterName: ticket.requesterName ?? '',
     requesterEmail: ticket.requesterEmail ?? '',
     attachments: Array.isArray(ticket.attachments) ? ticket.attachments : [],

package/packages/functions/tickets/list.ts

@@ -5,12 +5,12 @@ import { createResponse, logger, middlewareConfig } from '../config';
 import { ticketListQuerySchema } from '../types';
 import {
     buildTicketFilters,
-    decodeOffsetToken,
-    encodeOffsetToken,
     getTicketIndex,
     type TicketSearchDocument,
 } from '../search/ticketSearch';
 
+const DEFAULT_PAGE_SIZE = 25;
+
 const listTickets = async (event: APIGatewayProxyEventV2) => {
     let query;
     try {
@@ -22,10 +22,18 @@ const listTickets = async (event: APIGatewayProxyEventV2) => {
         throw error;
     }
 
-    const { status, priority, categoryId, assigneeUserId, teamId, search, limit, nextToken } =
-        query;
+    const {
+        status,
+        priority,
+        categoryId,
+        assigneeUserId,
+        teamId,
+        search,
+        page = 1,
+        pageSize = DEFAULT_PAGE_SIZE,
+    } = query;
 
-    const offset = decodeOffsetToken(nextToken);
+    const offset = (page - 1) * pageSize;
     logger.info('List tickets', {
         status,
         priority,
@@ -33,7 +41,8 @@ const listTickets = async (event: APIGatewayProxyEventV2) => {
         assigneeUserId,
         teamId,
         search,
-        limit,
+        page,
+        pageSize,
         offset,
     });
 
@@ -43,20 +52,20 @@ const listTickets = async (event: APIGatewayProxyEventV2) => {
     const searchResult = await index.search<TicketSearchDocument>(search ?? '', {
         filter: filters.length ? filters.join(' AND ') : undefined,
         sort: ['createdAt:desc'],
-        limit,
+        limit: pageSize,
         offset,
     });
 
+    const total = searchResult.estimatedTotalHits ?? 0;
+
     return createResponse({
         items: (searchResult.hits ?? []).map((hit: TicketSearchDocument) => ({
             ...hit,
             attachments: hit.attachments ?? [],
         })),
-        nextToken:
-            typeof searchResult.estimatedTotalHits === 'number' &&
-            offset + (searchResult.hits?.length ?? 0) < searchResult.estimatedTotalHits
-                ? encodeOffsetToken(offset + (searchResult.hits?.length ?? 0))
-                : undefined,
+        page,
+        pageSize,
+        total,
     });
 };
 

package/packages/functions/tickets/update.ts

@@ -18,297 +18,269 @@ import { SqsService } from '@xcelsior/aws/src/sqs';
 import { randomUUID } from 'node:crypto';
 
 type SlaConfig = { low?: number; medium?: number; high?: number; critical?: number };
-const defaultSla: Required<SlaConfig> = { low: 7, medium: 5, high: 3, critical: 1 };
+type TicketUpdatePayload = z.infer<typeof ticketUpdateSchema>;
 
-const computeReminderAt = (priority?: string, sla?: SlaConfig) => {
+const DEFAULT_SLA: Required<SlaConfig> = { low: 7, medium: 5, high: 3, critical: 1 };
+
+// Reserved words in DynamoDB that need expression attribute names
+const RESERVED_WORDS = new Set(['status', 'subject']);
+
+interface UpdateExpressionBuilder {
+    setExpressions: string[];
+    removeExpressions: string[];
+    values: Record<string, any>;
+    names: Record<string, string>;
+}
+
+interface ChangeTracker {
+    changes: Record<string, { oldValue: any; newValue: any }>;
+}
+
+/**
+ * Compute the reminder date based on priority and SLA configuration
+ */
+const computeReminderAt = (priority?: string | null, sla?: SlaConfig): string | undefined => {
     if (!priority) return undefined;
-    const days = (sla?.[priority as keyof SlaConfig] ??
-        defaultSla[priority as keyof typeof defaultSla]) as number | undefined;
+    const days =
+        sla?.[priority as keyof SlaConfig] ?? DEFAULT_SLA[priority as keyof typeof DEFAULT_SLA];
     if (!days) return undefined;
     const date = new Date();
     date.setDate(date.getDate() + days);
     return date.toISOString();
 };
 
-const updateTicket = async (event: APIGatewayProxyEventV2) => {
-    const id = event.pathParameters?.id;
-    if (!id) {
-        throw new ValidationError('Ticket id is required', []);
-    }
+/**
+ * Add a field to the update expression and track changes
+ */
+const addFieldUpdate = (
+    field: string,
+    newValue: any,
+    oldValue: any,
+    builder: UpdateExpressionBuilder,
+    tracker: ChangeTracker,
+    options: { nullableOldValue?: boolean; arrayDefault?: boolean } = {}
+) => {
+    const isReserved = RESERVED_WORDS.has(field);
+    const attrName = isReserved ? `#${field}` : field;
+    const attrValue = `:${field}`;
+
+    builder.setExpressions.push(`${attrName} = ${attrValue}`);
+    builder.values[attrValue] = newValue;
+
+    if (isReserved) {
+        builder.names[attrName] = field;
+    }
+
+    // Track the change
+    const normalizedOldValue = options.arrayDefault
+        ? (oldValue ?? [])
+        : options.nullableOldValue
+          ? (oldValue ?? null)
+          : oldValue;
+
+    tracker.changes[field] = {
+        oldValue: normalizedOldValue,
+        newValue,
+    };
+};
 
-    let payload;
+/**
+ * Validate the request payload
+ */
+const parsePayload = (body: unknown): TicketUpdatePayload => {
     try {
-        payload = ticketUpdateSchema.parse(event.body);
+        return ticketUpdateSchema.parse(body);
     } catch (error) {
         if (error instanceof z.ZodError) {
             throw new ValidationError('Invalid ticket update payload', error.errors);
         }
         throw error;
     }
+};
 
-    const existing = await DynamoDBService.getItem<any>(
-        {
-            tableName: TICKETS_TABLE,
-            key: id,
-        },
+/**
+ * Validate that the category exists and is active
+ */
+const validateCategory = async (categoryId: string): Promise<void> => {
+    const category = await DynamoDBService.getItem<any>(
+        { tableName: CATEGORIES_TABLE, key: categoryId },
         logger
     );
-
-    if (!existing) {
-        throw new NotFoundError('Ticket not found');
-    }
-
-    if (payload.categoryId) {
-        const category = await DynamoDBService.getItem<any>(
-            {
-                tableName: CATEGORIES_TABLE,
-                key: payload.categoryId,
-            },
-            logger
-        );
-
-        if (!category || category.archivedAt) {
-            throw new NotFoundError('Category not found');
-        }
+    if (!category || category.archivedAt) {
+        throw new NotFoundError('Category not found');
     }
+};
 
-    const teamId = payload.teamId ?? existing.teamId;
-    if (!teamId) {
-        throw new ValidationError('Team is required', []);
-    }
+/**
+ * Get team and validate it exists, returns team members
+ */
+const getTeamMembers = async (teamId: string): Promise<string[]> => {
     const team = await DynamoDBService.getItem<any>(
-        {
-            tableName: TEAMS_TABLE,
-            key: teamId,
-        },
+        { tableName: TEAMS_TABLE, key: teamId },
         logger
     );
     if (!team) {
         throw new NotFoundError('Team not found');
     }
-    const members: string[] = Array.isArray(team.members) ? team.members : [];
-    const assigneeToCheck =
-        payload.assigneeUserId !== undefined ? payload.assigneeUserId : existing.assigneeUserId;
-    if (assigneeToCheck && !members.includes(assigneeToCheck)) {
+    return Array.isArray(team.members) ? team.members : [];
+};
+
+/**
+ * Validate that the assignee belongs to the team
+ */
+const validateAssignee = (
+    assigneeUserId: string | null | undefined,
+    teamMembers: string[]
+): void => {
+    if (assigneeUserId && !teamMembers.includes(assigneeUserId)) {
         throw new ValidationError('Assignee must belong to the team', []);
     }
+};
 
+/**
+ * Get support configuration (SLA settings)
+ */
+const getSupportConfig = async (): Promise<{ sla: SlaConfig }> => {
     const config = await DynamoDBService.getItem<{
         id: string;
         notification?: { emailOnAssignment?: boolean };
         sla?: SlaConfig;
-    }>(
-        {
-            tableName: SUPPORT_CONFIG_TABLE,
-            key: 'support-config',
-        },
-        logger
-    );
-    const sla: SlaConfig = config?.sla ?? defaultSla;
-
-    const updates: string[] = [];
-    const values: Record<string, any> = {};
-    const names: Record<string, string> = {};
-
-    if (payload.priority !== undefined) {
-        updates.push('priority = :priority');
-        values[':priority'] = payload.priority ?? null;
-    }
-
-    if (payload.assigneeUserId !== undefined) {
-        updates.push('assigneeUserId = :assigneeUserId');
-        values[':assigneeUserId'] = payload.assigneeUserId ?? null;
-    }
-
-    if (payload.assigneeEmail !== undefined) {
-        updates.push('assigneeEmail = :assigneeEmail');
-        values[':assigneeEmail'] = payload.assigneeEmail ?? null;
-    }
-
-    if (payload.status) {
-        updates.push('#status = :status');
-        values[':status'] = payload.status;
-        names['#status'] = 'status';
-    }
-
-    if (payload.categoryId) {
-        updates.push('categoryId = :categoryId');
-        values[':categoryId'] = payload.categoryId;
-    }
-
-    if (payload.teamId) {
-        updates.push('teamId = :teamId');
-        values[':teamId'] = payload.teamId;
-    }
-
-    if (payload.subject) {
-        updates.push('#subject = :subject');
-        values[':subject'] = payload.subject;
-        names['#subject'] = 'subject';
-    }
-
-    if (payload.description !== undefined) {
-        updates.push('description = :description');
-        values[':description'] = payload.description ?? null;
-    }
-
-    if (payload.attachments !== undefined) {
-        updates.push('attachments = :attachments');
-        values[':attachments'] = payload.attachments;
-    }
+    }>({ tableName: SUPPORT_CONFIG_TABLE, key: 'support-config' }, logger);
+    return { sla: config?.sla ?? DEFAULT_SLA };
+};
 
-    if (payload.requesterName) {
-        updates.push('requesterName = :requesterName');
-        values[':requesterName'] = payload.requesterName;
+/**
+ * Build the DynamoDB update expression from payload
+ */
+const buildUpdateExpression = (
+    payload: TicketUpdatePayload,
+    existing: any,
+    sla: SlaConfig,
+    shouldClearAssignee: boolean
+): { builder: UpdateExpressionBuilder; tracker: ChangeTracker } => {
+    const builder: UpdateExpressionBuilder = {
+        setExpressions: [],
+        removeExpressions: [],
+        values: {},
+        names: {},
+    };
+    const tracker: ChangeTracker = { changes: {} };
+
+    // Define field mappings: [payloadKey, options]
+    const fieldMappings: Array<{
+        key: keyof TicketUpdatePayload;
+        options?: { nullableOldValue?: boolean; arrayDefault?: boolean };
+    }> = [
+        { key: 'priority', options: { nullableOldValue: true } },
+        { key: 'assigneeUserId', options: { nullableOldValue: true } },
+        { key: 'assigneeEmail', options: { nullableOldValue: true } },
+        { key: 'status' },
+        { key: 'categoryId' },
+        { key: 'teamId' },
+        { key: 'subject' },
+        { key: 'description', options: { nullableOldValue: true } },
+        { key: 'attachments', options: { arrayDefault: true } },
+        { key: 'requesterName' },
+        { key: 'requesterEmail' },
+    ];
+
+    // Process each field from payload
+    for (const { key, options } of fieldMappings) {
+        if (payload[key] !== undefined) {
+            const newValue = payload[key] ?? null;
+            addFieldUpdate(key, newValue, existing[key], builder, tracker, options);
+        }
     }
 
-    if (payload.requesterEmail) {
-        updates.push('requesterEmail = :requesterEmail');
-        values[':requesterEmail'] = payload.requesterEmail;
+    // Handle assignee clearing when team changes and assignee is not in new team
+    if (shouldClearAssignee && payload.assigneeUserId === undefined) {
+        addFieldUpdate('assigneeUserId', null, existing.assigneeUserId, builder, tracker, {
+            nullableOldValue: true,
+        });
+        addFieldUpdate('assigneeEmail', null, existing.assigneeEmail, builder, tracker, {
+            nullableOldValue: true,
+        });
     }
 
+    // Handle reminder based on status and priority
     const shouldClearReminder = payload.status === 'Resolved' || payload.status === 'Archived';
-    const effectivePriority =
-        payload.priority !== undefined ? payload.priority : (existing.priority ?? undefined);
+    const effectivePriority = payload.priority !== undefined ? payload.priority : existing.priority;
 
-    const reminderAt = shouldClearReminder
-        ? null
-        : computeReminderAt(effectivePriority as string | undefined, sla);
-
-    // Remove reminderAt entirely if it should be cleared (for sparse GSI)
-    const removeExpressions: string[] = [];
     if (shouldClearReminder) {
-        removeExpressions.push('reminderAt');
-    } else if (reminderAt) {
-        updates.push('reminderAt = :reminderAt');
-        values[':reminderAt'] = reminderAt;
+        builder.removeExpressions.push('reminderAt');
+    } else {
+        const reminderAt = computeReminderAt(effectivePriority, sla);
+        if (reminderAt) {
+            builder.setExpressions.push('reminderAt = :reminderAt');
+            builder.values[':reminderAt'] = reminderAt;
+        }
     }
 
-    updates.push('updatedAt = :updatedAt');
-    values[':updatedAt'] = new Date().toISOString();
+    // Always update timestamp
+    builder.setExpressions.push('updatedAt = :updatedAt');
+    builder.values[':updatedAt'] = new Date().toISOString();
+
+    return { builder, tracker };
+};
 
+/**
+ * Execute the DynamoDB update
+ */
+const executeUpdate = async (id: string, builder: UpdateExpressionBuilder): Promise<any> => {
     const expressionParts: string[] = [];
-    if (updates.length > 0) {
-        expressionParts.push(`SET ${updates.join(', ')}`);
+
+    if (builder.setExpressions.length > 0) {
+        expressionParts.push(`SET ${builder.setExpressions.join(', ')}`);
     }
-    if (removeExpressions.length > 0) {
-        expressionParts.push(`REMOVE ${removeExpressions.join(', ')}`);
+    if (builder.removeExpressions.length > 0) {
+        expressionParts.push(`REMOVE ${builder.removeExpressions.join(', ')}`);
     }
 
-    const updated = await DynamoDBService.updateItem(
+    return DynamoDBService.updateItem(
         {
             tableName: TICKETS_TABLE,
             key: { id },
             updateExpression: expressionParts.join(' '),
-            expressionAttributeValues: Object.keys(values).length ? values : undefined,
-            expressionAttributeNames: Object.keys(names).length ? names : undefined,
+            expressionAttributeValues: Object.keys(builder.values).length
+                ? builder.values
+                : undefined,
+            expressionAttributeNames: Object.keys(builder.names).length ? builder.names : undefined,
         },
         logger
     );
+};
 
-    // Track the changes with old and new values
-    const changes: Record<string, { oldValue: any; newValue: any }> = {};
-
-    if (payload.priority !== undefined) {
-        changes.priority = {
-            oldValue: existing.priority ?? null,
-            newValue: payload.priority ?? null,
-        };
-    }
-
-    if (payload.assigneeUserId !== undefined) {
-        changes.assigneeUserId = {
-            oldValue: existing.assigneeUserId ?? null,
-            newValue: payload.assigneeUserId ?? null,
-        };
-    }
-
-    if (payload.assigneeEmail !== undefined) {
-        changes.assigneeEmail = {
-            oldValue: existing.assigneeEmail ?? null,
-            newValue: payload.assigneeEmail ?? null,
-        };
-    }
-
-    if (payload.status) {
-        changes.status = {
-            oldValue: existing.status,
-            newValue: payload.status,
-        };
-    }
-
-    if (payload.categoryId) {
-        changes.categoryId = {
-            oldValue: existing.categoryId,
-            newValue: payload.categoryId,
-        };
-    }
-
-    if (payload.teamId) {
-        changes.teamId = {
-            oldValue: existing.teamId,
-            newValue: payload.teamId,
-        };
-    }
-
-    if (payload.subject) {
-        changes.subject = {
-            oldValue: existing.subject,
-            newValue: payload.subject,
-        };
-    }
-
-    if (payload.description !== undefined) {
-        changes.description = {
-            oldValue: existing.description ?? null,
-            newValue: payload.description ?? null,
-        };
-    }
-
-    if (payload.attachments !== undefined) {
-        changes.attachments = {
-            oldValue: existing.attachments ?? [],
-            newValue: payload.attachments,
-        };
-    }
-
-    if (payload.requesterName) {
-        changes.requesterName = {
-            oldValue: existing.requesterName,
-            newValue: payload.requesterName,
-        };
-    }
-
-    if (payload.requesterEmail) {
-        changes.requesterEmail = {
-            oldValue: existing.requesterEmail,
-            newValue: payload.requesterEmail,
-        };
-    }
-
+/**
+ * Record the ticket update event for audit trail
+ */
+const recordUpdateEvent = async (
+    ticketId: string,
+    changes: Record<string, { oldValue: any; newValue: any }>
+): Promise<void> => {
     await DynamoDBService.putItem(
         {
             tableName: TICKET_EVENTS_TABLE,
             item: {
                 id: randomUUID(),
-                ticketId: id,
+                ticketId,
                 type: 'updated',
-                payload: {
-                    changes,
-                    userId: event.requestContext?.authorizer?.jwt?.claims?.sub,
-                },
+                payload: { changes },
                 createdAt: new Date().toISOString(),
             },
         },
         logger
     );
+};
 
-    const safeUpdated = (updated as any) ?? {
-        id,
-        attachments: [],
-    };
-
-    // Queue assignment notification email if assignee changed and has email (processed async)
+/**
+ * Send assignment notification if assignee changed
+ */
+const sendAssignmentNotification = async (
+    ticketId: string,
+    payload: TicketUpdatePayload,
+    existing: any,
+    updated: any
+): Promise<void> => {
     const newAssigneeEmail = payload.assigneeEmail ?? existing.assigneeEmail;
     const assigneeChanged =
         payload.assigneeUserId !== undefined &&
@@ -320,16 +292,75 @@ const updateTicket = async (event: APIGatewayProxyEventV2) => {
             url: REMINDER_QUEUE,
             messages: {
                 type: 'assignment',
-                ticketId: id,
+                ticketId,
                 assigneeEmail: newAssigneeEmail,
-                ticketNumber: safeUpdated.ticketNumber ?? existing.ticketNumber,
-                subject: safeUpdated.subject ?? existing.subject,
-                priority: safeUpdated.priority ?? existing.priority,
-                requesterName: safeUpdated.requesterName ?? existing.requesterName,
-                requesterEmail: safeUpdated.requesterEmail ?? existing.requesterEmail,
+                ticketNumber: updated.ticketNumber ?? existing.ticketNumber,
+                subject: updated.subject ?? existing.subject,
+                priority: updated.priority ?? existing.priority,
+                requesterName: updated.requesterName ?? existing.requesterName,
+                requesterEmail: updated.requesterEmail ?? existing.requesterEmail,
             },
         });
     }
+};
+
+/**
+ * Main handler for updating a ticket
+ */
+const updateTicket = async (event: APIGatewayProxyEventV2) => {
+    const id = event.pathParameters?.id;
+    if (!id) {
+        throw new ValidationError('Ticket id is required', []);
+    }
+
+    const payload = parsePayload(event.body);
+
+    // Fetch existing ticket
+    const existing = await DynamoDBService.getItem<any>(
+        { tableName: TICKETS_TABLE, key: id },
+        logger
+    );
+    if (!existing) {
+        throw new NotFoundError('Ticket not found');
+    }
+
+    // Validate category if being updated
+    if (payload.categoryId) {
+        await validateCategory(payload.categoryId);
+    }
+
+    // Validate team and get members
+    const teamId = payload.teamId ?? existing.teamId;
+    if (!teamId) {
+        throw new ValidationError('Team is required', []);
+    }
+    const teamMembers = await getTeamMembers(teamId);
+
+    // Determine if we need to clear the assignee (team changed and current assignee not in new team)
+    const teamChanged = payload.teamId && payload.teamId !== existing.teamId;
+    const currentAssignee =
+        payload.assigneeUserId !== undefined ? payload.assigneeUserId : existing.assigneeUserId;
+    const shouldClearAssignee =
+        teamChanged && currentAssignee && !teamMembers.includes(currentAssignee);
+
+    // Validate assignee (only if not being auto-cleared)
+    const effectiveAssignee = shouldClearAssignee ? null : currentAssignee;
+    validateAssignee(effectiveAssignee, teamMembers);
+
+    // Get SLA configuration
+    const { sla } = await getSupportConfig();
+
+    // Build and execute update
+    const { builder, tracker } = buildUpdateExpression(payload, existing, sla, shouldClearAssignee);
+    const updated = await executeUpdate(id, builder);
+
+    // Record update event
+    await recordUpdateEvent(id, tracker.changes);
+
+    const safeUpdated = (updated as any) ?? { id, attachments: [] };
+
+    // Send assignment notification if needed
+    await sendAssignmentNotification(id, payload, existing, safeUpdated);
 
     return createResponse({
         ...safeUpdated,

package/stacks/SupportStack.ts

@@ -171,16 +171,15 @@ export function SupportStack({ stack }: StackContext) {
         },
     });
 
-
-  const binds = [
-    supportConfigTable,
-    categoriesTable,
-    teamsTable,
-    ticketsTable,
-    ticketEventsTable,
-    attachmentsBucket,
-    reminderQueue,
-  ];
+    const binds = [
+        supportConfigTable,
+        categoriesTable,
+        teamsTable,
+        ticketsTable,
+        ticketEventsTable,
+        attachmentsBucket,
+        reminderQueue,
+    ];
 
     const notificationWorker = new Function(stack, 'support-notification-worker', {
         handler: 'packages/functions/workers/notificationWorker.handler',