bskyrb 0.4 → 0.5.1

data/lib/bskyrb/records.rb

@@ -0,0 +1,190 @@
+# typed: true
+module Bskyrb
+  class RecordManager
+    include RequestUtils
+    attr_reader :session
+
+    def initialize(session)
+      @session = session
+    end
+
+    def get_post_by_url(url, depth = 10)
+      # e.g. "https://staging.bsky.app/profile/naia.bsky.social/post/3jszsrnruws27"
+      # or "at://did:plc:scx5mrfxxrqlfzkjcpbt3xfr/app.bsky.feed.post/3jszsrnruws27"
+      # regex by chatgpt:
+      query = Bskyrb::AppBskyFeedGetpostthread::GetPostThread::Input.new.tap do |q|
+        q.uri = at_post_link(session.pds, url)
+        q.depth = depth
+      end
+      res = HTTParty.get(
+        get_post_thread_uri(session.pds, query),
+        headers: default_authenticated_headers(session),
+      )
+      Bskyrb::AppBskyFeedDefs::PostView.from_hash res["thread"]["post"]
+    end
+
+    def upload_blob(blob_path, content_type)
+      # only images?
+      image_bytes = File.binread(blob_path)
+      HTTParty.post(
+        upload_blob_uri(session.pds),
+        body: image_bytes,
+        headers: default_authenticated_headers(session),
+      )
+    end
+
+    def create_record(input)
+      unless input.is_a?(Hash) || input.class.name.include?("Input")
+        raise "`create_record` takes an Input class or a hash"
+      end
+      HTTParty.post(
+        create_record_uri(session.pds),
+        body: input.to_h.compact.to_json,
+        headers: default_authenticated_headers(session),
+      )
+    end
+
+    def delete_record(collection, rkey)
+      data = { collection: collection, repo: session.did, rkey: rkey }
+      HTTParty.post(
+        delete_record_uri(session),
+        body: data.to_json,
+        headers: default_authenticated_headers(session),
+      )
+    end
+
+    def create_post(text)
+      input = Bskyrb::ComAtprotoRepoCreaterecord::CreateRecord::Input.from_hash({
+        "collection" => "app.bsky.feed.post",
+        "$type" => "app.bsky.feed.post",
+        "repo" => session.did,
+        "record" => {
+          "$type" => "app.bsky.feed.post",
+          "createdAt" => DateTime.now.iso8601(3),
+          "text" => text,
+        },
+      })
+      create_record(input)
+    end
+
+    def create_reply(replylink, text)
+      reply_to = get_post_by_url(replylink)
+      input = Bskyrb::ComAtprotoRepoCreaterecord::CreateRecord::Input.from_hash({
+        "collection" => "app.bsky.feed.post",
+        "$type" => "app.bsky.feed.post",
+        "repo" => session.did,
+
+        "record" => {
+          "reply" => {
+            "parent" => {
+              "uri" => reply_to.uri,
+              "cid" => reply_to.cid,
+            },
+            "root" => {
+              "uri" => reply_to.uri,
+              "cid" => reply_to.cid,
+            },
+          },
+          "$type" => "app.bsky.feed.post",
+          "createdAt" => DateTime.now.iso8601(3),
+          "text" => text,
+        },
+      })
+      create_record(input)
+    end
+
+    def profile_action(username, type)
+      input = Bskyrb::ComAtprotoRepoCreaterecord::CreateRecord::Input.from_hash({
+        "collection" => type,
+        "repo" => session.did,
+        "record" => {
+          "subject" => resolve_handle(session.pds, username)["did"],
+          "createdAt" => DateTime.now.iso8601(3),
+          "$type" => type,
+        },
+      })
+      create_record(input)
+    end
+
+    def post_action(post, action_type)
+      data = {
+        collection: action_type,
+        repo: session.did,
+        record: {
+          subject: {
+            uri: post.uri,
+            cid: post.cid,
+          },
+          createdAt: DateTime.now.iso8601(3),
+          "$type": action_type,
+        },
+      }
+      create_record(data)
+    end
+
+    def like(post_url)
+      post = get_post_by_url(post_url)
+      post_action(post, "app.bsky.feed.like")
+    end
+
+    def repost(post_url)
+      post = get_post_by_url(post_url)
+      post_action(post, "app.bsky.feed.repost")
+    end
+
+    def follow(username)
+      profile_action(username, "app.bsky.graph.follow")
+    end
+
+    def block(username)
+      profile_action(username, "app.bsky.graph.block")
+    end
+
+    def get_latest_post(username)
+      feed = get_latest_n_posts(username, 1)
+      feed.feed.first
+    end
+
+    def get_latest_n_posts(username, n)
+      query = Bskyrb::AppBskyFeedGetauthorfeed::GetAuthorFeed::Input.new.tap do |q|
+        q.actor = username
+        q.limit = n
+      end
+      hydrate_feed HTTParty.get(
+        get_author_feed_uri(session.pds, query),
+        headers: default_authenticated_headers(session),
+      ), Bskyrb::AppBskyFeedGetauthorfeed::GetAuthorFeed::Output
+    end
+
+    def get_skyline(n)
+      query = Bskyrb::AppBskyFeedGettimeline::GetTimeline::Input.new.tap do |q|
+        q.limit = n
+      end
+      hydrate_feed HTTParty.get(
+        get_timeline_uri(session.pds, query),
+        headers: default_authenticated_headers(session),
+      ), Bskyrb::AppBskyFeedGettimeline::GetTimeline::Output
+    end
+
+    def get_popular(n)
+      query = Bskyrb::AppBskyUnspeccedGetpopular::GetPopular::Input.new.tap do |q|
+        q.limit = n
+      end
+      hydrate_feed HTTParty.get(
+        get_popular_uri(session.pds, query),
+        headers: default_authenticated_headers(session),
+      ), Bskyrb::AppBskyUnspeccedGetpopular::GetPopular::Output
+    end
+
+    def hydrate_feed(response_hash, klass)
+      klass.from_hash(response_hash).tap do |feed|
+        feed.feed = response_hash["feed"].map do |h|
+          Bskyrb::AppBskyFeedDefs::FeedViewPost.from_hash(h).tap do |obj|
+            obj.post = Bskyrb::AppBskyFeedDefs::PostView.from_hash h["post"]
+            obj.reply = Bskyrb::AppBskyFeedDefs::ReplyRef.from_hash h["reply"] if h["reply"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bskyrb/session.rb

@@ -0,0 +1,126 @@
+# typed: false
+require "uri"
+require "httparty"
+
+module Bskyrb
+  module RequestUtils
+    def resolve_handle(pds, username)
+      resolveHandle = XRPC::Endpoint.new(pds, "com.atproto.identity.resolveHandle", :handle)
+      resolveHandle.get(handle: username)
+    end
+
+    def query_obj_to_query_params(q)
+      out = "?"
+      q.to_h.each do |key, value|
+        out += "#{key}=#{value}&" unless value.nil? || (value.class.method_defined?(:empty?) && value.empty?)
+      end
+      out.slice(0...-1)
+    end
+
+    def default_headers
+      { "Content-Type" => "application/json" }
+    end
+
+    def create_record_uri(pds)
+      "#{pds}/xrpc/com.atproto.repo.createRecord"
+    end
+
+    def delete_record_uri(pds)
+      "#{pds}/xrpc/com.atproto.repo.deleteRecord"
+    end
+
+    def upload_blob_uri(pds)
+      "#{pds}/xrpc/com.atproto.repo.uploadBlob"
+    end
+
+    def get_post_thread_uri(pds, query)
+      "#{pds}/xrpc/app.bsky.feed.getPostThread#{query_obj_to_query_params(query)}"
+    end
+
+    def get_author_feed_uri(pds, query)
+      "#{pds}/xrpc/app.bsky.feed.getAuthorFeed#{query_obj_to_query_params(query)}"
+    end
+
+    def get_timeline_uri(pds, query)
+      "#{pds}/xrpc/app.bsky.feed.getTimeline#{query_obj_to_query_params(query)}"
+    end
+
+    def get_popular_uri(pds, query)
+      "#{pds}/xrpc/app.bsky.unspecced.getPopular#{query_obj_to_query_params(query)}"
+    end
+
+    def default_authenticated_headers(session)
+      default_headers.merge({
+        Authorization: "Bearer #{session.access_token}",
+      })
+    end
+
+    def at_post_link(pds, url)
+      url = url.to_s
+
+      # Check if the URL is already in AT format
+      if url.start_with?("at://")
+        # Validate the username and post ID in the URL
+        parts = url.split("/")
+        if parts.length == 5 && parts[3] == "app.bsky.feed.post"
+          username = parts[2]
+          post_id = parts[4]
+          if post_id
+            return url
+          end
+        end
+
+        # If the URL is not valid, raise an error
+        raise "The provided URL #{url} is not a valid AT URL"
+      end
+
+      # Validate the format of the regular URL and extract the username and post ID
+      regex = /https:\/\/[a-zA-Z0-9.-]+\/profile\/[a-zA-Z0-9.-]+\/post\/[a-zA-Z0-9.-]+/
+      raise "The provided URL #{url} does not match the expected schema" unless regex.match?(url)
+      username = url.split("/")[-3]
+      post_id = url.split("/")[-1]
+
+      # Validate the username and post ID in the AT URL
+      did = resolve_handle(pds, username)["did"]
+
+      # Construct the AT URL
+      "at://#{did}/app.bsky.feed.post/#{post_id}"
+    end
+  end
+
+  class Credentials
+    attr_reader :username, :pw
+
+    def initialize(username, pw)
+      @username = username
+      @pw = pw
+    end
+  end
+
+  class Session
+    include RequestUtils
+
+    attr_reader :credentials, :pds, :access_token, :refresh_token, :did
+
+    def initialize(credentials, pds, should_open = true)
+      @credentials = credentials
+      @pds = pds
+      open! if should_open
+    end
+
+    def open!
+      uri = URI("#{pds}/xrpc/com.atproto.server.createSession")
+      response = HTTParty.post(
+        uri,
+        body: { identifier: credentials.username, password: credentials.pw }.to_json,
+        headers: default_headers,
+      )
+
+      raise UnauthorizedError if response.code == 401
+
+      @access_token = response["accessJwt"]
+      @refresh_token = response["refreshJwt"]
+      @did = response["did"]
+    end
+  end
+end

data/lib/bskyrb/version.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bskyrb
+  VERSION = "0.5.1"
+end

data/lib/bskyrb.rb

@@ -0,0 +1,8 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "bskyrb/error"
+require "bskyrb/session"
+require "bskyrb/records"
+require "bskyrb/generated_classes"
+require "xrpc"

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: bskyrb
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: 0.5.1
 platform: ruby
 authors:
 - Shreyan Jain
+- Tynan Burke
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-01 00:00:00.000000000 Z
+date: 2023-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -24,20 +25,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: net-http
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: date
   requirement: !ruby/object:Gem::Requirement
@@ -66,13 +53,21 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A script for interacting with bsky/atproto
+description: A Ruby gem for interacting with bsky/atproto
 email:
 - shreyan.jain.9@outlook.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- "./lib/bskyrb.rb"
+- "./lib/bskyrb/codegen.rb"
+- "./lib/bskyrb/error.rb"
+- "./lib/bskyrb/firehose.rb"
+- "./lib/bskyrb/generated_classes.rb"
+- "./lib/bskyrb/records.rb"
+- "./lib/bskyrb/session.rb"
+- "./lib/bskyrb/version.rb"
 homepage: https://github.com/ShreyanJain9/bskyrb
 licenses:
 - MIT