proofio-sdk 1.0.0 → 1.1.0

package/dist/cjs/client.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const error_1 = require("./error");
+const DEFAULT_BASE_URL = 'https://api.proofio.app';
+const DEFAULT_TIMEOUT = 30000;
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY = 1000;
+class HttpClient {
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new Error('proofio-sdk: apiKey is required');
+        }
+        this.apiKey = config.apiKey;
+        this.baseURL = (config.baseURL ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+        this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+        this.retryDelay = config.retryDelay ?? DEFAULT_RETRY_DELAY;
+    }
+    async get(path, params) {
+        const url = this.buildURL(path, params);
+        return this.request(url);
+    }
+    buildURL(path, params) {
+        const url = new URL(`${this.baseURL}${path}`);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.set(key, String(value));
+                }
+            }
+        }
+        return url.toString();
+    }
+    async request(url, attempt = 0) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'x-api-key': this.apiKey,
+                    'Content-Type': 'application/json',
+                },
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const body = await response.json().catch(() => ({ error: response.statusText }));
+                const error = new error_1.ProofioError(body.message ?? body.error ?? `HTTP ${response.status}`, response.status, body.error ?? 'unknown_error', response.headers);
+                // Retry on 5xx or 429 (with backoff)
+                if (error.isRetryable() && attempt < this.maxRetries) {
+                    const delay = error.status === 429 && error.retryAfter
+                        ? error.retryAfter * 1000
+                        : this.retryDelay * Math.pow(2, attempt);
+                    await sleep(delay);
+                    return this.request(url, attempt + 1);
+                }
+                throw error;
+            }
+            return (await response.json());
+        }
+        catch (err) {
+            if (err instanceof error_1.ProofioError)
+                throw err;
+            // Network / timeout errors are retryable
+            if (attempt < this.maxRetries) {
+                await sleep(this.retryDelay * Math.pow(2, attempt));
+                return this.request(url, attempt + 1);
+            }
+            if (err instanceof DOMException && err.name === 'AbortError') {
+                throw new error_1.ProofioError(`Request timed out after ${this.timeout}ms`, 0, 'timeout');
+            }
+            throw new error_1.ProofioError(err instanceof Error ? err.message : 'Network error', 0, 'network_error');
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+exports.HttpClient = HttpClient;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/cjs/error.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProofioError = void 0;
+class ProofioError extends Error {
+    constructor(message, status, code, headers) {
+        super(message);
+        this.name = 'ProofioError';
+        this.status = status;
+        this.code = code;
+        const retryAfterHeader = headers?.get('retry-after');
+        this.retryAfter = retryAfterHeader ? parseInt(retryAfterHeader, 10) : null;
+        this.rateLimit = {
+            limit: parseHeaderInt(headers, 'x-ratelimit-limit'),
+            remaining: parseHeaderInt(headers, 'x-ratelimit-remaining'),
+            reset: parseHeaderInt(headers, 'x-ratelimit-reset'),
+        };
+    }
+    /** Whether this error is retryable (5xx or 429) */
+    isRetryable() {
+        return this.status === 429 || this.status >= 500;
+    }
+}
+exports.ProofioError = ProofioError;
+function parseHeaderInt(headers, name) {
+    const value = headers?.get(name);
+    if (!value)
+        return null;
+    const parsed = parseInt(value, 10);
+    return isNaN(parsed) ? null : parsed;
+}

package/dist/cjs/index.js

@@ -1,74 +1,23 @@
 "use strict";
-/**
- * Proofio SDK
- *
- * Official JavaScript/TypeScript SDK for Proofio API
- *
- * @example
- * ```typescript
- * import { Proofio } from 'proofio-sdk';
- *
- * const proofio = new Proofio({ apiKey: 'your-api-key' });
- *
- * const reviews = await proofio.reviews.list();
- * const summary = await proofio.insights.summary();
- * ```
- */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Proofio = exports.ApiClient = exports.ProofioError = void 0;
-const api_client_1 = require("./client/api-client");
+exports.ProofioError = exports.Proofio = void 0;
+const client_1 = require("./client");
 const reviews_1 = require("./resources/reviews");
+const aggregations_1 = require("./resources/aggregations");
+const clusters_1 = require("./resources/clusters");
 const insights_1 = require("./resources/insights");
-const competitors_1 = require("./resources/competitors");
 const widget_1 = require("./resources/widget");
-var errors_1 = require("./utils/errors");
-Object.defineProperty(exports, "ProofioError", { enumerable: true, get: function () { return errors_1.ProofioError; } });
-var api_client_2 = require("./client/api-client");
-Object.defineProperty(exports, "ApiClient", { enumerable: true, get: function () { return api_client_2.ApiClient; } });
-/**
- * Main Proofio SDK Client
- *
- * Provides access to all Proofio API resources:
- * - reviews: List and get reviews
- * - insights: Get summaries and trends
- * - competitors: Compare with competitors
- * - widget: Get widget data and configuration
- */
 class Proofio {
-    /**
-     * Create a new Proofio SDK instance
-     *
-     * @param config - SDK configuration
-     * @param config.apiKey - Your Proofio API key (required)
-     * @param config.baseURL - Base URL for API (default: https://proofio.app)
-     * @param config.timeout - Request timeout in milliseconds (default: 30000)
-     * @param config.maxRetries - Maximum number of retries (default: 3)
-     * @param config.retryDelay - Delay between retries in milliseconds (default: 1000)
-     *
-     * @example
-     * ```typescript
-     * const proofio = new Proofio({
-     *   apiKey: 'your-api-key-here',
-     *   baseURL: 'https://proofio.app', // optional
-     *   timeout: 30000, // optional
-     * });
-     * ```
-     */
     constructor(config) {
-        this.client = new api_client_1.ApiClient(config);
-        // Initialize resources
-        this.reviews = new reviews_1.ReviewsResource(this.client);
-        this.insights = new insights_1.InsightsResource(this.client);
-        this.competitors = new competitors_1.CompetitorsResource(this.client);
-        this.widget = new widget_1.WidgetResource(this.client);
-    }
-    /**
-     * Get the underlying API client (for advanced usage)
-     */
-    getClient() {
-        return this.client;
+        const client = new client_1.HttpClient(config);
+        this.reviews = new reviews_1.Reviews(client);
+        this.aggregations = new aggregations_1.AggregationsResource(client);
+        this.clusters = new clusters_1.Clusters(client);
+        this.insights = new insights_1.InsightsResource(client);
+        this.widget = new widget_1.Widget(client);
     }
 }
 exports.Proofio = Proofio;
-// Default export
-exports.default = Proofio;
+// Re-export everything
+var error_1 = require("./error");
+Object.defineProperty(exports, "ProofioError", { enumerable: true, get: function () { return error_1.ProofioError; } });

package/dist/cjs/resources/aggregations.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregationsResource = void 0;
+class AggregationsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /** Get aggregated review statistics */
+    async get() {
+        return this.client.get('/api/v1/public/aggregations');
+    }
+}
+exports.AggregationsResource = AggregationsResource;

