proofio-sdk 1.0.0

package/dist/cjs/resources/competitors.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Competitors Resource
+ *
+ * Handles competitor comparison functionality
+ *
+ * Note: Competitor comparison requires authentication and is typically
+ * accessed via the dashboard API. This resource provides a placeholder
+ * structure that matches the SDK API style.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompetitorsResource = void 0;
+class CompetitorsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Compare with a competitor
+     *
+     * Generates an AI-powered comparison between your product and a competitor.
+     *
+     * Note: This endpoint requires dashboard API access (authentication).
+     * The public API doesn't support competitor comparisons directly.
+     * This method is provided for API consistency but may require
+     * additional authentication setup.
+     *
+     * @param competitorId - Competitor ID
+     * @param options - Optional parameters (e.g., force refresh)
+     * @returns Promise with competitor comparison
+     */
+    async compare(competitorId, options) {
+        const queryParams = {};
+        if (options?.force) {
+            queryParams.force = 'true';
+        }
+        // Note: This endpoint typically requires authentication
+        // The public API doesn't expose competitor comparisons
+        // This is a placeholder that matches the expected API structure
+        const response = await this.client.get(`/api/dashboard/competitors/${competitorId}/comparison`, {
+            queryParams,
+        });
+        return response.data;
+    }
+}
+exports.CompetitorsResource = CompetitorsResource;

package/dist/cjs/resources/insights.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Insights Resource
+ *
+ * Handles insights, summaries, and trend analysis
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsightsResource = void 0;
+class InsightsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get insight summary
+     *
+     * Returns aggregated statistics including:
+     * - Total reviews
+     * - Average rating
+     * - Rating distribution
+     * - Sentiment distribution
+     * - Source breakdown
+     * - AI summary (if available for paid plans)
+     *
+     * @returns Promise with insight summary
+     */
+    async summary() {
+        const response = await this.client.get('/api/v1/public/aggregations');
+        return response.data;
+    }
+    /**
+     * Get trend analysis
+     *
+     * Returns detailed trend data including:
+     * - Trend over time (last 30 days)
+     * - Review volume (7, 30, 90 days)
+     * - Top topics
+     * - Key takeaways
+     * - Recent changes
+     *
+     * Note: The public API provides limited trend data. For full trend analysis
+     * including trendOverTime, topTopics, and recentChanges, you need access
+     * to the dashboard API (requires authentication).
+     *
+     * This method returns available data from the public aggregations endpoint
+     * and sets default/empty values for fields not available in the public API.
+     *
+     * @returns Promise with trend data
+     */
+    async trends() {
+        // Get data from public aggregations endpoint
+        const response = await this.client.get('/api/v1/public/aggregations');
+        const data = response.data;
+        // Calculate positive percentage
+        const positivePercentage = data.totalReviews > 0
+            ? (data.sentimentDistribution.positive / data.totalReviews) * 100
+            : 0;
+        // Transform to InsightTrends format
+        // Note: The public API doesn't provide all trend fields,
+        // so we provide what's available and set defaults for missing fields
+        return {
+            totalReviews: data.totalReviews,
+            averageRating: data.averageRating,
+            ratingDistribution: data.ratingDistribution,
+            sentimentDistribution: data.sentimentDistribution,
+            thisWeekCount: 0, // Not available in public API
+            thisWeekChange: 0, // Not available in public API
+            positivePercentage: Math.round(positivePercentage * 10) / 10,
+            reviewVolume: {
+                last7Days: 0, // Not available in public API
+                last30Days: 0, // Not available in public API
+                last90Days: 0, // Not available in public API
+                total: data.totalReviews,
+            },
+            sourceBreakdown: data.sources.reduce((acc, source) => {
+                acc[source.id] = {
+                    count: source.total,
+                    avgRating: source.averageRating,
+                    sentiment: {
+                        positive: 0, // Not available in public API
+                        neutral: 0,
+                        negative: 0,
+                    },
+                };
+                return acc;
+            }, {}),
+            sourcesMap: data.sources.reduce((acc, source) => {
+                acc[source.id] = {
+                    name: source.name || source.type || 'Unknown',
+                    type: source.type || 'UNKNOWN',
+                };
+                return acc;
+            }, {}),
+            trendOverTime: [], // Not available in public API - requires dashboard API
+            topTopics: [], // Not available in public API - requires dashboard API
+            keyTakeaways: [], // Not available in public API - requires dashboard API
+            recentChanges: [], // Not available in public API - requires dashboard API
+            lastSync: null, // Not available in public API
+        };
+    }
+}
+exports.InsightsResource = InsightsResource;

