threads-api 0.0.1.pre → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ddb297052b28cab7f6a56c010ede66c4a1ef818a8d0862da7fb365856f482b0
-  data.tar.gz: ed7000a484974ebb0dc2d66b87db2c59538f50f20616a54f64882f32c52523d5
+  metadata.gz: 7bc7d9996e4a119f65407f455788ff761710855ceb5e8d01eae7853a0d5c8022
+  data.tar.gz: d13d7280d9f19a53cc3acca6d58bb7871e5f1faa5e93767adfb4e3a2f8a9a83c
 SHA512:
-  metadata.gz: d4f1504a2956ab19bd2133fc780cb6f679c0a2ec7ddc3c58ba75e2af99f3f0cf5899067f2909b58f1483cb4d55a8d094b089e5a1347140b6275518efdf0e575c
-  data.tar.gz: 5e45860b0c861e477d5812fede1bdc4d1a0619cc30a0563442c6bd83001f73c7b29425f43665e8777f7439ffbb600fea6574a3893c54631a22050cdccd3cd81f
+  metadata.gz: a51396bdc11e60e5a853a1a04bbce0cf35ba3b4a1685ce81da34a8e230c1b5f647dd4f27dc2bf0985e835d6ff75db9c68c926c73d46c197feef55096b1555672
+  data.tar.gz: 580e44a8a236e33b4489e55db83b58d04d5a2450639bda7960c24ee55ef9db5fdfdab1f60352af504b215cae499c688cdb80e45c6dfc829b8c83a073ed8df7fa

data/README.md

