@alliance-droid/status-feedback-system 0.1.0 → 0.2.0

package/dist/api.d.ts

@@ -0,0 +1,94 @@
+/**
+ * API client for communicating with the status-feedback-admin backend.
+ *
+ * Usage:
+ *   import { createStatusClient } from '@alliance-droid/status-feedback-system';
+ *
+ *   const client = createStatusClient({
+ *     apiUrl: 'https://status-admin.yourcompany.com',
+ *     apiKey: 'sf_abc123...',
+ *   });
+ *
+ *   const { systems, incidents } = await client.getStatus();
+ */
+import type { System, Incident, StatusHistoryEntry, Feedback, FeedbackResponse } from './types.js';
+export interface StatusClientConfig {
+    /** Base URL of the status-feedback-admin app */
+    apiUrl: string;
+    /** API key for the project (sf_ prefixed) */
+    apiKey: string;
+    /** Optional custom fetch function (for SSR) */
+    fetch?: typeof globalThis.fetch;
+}
+export interface StatusData {
+    systems: System[];
+    overallStatus: string;
+}
+export interface IncidentData {
+    incidents: Incident[];
+}
+export interface UptimeData {
+    history: Record<string, StatusHistoryEntry[]>;
+}
+export interface BoardCategory {
+    name: string;
+    count: number;
+}
+export interface BoardItem {
+    id: string;
+    title: string | null;
+    category: string | null;
+    message: string;
+    status: string;
+    votes: number;
+    adminResponse: string | null;
+    responseCount: number;
+    createdAt: number;
+}
+export interface BoardData {
+    items: BoardItem[];
+    total: number;
+    categories: BoardCategory[];
+}
+export interface StatusClient {
+    /** Get current system statuses */
+    getStatus(): Promise<StatusData>;
+    /** Get incidents (active + recent resolved) */
+    getIncidents(options?: {
+        limit?: number;
+        includeResolved?: boolean;
+    }): Promise<IncidentData>;
+    /** Get uptime history for all systems (90 days) */
+    getUptime(options?: {
+        days?: number;
+    }): Promise<UptimeData>;
+    /** Submit user feedback */
+    submitFeedback(data: {
+        message: string;
+        title?: string;
+        category?: string;
+        email?: string;
+        pageUrl?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Feedback>;
+    /** Get public feedback board */
+    getBoard(options?: {
+        category?: string;
+        status?: 'open' | 'resolved' | 'all';
+        sort?: 'votes' | 'newest';
+        limit?: number;
+        offset?: number;
+    }): Promise<BoardData>;
+    /** Vote on a feedback item */
+    vote(feedbackId: string, direction?: 'up' | 'down'): Promise<{
+        votes: number;
+    }>;
+    /** Get responses for a feedback item */
+    getResponses(feedbackId: string): Promise<{
+        responses: FeedbackResponse[];
+    }>;
+}
+/**
+ * Create a status API client instance
+ */
+export declare function createStatusClient(config: StatusClientConfig): StatusClient;

package/dist/api.js

@@ -0,0 +1,100 @@
+/**
+ * API client for communicating with the status-feedback-admin backend.
+ *
+ * Usage:
+ *   import { createStatusClient } from '@alliance-droid/status-feedback-system';
+ *
+ *   const client = createStatusClient({
+ *     apiUrl: 'https://status-admin.yourcompany.com',
+ *     apiKey: 'sf_abc123...',
+ *   });
+ *
+ *   const { systems, incidents } = await client.getStatus();
+ */
+/**
+ * Create a status API client instance
+ */
+export function createStatusClient(config) {
+    const { apiUrl, apiKey } = config;
+    const fetchFn = config.fetch ?? globalThis.fetch;
+    const baseUrl = apiUrl.replace(/\/$/, '');
+    async function request(path, options) {
+        const url = `${baseUrl}${path}${path.includes('?') ? '&' : '?'}key=${encodeURIComponent(apiKey)}`;
+        const response = await fetchFn(url, {
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options?.headers,
+            },
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            let message = `API error: ${response.status}`;
+            try {
+                const parsed = JSON.parse(body);
+                if (parsed.error)
+                    message = parsed.error;
+            }
+            catch {
+                // ignore parse errors
+            }
+            throw new Error(message);
+        }
+        const json = (await response.json());
+        if (!json.success) {
+            throw new Error(json.error ?? 'Unknown API error');
+        }
+        return json.data;
+    }
+    return {
+        async getStatus() {
+            return request('/api/status');
+        },
+        async getIncidents(options) {
+            const params = new URLSearchParams();
+            if (options?.limit)
+                params.set('limit', String(options.limit));
+            if (options?.includeResolved !== undefined)
+                params.set('includeResolved', String(options.includeResolved));
+            const qs = params.toString();
+            return request(`/api/incidents${qs ? `?${qs}` : ''}`);
+        },
+        async getUptime(options) {
+            const params = new URLSearchParams();
+            if (options?.days)
+                params.set('days', String(options.days));
+            const qs = params.toString();
+            return request(`/api/uptime${qs ? `?${qs}` : ''}`);
+        },
+        async submitFeedback(data) {
+            return request('/api/feedback', {
+                method: 'POST',
+                body: JSON.stringify(data),
+            });
+        },
+        async getBoard(options) {
+            const params = new URLSearchParams();
+            if (options?.category)
+                params.set('category', options.category);
+            if (options?.status)
+                params.set('status', options.status);
+            if (options?.sort)
+                params.set('sort', options.sort);
+            if (options?.limit)
+                params.set('limit', String(options.limit));
+            if (options?.offset)
+                params.set('offset', String(options.offset));
+            const qs = params.toString();
+            return request(`/api/board${qs ? `?${qs}` : ''}`);
+        },
+        async vote(feedbackId, direction = 'up') {
+            return request('/api/board/vote', {
+                method: 'POST',
+                body: JSON.stringify({ feedbackId, direction }),
+            });
+        },
+        async getResponses(feedbackId) {
+            return request(`/api/board/${feedbackId}/responses`);
+        },
+    };
+}