package/dist/cjs/resources/reviews.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Reviews Resource
+ *
+ * Handles all review-related API calls
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReviewsResource = void 0;
+class ReviewsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List reviews
+     *
+     * @param options - Filter and pagination options
+     * @returns Promise with array of reviews
+     */
+    async list(options) {
+        const queryParams = {};
+        if (options?.limit !== undefined) {
+            queryParams.limit = Math.min(options.limit, 100); // Max 100 per API
+        }
+        else {
+            queryParams.limit = 10; // Default
+        }
+        if (options?.offset !== undefined) {
+            queryParams.offset = options.offset;
+        }
+        if (options?.minRating !== undefined) {
+            queryParams.minRating = options.minRating;
+        }
+        if (options?.maxRating !== undefined) {
+            queryParams.maxRating = options.maxRating;
+        }
+        if (options?.sentiment) {
+            queryParams.sentiment = options.sentiment;
+        }
+        if (options?.language) {
+            queryParams.language = options.language;
+        }
+        if (options?.sourceId) {
+            queryParams.sourceId = options.sourceId;
+        }
+        if (options?.since) {
+            queryParams.since = options.since;
+        }
+        const response = await this.client.get('/api/v1/public/reviews', {
+            queryParams,
+        });
+        return response.data;
+    }
+    /**
+     * Get a single review by ID
+     *
+     * Note: The API doesn't have a direct GET /reviews/:id endpoint,
+     * so we fetch the list and filter. This is a convenience method.
+     *
+     * @param id - Review ID
+     * @returns Promise with review or null if not found
+     */
+    async get(id) {
+        // Since there's no direct GET endpoint, we need to fetch and filter
+        // In a real implementation, you might want to cache reviews or use a different approach
+        const reviews = await this.list({ limit: 100 });
+        return reviews.find((review) => review.id === id) || null;
+    }
+}
+exports.ReviewsResource = ReviewsResource;

package/dist/cjs/resources/widget.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Widget Resource
+ *
+ * Handles widget-related API calls
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WidgetResource = void 0;
+class WidgetResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get widget data
+     *
+     * Returns widget statistics and settings including:
+     * - Total reviews
+     * - Average rating
+     * - Number of platforms
+     * - Widget configuration (language, theme, badges, branding)
+     *
+     * @returns Promise with widget data
+     */
+    async get() {
+        const response = await this.client.get('/api/v1/public/widget');
+        return response.data;
+    }
+    /**
+     * Get widget configuration
+     *
+     * Returns only the widget settings/configuration.
+     * This is a convenience method that extracts settings from get().
+     *
+     * @returns Promise with widget settings
+     */
+    async config() {
+        const data = await this.get();
+        return data.settings;
+    }
+    /**
+     * Update widget configuration
+     *
+     * Note: Widget configuration updates typically require dashboard API access.
+     * This method is provided for API consistency but may require
+     * additional authentication setup.
+     *
+     * @param options - Widget configuration options
+     * @returns Promise with updated widget settings
+     */
+    async updateConfig(options) {
+        // Note: This endpoint typically requires authentication
+        // The public API doesn't support widget config updates
+        // This is a placeholder that matches the expected API structure
+        const response = await this.client.post('/api/dashboard/widget-settings', options);
+        return response.data;
+    }
+}
+exports.WidgetResource = WidgetResource;

package/dist/cjs/types/index.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * TypeScript Types für Proofio SDK
+ *
+ * Alle API Response Types basierend auf der tatsächlichen API-Struktur
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils/errors.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Proofio Error Handling
+ *
+ * Normalized error class for all SDK errors
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProofioError = void 0;
+class ProofioError extends Error {
+    constructor(data) {
+        super(data.message);
+        this.name = 'ProofioError';
+        this.status = data.status;
+        this.code = data.code;
+        this.requestId = data.requestId;
+        this.retryAfter = data.retryAfter;
+        this.rateLimitRemaining = data.rateLimitRemaining;
+        this.rateLimitReset = data.rateLimitReset;
+        // Maintains proper stack trace for where our error was thrown (only available on V8/Node.js)
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, ProofioError);
+        }
+    }
+    /**
+     * Check if error is retryable
+     */
+    isRetryable() {
+        return (this.status >= 500 ||
+            this.status === 429 ||
+            this.status === 408 ||
+            this.status === 0 // Network error
+        );
+    }
+    /**
+     * Convert to JSON (sanitized, no sensitive data)
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            status: this.status,
+            code: this.code,
+            requestId: this.requestId,
+            retryAfter: this.retryAfter,
+            rateLimitRemaining: this.rateLimitRemaining,
+            rateLimitReset: this.rateLimitReset,
+        };
+    }
+}
+exports.ProofioError = ProofioError;

package/dist/client/api-client.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Core API Client für Proofio SDK
+ *
+ * Handles:
+ * - API Key Authentication
+ * - Base URL Management
+ * - Request/Response Handling
+ * - Error Normalization
+ * - Rate Limit Handling
+ * - Retry Logic
+ */
+import type { RequestOptions, Response } from '../types';
+export interface ProofioConfig {
+    apiKey: string;
+    baseURL?: string;
+    timeout?: number;
+    maxRetries?: number;
+    retryDelay?: number;
+}
+export declare class ApiClient {
+    private apiKey;
+    private baseURL;
+    private timeout;
+    private maxRetries;
+    private retryDelay;
+    constructor(config: ProofioConfig);
+    /**
+     * Sanitize API key for logging (never log full key)
+     */
+    private sanitizeApiKey;
+    /**
+     * Build headers for requests
+     */
+    private buildHeaders;
+    /**
+     * Build full URL
+     */
+    private buildURL;
+    /**
+     * Handle rate limit errors
+     */
+    private handleRateLimit;
+    /**
+     * Parse error response
+     */
+    private parseErrorResponse;
+    /**
+     * Sleep helper for retries
+     */
+    private sleep;
+    /**
+     * Check if error is retryable
+     */
+    private isRetryableError;
+    /**
+     * Execute request with retry logic
+     */
+    private executeWithRetry;
+    /**
+     * Make GET request
+     */
+    get<T>(path: string, options?: RequestOptions): Promise<Response<T>>;
+    /**
+     * Make POST request
+     */
+    post<T>(path: string, body?: any, options?: RequestOptions): Promise<Response<T>>;
+}
+//# sourceMappingURL=api-client.d.ts.map

package/dist/client/api-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-client.d.ts","sourceRoot":"","sources":["../../src/client/api-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExD,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,UAAU,CAAQ;gBAEd,MAAM,EAAE,aAAa;IAyBjC;;OAEG;IACH,OAAO,CAAC,cAAc;IAOtB;;OAEG;IACH,OAAO,CAAC,YAAY;IAYpB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAchB;;OAEG;YACW,eAAe;IAwB7B;;OAEG;YACW,kBAAkB;IAyBhC;;OAEG;IACH,OAAO,CAAC,KAAK;IAIb;;OAEG;IACH,OAAO,CAAC,gBAAgB;IASxB;;OAEG;YACW,gBAAgB;IAgC9B;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IA6D1E;;OAEG;IACG,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;CA6DxF"}

package/dist/esm/client/api-client.js

@@ -0,0 +1,280 @@
+/**
+ * Core API Client für Proofio SDK
+ *
+ * Handles:
+ * - API Key Authentication
+ * - Base URL Management
+ * - Request/Response Handling
+ * - Error Normalization
+ * - Rate Limit Handling
+ * - Retry Logic
+ */
+import { ProofioError } from '../utils/errors';
+export class ApiClient {
+    constructor(config) {
+        if (!config.apiKey || typeof config.apiKey !== 'string' || config.apiKey.trim().length === 0) {
+            throw new ProofioError({
+                message: 'API key is required',
+                status: 0,
+                code: 'INVALID_API_KEY',
+            });
+        }
+        // Validate API key format (basic validation)
+        if (config.apiKey.length < 10) {
+            throw new ProofioError({
+                message: 'API key format is invalid',
+                status: 0,
+                code: 'INVALID_API_KEY',
+            });
+        }
+        this.apiKey = config.apiKey.trim();
+        this.baseURL = config.baseURL || 'https://proofio.app';
+        this.timeout = config.timeout || 30000; // 30 seconds
+        this.maxRetries = config.maxRetries ?? 3;
+        this.retryDelay = config.retryDelay ?? 1000; // 1 second
+    }
+    /**
+     * Sanitize API key for logging (never log full key)
+     */
+    sanitizeApiKey() {
+        if (this.apiKey.length <= 8) {
+            return '***';
+        }
+        return `${this.apiKey.substring(0, 4)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
+    }
+    /**
+     * Build headers for requests
+     */
+    buildHeaders(customHeaders) {
+        const headers = new Headers({
+            'Content-Type': 'application/json',
+            'x-api-key': this.apiKey,
+            'User-Agent': 'proofio-sdk/1.0.0',
+            ...customHeaders,
+        });
+        // Make headers immutable by creating new Headers object
+        return new Headers(headers);
+    }
+    /**
+     * Build full URL
+     */
+    buildURL(path, queryParams) {
+        const url = new URL(path, this.baseURL);
+        if (queryParams) {
+            Object.entries(queryParams).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.append(key, String(value));
+                }
+            });
+        }
+        return url.toString();
+    }
+    /**
+     * Handle rate limit errors
+     */
+    async handleRateLimit(response) {
+        const retryAfter = response.headers.get('Retry-After');
+        const rateLimitRemaining = response.headers.get('X-RateLimit-Remaining');
+        const rateLimitReset = response.headers.get('X-RateLimit-Reset');
+        const errorData = {
+            message: 'Rate limit exceeded',
+            status: 429,
+            code: 'RATE_LIMIT_EXCEEDED',
+        };
+        if (retryAfter) {
+            errorData.retryAfter = parseInt(retryAfter, 10);
+        }
+        if (rateLimitRemaining !== null) {
+            errorData.rateLimitRemaining = parseInt(rateLimitRemaining, 10);
+        }
+        if (rateLimitReset) {
+            errorData.rateLimitReset = parseInt(rateLimitReset, 10);
+        }
+        throw new ProofioError(errorData);
+    }
+    /**
+     * Parse error response
+     */
+    async parseErrorResponse(response) {
+        let errorData = {
+            message: `API request failed with status ${response.status}`,
+            status: response.status,
+            code: 'API_ERROR',
+        };
+        try {
+            const contentType = response.headers.get('content-type');
+            if (contentType && contentType.includes('application/json')) {
+                const data = await response.json();
+                errorData = {
+                    ...errorData,
+                    message: data.error || data.message || errorData.message,
+                    code: data.code || errorData.code,
+                    requestId: data.requestId,
+                };
+            }
+        }
+        catch {
+            // If JSON parsing fails, use default error
+        }
+        return new ProofioError(errorData);
+    }
+    /**
+     * Sleep helper for retries
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Check if error is retryable
+     */
+    isRetryableError(status, error) {
+        // Retry on network errors, timeouts, and 5xx errors
+        if (!status)
+            return true; // Network error
+        if (status >= 500)
+            return true; // Server errors
+        if (status === 429)
+            return true; // Rate limit (with backoff)
+        if (status === 408)
+            return true; // Request timeout
+        return false;
+    }
+    /**
+     * Execute request with retry logic
+     */
+    async executeWithRetry(requestFn, retryCount = 0) {
+        try {
+            const response = await requestFn();
+            // If rate limited, throw immediately (don't retry immediately)
+            if (response.status === 429) {
+                await this.handleRateLimit(response);
+            }
+            // If error is retryable and we haven't exceeded max retries
+            if (!response.ok && this.isRetryableError(response.status) && retryCount < this.maxRetries) {
+                // Exponential backoff with jitter
+                const delay = this.retryDelay * Math.pow(2, retryCount) + Math.random() * 1000;
+                await this.sleep(delay);
+                return this.executeWithRetry(requestFn, retryCount + 1);
+            }
+            return response;
+        }
+        catch (error) {
+            // Network errors are retryable
+            if (retryCount < this.maxRetries && this.isRetryableError(0, error)) {
+                const delay = this.retryDelay * Math.pow(2, retryCount) + Math.random() * 1000;
+                await this.sleep(delay);
+                return this.executeWithRetry(requestFn, retryCount + 1);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Make GET request
+     */
+    async get(path, options) {
+        const url = this.buildURL(path, options?.queryParams);
+        const headers = this.buildHeaders(options?.headers);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await this.executeWithRetry(async () => {
+                return fetch(url, {
+                    method: 'GET',
+                    headers,
+                    signal: controller.signal,
+                });
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                if (response.status === 429) {
+                    await this.handleRateLimit(response);
+                }
+                throw await this.parseErrorResponse(response);
+            }
+            const data = await response.json();
+            // Convert Headers to plain object
+            const headers = {};
+            response.headers.forEach((value, key) => {
+                headers[key] = value;
+            });
+            return {
+                data,
+                status: response.status,
+                headers,
+            };
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof ProofioError) {
+                throw error;
+            }
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new ProofioError({
+                    message: 'Request timeout',
+                    status: 408,
+                    code: 'TIMEOUT',
+                });
+            }
+            throw new ProofioError({
+                message: error instanceof Error ? error.message : 'Unknown error occurred',
+                status: 0,
+                code: 'NETWORK_ERROR',
+            });
+        }
+    }
+    /**
+     * Make POST request
+     */
+    async post(path, body, options) {
+        const url = this.buildURL(path, options?.queryParams);
+        const headers = this.buildHeaders(options?.headers);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await this.executeWithRetry(async () => {
+                return fetch(url, {
+                    method: 'POST',
+                    headers,
+                    body: body ? JSON.stringify(body) : undefined,
+                    signal: controller.signal,
+                });
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                if (response.status === 429) {
+                    await this.handleRateLimit(response);
+                }
+                throw await this.parseErrorResponse(response);
+            }
+            const data = await response.json();
+            // Convert Headers to plain object
+            const headers = {};
+            response.headers.forEach((value, key) => {
+                headers[key] = value;
+            });
+            return {
+                data,
+                status: response.status,
+                headers,
+            };
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof ProofioError) {
+                throw error;
+            }
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new ProofioError({
+                    message: 'Request timeout',
+                    status: 408,
+                    code: 'TIMEOUT',
+                });
+            }
+            throw new ProofioError({
+                message: error instanceof Error ? error.message : 'Unknown error occurred',
+                status: 0,
+                code: 'NETWORK_ERROR',
+            });
+        }
+    }
+}