@alliance-droid/status-feedback-system 0.1.0

package/dist/server/handlers.js

@@ -0,0 +1,251 @@
+/**
+ * Composable API route handlers for SvelteKit
+ *
+ * Usage in consuming app:
+ *   // src/routes/api/status/[...path]/+server.ts
+ *   import { statusServer } from './status';
+ *   const handlers = statusServer.createHandlers();
+ *   export const GET = handlers.GET;
+ *   export const POST = handlers.POST;
+ *   export const PATCH = handlers.PATCH;
+ *   export const DELETE = handlers.DELETE;
+ */
+import { validateApiKey } from './projects.js';
+import { createSystem, getSystemsByProject, getSystemById, updateSystem, deleteSystem, updateSystemStatus, getStatusHistory } from './systems.js';
+import { createIncident, getIncidentsByProject, getIncidentById, updateIncident, deleteIncident, addIncidentUpdate } from './incidents.js';
+import { submitFeedback, getFeedbackByProject } from './feedback.js';
+function json(data, status = 200) {
+    return new Response(JSON.stringify(data), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+    });
+}
+function error(message, status = 400) {
+    return json({ success: false, error: message }, status);
+}
+/**
+ * Extract API key from request headers or query params
+ */
+function getApiKey(event) {
+    const header = event.request.headers.get('x-api-key');
+    if (header)
+        return header;
+    return event.url.searchParams.get('apiKey');
+}
+/**
+ * Parse the path segments from the catch-all route param
+ */
+function parsePath(params) {
+    const path = params.path || '';
+    return path.split('/').filter(Boolean);
+}
+/**
+ * Create composable route handlers
+ *
+ * Routes:
+ *   GET    /systems              — list systems for project
+ *   GET    /systems/:id          — get system details
+ *   GET    /systems/:id/history  — get status history (90 days)
+ *   GET    /incidents            — list incidents for project
+ *   GET    /incidents/:id        — get incident with updates
+ *   GET    /feedback             — list feedback (admin)
+ *   POST   /feedback             — submit feedback
+ *   PATCH  /systems/:id/status   — update system status (admin)
+ *   PATCH  /feedback/:id/status  — update feedback status (admin)
+ */
+export function createRouteHandlers(pool) {
+    async function authenticateProject(event) {
+        const apiKey = getApiKey(event);
+        if (!apiKey)
+            return null;
+        return validateApiKey(pool, apiKey);
+    }
+    const GET = async (event) => {
+        const project = await authenticateProject(event);
+        if (!project)
+            return error('Invalid or missing API key', 401);
+        const segments = parsePath(event.params);
+        // GET /systems
+        if (segments[0] === 'systems' && segments.length === 1) {
+            const systems = await getSystemsByProject(pool, project.id);
+            return json({ success: true, data: systems });
+        }
+        // GET /systems/:id
+        if (segments[0] === 'systems' && segments.length === 2) {
+            const system = await getSystemById(pool, segments[1]);
+            if (!system || system.projectId !== project.id)
+                return error('System not found', 404);
+            return json({ success: true, data: system });
+        }
+        // GET /systems/:id/history
+        if (segments[0] === 'systems' && segments.length === 3 && segments[2] === 'history') {
+            const days = parseInt(event.url.searchParams.get('days') || '90');
+            const history = await getStatusHistory(pool, segments[1], days);
+            return json({ success: true, data: history });
+        }
+        // GET /incidents
+        if (segments[0] === 'incidents' && segments.length === 1) {
+            const limit = parseInt(event.url.searchParams.get('limit') || '20');
+            const includeResolved = event.url.searchParams.get('includeResolved') !== 'false';
+            const incidents = await getIncidentsByProject(pool, project.id, { limit, includeResolved });
+            return json({ success: true, data: incidents });
+        }
+        // GET /incidents/:id
+        if (segments[0] === 'incidents' && segments.length === 2) {
+            const incident = await getIncidentById(pool, segments[1]);
+            if (!incident || incident.projectId !== project.id)
+                return error('Incident not found', 404);
+            return json({ success: true, data: incident });
+        }
+        // GET /feedback
+        if (segments[0] === 'feedback' && segments.length === 1) {
+            const limit = parseInt(event.url.searchParams.get('limit') || '50');
+            const offset = parseInt(event.url.searchParams.get('offset') || '0');
+            const category = event.url.searchParams.get('category') || undefined;
+            const status = event.url.searchParams.get('status');
+            const result = await getFeedbackByProject(pool, project.id, { limit, offset, category, status });
+            return json({ success: true, data: result });
+        }
+        return error('Not found', 404);
+    };
+    const POST = async (event) => {
+        const project = await authenticateProject(event);
+        if (!project)
+            return error('Invalid or missing API key', 401);
+        const segments = parsePath(event.params);
+        // POST /systems
+        if (segments[0] === 'systems' && segments.length === 1) {
+            const body = await event.request.json();
+            if (!body.name || typeof body.name !== 'string') {
+                return error('System name is required');
+            }
+            const system = await createSystem(pool, project.id, {
+                name: body.name,
+                description: body.description,
+                displayOrder: body.displayOrder,
+            });
+            return json({ success: true, data: system }, 201);
+        }
+        // POST /incidents
+        if (segments[0] === 'incidents' && segments.length === 1) {
+            const body = await event.request.json();
+            if (!body.title || typeof body.title !== 'string') {
+                return error('Incident title is required');
+            }
+            const incident = await createIncident(pool, project.id, {
+                title: body.title,
+                severity: body.severity,
+                affectedSystems: body.affectedSystems,
+                message: body.message,
+            });
+            return json({ success: true, data: incident }, 201);
+        }
+        // POST /incidents/:id/updates
+        if (segments[0] === 'incidents' && segments.length === 3 && segments[2] === 'updates') {
+            const body = await event.request.json();
+            const validStatuses = ['investigating', 'identified', 'monitoring', 'resolved'];
+            if (!body.status || !validStatuses.includes(body.status)) {
+                return error(`Status must be one of: ${validStatuses.join(', ')}`);
+            }
+            if (!body.message || typeof body.message !== 'string') {
+                return error('Message is required');
+            }
+            const incident = await getIncidentById(pool, segments[1], false);
+            if (!incident || incident.projectId !== project.id)
+                return error('Incident not found', 404);
+            const update = await addIncidentUpdate(pool, segments[1], {
+                status: body.status,
+                message: body.message,
+            });
+            return json({ success: true, data: update }, 201);
+        }
+        // POST /feedback
+        if (segments[0] === 'feedback' && segments.length === 1) {
+            const body = await event.request.json();
+            if (!body.message || typeof body.message !== 'string' || body.message.trim().length === 0) {
+                return error('Message is required');
+            }
+            if (body.message.length > 5000) {
+                return error('Message must be under 5000 characters');
+            }
+            if (body.email && typeof body.email === 'string' && body.email.length > 255) {
+                return error('Email must be under 255 characters');
+            }
+            const feedback = await submitFeedback(pool, project.id, {
+                category: body.category,
+                message: body.message.trim(),
+                email: body.email,
+                userAgent: event.request.headers.get('user-agent') || undefined,
+                pageUrl: body.pageUrl,
+                metadata: body.metadata,
+            });
+            return json({ success: true, data: feedback }, 201);
+        }
+        return error('Not found', 404);
+    };
+    const PATCH = async (event) => {
+        const project = await authenticateProject(event);
+        if (!project)
+            return error('Invalid or missing API key', 401);
+        const segments = parsePath(event.params);
+        const body = await event.request.json();
+        // PATCH /systems/:id/status
+        if (segments[0] === 'systems' && segments.length === 3 && segments[2] === 'status') {
+            const validStatuses = ['operational', 'degraded', 'outage', 'maintenance'];
+            if (!body.status || !validStatuses.includes(body.status)) {
+                return error(`Status must be one of: ${validStatuses.join(', ')}`);
+            }
+            const system = await getSystemById(pool, segments[1]);
+            if (!system || system.projectId !== project.id)
+                return error('System not found', 404);
+            const updated = await updateSystemStatus(pool, segments[1], body.status);
+            return json({ success: true, data: updated });
+        }
+        // PATCH /feedback/:id/status
+        if (segments[0] === 'feedback' && segments.length === 3 && segments[2] === 'status') {
+            const validStatuses = ['new', 'reviewed', 'resolved', 'archived'];
+            if (!body.status || !validStatuses.includes(body.status)) {
+                return error(`Status must be one of: ${validStatuses.join(', ')}`);
+            }
+            const { updateFeedbackStatus } = await import('./feedback.js');
+            const updated = await updateFeedbackStatus(pool, segments[1], body.status);
+            if (!updated)
+                return error('Feedback not found', 404);
+            return json({ success: true, data: updated });
+        }
+        return error('Not found', 404);
+    };
+    const DELETE = async (event) => {
+        const project = await authenticateProject(event);
+        if (!project)
+            return error('Invalid or missing API key', 401);
+        const segments = parsePath(event.params);
+        // DELETE /systems/:id
+        if (segments[0] === 'systems' && segments.length === 2) {
+            const system = await getSystemById(pool, segments[1]);
+            if (!system || system.projectId !== project.id)
+                return error('System not found', 404);
+            await deleteSystem(pool, segments[1]);
+            return json({ success: true });
+        }
+        // DELETE /incidents/:id
+        if (segments[0] === 'incidents' && segments.length === 2) {
+            const incident = await getIncidentById(pool, segments[1], false);
+            if (!incident || incident.projectId !== project.id)
+                return error('Incident not found', 404);
+            await deleteIncident(pool, segments[1]);
+            return json({ success: true });
+        }
+        // DELETE /feedback/:id
+        if (segments[0] === 'feedback' && segments.length === 2) {
+            const { getFeedbackById, deleteFeedback } = await import('./feedback.js');
+            const existing = await getFeedbackById(pool, segments[1]);
+            if (!existing || existing.projectId !== project.id)
+                return error('Feedback not found', 404);
+            await deleteFeedback(pool, segments[1]);
+            return json({ success: true });
+        }
+        return error('Not found', 404);
+    };
+    return { GET, POST, PATCH, DELETE };
+}

package/dist/server/incidents.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Incidents CRUD + updates
+ */
+import type { ConnectionPool } from 'mssql';
+import type { Incident, IncidentUpdate, IncidentStatus, IncidentSeverity } from './types.js';
+export declare function createIncident(pool: ConnectionPool, projectId: string, data: {
+    title: string;
+    severity?: IncidentSeverity;
+    affectedSystems?: string[];
+    message?: string;
+}): Promise<Incident>;
+export declare function getIncidentById(pool: ConnectionPool, id: string, includeUpdates?: boolean): Promise<Incident | null>;
+export declare function getIncidentsByProject(pool: ConnectionPool, projectId: string, options?: {
+    limit?: number;
+    includeResolved?: boolean;
+}): Promise<Incident[]>;
+export declare function updateIncident(pool: ConnectionPool, id: string, data: {
+    title?: string;
+    severity?: IncidentSeverity;
+    affectedSystems?: string[];
+}): Promise<Incident | null>;
+export declare function deleteIncident(pool: ConnectionPool, id: string): Promise<boolean>;
+export declare function addIncidentUpdate(pool: ConnectionPool, incidentId: string, data: {
+    status: IncidentStatus;
+    message: string;
+}): Promise<IncidentUpdate>;
+export declare function getIncidentUpdates(pool: ConnectionPool, incidentId: string): Promise<IncidentUpdate[]>;

package/dist/server/incidents.js

@@ -0,0 +1,180 @@
+/**
+ * Incidents CRUD + updates
+ */
+import { nanoid } from 'nanoid';
+// ── CRUD ──
+export async function createIncident(pool, projectId, data) {
+    const id = nanoid(16);
+    const now = Date.now();
+    const severity = data.severity ?? 'minor';
+    await pool
+        .request()
+        .input('id', id)
+        .input('projectId', projectId)
+        .input('title', data.title)
+        .input('severity', severity)
+        .input('affectedSystems', JSON.stringify(data.affectedSystems || []))
+        .input('createdAt', now)
+        .input('updatedAt', now)
+        .query(`
+			INSERT INTO sf_incidents (id, project_id, title, status, severity, affected_systems, created_at, updated_at)
+			VALUES (@id, @projectId, @title, 'investigating', @severity, @affectedSystems, @createdAt, @updatedAt)
+		`);
+    // Create initial update if message provided
+    const updates = [];
+    if (data.message) {
+        const update = await addIncidentUpdate(pool, id, {
+            status: 'investigating',
+            message: data.message,
+        });
+        updates.push(update);
+    }
+    return {
+        id,
+        projectId,
+        title: data.title,
+        status: 'investigating',
+        severity,
+        affectedSystems: data.affectedSystems || [],
+        createdAt: now,
+        updatedAt: now,
+        resolvedAt: null,
+        updates,
+    };
+}
+export async function getIncidentById(pool, id, includeUpdates = true) {
+    const result = await pool
+        .request()
+        .input('id', id)
+        .query('SELECT * FROM sf_incidents WHERE id = @id');
+    if (result.recordset.length === 0)
+        return null;
+    const incident = mapIncidentRow(result.recordset[0]);
+    if (includeUpdates) {
+        incident.updates = await getIncidentUpdates(pool, id);
+    }
+    return incident;
+}
+export async function getIncidentsByProject(pool, projectId, options = {}) {
+    const limit = options.limit ?? 50;
+    const includeResolved = options.includeResolved ?? true;
+    let query = 'SELECT TOP (@limit) * FROM sf_incidents WHERE project_id = @projectId';
+    if (!includeResolved) {
+        query += " AND status != 'resolved'";
+    }
+    query += ' ORDER BY created_at DESC';
+    const result = await pool
+        .request()
+        .input('projectId', projectId)
+        .input('limit', limit)
+        .query(query);
+    const incidents = result.recordset.map(mapIncidentRow);
+    // Load updates for each incident
+    for (const incident of incidents) {
+        incident.updates = await getIncidentUpdates(pool, incident.id);
+    }
+    return incidents;
+}
+export async function updateIncident(pool, id, data) {
+    const existing = await getIncidentById(pool, id, false);
+    if (!existing)
+        return null;
+    const now = Date.now();
+    await pool
+        .request()
+        .input('id', id)
+        .input('title', data.title ?? existing.title)
+        .input('severity', data.severity ?? existing.severity)
+        .input('affectedSystems', JSON.stringify(data.affectedSystems ?? existing.affectedSystems))
+        .input('updatedAt', now)
+        .query(`
+			UPDATE sf_incidents
+			SET title = @title, severity = @severity, affected_systems = @affectedSystems, updated_at = @updatedAt
+			WHERE id = @id
+		`);
+    return {
+        ...existing,
+        title: data.title ?? existing.title,
+        severity: data.severity ?? existing.severity,
+        affectedSystems: data.affectedSystems ?? existing.affectedSystems,
+        updatedAt: now,
+    };
+}
+export async function deleteIncident(pool, id) {
+    await pool.request().input('id', id).query(`
+		DELETE FROM sf_incident_updates WHERE incident_id = @id;
+		DELETE FROM sf_incidents WHERE id = @id;
+	`);
+    return true;
+}
+// ── Incident Updates ──
+export async function addIncidentUpdate(pool, incidentId, data) {
+    const id = nanoid(16);
+    const now = Date.now();
+    await pool
+        .request()
+        .input('id', id)
+        .input('incidentId', incidentId)
+        .input('status', data.status)
+        .input('message', data.message)
+        .input('createdAt', now)
+        .query(`
+			INSERT INTO sf_incident_updates (id, incident_id, status, message, created_at)
+			VALUES (@id, @incidentId, @status, @message, @createdAt)
+		`);
+    // Update incident status + resolved_at
+    const resolvedAt = data.status === 'resolved' ? now : null;
+    await pool
+        .request()
+        .input('incidentId', incidentId)
+        .input('status', data.status)
+        .input('updatedAt', now)
+        .input('resolvedAt', resolvedAt)
+        .query(`
+			UPDATE sf_incidents
+			SET status = @status, updated_at = @updatedAt, resolved_at = COALESCE(@resolvedAt, resolved_at)
+			WHERE id = @incidentId
+		`);
+    return { id, incidentId, status: data.status, message: data.message, createdAt: now };
+}
+export async function getIncidentUpdates(pool, incidentId) {
+    const result = await pool
+        .request()
+        .input('incidentId', incidentId)
+        .query('SELECT * FROM sf_incident_updates WHERE incident_id = @incidentId ORDER BY created_at DESC');
+    return result.recordset.map(mapUpdateRow);
+}
+// ── Helpers ──
+function mapIncidentRow(row) {
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        title: row.title,
+        status: row.status,
+        severity: row.severity,
+        affectedSystems: parseJsonArray(row.affected_systems),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        resolvedAt: row.resolved_at || null,
+    };
+}
+function mapUpdateRow(row) {
+    return {
+        id: row.id,
+        incidentId: row.incident_id,
+        status: row.status,
+        message: row.message,
+        createdAt: row.created_at,
+    };
+}
+function parseJsonArray(value) {
+    if (!value)
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/server/index.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Server module for @alliance-droid/status-feedback-system
+ *
+ * Usage:
+ *   import { createStatusServer } from '@alliance-droid/status-feedback-system/server';
+ *
+ *   const server = createStatusServer({
+ *     database: { connectionString: env.MSSQL_CONNECTION_STRING }
+ *   });
+ *   await server.init();
+ */
+import { type RouteHandlers } from './handlers.js';
+import type { StatusServerConfig, Project, System, SystemStatus, Incident, IncidentStatus, IncidentSeverity, IncidentUpdate, Feedback, FeedbackStatus, StatusHistoryEntry } from './types.js';
+export interface StatusServer {
+    /** Initialize database connection and run migrations */
+    init(): Promise<void>;
+    /** Close the database connection */
+    close(): Promise<void>;
+    createProject(data: {
+        name: string;
+        description?: string;
+        allowedOrigins?: string[];
+    }): Promise<Project>;
+    getProject(id: string): Promise<Project | null>;
+    getProjectByApiKey(apiKey: string): Promise<Project | null>;
+    listProjects(): Promise<Project[]>;
+    updateProject(id: string, data: {
+        name?: string;
+        description?: string;
+        allowedOrigins?: string[];
+    }): Promise<Project | null>;
+    deleteProject(id: string): Promise<boolean>;
+    regenerateApiKey(id: string): Promise<string | null>;
+    validateApiKey(apiKey: string): Promise<Project | null>;
+    createSystem(projectId: string, data: {
+        name: string;
+        description?: string;
+        displayOrder?: number;
+    }): Promise<System>;
+    getSystem(id: string): Promise<System | null>;
+    getSystems(projectId: string): Promise<System[]>;
+    updateSystem(id: string, data: {
+        name?: string;
+        description?: string;
+        displayOrder?: number;
+    }): Promise<System | null>;
+    deleteSystem(id: string): Promise<boolean>;
+    updateSystemStatus(id: string, status: SystemStatus): Promise<System | null>;
+    getStatusHistory(systemId: string, days?: number): Promise<StatusHistoryEntry[]>;
+    createIncident(projectId: string, data: {
+        title: string;
+        severity?: IncidentSeverity;
+        affectedSystems?: string[];
+        message?: string;
+    }): Promise<Incident>;
+    getIncident(id: string): Promise<Incident | null>;
+    getIncidents(projectId: string, options?: {
+        limit?: number;
+        includeResolved?: boolean;
+    }): Promise<Incident[]>;
+    updateIncident(id: string, data: {
+        title?: string;
+        severity?: IncidentSeverity;
+        affectedSystems?: string[];
+    }): Promise<Incident | null>;
+    deleteIncident(id: string): Promise<boolean>;
+    addIncidentUpdate(incidentId: string, data: {
+        status: IncidentStatus;
+        message: string;
+    }): Promise<IncidentUpdate>;
+    getIncidentUpdates(incidentId: string): Promise<IncidentUpdate[]>;
+    submitFeedback(projectId: string, data: {
+        category?: string;
+        message: string;
+        email?: string;
+        userAgent?: string;
+        pageUrl?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Feedback>;
+    getFeedback(id: string): Promise<Feedback | null>;
+    getFeedbackByProject(projectId: string, options?: {
+        limit?: number;
+        offset?: number;
+        category?: string;
+        status?: FeedbackStatus;
+        sortBy?: 'created_at' | 'status';
+        sortOrder?: 'ASC' | 'DESC';
+    }): Promise<{
+        items: Feedback[];
+        total: number;
+    }>;
+    updateFeedbackStatus(id: string, status: FeedbackStatus): Promise<Feedback | null>;
+    deleteFeedback(id: string): Promise<boolean>;
+    createHandlers(): RouteHandlers;
+}
+/**
+ * Create a status server instance
+ */
+export declare function createStatusServer(config: StatusServerConfig): StatusServer;
+export type { Project, System, Incident, IncidentUpdate, Feedback, StatusHistoryEntry, SystemStatus, IncidentStatus, IncidentSeverity, FeedbackStatus, StatusServerConfig, ApiResponse, } from './types.js';
+export type { RouteHandlers } from './handlers.js';

package/dist/server/index.js

@@ -0,0 +1,71 @@
+/**
+ * Server module for @alliance-droid/status-feedback-system
+ *
+ * Usage:
+ *   import { createStatusServer } from '@alliance-droid/status-feedback-system/server';
+ *
+ *   const server = createStatusServer({
+ *     database: { connectionString: env.MSSQL_CONNECTION_STRING }
+ *   });
+ *   await server.init();
+ */
+import { initDatabase, closeDatabase } from './db.js';
+import { createProject, getProjectById, getProjectByApiKey, listProjects, updateProject, deleteProject, regenerateApiKey, validateApiKey, } from './projects.js';
+import { createSystem, getSystemById, getSystemsByProject, updateSystem, deleteSystem, updateSystemStatus, getStatusHistory, } from './systems.js';
+import { createIncident, getIncidentById, getIncidentsByProject, updateIncident, deleteIncident, addIncidentUpdate, getIncidentUpdates, } from './incidents.js';
+import { submitFeedback, getFeedbackById, getFeedbackByProject, updateFeedbackStatus, deleteFeedback, } from './feedback.js';
+import { createRouteHandlers } from './handlers.js';
+/**
+ * Create a status server instance
+ */
+export function createStatusServer(config) {
+    let pool = null;
+    function getPool() {
+        if (!pool) {
+            throw new Error('StatusServer not initialized. Call init() first.');
+        }
+        return pool;
+    }
+    return {
+        async init() {
+            pool = await initDatabase(config.database.connectionString);
+        },
+        async close() {
+            await closeDatabase();
+            pool = null;
+        },
+        // ── Project Management ──
+        createProject: (data) => createProject(getPool(), data),
+        getProject: (id) => getProjectById(getPool(), id),
+        getProjectByApiKey: (apiKey) => getProjectByApiKey(getPool(), apiKey),
+        listProjects: () => listProjects(getPool()),
+        updateProject: (id, data) => updateProject(getPool(), id, data),
+        deleteProject: (id) => deleteProject(getPool(), id),
+        regenerateApiKey: (id) => regenerateApiKey(getPool(), id),
+        validateApiKey: (apiKey) => validateApiKey(getPool(), apiKey),
+        // ── System Management ──
+        createSystem: (projectId, data) => createSystem(getPool(), projectId, data),
+        getSystem: (id) => getSystemById(getPool(), id),
+        getSystems: (projectId) => getSystemsByProject(getPool(), projectId),
+        updateSystem: (id, data) => updateSystem(getPool(), id, data),
+        deleteSystem: (id) => deleteSystem(getPool(), id),
+        updateSystemStatus: (id, status) => updateSystemStatus(getPool(), id, status),
+        getStatusHistory: (systemId, days) => getStatusHistory(getPool(), systemId, days),
+        // ── Incident Management ──
+        createIncident: (projectId, data) => createIncident(getPool(), projectId, data),
+        getIncident: (id) => getIncidentById(getPool(), id),
+        getIncidents: (projectId, options) => getIncidentsByProject(getPool(), projectId, options),
+        updateIncident: (id, data) => updateIncident(getPool(), id, data),
+        deleteIncident: (id) => deleteIncident(getPool(), id),
+        addIncidentUpdate: (incidentId, data) => addIncidentUpdate(getPool(), incidentId, data),
+        getIncidentUpdates: (incidentId) => getIncidentUpdates(getPool(), incidentId),
+        // ── Feedback Management ──
+        submitFeedback: (projectId, data) => submitFeedback(getPool(), projectId, data),
+        getFeedback: (id) => getFeedbackById(getPool(), id),
+        getFeedbackByProject: (projectId, options) => getFeedbackByProject(getPool(), projectId, options),
+        updateFeedbackStatus: (id, status) => updateFeedbackStatus(getPool(), id, status),
+        deleteFeedback: (id) => deleteFeedback(getPool(), id),
+        // ── Route Handlers ──
+        createHandlers: () => createRouteHandlers(getPool()),
+    };
+}

package/dist/server/projects.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Project CRUD + API key management
+ */
+import type { ConnectionPool } from 'mssql';
+import type { Project } from './types.js';
+/**
+ * Create a new project
+ */
+export declare function createProject(pool: ConnectionPool, data: {
+    name: string;
+    description?: string;
+    allowedOrigins?: string[];
+}): Promise<Project>;
+/**
+ * Get a project by API key
+ */
+export declare function getProjectByApiKey(pool: ConnectionPool, apiKey: string): Promise<Project | null>;
+/**
+ * Get a project by ID
+ */
+export declare function getProjectById(pool: ConnectionPool, id: string): Promise<Project | null>;
+/**
+ * List all projects
+ */
+export declare function listProjects(pool: ConnectionPool): Promise<Project[]>;
+/**
+ * Update a project
+ */
+export declare function updateProject(pool: ConnectionPool, id: string, data: {
+    name?: string;
+    description?: string;
+    allowedOrigins?: string[];
+}): Promise<Project | null>;
+/**
+ * Delete a project and all related data
+ */
+export declare function deleteProject(pool: ConnectionPool, id: string): Promise<boolean>;
+/**
+ * Regenerate a project's API key
+ */
+export declare function regenerateApiKey(pool: ConnectionPool, id: string): Promise<string | null>;
+/**
+ * Validate an API key and return the project
+ */
+export declare function validateApiKey(pool: ConnectionPool, apiKey: string): Promise<Project | null>;