package/dist/cjs/resources/clusters.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Clusters = void 0;
+class Clusters {
+    constructor(client) {
+        this.client = client;
+    }
+    /** Get review clusters with keyword groupings */
+    async list() {
+        const response = await this.client.get('/api/v1/public/clusters');
+        return response.clusters;
+    }
+}
+exports.Clusters = Clusters;

package/dist/cjs/resources/insights.js

@@ -1,101 +1,20 @@
 "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 AI-powered review intelligence (trust score, risk, emotions, topics) */
+    async get() {
+        return this.client.get('/api/v1/public/insights');
     }
     /**
-     * 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
+     * Get aggregated summary (totalReviews, averageRating, etc.)
+     * Alias for aggregations endpoint - provided for convenience.
      */
-    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
-        };
+    async summary() {
+        return this.client.get('/api/v1/public/aggregations');
     }
 }
 exports.InsightsResource = InsightsResource;

package/dist/cjs/resources/reviews.js

@@ -1,69 +1,19 @@
 "use strict";
-/**
- * Reviews Resource
- *
- * Handles all review-related API calls
- */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReviewsResource = void 0;
-class ReviewsResource {
+exports.Reviews = void 0;
+class Reviews {
     constructor(client) {
         this.client = client;
     }
-    /**
-     * List reviews
-     *
-     * @param options - Filter and pagination options
-     * @returns Promise with array of reviews
-     */
+    /** List reviews with optional filters */
     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 this.client.get('/api/v1/public/reviews', {
+            limit: options?.limit,
+            minRating: options?.minRating,
+            sentiment: options?.sentiment,
+            language: options?.language,
+            sourceId: options?.sourceId,
         });
-        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;
+exports.Reviews = Reviews;

package/dist/cjs/resources/widget.js

@@ -1,58 +1,13 @@
 "use strict";
-/**
- * Widget Resource
- *
- * Handles widget-related API calls
- */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WidgetResource = void 0;
-class WidgetResource {
+exports.Widget = void 0;
+class Widget {
     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
-     */
+    /** Get widget data (stats + display settings) */
     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;
+        return this.client.get('/api/v1/public/widget');
     }
 }
-exports.WidgetResource = WidgetResource;
+exports.Widget = Widget;

package/dist/cjs/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// ─── Client Configuration ────────────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/client.d.ts

@@ -0,0 +1,12 @@
+import { ProofioConfig } from './types';
+export declare class HttpClient {
+    private readonly apiKey;
+    private readonly baseURL;
+    private readonly timeout;
+    private readonly maxRetries;
+    private readonly retryDelay;
+    constructor(config: ProofioConfig);
+    get<T>(path: string, params?: Record<string, string | number | undefined>): Promise<T>;
+    private buildURL;
+    private request;
+}

package/dist/error.d.ts

@@ -0,0 +1,17 @@
+export declare class ProofioError extends Error {
+    /** HTTP status code */
+    readonly status: number;
+    /** Error code from API response */
+    readonly code: string;
+    /** Retry-After header value in seconds (present on 429) */
+    readonly retryAfter: number | null;
+    /** Rate limit info from response headers */
+    readonly rateLimit: {
+        limit: number | null;
+        remaining: number | null;
+        reset: number | null;
+    };
+    constructor(message: string, status: number, code: string, headers?: Headers);
+    /** Whether this error is retryable (5xx or 429) */
+    isRetryable(): boolean;
+}

package/dist/esm/client.js

@@ -0,0 +1,79 @@
+import { ProofioError } from './error';
+const DEFAULT_BASE_URL = 'https://api.proofio.app';
+const DEFAULT_TIMEOUT = 30000;
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY = 1000;
+export class HttpClient {
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new Error('proofio-sdk: apiKey is required');
+        }
+        this.apiKey = config.apiKey;
+        this.baseURL = (config.baseURL ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+        this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+        this.retryDelay = config.retryDelay ?? DEFAULT_RETRY_DELAY;
+    }
+    async get(path, params) {
+        const url = this.buildURL(path, params);
+        return this.request(url);
+    }
+    buildURL(path, params) {
+        const url = new URL(`${this.baseURL}${path}`);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.set(key, String(value));
+                }
+            }
+        }
+        return url.toString();
+    }
+    async request(url, attempt = 0) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'x-api-key': this.apiKey,
+                    'Content-Type': 'application/json',
+                },
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const body = await response.json().catch(() => ({ error: response.statusText }));
+                const error = new ProofioError(body.message ?? body.error ?? `HTTP ${response.status}`, response.status, body.error ?? 'unknown_error', response.headers);
+                // Retry on 5xx or 429 (with backoff)
+                if (error.isRetryable() && attempt < this.maxRetries) {
+                    const delay = error.status === 429 && error.retryAfter
+                        ? error.retryAfter * 1000
+                        : this.retryDelay * Math.pow(2, attempt);
+                    await sleep(delay);
+                    return this.request(url, attempt + 1);
+                }
+                throw error;
+            }
+            return (await response.json());
+        }
+        catch (err) {
+            if (err instanceof ProofioError)
+                throw err;
+            // Network / timeout errors are retryable
+            if (attempt < this.maxRetries) {
+                await sleep(this.retryDelay * Math.pow(2, attempt));
+                return this.request(url, attempt + 1);
+            }
+            if (err instanceof DOMException && err.name === 'AbortError') {
+                throw new ProofioError(`Request timed out after ${this.timeout}ms`, 0, 'timeout');
+            }
+            throw new ProofioError(err instanceof Error ? err.message : 'Network error', 0, 'network_error');
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/esm/error.js

@@ -0,0 +1,26 @@
+export class ProofioError extends Error {
+    constructor(message, status, code, headers) {
+        super(message);
+        this.name = 'ProofioError';
+        this.status = status;
+        this.code = code;
+        const retryAfterHeader = headers?.get('retry-after');
+        this.retryAfter = retryAfterHeader ? parseInt(retryAfterHeader, 10) : null;
+        this.rateLimit = {
+            limit: parseHeaderInt(headers, 'x-ratelimit-limit'),
+            remaining: parseHeaderInt(headers, 'x-ratelimit-remaining'),
+            reset: parseHeaderInt(headers, 'x-ratelimit-reset'),
+        };
+    }
+    /** Whether this error is retryable (5xx or 429) */
+    isRetryable() {
+        return this.status === 429 || this.status >= 500;
+    }
+}
+function parseHeaderInt(headers, name) {
+    const value = headers?.get(name);
+    if (!value)
+        return null;
+    const parsed = parseInt(value, 10);
+    return isNaN(parsed) ? null : parsed;
+}