@foru-ms/sdk 0.1.0 → 1.1.0

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',
+        });
+    }
+}

package/src/resources/Search.ts

@@ -0,0 +1,27 @@
+import { ForumClient } from '../Client';
+import { SearchResponse } from '../types';
+
+export class SearchResource {
+    private client: ForumClient;
+
+    constructor(client: ForumClient) {
+        this.client = client;
+    }
+
+    async search(params: {
+        query: string;
+        type: 'threads' | 'posts' | 'users' | 'tags';
+        cursor?: string;
+    }): Promise<SearchResponse> {
+        const searchParams = new URLSearchParams();
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined) {
+                searchParams.append(key, value as string);
+            }
+        });
+
+        return this.client.request<SearchResponse>(`/search?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+}

package/src/resources/Stats.ts

@@ -0,0 +1,31 @@
+import { ForumClient } from '../Client';
+import { StatsResponse } from '../types';
+
+export class StatsResource {
+    private client: ForumClient;
+
+    constructor(client: ForumClient) {
+        this.client = client;
+    }
+
+    async get(params?: {
+        filter?: 'newest' | 'oldest';
+        threadCursor?: string;
+        postCursor?: string;
+        userCursor?: string;
+        reportCursor?: string;
+    }): Promise<StatsResponse> {
+        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<StatsResponse>(`/stats?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+}

package/src/resources/Tags.ts

@@ -25,4 +25,72 @@ export class TagsResource {
             method: 'GET',
         });
     }
