@foru-ms/sdk 1.1.0 → 1.2.0

package/dist/Client.js

@@ -15,13 +15,34 @@ const PrivateMessages_1 = require("./resources/PrivateMessages");
 const Reports_1 = require("./resources/Reports");
 const Roles_1 = require("./resources/Roles");
 const SSO_1 = require("./resources/SSO");
+const errors_1 = require("./errors");
+const utils_1 = require("./utils");
 // Polyfill fetch if needed (e.g. older Node versions)
 const fetch = globalThis.fetch || require('cross-fetch');
+/**
+ * Main client for interacting with the Foru.ms API
+ * @example
+ * ```typescript
+ * const client = new ForumClient({
+ *   apiKey: 'your_api_key',
+ *   baseUrl: 'https://api.foru.ms/v1'
+ * });
+ *
+ * // Set user token
+ * client.setToken('user_jwt_token');
+ *
+ * // Use resources
+ * const threads = await client.threads.list();
+ * ```
+ */
 class ForumClient {
     constructor(options) {
+        var _a, _b;
         this.token = null;
         this.apiKey = options.apiKey;
         this.baseUrl = options.baseUrl || 'https://api.foru.ms/v1';
+        this.maxRetries = (_a = options.maxRetries) !== null && _a !== void 0 ? _a : 3;
+        this.enableRetry = (_b = options.enableRetry) !== null && _b !== void 0 ? _b : true;
         this.auth = new Auth_1.AuthResource(this);
         this.threads = new Threads_1.ThreadsResource(this);
         this.posts = new Posts_1.PostsResource(this);
@@ -36,35 +57,116 @@ class ForumClient {
         this.reports = new Reports_1.ReportsResource(this);
         this.roles = new Roles_1.RolesResource(this);
         this.sso = new SSO_1.SSOResource(this);
+        this.pagination = new utils_1.PaginationHelper();
     }
+    /**
+     * Make an HTTP request to the API
+     * @param path - API endpoint path
+     * @param options - Fetch options
+     * @returns Promise resolving to the response data
+     * @throws {ForumAPIError} When the API returns an error
+     * @throws {NetworkError} When the network request fails
+     */
     async request(path, options = {}) {
-        const headers = {
-            'Content-Type': 'application/json',
-            'x-api-key': this.apiKey,
-            ...options.headers,
+        const makeRequest = async () => {
+            const headers = {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+                ...options.headers,
+            };
+            if (this.token) {
+                headers['Authorization'] = `Bearer ${this.token}`;
+            }
+            let response;
+            try {
+                response = await fetch(`${this.baseUrl}${path}`, {
+                    ...options,
+                    headers,
+                });
+            }
+            catch (error) {
+                throw new errors_1.NetworkError('Network request failed', error);
+            }
+            // Extract rate limit info
+            this.extractRateLimitInfo(response);
+            const contentType = response.headers.get('content-type');
+            let data;
+            if (contentType && contentType.includes('application/json')) {
+                data = await response.json();
+            }
+            else {
+                data = await response.text();
+            }
+            if (!response.ok) {
+                this.handleErrorResponse(response.status, data);
+            }
+            return data;
         };
-        if (this.token) {
-            headers['Authorization'] = `Bearer ${this.token}`;
+        // Apply retry logic if enabled
+        if (this.enableRetry) {
+            return utils_1.RetryHelper.withRetry(makeRequest, this.maxRetries);
         }
-        const response = await fetch(`${this.baseUrl}${path}`, {
-            ...options,
-            headers,
-        });
-        const contentType = response.headers.get('content-type');
-        let data;
-        if (contentType && contentType.includes('application/json')) {
-            data = await response.json();
-        }
-        else {
-            data = await response.text();
-        }
-        if (!response.ok) {
-            throw new Error((data && data.message) || data.error || 'API Error');
-        }
-        return data;
+        return makeRequest();
     }
+    /**
+     * Set the authentication token for user-scoped requests
+     * @param token - JWT token
+     */
     setToken(token) {
         this.token = token;
     }
+    /**
+     * Clear the authentication token
+     */
+    clearToken() {
+        this.token = null;
+    }
+    /**
+     * Check if client is authenticated
+     */
+    isAuthenticated() {
+        return this.token !== null;
+    }
+    /**
+     * Extract and store rate limit information from response headers
+     */
+    extractRateLimitInfo(response) {
+        const limit = response.headers.get('x-ratelimit-limit');
+        const remaining = response.headers.get('x-ratelimit-remaining');
+        const reset = response.headers.get('x-ratelimit-reset');
+        if (limit && remaining && reset) {
+            this.lastRateLimitInfo = {
+                limit: parseInt(limit, 10),
+                remaining: parseInt(remaining, 10),
+                reset: parseInt(reset, 10),
+            };
+        }
+    }
+    /**
+     * Handle error responses by throwing appropriate error types
+     */
+    handleErrorResponse(status, data) {
+        const message = (data && data.message) || data.error || 'API Error';
+        switch (status) {
+            case 401:
+                throw new errors_1.AuthenticationError(message, data);
+            case 403:
+                throw new errors_1.AuthorizationError(message, data);
+            case 404:
+                throw new errors_1.NotFoundError(message, data);
+            case 422:
+                throw new errors_1.ValidationError(message, data);
+            case 429:
+                const retryAfter = data.retryAfter || 60;
+                throw new errors_1.RateLimitError(message, retryAfter, data);
+            case 500:
+            case 502:
+            case 503:
+            case 504:
+                throw new errors_1.ServerError(message, status, data);
+            default:
+                throw new errors_1.ForumAPIError(message, status, data);
+        }
+    }
 }
 exports.ForumClient = ForumClient;

package/dist/errors.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Base error class for all Foru.ms API errors
+ */
+export declare class ForumAPIError extends Error {
+    statusCode: number;
+    response?: any;
+    constructor(message: string, statusCode: number, response?: any);
+}
+/**
+ * Error thrown when authentication fails or token is invalid
+ */
+export declare class AuthenticationError extends ForumAPIError {
+    constructor(message?: string, response?: any);
+}
+/**
+ * Error thrown when user doesn't have permission for an action
+ */
+export declare class AuthorizationError extends ForumAPIError {
+    constructor(message?: string, response?: any);
+}
+/**
+ * Error thrown when a requested resource is not found
+ */
+export declare class NotFoundError extends ForumAPIError {
+    constructor(message?: string, response?: any);
+}
+/**
+ * Error thrown when request validation fails
+ */
+export declare class ValidationError extends ForumAPIError {
+    constructor(message?: string, response?: any);
+}
+/**
+ * Error thrown when rate limit is exceeded
+ */
+export declare class RateLimitError extends ForumAPIError {
+    retryAfter?: number | undefined;
+    constructor(message?: string, retryAfter?: number | undefined, response?: any);
+}
+/**
+ * Error thrown when server encounters an error
+ */
+export declare class ServerError extends ForumAPIError {
+    constructor(message?: string, statusCode?: number, response?: any);
+}
+/**
+ * Error thrown when network request fails
+ */
+export declare class NetworkError extends Error {
+    cause?: Error | undefined;
+    constructor(message?: string, cause?: Error | undefined);
+}

package/dist/errors.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkError = exports.ServerError = exports.RateLimitError = exports.ValidationError = exports.NotFoundError = exports.AuthorizationError = exports.AuthenticationError = exports.ForumAPIError = void 0;
+/**
+ * Base error class for all Foru.ms API errors
+ */
+class ForumAPIError extends Error {
+    constructor(message, statusCode, response) {
+        super(message);
+        this.statusCode = statusCode;
+        this.response = response;
+        this.name = 'ForumAPIError';
+        Object.setPrototypeOf(this, ForumAPIError.prototype);
+    }
+}
+exports.ForumAPIError = ForumAPIError;
+/**
+ * Error thrown when authentication fails or token is invalid
+ */
+class AuthenticationError extends ForumAPIError {
+    constructor(message = 'Authentication failed', response) {
+        super(message, 401, response);
+        this.name = 'AuthenticationError';
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+/**
+ * Error thrown when user doesn't have permission for an action
+ */
+class AuthorizationError extends ForumAPIError {
+    constructor(message = 'Permission denied', response) {
+        super(message, 403, response);
+        this.name = 'AuthorizationError';
+        Object.setPrototypeOf(this, AuthorizationError.prototype);
+    }
+}
+exports.AuthorizationError = AuthorizationError;
+/**
+ * Error thrown when a requested resource is not found
+ */
+class NotFoundError extends ForumAPIError {
+    constructor(message = 'Resource not found', response) {
+        super(message, 404, response);
+        this.name = 'NotFoundError';
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+}
+exports.NotFoundError = NotFoundError;
+/**
+ * Error thrown when request validation fails
+ */
+class ValidationError extends ForumAPIError {
+    constructor(message = 'Validation failed', response) {
+        super(message, 422, response);
+        this.name = 'ValidationError';
+        Object.setPrototypeOf(this, ValidationError.prototype);
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * Error thrown when rate limit is exceeded
+ */
+class RateLimitError extends ForumAPIError {
+    constructor(message = 'Rate limit exceeded', retryAfter, response) {
+        super(message, 429, response);
+        this.retryAfter = retryAfter;
+        this.name = 'RateLimitError';
+        Object.setPrototypeOf(this, RateLimitError.prototype);
+    }
+}
+exports.RateLimitError = RateLimitError;
+/**
+ * Error thrown when server encounters an error
+ */
+class ServerError extends ForumAPIError {
+    constructor(message = 'Server error', statusCode = 500, response) {
+        super(message, statusCode, response);
+        this.name = 'ServerError';
+        Object.setPrototypeOf(this, ServerError.prototype);
+    }
+}
+exports.ServerError = ServerError;
+/**
+ * Error thrown when network request fails
+ */
+class NetworkError extends Error {
+    constructor(message = 'Network request failed', cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'NetworkError';
+        Object.setPrototypeOf(this, NetworkError.prototype);
+    }
+}
+exports.NetworkError = NetworkError;

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 export * from './Client';
 export * from './types';
+export * from './errors';
+export * from './response-types';
+export * from './utils';
 export * from './resources/Auth';
 export * from './resources/Threads';
 export * from './resources/Posts';

package/dist/index.js

@@ -16,6 +16,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Client"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./response-types"), exports);
+__exportStar(require("./utils"), exports);
 __exportStar(require("./resources/Auth"), exports);
 __exportStar(require("./resources/Threads"), exports);
 __exportStar(require("./resources/Posts"), exports);

package/dist/resources/Integrations.d.ts

@@ -14,6 +14,13 @@ export declare class IntegrationsResource {
     retrieve(id: string): Promise<{
         integration: Integration;
     }>;
+    update(id: string, payload: {
+        name?: string;
+        config?: any;
+        active?: boolean;
+    }): Promise<{
+        integration: Integration;
+    }>;
     delete(id: string): Promise<{
         success: boolean;
     }>;

package/dist/resources/Integrations.js

@@ -21,6 +21,12 @@ class IntegrationsResource {
             method: 'GET',
         });
     }
+    async update(id, payload) {
+        return this.client.request(`/integrations/${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify(payload),
+        });
+    }
     async delete(id) {
         return this.client.request(`/integrations/${id}`, {
             method: 'DELETE',

package/dist/resources/Posts.d.ts

@@ -25,10 +25,22 @@ export declare class PostsResource {
     }): Promise<any>;
     like(id: string, userId?: string, extendedData?: any): Promise<any>;
     unlike(id: string, userId: string): Promise<any>;
+    getLikes(id: string, params?: {
+        cursor?: string;
+    }): Promise<any>;
     dislike(id: string, userId?: string, extendedData?: any): Promise<any>;
     undislike(id: string, userId: string): Promise<any>;
+    getDislikes(id: string, params?: {
+        cursor?: string;
+    }): Promise<any>;
     upvote(id: string, userId?: string, extendedData?: any): Promise<any>;
     unupvote(id: string, userId: string): Promise<any>;
+    getUpvotes(id: string, params?: {
+        cursor?: string;
+    }): Promise<any>;
     downvote(id: string, userId?: string, extendedData?: any): Promise<any>;
     undownvote(id: string, userId: string): Promise<any>;
+    getDownvotes(id: string, params?: {
+        cursor?: string;
+    }): Promise<any>;
 }

package/dist/resources/Posts.js

@@ -63,6 +63,17 @@ class PostsResource {
             method: 'DELETE',
         });
     }
+    async getLikes(id, params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value);
+                }
+            });
+        }
+        return this.client.request(`/post/${id}/likes?${searchParams.toString()}`, { method: 'GET' });
+    }
     async dislike(id, userId, extendedData) {
         return this.client.request(`/post/${id}/dislikes`, {
             method: 'POST',
@@ -74,6 +85,17 @@ class PostsResource {
             method: 'DELETE',
         });
     }
+    async getDislikes(id, params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value);
+                }
+            });
+        }
+        return this.client.request(`/post/${id}/dislikes?${searchParams.toString()}`, { method: 'GET' });
+    }
     async upvote(id, userId, extendedData) {
         return this.client.request(`/post/${id}/upvotes`, {
             method: 'POST',
@@ -85,6 +107,17 @@ class PostsResource {
             method: 'DELETE',
         });
     }
+    async getUpvotes(id, params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value);
+                }
+            });
+        }
+        return this.client.request(`/post/${id}/upvotes?${searchParams.toString()}`, { method: 'GET' });
+    }
     async downvote(id, userId, extendedData) {
         return this.client.request(`/post/${id}/downvotes`, {
             method: 'POST',
@@ -96,5 +129,16 @@ class PostsResource {
             method: 'DELETE',
         });
     }
+    async getDownvotes(id, params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value);
+                }
+            });
+        }
+        return this.client.request(`/post/${id}/downvotes?${searchParams.toString()}`, { method: 'GET' });
+    }
 }
 exports.PostsResource = PostsResource;

package/dist/resources/PrivateMessages.d.ts

@@ -23,6 +23,10 @@ export declare class PrivateMessagesResource {
         recipientId: string;
         extendedData?: Record<string, any>;
     }): Promise<PrivateMessage>;
+    update(id: string, payload: {
+        read?: boolean;
+        extendedData?: Record<string, any>;
+    }): Promise<PrivateMessage>;
     delete(id: string): Promise<PrivateMessage & {
         deleted: boolean;
     }>;

package/dist/resources/PrivateMessages.js

@@ -35,6 +35,12 @@ class PrivateMessagesResource {
             body: JSON.stringify(payload),
         });
     }
+    async update(id, payload) {
+        return this.client.request(`/private-message/${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify(payload),
+        });
+    }
     async delete(id) {
         return this.client.request(`/private-message/${id}`, {
             method: 'DELETE',

package/dist/resources/SSO.d.ts

@@ -11,6 +11,16 @@ export declare class SSOResource {
     }): Promise<{
         ssoProvider: SSOProvider;
     }>;
+    retrieve(id: string): Promise<{
+        ssoProvider: SSOProvider;
+    }>;
+    update(id: string, payload: {
+        domain?: string;
+        config?: any;
+        active?: boolean;
+    }): Promise<{
+        ssoProvider: SSOProvider;
+    }>;
     delete(id: string): Promise<{
         success: boolean;
     }>;

package/dist/resources/SSO.js

@@ -16,6 +16,17 @@ class SSOResource {
             body: JSON.stringify(payload),
         });
     }
+    async retrieve(id) {
+        return this.client.request(`/sso/${id}`, {
+            method: 'GET',
+        });
+    }
+    async update(id, payload) {
+        return this.client.request(`/sso/${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify(payload),
+        });
+    }
     async delete(id) {
         return this.client.request(`/sso/${id}`, {
             method: 'DELETE',

package/dist/resources/Tags.d.ts

@@ -27,8 +27,16 @@ export declare class TagsResource {
     delete(id: string): Promise<import('../types').Tag & {
         deleted: boolean;
     }>;
+    getThreads(id: string, params?: {
+        query?: string;
+        cursor?: string;
+        filter?: 'newest' | 'oldest';
+    }): Promise<import('../types').ThreadListResponse>;
     subscribe(id: string, userId: string): Promise<any>;
     unsubscribe(id: string, userId: string): Promise<any>;
+    getSubscribers(id: string, params?: {
+        cursor?: string;
+    }): Promise<any>;
     listSubscribed(params: {
         userId: string;
         query?: string;

package/dist/resources/Tags.js

@@ -43,6 +43,19 @@ class TagsResource {
             method: 'DELETE',
         });
     }
+    async getThreads(id, params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value);
+                }
+            });
+        }
+        return this.client.request(`/tag/${id}/threads?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
     async subscribe(id, userId) {
         return this.client.request(`/tag/${id}/subscribers`, {
             method: 'POST',
@@ -54,6 +67,17 @@ class TagsResource {
             method: 'DELETE',
         });
     }
+    async getSubscribers(id, params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value);
+                }
+            });
+        }
+        return this.client.request(`/tag/${id}/subscribers?${searchParams.toString()}`, { method: 'GET' });
+    }
     async listSubscribed(params) {
         const searchParams = new URLSearchParams();
         Object.entries(params).forEach(([key, value]) => {

package/dist/resources/Threads.d.ts

@@ -26,10 +26,30 @@ export declare class ThreadsResource {
     }): Promise<any>;
     like(id: string, userId?: string, extendedData?: any): Promise<any>;
     unlike(id: string, userId: string): Promise<any>;
+    getLikes(id: string, params?: {
+        cursor?: string;
+    }): Promise<any>;
     dislike(id: string, userId?: string, extendedData?: any): Promise<any>;
     undislike(id: string, userId: string): Promise<any>;
+    getDislikes(id: string, params?: {
+        cursor?: string;
+    }): Promise<any>;
     subscribe(id: string, userId: string, extendedData?: any): Promise<any>;
     unsubscribe(id: string, userId: string): Promise<any>;
+    getSubscribers(id: string, params?: {
+        cursor?: string;
+    }): Promise<any>;
+    upvote(id: string, userId?: string, extendedData?: any): Promise<any>;
+    unupvote(id: string, userId: string): Promise<any>;
+    getUpvotes(id: string, params?: {
+        cursor?: string;
+    }): Promise<any>;
+    downvote(id: string, userId?: string, extendedData?: any): Promise<any>;
+    undownvote(id: string, userId: string): Promise<any>;
+    getDownvotes(id: string, params?: {
+        cursor?: string;
+    }): Promise<any>;
+    getPoll(threadId: string, userId?: string): Promise<any>;
     vote(id: string, optionId: string, userId: string): Promise<any>;
     voteUpdate(id: string, optionId: string, userId: string): Promise<any>;
     unvote(id: string, userId: string): Promise<any>;