@@ -49,7 +49,116 @@ access_token = response.access_token
 expires_at = Time.now + response.expires_in
 ```
 
-Once you have a valid access token, whether it's short-lived or long-lived, you can use it to make requests to the Threads API.
+Once you have a valid access token, whether it's short-lived or long-lived, you can use it to make requests to the Threads API using a `Threads::API::Client`:
+
+```ruby
+client = Threads::API::Client.new(access_token)
+```
+
+## Reading Threads
+
+To read threads for a user:
+
+```ruby
+# List recent threads for a user.
+response = client.list_threads # Defaults to the authenticated user
+response = client.list_threads(user_id: "7770386109746442")
+
+# By default, the Threads API returns 25 threads at a time. You can paginate through them like so:
+next_page = client.list_threads(after: response.after_cursor) # or
+previous_page = client.list_threads(before: response.before_cursor)
+
+# Get a specific thread by ID.
+thread = client.get_thread("18050206876707110") # Defaults to the authenticated user
+thread = client.get_thread("18050206876707110", user_id: "7770386109746442")
+```
+
+`Threads::API::Client#list_threads` accepts the following options:
+
+* `user_id` - The ID of the user whose threads you want to read. Defaults to `"me"`, the authenticated user.
+* `fields` - An Array (or comma-separated String) of fields to include in the response. By default, only `id` is requested. See the [Threads API documentation](https://developers.facebook.com/docs/threads/threads-media#fields) for a list of available fields.
+* `since` - An ISO 8601 date string. Only threads published after this date will be returned.
+* `until` - An ISO 8601 date string. Only threads published before this date will be returned.
+* `before` - A cursor string returned by a previous request for pagination.
+* `after` - A cursor string returned by a previous request for pagination.
+* `limit` - The number of threads to return. Defaults to `25`, with a maximum of `100`.
+
+`Threads::API::Client#get_thread` accepts only the `user_id` and `fields` options.
+
+## Posting to Threads
+
+Posting to Threads is, at the very least, a two-step process. Threads requires that you first create a container for the media you want to post, then explicitly publishing that container as a thread. However, more steps are involved if you want to post multiple media items in a single thread.
+
+### Creating the Thread
+
+The first step in posting to Threads is to create a "media container", even if your post is text-only.
+
+```ruby
+# Create a text-only post
+client.create_thread(text: "Hello, world!")
+
+# Create a post with a photo or video
+client.create_thread(type: "IMAGE", image_url: "https://example.com/image.jpg", text: "Some optional text")
+client.create_thread(type: "VIDEO", video_url: "https://example.com/video.mp4", text: "Some optional text")
+
+# Reply to one of your own threads
+client.create_thread(text: "Hello, world!", reply_to_id: "18050206876707110")
+
+# Control who can reply to your thread. Defaults to "everyone".
+client.create_thread(text: "Hello, world!", reply_control: "accounts_you_follow") # or "mentioned_only"
+```
+
+### Publishing the Thread
+
+Once you've created a media container, you can publish it as a thread:
+
+```ruby
+pending_thread = client.create_thread(text: "Hello, world!")
+client.publish_thread(pending_thread.id)
+```
+
+According to Meta, you may need to wait before attempting to publish a thread, especially if the thread contains images or videos. They suggest checking the status of the pending thread before attempting to publish it:
+
+```ruby
+pending_thread = client.create_thread(text: "Hello, world!")
+pending_thread = client.get_thread_status(pending_thread.id)
+
+while pending_thread.in_progress?
+  # Wait a bit (they recommend checking only once per minute) and try again
+  sleep 60
+  pending_thread = client.get_thread_status(pending_thread.id)
+end
+
+if pending_thread.finished?
+  client.publish_thread(pending_thread.id)
+elsif pending_thread.errored?
+  # Handle the error
+else
+  # Unpublished threads expire after 24 hours.
+  pending_thread.expired?
+
+  # If you've already published the thread, the status will be "PUBLISHED".
+  pending_thread.published?
+end
+```
+
+### Posting multiple photos and/or videos
+
+Threads allows you to post a combination of up to 10 photos and/or videos in a single thread. To do so, you must first create a media container for each photo or video you want to post, then create a media container for the thread itself, and finally publish the thread.
+
+```ruby
+# Create carousel items for each photo or video you want to post
+image1 = client.create_carousel_item(type: "IMAGE", image_url: "https://example.com/image1.jpg")
+image2 = client.create_carousel_item(type: "IMAGE", image_url: "https://example.com/image2.jpg")
+video1 = client.create_carousel_item(type: "VIDEO", video_url: "https://example.com/video1.mp4")
+video2 = client.create_carousel_item(type: "VIDEO", video_url: "https://example.com/video2.mp4")
+
+# Create the media container for the thread itself
+pending_thread = client.create_carousel_thread(text: "Some optional text", children: [image1.id, image2.id, video1.id, video2.id])
+
+# Publish the thread
+client.publish_thread(pending_thread.id)
+```
 
 ## Contributing
 

data/lib/threads/api/client.rb

@@ -0,0 +1,108 @@
+require_relative "thread"
+
+module Threads
+  module API
+    class Client
+      def initialize(access_token)
+        @access_token = access_token
+      end
+
+      def list_threads(user_id: "me", **options)
+        params = options.slice(:since, :until, :before, :after, :limit).compact
+        params[:access_token] = @access_token
+
+        fields = Array(options[:fields]).join(",")
+        params[:fields] = fields unless fields.empty?
+
+        response = connection.get("#{user_id}/threads", params)
+
+        Threads::API::Thread::List.new(response.body)
+      end
+
+      def get_thread(thread_id, fields: nil)
+        params = {access_token: @access_token}
+        params[:fields] = Array(fields).join(",") if fields
+
+        response = connection.get(thread_id, params)
+
+        Threads::API::Thread.new(response.body)
+      end
+
+      def create_thread(type: "TEXT", text: nil, image_url: nil, video_url: nil, reply_to_id: nil, reply_control: nil)
+        params = {access_token: @access_token, media_type: type, text: text}
+        params[:reply_to_id] = reply_to_id if reply_to_id
+        params[:reply_control] = reply_control if reply_control
+
+        case type
+        when "IMAGE"
+          params[:image_url] = image_url || raise(ArgumentError, "The `:image_url` option is required when the post's type is \"IMAGE\"")
+        when "VIDEO"
+          params[:video_url] = video_url || raise(ArgumentError, "The `:video_url` option is required when the post's type is \"VIDEO\"")
+        when "TEXT"
+          raise ArgumentError, "The `:text` option is required when the post's type is \"TEXT\"" if text.nil? || text.empty?
+        else
+          raise ArgumentError, "Invalid post type: #{type}. Must be one of: \"TEXT\", \"IMAGE\", or \"VIDEO\""
+        end
+
+        response = connection.post("me/threads", params)
+
+        Threads::API::UnpublishedThread.new(response.body)
+      end
+
+      def get_thread_status(thread_id)
+        response = connection.get(thread_id, {
+          access_token: @access_token,
+          fields: "id,status,error_message"
+        })
+
+        Threads::API::ThreadStatus.new(response.body)
+      end
+
+      def create_carousel_item(type:, image_url: nil, video_url: nil)
+        params = {access_token: @access_token, media_type: type, is_carousel_item: true}
+
+        case type
+        when "IMAGE"
+          params[:image_url] = image_url || raise(ArgumentError, "The `:image_url` option is required when the item's type is \"IMAGE\"")
+        when "VIDEO"
+          params[:video_url] = video_url || raise(ArgumentError, "The `:video_url` option is required when the item's type is \"VIDEO\"")
+        else
+          raise ArgumentError, "Invalid item type: #{type}. Must be \"IMAGE\" or \"VIDEO\""
+        end
+
+        response = connection.post("me/threads", params)
+
+        Threads::API::UnpublishedThread.new(response.body)
+      end
+
+      def create_carousel_thread(children:, text: nil)
+        params = {access_token: @access_token, media_type: "CAROUSEL", text: text}
+        params[:children] = Array(children).join(",")
+
+        raise ArgumentError, "At least one item must be present in the `:children` option" if params[:children].empty?
+
+        response = connection.post("me/threads", params)
+
+        Threads::API::UnpublishedThread.new(response.body)
+      end
+
+      def publish_thread(id)
+        response = connection.post("me/threads_publish", {access_token: @access_token, creation_id: id})
+
+        Threads::API::ThreadStatus.new(response.body)
+      end
+      alias_method :publish_carousel, :publish_thread
+
+      private
+
+      def connection
+        @connection ||= Faraday.new(url: "https://graph.threads.net/v1.0/") do |f|
+          f.request :url_encoded
+
+          f.response :json
+          f.response :raise_error
+        end
+      end
+    end
+  end
+end

data/lib/threads/api/oauth2/client.rb

@@ -2,7 +2,7 @@ module Threads
   module API
     module OAuth2
       class Client
-        ShortLivedResponse = Struct.new(:access_token, :user_id)
+        ShortLivedResponse = Struct.new(:access_token, :user_id, :error_type, :error_message, :code)
         LongLivedResponse = Struct.new(:access_token, :token_type, :expires_in)
 
         def initialize(client_id:, client_secret:)
@@ -19,7 +19,7 @@ module Threads
             redirect_uri: redirect_uri
           })
 
