@hasna/connectors 0.0.1

package/connectors/connect-reddit/src/api/comments.ts

@@ -0,0 +1,268 @@
+import type { RedditClient } from './client';
+import type { RedditComment, SubmitCommentOptions, VoteDirection } from '../types';
+
+interface CommentResponse {
+  json: {
+    errors: string[][];
+    data?: {
+      things: {
+        kind: string;
+        data: Record<string, unknown>;
+      }[];
+    };
+  };
+}
+
+interface RedditListingResponse {
+  kind: string;
+  data: {
+    after: string | null;
+    before: string | null;
+    children: {
+      kind: string;
+      data: Record<string, unknown>;
+    }[];
+  };
+}
+
+/**
+ * Comments API - post, get, delete comments
+ */
+export class CommentsApi {
+  private readonly client: RedditClient;
+
+  constructor(client: RedditClient) {
+    this.client = client;
+  }
+
+  /**
+   * Submit a new comment
+   */
+  async submit(options: SubmitCommentOptions): Promise<RedditComment> {
+    const response = await this.client.request<CommentResponse>('/api/comment', {
+      method: 'POST',
+      body: {
+        thing_id: options.parentFullname,
+        text: options.text,
+        api_type: 'json',
+      },
+      isFormData: true,
+    });
+
+    if (response.json.errors && response.json.errors.length > 0) {
+      throw new Error(response.json.errors.map(e => e.join(': ')).join('; '));
+    }
+
+    if (!response.json.data?.things?.[0]) {
+      throw new Error('No comment data in response');
+    }
+
+    return this.parseComment(response.json.data.things[0].data);
+  }
+
+  /**
+   * Get comments for a post
+   */
+  async getForPost(
+    postId: string,
+    options: {
+      sort?: 'confidence' | 'top' | 'new' | 'controversial' | 'old' | 'random' | 'qa';
+      limit?: number;
+      depth?: number;
+    } = {}
+  ): Promise<RedditComment[]> {
+    const { sort = 'confidence', limit = 100, depth = 10 } = options;
+    const id = postId.replace(/^t3_/, '');
+
+    const response = await this.client.request<RedditListingResponse[]>(`/comments/${id}`, {
+      params: {
+        sort,
+        limit,
+        depth,
+        raw_json: 1,
+      },
+    });
+
+    // Comments are in the second listing
+    const commentsListing = response[1];
+    return this.parseCommentTree(commentsListing.data.children);
+  }
+
+  /**
+   * Get a specific comment by ID
+   */
+  async getComment(commentId: string, postId: string): Promise<RedditComment> {
+    const cid = commentId.replace(/^t1_/, '');
+    const pid = postId.replace(/^t3_/, '');
+
+    const response = await this.client.request<RedditListingResponse[]>(`/comments/${pid}`, {
+      params: {
+        comment: cid,
+        context: 0,
+        raw_json: 1,
+      },
+    });
+
+    const commentsListing = response[1];
+    if (commentsListing.data.children.length === 0) {
+      throw new Error('Comment not found');
+    }
+
+    return this.parseComment(commentsListing.data.children[0].data);
+  }
+
+  /**
+   * Edit a comment
+   */
+  async edit(commentFullname: string, text: string): Promise<void> {
+    const fullname = commentFullname.startsWith('t1_') ? commentFullname : `t1_${commentFullname}`;
+
+    await this.client.request('/api/editusertext', {
+      method: 'POST',
+      body: {
+        thing_id: fullname,
+        text,
+        api_type: 'json',
+      },
+      isFormData: true,
+    });
+  }
+
+  /**
+   * Delete a comment
+   */
+  async delete(commentFullname: string): Promise<void> {
+    const fullname = commentFullname.startsWith('t1_') ? commentFullname : `t1_${commentFullname}`;
+
+    await this.client.request('/api/del', {
+      method: 'POST',
+      body: { id: fullname },
+      isFormData: true,
+    });
+  }
+
+  /**
+   * Vote on a comment
+   */
+  async vote(commentFullname: string, direction: VoteDirection): Promise<void> {
+    const fullname = commentFullname.startsWith('t1_') ? commentFullname : `t1_${commentFullname}`;
+
+    await this.client.request('/api/vote', {
+      method: 'POST',
+      body: {
+        id: fullname,
+        dir: direction,
+      },
+      isFormData: true,
+    });
+  }
+
+  /**
+   * Upvote a comment
+   */
+  async upvote(commentFullname: string): Promise<void> {
+    return this.vote(commentFullname, 1);
+  }
+
+  /**
+   * Downvote a comment
+   */
+  async downvote(commentFullname: string): Promise<void> {
+    return this.vote(commentFullname, -1);
+  }
+
+  /**
+   * Remove vote from a comment
+   */
+  async unvote(commentFullname: string): Promise<void> {
+    return this.vote(commentFullname, 0);
+  }
+
+  /**
+   * Save a comment
+   */
+  async save(commentFullname: string): Promise<void> {
+    const fullname = commentFullname.startsWith('t1_') ? commentFullname : `t1_${commentFullname}`;
+
+    await this.client.request('/api/save', {
+      method: 'POST',
+      body: { id: fullname },
+      isFormData: true,
+    });
+  }
+
+  /**
+   * Unsave a comment
+   */
+  async unsave(commentFullname: string): Promise<void> {
+    const fullname = commentFullname.startsWith('t1_') ? commentFullname : `t1_${commentFullname}`;
+
+    await this.client.request('/api/unsave', {
+      method: 'POST',
+      body: { id: fullname },
+      isFormData: true,
+    });
+  }
+
+  /**
+   * Parse raw comment data to RedditComment
+   */
+  private parseComment(data: Record<string, unknown>, depth = 0): RedditComment {
+    return {
+      id: String(data.id),
+      name: String(data.name),
+      author: String(data.author),
+      body: String(data.body),
+      bodyHtml: data.body_html ? String(data.body_html) : undefined,
+      score: Number(data.score),
+      created: Number(data.created),
+      createdUtc: Number(data.created_utc),
+      parentId: String(data.parent_id),
+      linkId: String(data.link_id),
+      subreddit: String(data.subreddit),
+      isSubmitter: Boolean(data.is_submitter),
+      edited: data.edited === false ? false : Number(data.edited),
+      stickied: Boolean(data.stickied),
+      scoreHidden: Boolean(data.score_hidden),
+      depth,
+      likes: data.likes === null ? null : Boolean(data.likes),
+      replies: data.replies && typeof data.replies === 'object'
+        ? this.parseCommentReplies(data.replies as Record<string, unknown>, depth + 1)
+        : undefined,
+    };
+  }
+
+  /**
+   * Parse comment replies
+   */
+  private parseCommentReplies(
+    repliesData: Record<string, unknown>,
+    depth: number
+  ): RedditComment[] | undefined {
+    if (!repliesData || repliesData.kind !== 'Listing') {
+      return undefined;
+    }
+
+    const data = repliesData.data as {
+      children: { kind: string; data: Record<string, unknown> }[];
+    };
+
+    if (!data.children || data.children.length === 0) {
+      return undefined;
+    }
+
+    return this.parseCommentTree(data.children, depth);
+  }
+
+  /**
+   * Parse a tree of comments
+   */
+  private parseCommentTree(
+    children: { kind: string; data: Record<string, unknown> }[],
+    depth = 0
+  ): RedditComment[] {
+    return children
+      .filter(child => child.kind === 't1')
+      .map(child => this.parseComment(child.data, depth));
+  }
+}

package/connectors/connect-reddit/src/api/index.ts

@@ -0,0 +1,113 @@
+import type { RedditConfig } from '../types';
+import { RedditClient } from './client';
+import { PostsApi } from './posts';
+import { CommentsApi } from './comments';
+import { SubredditsApi } from './subreddits';
+import { UsersApi } from './users';
+import { SearchApi } from './search';
+
+/**
+ * Main Reddit Connector class
+ * Provides access to Posts, Comments, Subreddits, Users, and Search APIs
+ */
+export class Reddit {
+  private readonly client: RedditClient;
+
+  // Service APIs
+  public readonly posts: PostsApi;
+  public readonly comments: CommentsApi;
+  public readonly subreddits: SubredditsApi;
+  public readonly users: UsersApi;
+  public readonly search: SearchApi;
+
+  constructor(config: RedditConfig) {
+    this.client = new RedditClient(config);
+    this.posts = new PostsApi(this.client);
+    this.comments = new CommentsApi(this.client);
+    this.subreddits = new SubredditsApi(this.client);
+    this.users = new UsersApi(this.client);
+    this.search = new SearchApi(this.client);
+  }
+
+  /**
+   * Create a client from environment variables
+   * Looks for REDDIT_CLIENT_ID, REDDIT_CLIENT_SECRET, REDDIT_ACCESS_TOKEN, REDDIT_REFRESH_TOKEN
+   */
+  static fromEnv(): Reddit {
+    const clientId = process.env.REDDIT_CLIENT_ID;
+    const clientSecret = process.env.REDDIT_CLIENT_SECRET;
+    const accessToken = process.env.REDDIT_ACCESS_TOKEN;
+    const refreshToken = process.env.REDDIT_REFRESH_TOKEN;
+
+    if (!clientId) {
+      throw new Error('REDDIT_CLIENT_ID environment variable is required');
+    }
+    if (!clientSecret) {
+      throw new Error('REDDIT_CLIENT_SECRET environment variable is required');
+    }
+
+    return new Reddit({
+      clientId,
+      clientSecret,
+      accessToken,
+      refreshToken,
+    });
+  }
+
+  /**
+   * Get the underlying client for direct API access
+   */
+  getClient(): RedditClient {
+    return this.client;
+  }
+
+  /**
+   * Revoke the current access token
+   */
+  async logout(): Promise<void> {
+    return this.client.revokeToken();
+  }
+
+  /**
+   * Get the OAuth2 authorization URL for user authentication
+   */
+  static getAuthorizationUrl(
+    clientId: string,
+    redirectUri: string,
+    scope: string[],
+    state: string,
+    duration: 'temporary' | 'permanent' = 'permanent'
+  ): string {
+    return RedditClient.getAuthorizationUrl(clientId, redirectUri, scope, state, duration);
+  }
+
+  /**
+   * Exchange an authorization code for tokens
+   */
+  static async exchangeCode(
+    clientId: string,
+    clientSecret: string,
+    code: string,
+    redirectUri: string
+  ): Promise<{
+    accessToken: string;
+    refreshToken?: string;
+    expiresIn: number;
+    scope: string;
+  }> {
+    const response = await RedditClient.exchangeCode(clientId, clientSecret, code, redirectUri);
+    return {
+      accessToken: response.access_token,
+      refreshToken: response.refresh_token,
+      expiresIn: response.expires_in,
+      scope: response.scope,
+    };
+  }
+}
+
+export { RedditClient } from './client';
+export { PostsApi } from './posts';
+export { CommentsApi } from './comments';
+export { SubredditsApi } from './subreddits';
+export { UsersApi } from './users';
+export { SearchApi } from './search';

package/connectors/connect-reddit/src/api/posts.ts

@@ -0,0 +1,298 @@
+import type { RedditClient } from './client';
+import type {
+  RedditPost,
+  SubmitPostOptions,
+  SubmitPostResponse,
+  FeedOptions,
+  VoteDirection,
+} from '../types';
+
+interface RedditListingResponse {
+  kind: string;
+  data: {
+    after: string | null;
+    before: string | null;
+    children: {
+      kind: string;
+      data: Record<string, unknown>;
+    }[];
+    dist: number;
+  };
+}
+
+interface SubmitResponse {
+  json: {
+    errors: string[][];
+    data?: {
+      id: string;
+      name: string;
+      url: string;
+    };
+  };
+}
+
+/**
+ * Posts API - submit, get, delete posts
+ */
+export class PostsApi {
+  private readonly client: RedditClient;
+
+  constructor(client: RedditClient) {
+    this.client = client;
+  }
+
+  /**
+   * Get posts from a subreddit feed
+   */
+  async getFeed(
+    subreddit?: string,
+    options: FeedOptions = {}
+  ): Promise<{ posts: RedditPost[]; after?: string; before?: string }> {
+    const { sort = 'hot', time, limit = 25, after, before } = options;
+
+    const path = subreddit ? `/r/${subreddit}/${sort}` : `/${sort}`;
+
+    const response = await this.client.request<RedditListingResponse>(path, {
+      params: {
+        t: sort === 'top' || sort === 'controversial' ? time : undefined,
+        limit,
+        after,
+        before,
+        raw_json: 1,
+      },
+    });
+
+    const posts = response.data.children
+      .filter(child => child.kind === 't3')
+      .map(child => this.parsePost(child.data));
+
+    return {
+      posts,
+      after: response.data.after || undefined,
+      before: response.data.before || undefined,
+    };
+  }
+
+  /**
+   * Get a single post by ID
+   */
+  async getPost(postId: string): Promise<{ post: RedditPost; comments: unknown[] }> {
+    // Remove t3_ prefix if present
+    const id = postId.replace(/^t3_/, '');
+
+    const response = await this.client.request<RedditListingResponse[]>(`/comments/${id}`, {
+      params: {
+        raw_json: 1,
+      },
+    });
+
+    const postListing = response[0];
+    const postData = postListing.data.children[0];
+    const post = this.parsePost(postData.data);
+
+    // Comments are in the second listing
+    const commentsListing = response[1];
+    const comments = commentsListing.data.children;
+
+    return { post, comments };
+  }
+
+  /**
+   * Submit a new post
+   */
+  async submit(options: SubmitPostOptions): Promise<SubmitPostResponse> {
+    const body: Record<string, unknown> = {
+      sr: options.subreddit,
+      title: options.title,
+      kind: options.kind,
+      api_type: 'json',
+    };
+
+    if (options.kind === 'self' && options.text) {
+      body.text = options.text;
+    } else if (options.kind === 'link' && options.url) {
+      body.url = options.url;
+    }
+
+    if (options.nsfw) body.nsfw = true;
+    if (options.spoiler) body.spoiler = true;
+    if (options.flairId) body.flair_id = options.flairId;
+    if (options.flairText) body.flair_text = options.flairText;
+    if (options.sendReplies !== undefined) body.sendreplies = options.sendReplies;
+
+    const response = await this.client.request<SubmitResponse>('/api/submit', {
+      method: 'POST',
+      body,
+      isFormData: true,
+    });
+
+    if (response.json.errors && response.json.errors.length > 0) {
+      throw new Error(response.json.errors.map(e => e.join(': ')).join('; '));
+    }
+
+    if (!response.json.data) {
+      throw new Error('No data in submit response');
+    }
+
+    return {
+      id: response.json.data.id,
+      name: response.json.data.name,
+      url: response.json.data.url,
+    };
+  }
+
+  /**
+   * Delete a post
+   */
+  async delete(postFullname: string): Promise<void> {
+    // Ensure fullname format
+    const fullname = postFullname.startsWith('t3_') ? postFullname : `t3_${postFullname}`;
+
+    await this.client.request('/api/del', {
+      method: 'POST',
+      body: { id: fullname },
+      isFormData: true,
+    });
+  }
+
+  /**
+   * Edit a post's text
+   */
+  async edit(postFullname: string, text: string): Promise<void> {
+    const fullname = postFullname.startsWith('t3_') ? postFullname : `t3_${postFullname}`;
+
+    await this.client.request('/api/editusertext', {
+      method: 'POST',
+      body: {
+        thing_id: fullname,
+        text,
+        api_type: 'json',
+      },
+      isFormData: true,
+    });
+  }
+
+  /**
+   * Vote on a post
+   */
+  async vote(postFullname: string, direction: VoteDirection): Promise<void> {
+    const fullname = postFullname.startsWith('t3_') ? postFullname : `t3_${postFullname}`;
+
+    await this.client.request('/api/vote', {
+      method: 'POST',
+      body: {
+        id: fullname,
+        dir: direction,
+      },
+      isFormData: true,
+    });
+  }
+
+  /**
+   * Upvote a post
+   */
+  async upvote(postFullname: string): Promise<void> {
+    return this.vote(postFullname, 1);
+  }
+
+  /**
+   * Downvote a post
+   */
+  async downvote(postFullname: string): Promise<void> {
+    return this.vote(postFullname, -1);
+  }
+
+  /**
+   * Remove vote from a post
+   */
+  async unvote(postFullname: string): Promise<void> {
+    return this.vote(postFullname, 0);
+  }
+
+  /**
+   * Save a post
+   */
+  async save(postFullname: string): Promise<void> {
+    const fullname = postFullname.startsWith('t3_') ? postFullname : `t3_${postFullname}`;
+
+    await this.client.request('/api/save', {
+      method: 'POST',
+      body: { id: fullname },
+      isFormData: true,
+    });
+  }
+
+  /**
+   * Unsave a post
+   */
+  async unsave(postFullname: string): Promise<void> {
+    const fullname = postFullname.startsWith('t3_') ? postFullname : `t3_${postFullname}`;
+
+    await this.client.request('/api/unsave', {
+      method: 'POST',
+      body: { id: fullname },
+      isFormData: true,
+    });
+  }
+
+  /**
+   * Hide a post
+   */
+  async hide(postFullname: string): Promise<void> {
+    const fullname = postFullname.startsWith('t3_') ? postFullname : `t3_${postFullname}`;
+
+    await this.client.request('/api/hide', {
+      method: 'POST',
+      body: { id: fullname },
+      isFormData: true,
+    });
+  }
+
+  /**
+   * Unhide a post
+   */
+  async unhide(postFullname: string): Promise<void> {
+    const fullname = postFullname.startsWith('t3_') ? postFullname : `t3_${postFullname}`;
+
+    await this.client.request('/api/unhide', {
+      method: 'POST',
+      body: { id: fullname },
+      isFormData: true,
+    });
+  }
+
+  /**
+   * Parse raw post data to RedditPost
+   */
+  private parsePost(data: Record<string, unknown>): RedditPost {
+    return {
+      id: String(data.id),
+      name: String(data.name),
+      title: String(data.title),
+      author: String(data.author),
+      subreddit: String(data.subreddit),
+      subredditNamePrefixed: String(data.subreddit_name_prefixed),
+      selftext: data.selftext ? String(data.selftext) : undefined,
+      selftextHtml: data.selftext_html ? String(data.selftext_html) : undefined,
+      url: String(data.url),
+      permalink: `https://reddit.com${data.permalink}`,
+      thumbnail: data.thumbnail && data.thumbnail !== 'self' && data.thumbnail !== 'default'
+        ? String(data.thumbnail)
+        : undefined,
+      score: Number(data.score),
+      upvoteRatio: data.upvote_ratio ? Number(data.upvote_ratio) : undefined,
+      numComments: Number(data.num_comments),
+      created: Number(data.created),
+      createdUtc: Number(data.created_utc),
+      isNsfw: Boolean(data.over_18),
+      isSpoiler: Boolean(data.spoiler),
+      isStickied: Boolean(data.stickied),
+      isLocked: Boolean(data.locked),
+      isSelf: Boolean(data.is_self),
+      isVideo: Boolean(data.is_video),
+      domain: String(data.domain),
+      flair: data.link_flair_text ? String(data.link_flair_text) : undefined,
+      likes: data.likes === null ? null : Boolean(data.likes),
+    };
+  }
+}