@foru-ms/sdk 0.1.0 → 0.2.0

package/README.md

@@ -0,0 +1,144 @@
+# @foru-ms/sdk
+
+The official JavaScript/TypeScript SDK for [Foru.ms](https://foru.ms). Build powerful community features directly into your application.
+
+## Installation
+
+```bash
+npm install @foru-ms/sdk
+# or
+yarn add @foru-ms/sdk
+# or
+pnpm add @foru-ms/sdk
+```
+
+## Getting Started
+
+Initialize the client with your API key. You can find your API key in the Foru.ms dashboard.
+
+```typescript
+import { ForumClient } from '@foru-ms/sdk';
+
+const client = new ForumClient({
+  apiKey: 'your_api_key',
+  // baseUrl: 'https://api.foru.ms/v1' // Optional, defaults to production URL
+});
+```
+
+## Authentication
+
+Identify the current user to perform actions on their behalf. Use `authToken` obtained via login or your own auth provider integration.
+
+```typescript
+// Login with username/password
+const { token } = await client.auth.login({
+  login: 'username',
+  password: 'password'
+});
+
+// Or set an existing token
+client.setToken(token);
+
+// Get current user details
+const me = await client.auth.me();
+```
+
+## Usage Examples
+
+### Threads
+
+```typescript
+// List threads
+const { threads } = await client.threads.list({ 
+  limit: 10,
+  filter: 'newest' 
+});
+
+// Create a thread
+const newThread = await client.threads.create({
+  title: 'Hello World',
+  body: 'This is my first thread via the SDK!',
+  tags: ['introduction', 'general']
+});
+
+// Interact with a thread
+await client.threads.like(newThread.id, currentUser.id);
+```
+
+### Posts (Replies)
+
+```typescript
+// Reply to a thread
+const post = await client.posts.create({
+  threadId: 'thread_123',
+  body: 'Great discussion!'
+});
+
+// Get replies for a post (threaded view)
+const { posts } = await client.posts.getChildren('post_123');
+```
+
+### Users & Social
+
+```typescript
+// Follow a user
+await client.users.follow('target_user_id', 'current_user_id');
+
+// Get user feed/followers
+const { followers } = await client.users.getFollowers('user_123');
+```
+
+### Real-time Notifications
+
+```typescript
+// Get notifications
+const { list } = await client.notifications.list({ userId: 'user_123' });
+
+// Mark as read
+await client.notifications.markAllAsRead('user_123');
+```
+
+## Resources
+
+The SDK covers the full Foru.ms API surface:
+
+*   `client.auth`: Authentication & Registration
+*   `client.threads`: Discussions & Polls
+*   `client.posts`: Replies & Nested Comments
+*   `client.users`: User Profiles & Social Graph
+*   `client.tags`: Categorization & Subscriptions
+*   `client.notifications`: Alerts & Activity
+*   `client.search`: Unified Search
+*   `client.webhooks`: Event Subscriptions
+*   `client.stats`: Community Analytics
+*   `client.integrations`: 3rd Party Connections (Slack, Discord, etc.)
+*   `client.privateMessages`: Direct Messaging
+*   `client.reports`: Moderation & Safety
+*   `client.roles`: Permission Management
+*   `client.sso`: Single Sign-On Configuration
+
+## TypeScript Support
+
+This SDK is written in TypeScript and provides complete type definitions for all requests and responses.
+
+```typescript
+import { Thread, User } from '@foru-ms/sdk';
+
+const thread: Thread = await client.threads.retrieve('thread_123');
+```
+
+## Error Handling
+
+API errors throw standard JavaScript errors with messages from the server.
+
+```typescript
+try {
+  await client.threads.create({ ... });
+} catch (error) {
+  console.error('API Error:', error.message);
+}
+```
+
+## License
+
+MIT

package/dist/Client.d.ts

@@ -3,6 +3,15 @@ import { ThreadsResource } from './resources/Threads';
 import { PostsResource } from './resources/Posts';
 import { UsersResource } from './resources/Users';
 import { TagsResource } from './resources/Tags';
+import { NotificationsResource } from './resources/Notifications';
+import { SearchResource } from './resources/Search';
+import { WebhooksResource } from './resources/Webhooks';
+import { StatsResource } from './resources/Stats';
+import { IntegrationsResource } from './resources/Integrations';
+import { PrivateMessagesResource } from './resources/PrivateMessages';
+import { ReportsResource } from './resources/Reports';
+import { RolesResource } from './resources/Roles';
+import { SSOResource } from './resources/SSO';
 export declare class ForumClient {
     apiKey: string;
     token: string | null;
@@ -12,6 +21,15 @@ export declare class ForumClient {
     posts: PostsResource;
     users: UsersResource;
     tags: TagsResource;
+    notifications: NotificationsResource;
+    search: SearchResource;
+    webhooks: WebhooksResource;
+    stats: StatsResource;
+    integrations: IntegrationsResource;
+    privateMessages: PrivateMessagesResource;
+    reports: ReportsResource;
+    roles: RolesResource;
+    sso: SSOResource;
     constructor(options: {
         apiKey: string;
         baseUrl?: string;

package/dist/Client.js

@@ -6,6 +6,15 @@ const Threads_1 = require("./resources/Threads");
 const Posts_1 = require("./resources/Posts");
 const Users_1 = require("./resources/Users");
 const Tags_1 = require("./resources/Tags");
+const Notifications_1 = require("./resources/Notifications");
+const Search_1 = require("./resources/Search");
+const Webhooks_1 = require("./resources/Webhooks");
+const Stats_1 = require("./resources/Stats");
+const Integrations_1 = require("./resources/Integrations");
+const PrivateMessages_1 = require("./resources/PrivateMessages");
+const Reports_1 = require("./resources/Reports");
+const Roles_1 = require("./resources/Roles");
+const SSO_1 = require("./resources/SSO");
 // Polyfill fetch if needed (e.g. older Node versions)
 const fetch = globalThis.fetch || require('cross-fetch');
 class ForumClient {
@@ -18,6 +27,15 @@ class ForumClient {
         this.posts = new Posts_1.PostsResource(this);
         this.users = new Users_1.UsersResource(this);
         this.tags = new Tags_1.TagsResource(this);
+        this.notifications = new Notifications_1.NotificationsResource(this);
+        this.search = new Search_1.SearchResource(this);
+        this.webhooks = new Webhooks_1.WebhooksResource(this);
+        this.stats = new Stats_1.StatsResource(this);
+        this.integrations = new Integrations_1.IntegrationsResource(this);
+        this.privateMessages = new PrivateMessages_1.PrivateMessagesResource(this);
+        this.reports = new Reports_1.ReportsResource(this);
+        this.roles = new Roles_1.RolesResource(this);
+        this.sso = new SSO_1.SSOResource(this);
     }
     async request(path, options = {}) {
         const headers = {

package/dist/index.d.ts

@@ -5,3 +5,12 @@ export * from './resources/Threads';
 export * from './resources/Posts';
 export * from './resources/Users';
 export * from './resources/Tags';
+export * from './resources/Notifications';
+export * from './resources/Search';
+export * from './resources/Webhooks';
+export * from './resources/Stats';
+export * from './resources/Integrations';
+export * from './resources/PrivateMessages';
+export * from './resources/Reports';
+export * from './resources/Roles';
+export * from './resources/SSO';

package/dist/index.js

@@ -21,3 +21,12 @@ __exportStar(require("./resources/Threads"), exports);
 __exportStar(require("./resources/Posts"), exports);
 __exportStar(require("./resources/Users"), exports);
 __exportStar(require("./resources/Tags"), exports);
+__exportStar(require("./resources/Notifications"), exports);
+__exportStar(require("./resources/Search"), exports);
+__exportStar(require("./resources/Webhooks"), exports);
+__exportStar(require("./resources/Stats"), exports);
+__exportStar(require("./resources/Integrations"), exports);
+__exportStar(require("./resources/PrivateMessages"), exports);
+__exportStar(require("./resources/Reports"), exports);
+__exportStar(require("./resources/Roles"), exports);
+__exportStar(require("./resources/SSO"), exports);

package/dist/resources/Auth.d.ts

@@ -9,4 +9,16 @@ export declare class AuthResource {
     }): Promise<LoginResponse>;
     register(payload: import('../types').RegisterPayload): Promise<import('../types').User>;
     me(): Promise<import('../types').User>;
+    forgotPassword(email: string): Promise<{
+        resetToken?: string;
+        message?: string;
+    }>;
+    resetPassword(payload: {
+        password: string;
+        oldPassword?: string;
+        email?: string;
+        token?: string;
+    }): Promise<{
+        message: string;
+    }>;
 }

package/dist/resources/Auth.js

@@ -26,5 +26,24 @@ class AuthResource {
             method: 'GET',
         });
     }
+    async forgotPassword(email) {
+        return this.client.request('/auth/forgot-password', {
+            method: 'POST',
+            body: JSON.stringify({ email }),
+        });
+    }
+    async resetPassword(payload) {
+        const headers = {};
+        if (payload.token) {
+            headers['Authorization'] = `Bearer ${payload.token}`;
+        }
+        // Remove token from body
+        const { token, ...body } = payload;
+        return this.client.request('/auth/reset-password', {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+        });
+    }
 }
 exports.AuthResource = AuthResource;

package/dist/resources/Integrations.d.ts

@@ -0,0 +1,20 @@
+import { ForumClient } from '../Client';
+import { Integration, IntegrationListResponse } from '../types';
+export declare class IntegrationsResource {
+    private client;
+    constructor(client: ForumClient);
+    list(): Promise<IntegrationListResponse>;
+    create(payload: {
+        type: 'SLACK' | 'DISCORD' | 'SALESFORCE' | 'HUBSPOT' | 'OKTA' | 'AUTH0';
+        name: string;
+        config: any;
+    }): Promise<{
+        integration: Integration;
+    }>;
+    retrieve(id: string): Promise<{
+        integration: Integration;
+    }>;
+    delete(id: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/resources/Integrations.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationsResource = void 0;
+class IntegrationsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list() {
+        return this.client.request('/integrations', {
+            method: 'GET',
+        });
+    }
+    async create(payload) {
+        return this.client.request('/integrations', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+    async retrieve(id) {
+        return this.client.request(`/integrations/${id}`, {
+            method: 'GET',
+        });
+    }
+    async delete(id) {
+        return this.client.request(`/integrations/${id}`, {
+            method: 'DELETE',
+        });
+    }
+}
+exports.IntegrationsResource = IntegrationsResource;

package/dist/resources/Notifications.d.ts

@@ -0,0 +1,32 @@
+import { ForumClient } from '../Client';
+import { NotificationListResponse, Notification } from '../types';
+export declare class NotificationsResource {
+    private client;
+    constructor(client: ForumClient);
+    list(params: {
+        userId: string;
+        read?: boolean;
+        filter?: 'newest' | 'oldest';
+        cursor?: string;
+    }): Promise<NotificationListResponse>;
+    markAllAsRead(userId: string, read?: boolean): Promise<{
+        count: number;
+    }>;
+    retrieve(id: string): Promise<Notification>;
+    update(id: string, payload: {
+        read: boolean;
+    }): Promise<Notification>;
+    delete(id: string): Promise<Notification & {
+        deleted: boolean;
+    }>;
+    create(payload: {
+        threadId?: string;
+        postId?: string;
+        privateMessageId?: string;
+        notifierId: string;
+        notifiedId: string;
+        type: string;
+        description?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<Notification>;
+}

package/dist/resources/Notifications.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationsResource = void 0;
+class NotificationsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        const searchParams = new URLSearchParams();
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined) {
+                searchParams.append(key, String(value));
+            }
+        });
+        return this.client.request(`/notifications?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+    async markAllAsRead(userId, read = true) {
+        return this.client.request('/notifications', {
+            method: 'PATCH',
+            body: JSON.stringify({ userId, read }),
+        });
+    }
+    async retrieve(id) {
+        return this.client.request(`/notification/${id}`, {
+            method: 'GET',
+        });
+    }
+    async update(id, payload) {
+        return this.client.request(`/notification/${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify(payload),
+        });
+    }
+    async delete(id) {
+        return this.client.request(`/notification/${id}`, {
+            method: 'DELETE',
+        });
+    }
+    async create(payload) {
+        return this.client.request('/notification', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+}
+exports.NotificationsResource = NotificationsResource;

package/dist/resources/Posts.d.ts

@@ -18,4 +18,17 @@ export declare class PostsResource {
     }): Promise<import('../types').Post & {
         deleted: boolean;
     }>;
+    getChildren(id: string, params?: {
+        query?: string;
+        cursor?: string;
+        filter?: 'newest' | 'oldest';
+    }): Promise<any>;
+    like(id: string, userId?: string, extendedData?: any): Promise<any>;
+    unlike(id: string, userId: string): Promise<any>;
+    dislike(id: string, userId?: string, extendedData?: any): Promise<any>;
+    undislike(id: string, userId: string): Promise<any>;
+    upvote(id: string, userId?: string, extendedData?: any): Promise<any>;
+    unupvote(id: string, userId: string): Promise<any>;
+    downvote(id: string, userId?: string, extendedData?: any): Promise<any>;
+    undownvote(id: string, userId: string): Promise<any>;
 }

package/dist/resources/Posts.js

@@ -41,5 +41,60 @@ class PostsResource {
             body: payload ? JSON.stringify(payload) : undefined,
         });
     }
+    async getChildren(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}/posts?${searchParams.toString()}`, { method: 'GET' });
+    }
+    async like(id, userId, extendedData) {
+        return this.client.request(`/post/${id}/likes`, {
+            method: 'POST',
+            body: JSON.stringify({ userId, extendedData }),
+        });
+    }
+    async unlike(id, userId) {
+        return this.client.request(`/post/${id}/likes?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
+    async dislike(id, userId, extendedData) {
+        return this.client.request(`/post/${id}/dislikes`, {
+            method: 'POST',
+            body: JSON.stringify({ userId, extendedData }),
+        });
+    }
+    async undislike(id, userId) {
+        return this.client.request(`/post/${id}/dislikes?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
+    async upvote(id, userId, extendedData) {
+        return this.client.request(`/post/${id}/upvotes`, {
+            method: 'POST',
+            body: JSON.stringify({ userId, extendedData }),
+        });
+    }
+    async unupvote(id, userId) {
+        return this.client.request(`/post/${id}/upvotes?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
+    async downvote(id, userId, extendedData) {
+        return this.client.request(`/post/${id}/downvotes`, {
+            method: 'POST',
+            body: JSON.stringify({ userId, extendedData }),
+        });
+    }
+    async undownvote(id, userId) {
+        return this.client.request(`/post/${id}/downvotes?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
 }
 exports.PostsResource = PostsResource;

package/dist/resources/PrivateMessages.d.ts

@@ -0,0 +1,29 @@
+import { ForumClient } from '../Client';
+import { PrivateMessage, PrivateMessageListResponse } from '../types';
+export declare class PrivateMessagesResource {
+    private client;
+    constructor(client: ForumClient);
+    list(params?: {
+        query?: string;
+        userId?: string;
+        filter?: 'newest' | 'oldest';
+        cursor?: string;
+    }): Promise<PrivateMessageListResponse>;
+    create(payload: {
+        title?: string;
+        body: string;
+        recipientId: string;
+        senderId?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<PrivateMessage>;
+    retrieve(id: string): Promise<PrivateMessage>;
+    reply(id: string, payload: {
+        body: string;
+        senderId: string;
+        recipientId: string;
+        extendedData?: Record<string, any>;
+    }): Promise<PrivateMessage>;
+    delete(id: string): Promise<PrivateMessage & {
+        deleted: boolean;
+    }>;
+}

package/dist/resources/PrivateMessages.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateMessagesResource = void 0;
+class PrivateMessagesResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value);
+                }
+            });
+        }
+        return this.client.request(`/private-messages?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+    async create(payload) {
+        return this.client.request('/private-message', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+    async retrieve(id) {
+        return this.client.request(`/private-message/${id}`, {
+            method: 'GET',
+        });
+    }
+    async reply(id, payload) {
+        return this.client.request(`/private-message/${id}`, {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+    async delete(id) {
+        return this.client.request(`/private-message/${id}`, {
+            method: 'DELETE',
+        });
+    }
+}
+exports.PrivateMessagesResource = PrivateMessagesResource;

package/dist/resources/Reports.d.ts

@@ -0,0 +1,46 @@
+import { ForumClient } from '../Client';
+import { Report, ReportListResponse } from '../types';
+export declare class ReportsResource {
+    private client;
+    constructor(client: ForumClient);
+    list(params?: {
+        reporterId?: string;
+        reportedId?: string;
+        read?: boolean;
+        cursor?: string;
+        filter?: 'newest' | 'oldest';
+    }): Promise<ReportListResponse>;
+    create(payload: {
+        reporterId: string;
+        reportedId?: string;
+        threadId?: string;
+        postId?: string;
+        privateMessageId?: string;
+        type?: string;
+        description?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<Report>;
+    batchUpdate(payload: {
+        reportIds: string[];
+        read: boolean;
+    }): Promise<{
+        count?: number;
+        message?: string;
+    }>;
+    retrieve(id: string): Promise<Report>;
+    update(id: string, payload: {
+        threadId?: string;
+        postId?: string;
+        privateMessageId?: string;
+        reportedId?: string;
+        reporterId?: string;
+        type?: string;
+        description?: string;
+        read?: boolean;
+        extendedData?: Record<string, any>;
+    }): Promise<Report>;
+    delete(id: string): Promise<Report & {
+        deleted: boolean;
+    }>;
+    updateStatus(id: string, read: boolean): Promise<Report>;
+}

package/dist/resources/Reports.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportsResource = void 0;
+class ReportsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, String(value));
+                }
+            });
+        }
+        return this.client.request(`/reports?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+    async create(payload) {
+        return this.client.request('/report', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+    async batchUpdate(payload) {
+        return this.client.request('/reports', {
+            method: 'PATCH',
+            body: JSON.stringify(payload),
+        });
+    }
+    async retrieve(id) {
+        return this.client.request(`/report/${id}`, {
+            method: 'GET',
+        });
+    }
+    async update(id, payload) {
+        return this.client.request(`/report/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify(payload),
+        });
+    }
+    async delete(id) {
+        return this.client.request(`/report/${id}`, {
+            method: 'DELETE',
+        });
+    }
+    async updateStatus(id, read) {
+        return this.client.request(`/report/${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify({ read }),
+        });
+    }
+}
+exports.ReportsResource = ReportsResource;