-          ShortLivedResponse.new(*response.body.values_at("access_token", "user_id"))
+          ShortLivedResponse.new(*response.body.values_at("access_token", "user_id", "error_type", "error_message", "code"))
         end
 
         def exchange_access_token(access_token)

data/lib/threads/api/thread.rb

@@ -0,0 +1,82 @@
+require "time"
+
+module Threads
+  module API
+    class Thread
+      class List
+        attr_reader :threads, :before, :after
+
+        def initialize(json)
+          @threads = json["data"].map { |t| Threads::API::Thread.new(t) }
+
+          @before = json.dig("paging", "cursors", "before")
+          @after = json.dig("paging", "cursors", "after")
+        end
+      end
+
+      attr_reader :id, :type, :media_url, :permalink, :user_id, :username, :text, :timestamp, :created_at, :shortcode, :video_thumbnail_url, :children
+
+      def initialize(json)
+        @id = json["id"]
+        @type = json["media_type"]
+        @permalink = json["permalink"]
+        @shortcode = json["shortcode"]
+        @text = json["text"]
+        @media_url = json["media_url"]
+        @video_thumbnail_url = json["thumbnail_url"]
+        @user_id = json.dig("owner", "id")
+        @username = json["username"]
+        @is_quote_post = json["is_quote_post"]
+
+        @timestamp = json["timestamp"]
+        @created_at = Time.iso8601(@timestamp) if @timestamp
+
+        children = Array(json["children"])
+        @children = children.map { |c| Thread.new(c) } if children.any?
+      end
+
+      def quote_post?
+        @is_quote_post
+      end
+    end
+
+    class UnpublishedThread
+      attr_reader :id
+
+      def initialize(json)
+        @id = json["id"]
+      end
+    end
+
+    class ThreadStatus < UnpublishedThread
+      attr_reader :status, :error_message
+
+      def initialize(json)
+        super
+
+        @status = json["status"]
+        @error_message = json["error_message"]
+      end
+
+      def in_progress?
+        @status == "IN_PROGRESS"
+      end
+
+      def finished?
+        @status == "FINISHED"
+      end
+
+      def published?
+        @status == "PUBLISHED"
+      end
+
+      def errored?
+        @status == "ERROR"
+      end
+
+      def expired?
+        @status == "EXPIRED"
+      end
+    end
+  end
+end

data/lib/threads/api/version.rb

@@ -2,6 +2,6 @@
 
 module Threads
   module API
-    VERSION = "0.0.1.pre"
+    VERSION = "0.1.0"
   end
 end

data/lib/threads/api.rb

@@ -2,5 +2,6 @@
 
 require "faraday"
 
+require_relative "api/client"
 require_relative "api/oauth2/client"
 require_relative "api/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: threads-api
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre
+  version: 0.1.0
 platform: ruby
 authors:
 - David Celis
@@ -37,7 +37,9 @@ files:
 - README.md
 - Rakefile
 - lib/threads/api.rb
+- lib/threads/api/client.rb
 - lib/threads/api/oauth2/client.rb
+- lib/threads/api/thread.rb
 - lib/threads/api/version.rb
 homepage: https://github.com/davidcelis/threads-api
 licenses: