@xcelsior/support-api 0.1.1

package/packages/functions/tickets/statusFacets.ts

@@ -0,0 +1,59 @@
+import { middyfy, ValidationError } from '@xcelsior/lambda-http';
+import type { APIGatewayProxyEventV2 } from 'aws-lambda';
+import { ZodError } from 'zod';
+import { createResponse, logger, middlewareConfig } from '../config';
+import { ticketStatusFacetQuerySchema } from '../types';
+import { buildTicketFilters, getTicketIndex } from '../search/ticketSearch';
+
+const ticketStatusFacets = async (event: APIGatewayProxyEventV2) => {
+    let query;
+    try {
+        query = ticketStatusFacetQuerySchema.parse(event.queryStringParameters || {});
+    } catch (error) {
+        if (error instanceof ZodError) {
+            throw new ValidationError('Invalid query parameters', error.errors);
+        }
+        throw error;
+    }
+
+    const { status, priority, categoryId, assigneeUserId, teamId, search, facets } = query;
+
+    logger.info('Ticket status facet request', {
+        status,
+        priority,
+        categoryId,
+        assigneeUserId,
+        teamId,
+        search,
+        facets,
+    });
+
+    const filters = buildTicketFilters({ status, priority, categoryId, assigneeUserId, teamId });
+    const index = await getTicketIndex();
+
+    // Parse facets parameter - comma-separated list, defaults to ['status']
+    const facetsArray = facets
+        ? facets
+              .split(',')
+              .map((f) => f.trim())
+              .filter(Boolean)
+        : ['status'];
+
+    const result = await index.search(search ?? '', {
+        filter: filters.length ? filters.join(' AND ') : undefined,
+        facets: facetsArray,
+        limit: 0,
+    });
+
+    // Build response with only the requested facets
+    const response: Record<string, Record<string, number>> = {};
+    for (const facet of facetsArray) {
+        if (result.facetDistribution?.[facet]) {
+            response[facet] = result.facetDistribution[facet];
+        }
+    }
+
+    return createResponse(response);
+};
+
+export const handler = middyfy(ticketStatusFacets, middlewareConfig);

package/packages/functions/tickets/update.ts

@@ -0,0 +1,340 @@
+import type { APIGatewayProxyEventV2 } from 'aws-lambda';
+import {
+    CATEGORIES_TABLE,
+    createResponse,
+    logger,
+    middlewareConfig,
+    REMINDER_QUEUE,
+    SUPPORT_CONFIG_TABLE,
+    TEAMS_TABLE,
+    TICKET_EVENTS_TABLE,
+    TICKETS_TABLE,
+} from '../config';
+import { middyfy, NotFoundError, ValidationError } from '@xcelsior/lambda-http';
+import { ticketUpdateSchema } from '../types';
+import { z } from 'zod';
+import { DynamoDBService } from '@xcelsior/aws/src/dynamodb';
+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 };
+
+const computeReminderAt = (priority?: string, sla?: SlaConfig) => {
+    if (!priority) return undefined;
+    const days = (sla?.[priority as keyof SlaConfig] ??
+        defaultSla[priority as keyof typeof defaultSla]) as number | undefined;
+    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', []);
+    }
+
+    let payload;
+    try {
+        payload = ticketUpdateSchema.parse(event.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,
+        },
+        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');
+        }
+    }
+
+    const teamId = payload.teamId ?? existing.teamId;
+    if (!teamId) {
+        throw new ValidationError('Team is required', []);
+    }
+    const team = await DynamoDBService.getItem<any>(
+        {
+            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)) {
+        throw new ValidationError('Assignee must belong to the team', []);
+    }
+
+    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;
+    }
+
+    if (payload.requesterName) {
+        updates.push('requesterName = :requesterName');
+        values[':requesterName'] = payload.requesterName;
+    }
+
+    if (payload.requesterEmail) {
+        updates.push('requesterEmail = :requesterEmail');
+        values[':requesterEmail'] = payload.requesterEmail;
+    }
+
+    const shouldClearReminder = payload.status === 'Resolved' || payload.status === 'Archived';
+    const effectivePriority =
+        payload.priority !== undefined ? payload.priority : (existing.priority ?? undefined);
+
+    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;
+    }
+
+    updates.push('updatedAt = :updatedAt');
+    values[':updatedAt'] = new Date().toISOString();
+
+    const expressionParts: string[] = [];
+    if (updates.length > 0) {
+        expressionParts.push(`SET ${updates.join(', ')}`);
+    }
+    if (removeExpressions.length > 0) {
+        expressionParts.push(`REMOVE ${removeExpressions.join(', ')}`);
+    }
+
+    const updated = await DynamoDBService.updateItem(
+        {
+            tableName: TICKETS_TABLE,
+            key: { id },
+            updateExpression: expressionParts.join(' '),
+            expressionAttributeValues: Object.keys(values).length ? values : undefined,
+            expressionAttributeNames: Object.keys(names).length ? 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,
+        };
+    }
+
+    await DynamoDBService.putItem(
+        {
+            tableName: TICKET_EVENTS_TABLE,
+            item: {
+                id: randomUUID(),
+                ticketId: id,
+                type: 'updated',
+                payload: {
+                    changes,
+                    userId: event.requestContext?.authorizer?.jwt?.claims?.sub,
+                },
+                createdAt: new Date().toISOString(),
+            },
+        },
+        logger
+    );
+
+    const safeUpdated = (updated as any) ?? {
+        id,
+        attachments: [],
+    };
+
+    // Queue assignment notification email if assignee changed and has email (processed async)
+    const newAssigneeEmail = payload.assigneeEmail ?? existing.assigneeEmail;
+    const assigneeChanged =
+        payload.assigneeUserId !== undefined &&
+        payload.assigneeUserId !== existing.assigneeUserId &&
+        payload.assigneeUserId !== null;
+
+    if (assigneeChanged && newAssigneeEmail) {
+        await SqsService.sendMessage({
+            url: REMINDER_QUEUE,
+            messages: {
+                type: 'assignment',
+                ticketId: id,
+                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,
+            },
+        });
+    }
+
+    return createResponse({
+        ...safeUpdated,
+        attachments: safeUpdated.attachments ?? [],
+    });
+};
+
+export const handler = middyfy(updateTicket, middlewareConfig);

package/packages/functions/types.ts

@@ -0,0 +1,15 @@
+export type { SupportApiResponse as ApiResponse } from '@xcelsior/support-client';
+
+export {
+    supportConfigSchema,
+    categoryCreateSchema,
+    categoryUpdateSchema,
+    teamCreateSchema,
+    teamMemberSchema,
+    ticketCreateSchema,
+    ticketUpdateSchema,
+    ticketListQuerySchema,
+    ticketStatusFacetQuerySchema,
+    ticketStatusFacetSchema,
+    attachmentUploadRequestSchema,
+} from '@xcelsior/support-client';

package/packages/functions/workers/reminderSweep.ts

@@ -0,0 +1,11 @@
+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);

package/sst.config.ts

@@ -0,0 +1,15 @@
+import 'dotenv/config';
+import type { SSTConfig } from 'sst';
+import { SupportStack } from './stacks/SupportStack';
+
+export default {
+    config(_input) {
+        return {
+            name: 'support',
+            region: 'ap-southeast-2',
+        };
+    },
+    stacks(app) {
+        app.stack(SupportStack);
+    },
+} satisfies SSTConfig;