+    async create(payload: {
+        name: string;
+        description?: string;
+        color?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<import('../types').Tag> {
+        return this.client.request<import('../types').Tag>('/tag', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async retrieve(id: string, params?: { userId?: string }): Promise<import('../types').Tag & { isSubscribed?: boolean }> {
+        const searchParams = new URLSearchParams();
+        if (params?.userId) searchParams.append('userId', params.userId);
+
+        return this.client.request<import('../types').Tag & { isSubscribed?: boolean }>(`/tag/${id}?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+
+    async update(id: string, payload: {
+        name?: string;
+        description?: string;
+        color?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<import('../types').Tag> {
+        return this.client.request<import('../types').Tag>(`/tag/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async delete(id: string): Promise<import('../types').Tag & { deleted: boolean }> {
+        return this.client.request<import('../types').Tag & { deleted: boolean }>(`/tag/${id}`, {
+            method: 'DELETE',
+        });
+    }
+
+    async subscribe(id: string, userId: string): Promise<any> {
+        return this.client.request(`/tag/${id}/subscribers`, {
+            method: 'POST',
+            body: JSON.stringify({ userId }),
+        });
+    }
+
+    async unsubscribe(id: string, userId: string): Promise<any> {
+        return this.client.request(`/tag/${id}/subscribers?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
+
+    async listSubscribed(params: {
+        userId: string;
+        query?: string;
+        cursor?: string;
+    }): Promise<TagListResponse> {
+        const searchParams = new URLSearchParams();
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined) {
+                searchParams.append(key, value as string);
+            }
+        });
+
+        return this.client.request<TagListResponse>(`/tags/subscribed?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
 }

package/src/resources/Threads.ts

@@ -56,4 +56,78 @@ export class ThreadsResource {
             body: payload ? JSON.stringify(payload) : undefined,
         });
     }
+    async getPosts(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(`/thread/${id}/posts?${searchParams.toString()}`, { method: 'GET' });
+    }
+
+    async like(id: string, userId?: string, extendedData?: any): Promise<any> {
+        return this.client.request(`/thread/${id}/likes`, {
+            method: 'POST',
+            body: JSON.stringify({ userId, extendedData }),
+        });
+    }
+
+    async unlike(id: string, userId: string): Promise<any> {
+        return this.client.request(`/thread/${id}/likes?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
+
+    async dislike(id: string, userId?: string, extendedData?: any): Promise<any> {
+        return this.client.request(`/thread/${id}/dislikes`, {
+            method: 'POST',
+            body: JSON.stringify({ userId, extendedData }),
+        });
+    }
+
+    async undislike(id: string, userId: string): Promise<any> {
+        return this.client.request(`/thread/${id}/dislikes?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
+
+    async subscribe(id: string, userId: string, extendedData?: any): Promise<any> {
+        return this.client.request(`/thread/${id}/subscribers`, {
+            method: 'POST',
+            body: JSON.stringify({ userId, extendedData }),
+        });
+    }
+
+    async unsubscribe(id: string, userId: string): Promise<any> {
+        return this.client.request(`/thread/${id}/subscribers?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
+
+    async vote(id: string, optionId: string, userId: string): Promise<any> {
+        return this.client.request(`/thread/${id}/poll/votes`, {
+            method: 'POST',
+            body: JSON.stringify({ optionId, userId }),
+        });
+    }
+
+    async voteUpdate(id: string, optionId: string, userId: string): Promise<any> {
+        return this.client.request(`/thread/${id}/poll/votes`, {
+            method: 'PUT',
+            body: JSON.stringify({ optionId, userId }),
+        });
+    }
+
+    async unvote(id: string, userId: string): Promise<any> {
+        return this.client.request(`/thread/${id}/poll/votes?userId=${userId}`, {
+            method: 'DELETE',
+        });
+    }
 }

package/src/resources/Users.ts

@@ -32,4 +32,95 @@ export class UsersResource {
             method: 'GET',
         });
     }
+
+    async create(payload: {
+        username: string;
+        email: string;
+        password: string;
+        displayName?: string;
+        emailVerified?: boolean;
+        roles?: string[];
+        bio?: string;
+        signature?: string;
+        url?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<User> {
+        return this.client.request<User>('/user', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async update(id: string, payload: {
+        username?: string;
+        email?: string;
+        password?: string;
+        displayName?: string;
+        emailVerified?: boolean;
+        roles?: string[];
+        bio?: string;
+        signature?: string;
+        url?: string;
+        extendedData?: Record<string, any>;
+    }): Promise<User> {
+        return this.client.request<User>(`/user/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async delete(id: string): Promise<User & { deleted: boolean }> {
+        return this.client.request<User & { deleted: boolean }>(`/user/${id}`, {
+            method: 'DELETE',
+        });
+    }
+
+    async getFollowers(id: string, params?: {
+        query?: string;
+        cursor?: string;
+        filter?: 'newest' | 'oldest';
+    }): Promise<{ followers: User[]; nextUserCursor?: string; count: number }> {
+        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<{ followers: User[]; nextUserCursor?: string; count: number }>(`/user/${id}/followers?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+
+    async follow(id: string, followerId: string, extendedData?: any): Promise<any> {
+        return this.client.request(`/user/${id}/followers`, {
+            method: 'POST',
+            body: JSON.stringify({ followerId, extendedData }),
+        });
+    }
+
+    async unfollow(id: string, followerId: string): Promise<any> {
+        return this.client.request(`/user/${id}/followers?followerId=${followerId}`, {
+            method: 'DELETE',
+        });
+    }
+
+    async getFollowing(id: string, params?: {
+        query?: string;
+        cursor?: string;
+        filter?: 'newest' | 'oldest';
+    }): Promise<{ following: any[]; nextUserCursor?: string; count: number }> {
+        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<{ following: any[]; nextUserCursor?: string; count: number }>(`/user/${id}/following?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
 }

package/src/resources/Webhooks.ts

@@ -0,0 +1,60 @@
+import { ForumClient } from '../Client';
+import { Webhook, WebhookListResponse } from '../types';
+
+export class WebhooksResource {
+    private client: ForumClient;
+
+    constructor(client: ForumClient) {
+        this.client = client;
+    }
+
+    async list(): Promise<WebhookListResponse> {
+        return this.client.request<WebhookListResponse>('/webhooks', {
+            method: 'GET',
+        });
+    }
+
+    async create(payload: {
+        name: string;
+        url: string;
+        events: string[];
+    }): Promise<{ webhook: Webhook }> {
+        return this.client.request<{ webhook: Webhook }>('/webhooks', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async retrieve(id: string): Promise<{ webhook: Webhook }> {
+        return this.client.request<{ webhook: Webhook }>(`/webhooks/${id}`, {
+            method: 'GET',
+        });
+    }
+
+    async update(id: string, payload: {
+        name?: string;
+        url?: string;
+        events?: string[];
+        active?: boolean;
+    }): Promise<{ webhook: Webhook }> {
+        return this.client.request<{ webhook: Webhook }>(`/webhooks/${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify(payload),
+        });
+    }
+
+    async delete(id: string): Promise<{ success: boolean }> {
+        return this.client.request<{ success: boolean }>(`/webhooks/${id}`, {
+            method: 'DELETE',
+        });
+    }
+
+    async getDeliveries(id: string, params?: { cursor?: string }): Promise<{ deliveries: any[]; total: number; nextCursor?: string }> {
+        const searchParams = new URLSearchParams();
+        if (params?.cursor) searchParams.append('cursor', params.cursor);
+
+        return this.client.request<{ deliveries: any[]; total: number; nextCursor?: string }>(`/webhooks/${id}/deliveries?${searchParams.toString()}`, {
+            method: 'GET',
+        });
+    }
+}

package/src/types.ts

@@ -153,4 +153,169 @@ 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; // Computed field from API
+    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[]; // Accessing normalized events is better
+    active: boolean;
+    secret?: string; // Only on creation
+    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[];
+}
+
+