bskyrb 0.4 → 0.5

data/lib/bskyrb/records.rb

@@ -0,0 +1,231 @@
+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"
+      # 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 detect_facets(json_hash) # TODO, DOES NOT WORK YET
+      # For some reason this always fails at finding text records and I have no idea why
+      # Detect domain names that have been @mentioned in the text
+      matches = json_hash["record"]["text"].scan(/@([^\s.]+\.[^\s]+)/)
+
+      # Create a facets array to hold the resolved handles
+      facets = []
+
+      # Loop through the matches and resolve the handles
+      matches.each do |match|
+        handle = match[0]
+        resolved_handle = resolve_handle(session.pds, handle)
+        byte_start = json_hash["record"]["text"].index("@" + handle)
+        byte_end = byte_start + handle.length
+        facet = {
+          "$type": "app.bsky.richtext.facet",
+          features: [
+            {
+              "$type": "app.bsky.richtext.facet#mention",
+              did: resolved_handle
+            }
+          ],
+          index: {
+            byteStart: byte_start,
+            byteEnd: byte_end
+          }
+        }
+        facets.push(facet)
+      end
+
+      # Append the facets to the JSON hash
+      json_hash["record"]["facets"] = facets
+
+      # Convert the JSON hash back to a string
+      JSON.generate(json_hash)
+
+      # "Doesn't work yet"
+    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)
+      reply_json = {
+        root: {
+            uri: reply_to.uri,
+            cid: reply_to.cid,
+        },
+        parent: {
+            uri: reply_to.uri,
+            cid: reply_to.cid,
+        },
+        collection: "app.bsky.feed.post",
+        repo: session.did,
+        record: {
+          "$type": "app.bsky.feed.post",
+          createdAt: DateTime.now.iso8601(3),
+          text: text
+        }
+      },
+      reply_hash = JSON.parse(reply_json.to_json)
+      reply = Bskyrb::ComAtprotoRepoCreaterecord::CreateRecord::Input.from_hash(reply_hash)
+      create_record(reply)
+    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 unfollow(username)
+    #   profile_action(username, "app.bsky.graph.unfollow(?)")
+    # end
+                                    #NONE OF THESE WORK 
+    # def mute(username)
+    #   profile_action(username, "app.bsky.graph.mute")
+    # end
+
+    # def unmute(username)
+    #   profile_action(username, "app.bsky.graph.unmute")
+    # 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,116 @@
+require "uri"
+require "httparty"
+
+# def bsky_register(pds, user, password, invcode, email) # lets you create new accounts on a pds directly from ruby
+#   # doesn't go within session class because it wouldn't work unless you already have an account
+#   data = {
+#     "email": email,
+#     "handle": user + ".bsky.social", # defaulting to bsky.social handles because you can't add dns records for a DID that doesn't exist yet
+#     "inviteCode": invcode,
+#     "password": password,
+#   }
+#   resp = HTTParty.post(
+#     "#{pds}/xrpc/com.atproto.server.createAccount",
+#     body: data.to_json,
+#     headers: {'Content-Type' => 'application/json'}
+#   )
+#   resp
+# end
+
+module Bskyrb  
+  module RequestUtils
+    def resolve_handle(pds, username)
+      HTTParty.get(
+        "#{pds}/xrpc/com.atproto.identity.resolveHandle?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 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)
+      # e.g. "https://staging.bsky.app/profile/naia.bsky.social/post/3jszsrnruws27"
+      url = url.to_s
+      # regex by chatgpt:
+      raise "The provided URL #{url} does not match the expected schema" unless /https:\/\/[a-zA-Z0-9.-]+\/profile\/[a-zA-Z0-9.-]+\/post\/[a-zA-Z0-9.-]+/.match?(url)
+      username = url.split("/")[-3]
+      did = resolve_handle(pds, username)["did"]
+      post_id = url.split("/")[-1]
+      "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
+      )
+      @access_token = response["accessJwt"]
+      @refresh_token = response["refreshJwt"]
+      @did = response["did"]
+    end
+  end
+
+
+end

data/lib/bskyrb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Bskyrb
+  VERSION = "0.5"
+end

data/lib/bskyrb.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "bskyrb/session"
+require "bskyrb/records"
+require "bskyrb/generated_classes"

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: bskyrb
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: '0.5'
 platform: ruby
 authors:
 - Shreyan Jain
+- Tynan Burke
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-01 00:00:00.000000000 Z
+date: 2023-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -66,13 +67,20 @@ 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/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