@foru-ms/sdk 0.1.0 → 0.2.0

package/dist/types.d.ts

@@ -135,4 +135,153 @@ export interface UserListResponse {
 export interface TagListResponse {
     tags: Tag[];
     nextTagCursor?: string;
+    count?: number;
+}
+export interface Notification {
+    id: string;
+    threadId?: string;
+    postId?: string;
+    privateMessageId?: string;
+    notifierId: string;
+    notifiedId: string;
+    type: string;
+    description?: string;
+    read: boolean;
+    createdAt: string;
+    extendedData?: Record<string, any>;
+    post?: Post;
+    thread?: Thread;
+    notifier?: User;
+    message?: string;
+    isSystem?: boolean;
+}
+export interface NotificationListResponse {
+    list: Notification[];
+    nextCursor?: string;
+    count: number;
+}
+export interface SearchResponse {
+    type?: 'tags' | 'posts' | 'threads' | 'users';
+    tags?: Tag[];
+    posts?: Post[];
+    threads?: Thread[];
+    nextCursor?: string;
+}
+export interface Webhook {
+    id: string;
+    name: string;
+    url: string;
+    events: {
+        events: string[];
+    } | string[];
+    active: boolean;
+    secret?: string;
+    createdAt: string;
+    updatedAt: string;
+    _count?: {
+        deliveries: number;
+    };
+}
+export interface WebhookListResponse {
+    webhooks: Webhook[];
+}
+export interface StatsResponse {
+    counts: {
+        threads: number;
+        posts: number;
+        users: number;
+        reports: number;
+    };
+    latest: {
+        id: string;
+        createdAt: string;
+        type: 'thread' | 'post' | 'user' | 'report';
+        [key: string]: any;
+    }[];
+    usage: Record<string, any>;
+    cursors: {
+        threadCursor: string | null;
+        postCursor: string | null;
+        userCursor: string | null;
+        reportCursor: string | null;
+    };
+}
+export interface Integration {
+    id: string;
+    type: 'SLACK' | 'DISCORD' | 'SALESFORCE' | 'HUBSPOT' | 'OKTA' | 'AUTH0';
+    name: string;
+    active: boolean;
+    createdAt: string;
+    config?: any;
+}
+export interface IntegrationListResponse {
+    integrations: Integration[];
+}
+export interface PrivateMessage {
+    id: string;
+    senderId: string;
+    recipientId: string;
+    title?: string;
+    body: string;
+    read: boolean;
+    parentId?: string;
+    children?: PrivateMessage[];
+    sender?: User;
+    recipient?: User;
+    createdAt: string;
+    updatedAt: string;
+    extendedData?: Record<string, any>;
+}
+export interface PrivateMessageListResponse {
+    privateMessages: PrivateMessage[];
+    nextPrivateMessageCursor?: string;
+    count: number;
+}
+export interface Report {
+    id: string;
+    reporterId: string;
+    reportedId?: string;
+    threadId?: string;
+    postId?: string;
+    privateMessageId?: string;
+    type: string;
+    description?: string;
+    read: boolean;
+    createdAt: string;
+    post?: Post;
+    thread?: Thread;
+    privateMessage?: PrivateMessage;
+    reported?: User;
+    extendedData?: Record<string, any>;
+}
+export interface ReportListResponse {
+    list: Report[];
+    nextCursor?: string;
+    count: number;
+}
+export interface Role {
+    id: string;
+    name: string;
+    description?: string;
+    color?: string;
+    users?: User[];
+    createdAt: string;
+    updatedAt: string;
+    extendedData?: Record<string, any>;
+}
+export interface RoleListResponse {
+    roles: Role[];
+    nextCursor?: string;
+    count: number;
+}
+export interface SSOProvider {
+    id: string;
+    provider: 'OKTA' | 'AUTH0' | 'SAML';
+    domain: string;
+    active: boolean;
+    createdAt: string;
+    config?: any;
+}
+export interface SSOProviderListResponse {
+    ssoProviders: SSOProvider[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@foru-ms/sdk",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "scripts": {

package/src/Client.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';
 
 // Polyfill fetch if needed (e.g. older Node versions)
 const fetch = globalThis.fetch || require('cross-fetch');
@@ -17,6 +26,15 @@ export class ForumClient {
     public posts: PostsResource;
     public users: UsersResource;
     public tags: TagsResource;
+    public notifications: NotificationsResource;
+    public search: SearchResource;
+    public webhooks: WebhooksResource;
+    public stats: StatsResource;
+    public integrations: IntegrationsResource;
+    public privateMessages: PrivateMessagesResource;
+    public reports: ReportsResource;
+    public roles: RolesResource;
+    public sso: SSOResource;
 
     constructor(options: { apiKey: string; baseUrl?: string }) {
         this.apiKey = options.apiKey;
@@ -27,6 +45,15 @@ export class ForumClient {
         this.posts = new PostsResource(this);
         this.users = new UsersResource(this);
         this.tags = new TagsResource(this);
+        this.notifications = new NotificationsResource(this);
+        this.search = new SearchResource(this);
+        this.webhooks = new WebhooksResource(this);
+        this.stats = new StatsResource(this);
+        this.integrations = new IntegrationsResource(this);
+        this.privateMessages = new PrivateMessagesResource(this);
+        this.reports = new ReportsResource(this);
+        this.roles = new RolesResource(this);
+        this.sso = new SSOResource(this);
     }
 
     public async request<T>(path: string, options: RequestInit = {}): Promise<T> {

package/src/index.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/src/resources/Auth.ts

@@ -33,4 +33,32 @@ export class AuthResource {
             method: 'GET',
         });
     }
+
+    async forgotPassword(email: string): Promise<{ resetToken?: string; message?: string }> {
+        return this.client.request<{ resetToken?: string; message?: string }>('/auth/forgot-password', {
+            method: 'POST',
+            body: JSON.stringify({ email }),
+        });
+    }
+
+    async resetPassword(payload: {
+        password: string;
+        oldPassword?: string;
+        email?: string;
+        token?: string;
+    }): Promise<{ message: string }> {
+        const headers: Record<string, string> = {};
+        if (payload.token) {
+            headers['Authorization'] = `Bearer ${payload.token}`;
+        }
+
+        // Remove token from body
+        const { token, ...body } = payload;
+
+        return this.client.request<{ message: string }>('/auth/reset-password', {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+        });
+    }
 }

package/src/resources/Integrations.ts

@@ -0,0 +1,39 @@
+import { ForumClient } from '../Client';
+import { Integration, IntegrationListResponse } from '../types';
+
+export class IntegrationsResource {
+    private client: ForumClient;
+
+    constructor(client: ForumClient) {
+        this.client = client;
+    }
+
+    async list(): Promise<IntegrationListResponse> {
+        return this.client.request<IntegrationListResponse>('/integrations', {
+            method: 'GET',
+        });
+    }
+
+    async create(payload: {
+        type: 'SLACK' | 'DISCORD' | 'SALESFORCE' | 'HUBSPOT' | 'OKTA' | 'AUTH0';
+        name: string;
+        config: any;
+    }): Promise<{ integration: Integration }> {
+        return this.client.request<{ integration: Integration }>('/integrations', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async retrieve(id: string): Promise<{ integration: Integration }> {
+        return this.client.request<{ integration: Integration }>(`/integrations/${id}`, {
+            method: 'GET',
+        });
+    }
+
+    async delete(id: string): Promise<{ success: boolean }> {
+        return this.client.request<{ success: boolean }>(`/integrations/${id}`, {
+            method: 'DELETE',
+        });
+    }
+}

package/src/resources/Notifications.ts

@@ -0,0 +1,69 @@
+import { ForumClient } from '../Client';
+import { NotificationListResponse, Notification } from '../types';
+
+export class NotificationsResource {
+    private client: ForumClient;
+
+    constructor(client: ForumClient) {
+        this.client = client;
+    }
+
+    async list(params: {
+        userId: string;
+        read?: boolean;
+        filter?: 'newest' | 'oldest';
+        cursor?: string;
+    }): Promise<NotificationListResponse> {
+        const searchParams = new URLSearchParams();
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined) {
+                searchParams.append(key, String(value));
+            }
+        });
+
+        return this.client.request<NotificationListResponse>(`/notifications?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+
+    async markAllAsRead(userId: string, read: boolean = true): Promise<{ count: number }> {
+        return this.client.request<{ count: number }>('/notifications', {
+            method: 'PATCH',
+            body: JSON.stringify({ userId, read }),
+        });
+    }
+
+    async retrieve(id: string): Promise<Notification> {
+        return this.client.request<Notification>(`/notification/${id}`, {
+            method: 'GET',
+        });
+    }
+
+    async update(id: string, payload: { read: boolean }): Promise<Notification> {
+        return this.client.request<Notification>(`/notification/${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async delete(id: string): Promise<Notification & { deleted: boolean }> {
+        return this.client.request<Notification & { deleted: boolean }>(`/notification/${id}`, {
+            method: 'DELETE',
+        });
+    }
+    async create(payload: {
+        threadId?: string;
+        postId?: string;
+        privateMessageId?: string;
+        notifierId: string;
+        notifiedId: string;
+        type: string;
+        description?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<Notification> {
+        return this.client.request<Notification>('/notification', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+}

package/src/resources/Posts.ts

@@ -55,4 +55,71 @@ export class PostsResource {
             body: payload ? JSON.stringify(payload) : undefined,
         });
     }
+    async getChildren(id: string, params?: {
+        query?: string;
+        cursor?: string;
+        filter?: 'newest' | 'oldest';
+    }): Promise<any> {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value as string);
+                }
+            });
+        }
+        return this.client.request(`/post/${id}/posts?${searchParams.toString()}`, { method: 'GET' });
+    }
+
+    async like(id: string, userId?: string, extendedData?: any): Promise<any> {
+        return this.client.request(`/post/${id}/likes`, {
+            method: 'POST',
+            body: JSON.stringify({ userId, extendedData }),
+        });
+    }
+
+    async unlike(id: string, userId: string): Promise<any> {
+        return this.client.request(`/post/${id}/likes?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
+
+    async dislike(id: string, userId?: string, extendedData?: any): Promise<any> {
+        return this.client.request(`/post/${id}/dislikes`, {
+            method: 'POST',
+            body: JSON.stringify({ userId, extendedData }),
+        });
+    }
+
+    async undislike(id: string, userId: string): Promise<any> {
+        return this.client.request(`/post/${id}/dislikes?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
+
+    async upvote(id: string, userId?: string, extendedData?: any): Promise<any> {
+        return this.client.request(`/post/${id}/upvotes`, {
+            method: 'POST',
+            body: JSON.stringify({ userId, extendedData }),
+        });
+    }
+
+    async unupvote(id: string, userId: string): Promise<any> {
+        return this.client.request(`/post/${id}/upvotes?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
+
+    async downvote(id: string, userId?: string, extendedData?: any): Promise<any> {
+        return this.client.request(`/post/${id}/downvotes`, {
+            method: 'POST',
+            body: JSON.stringify({ userId, extendedData }),
+        });
+    }
+
+    async undownvote(id: string, userId: string): Promise<any> {
+        return this.client.request(`/post/${id}/downvotes?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
 }

package/src/resources/PrivateMessages.ts

@@ -0,0 +1,67 @@
+import { ForumClient } from '../Client';
+import { PrivateMessage, PrivateMessageListResponse } from '../types';
+
+export class PrivateMessagesResource {
+    private client: ForumClient;
+
+    constructor(client: ForumClient) {
+        this.client = client;
+    }
+
+    async list(params?: {
+        query?: string;
+        userId?: string;
+        filter?: 'newest' | 'oldest';
+        cursor?: string;
+    }): Promise<PrivateMessageListResponse> {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value as string);
+                }
+            });
+        }
+
+        return this.client.request<PrivateMessageListResponse>(`/private-messages?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+
+    async create(payload: {
+        title?: string;
+        body: string;
+        recipientId: string;
+        senderId?: string; // Optional if inferred from token
+        extendedData?: Record<string, any>;
+    }): Promise<PrivateMessage> {
+        return this.client.request<PrivateMessage>('/private-message', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async retrieve(id: string): Promise<PrivateMessage> {
+        return this.client.request<PrivateMessage>(`/private-message/${id}`, {
+            method: 'GET',
+        });
+    }
+
+    async reply(id: string, payload: {
+        body: string;
+        senderId: string;
+        recipientId: string;
+        extendedData?: Record<string, any>;
+    }): Promise<PrivateMessage> {
+        return this.client.request<PrivateMessage>(`/private-message/${id}`, {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async delete(id: string): Promise<PrivateMessage & { deleted: boolean }> {
+        return this.client.request<PrivateMessage & { deleted: boolean }>(`/private-message/${id}`, {
+            method: 'DELETE',
+        });
+    }
+}

package/src/resources/Reports.ts

@@ -0,0 +1,93 @@
+import { ForumClient } from '../Client';
+import { Report, ReportListResponse } from '../types';
+
+export class ReportsResource {
+    private client: ForumClient;
+
+    constructor(client: ForumClient) {
+        this.client = client;
+    }
+
+    async list(params?: {
+        reporterId?: string;
+        reportedId?: string;
+        read?: boolean;
+        cursor?: string;
+        filter?: 'newest' | 'oldest';
+    }): Promise<ReportListResponse> {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, String(value));
+                }
+            });
+        }
+
+        return this.client.request<ReportListResponse>(`/reports?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+
+    async create(payload: {
+        reporterId: string;
+        reportedId?: string;
+        threadId?: string;
+        postId?: string;
+        privateMessageId?: string;
+        type?: string;
+        description?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<Report> {
+        return this.client.request<Report>('/report', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async batchUpdate(payload: {
+        reportIds: string[];
+        read: boolean;
+    }): Promise<{ count?: number; message?: string }> {
+        return this.client.request<{ count?: number; message?: string }>('/reports', {
+            method: 'PATCH',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async retrieve(id: string): Promise<Report> {
+        return this.client.request<Report>(`/report/${id}`, {
+            method: 'GET',
+        });
+    }
+
+    async 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> {
+        return this.client.request<Report>(`/report/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async delete(id: string): Promise<Report & { deleted: boolean }> {
+        return this.client.request<Report & { deleted: boolean }>(`/report/${id}`, {
+            method: 'DELETE',
+        });
+    }
+
+    async updateStatus(id: string, read: boolean): Promise<Report> {
+        return this.client.request<Report>(`/report/${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify({ read }),
+        });
+    }
+}

package/src/resources/Roles.ts

@@ -0,0 +1,64 @@
+import { ForumClient } from '../Client';
+import { Role, RoleListResponse } from '../types';
+
+export class RolesResource {
+    private client: ForumClient;
+
+    constructor(client: ForumClient) {
+        this.client = client;
+    }
+
+    async list(params?: {
+        filter?: 'newest' | 'oldest';
+        cursor?: string;
+    }): Promise<RoleListResponse> {
+        const searchParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    searchParams.append(key, value as string);
+                }
+            });
+        }
+
+        return this.client.request<RoleListResponse>(`/roles?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+
+    async create(payload: {
+        name: string;
+        description?: string;
+        color?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<Role> {
+        return this.client.request<Role>('/role', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async retrieve(id: string): Promise<Role> {
+        return this.client.request<Role>(`/role/${id}`, {
+            method: 'GET',
+        });
+    }
+
+    async update(id: string, payload: {
+        name?: string;
+        description?: string;
+        color?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<Role> {
+        return this.client.request<Role>(`/role/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async delete(id: string): Promise<Role & { deleted: boolean }> {
+        return this.client.request<Role & { deleted: boolean }>(`/role/${id}`, {
+            method: 'DELETE',
+        });
+    }
+}

package/src/resources/SSO.ts

@@ -0,0 +1,33 @@
+import { ForumClient } from '../Client';
+import { SSOProvider, SSOProviderListResponse } from '../types';
+
+export class SSOResource {
+    private client: ForumClient;
+
+    constructor(client: ForumClient) {
+        this.client = client;
+    }
+
+    async list(): Promise<SSOProviderListResponse> {
+        return this.client.request<SSOProviderListResponse>('/sso', {
+            method: 'GET',
+        });
+    }
+
+    async create(payload: {
+        provider: 'OKTA' | 'AUTH0' | 'SAML';
+        domain: string;
+        config: any;
+    }): Promise<{ ssoProvider: SSOProvider }> {
+        return this.client.request<{ ssoProvider: SSOProvider }>('/sso', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async delete(id: string): Promise<{ success: boolean }> {
+        return this.client.request<{ success: boolean }>(`/sso/${id}`, {
+            method: 'DELETE',
+        });
+    }
+}