Atmosfire 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2e059c19199525a9436b51dc419fa63dd881800b3a2bbb976350742da931a131
+  data.tar.gz: b19e78694cf71cc16a563d0a8f7e6a863c9f216107cee4226efa1f553dd8ba57
+SHA512:
+  metadata.gz: f2abdb67eb28583c69ec45e6d1c8c140dd61b568060fe5dc95f74666cfb4bdb132c9c88fbcad15af46c4bb1f248a5f0a2edc28fd42231b9209909757ec765b6f
+  data.tar.gz: 3073642340513a9c597586258dcb26c0451d085c297776730de66e35870c64b29728ddcad01b871019e9b13421712d93e2af7031b7a9c32eeab0100a232bfede

data/lib/atmosfire/at_uri.rb

@@ -0,0 +1,73 @@
+# typed: true
+
+module Atmosfire
+  module RequestUtils
+    extend T::Sig
+    include Kernel
+
+    sig { params(url: String, atp_host: String).returns(T.nilable(AtUri)) }
+
+    def at_uri(url, atp_host = "https://bsky.social")
+      rulesets = [
+        AtUriParser.create_rule(%r{^#{Regexp.escape("https://")}(bsky\.app)/profile/(.+)/post/([\w]+)$}) do |handle, collection, rkey, pds|
+          handle.start_with?("did:") ? did = handle : did = resolve_handle(handle, pds)
+          AtUri.new(did, "app.bsky.feed.post", rkey)
+        end,
+
+        AtUriParser.create_rule(%r{^at://(.+)/(.+)/(\w+)$}) do |handle, collection, rkey, pds|
+          handle.start_with?("did:") ? did = handle : did = resolve_handle(handle, pds)
+          AtUri.new(did, collection, rkey)
+        end,
+
+      ]
+      AtUriParser.parse(url, rulesets, pds: atp_host)
+    end
+  end
+end
+
+module Atmosfire
+  module AtUriParser
+    extend T::Sig
+    Rule = Struct.new(:pattern, :transform)
+
+    sig { params(url: String, rulesets: T::Array[Rule], pds: String).returns(T.nilable(AtUri)) }
+    def self.parse(url, rulesets, pds: "https://bsky.social")
+      rulesets.each do |ruleset|
+        match_data = url.match(ruleset.pattern)
+        next unless match_data
+
+        at_uri = ruleset.transform.call(match_data, pds)
+        return at_uri if at_uri.is_a?(AtUri)
+      end
+
+      nil
+    end
+
+    def self.create_rule(pattern, &block)
+      transform = Proc.new do |match_data, pds|
+        block.call(*match_data.captures, pds)
+      end
+      Rule.new(pattern, transform)
+    end
+  end
+
+  AtUri = Struct.new :repo, :collection, :rkey do
+    extend T::Sig
+
+    def initialize(*args)
+      if args.count == 1
+        parts = args[0].split("/")
+        repo, collection, rkey = parts[2], parts[3], parts[4]
+      elsif args.count == 3
+        repo, collection, rkey = args
+      end
+      super(repo, collection, rkey)
+    end
+
+    sig { returns(String) }
+
+    def to_s
+      "at://#{repo}/#{collection}/#{rkey}"
+    end
+  end
+end

data/lib/atmosfire/collection.rb

@@ -0,0 +1,48 @@
+# typed: true
+module Atmosfire
+  class Repo
+    Collection = Struct.new :repo, :collection do
+      include RequestUtils
+      extend T::Sig
+
+      sig { params(repo: Atmosfire::Repo, lexicon_name: String).void }
+
+      def initialize(repo, lexicon_name)
+        super(repo, lexicon_name)
+      end
+
+      sig { params(limit: Integer).returns(T::Array[Atmosfire::Record]) }
+
+      def list_records(limit = 10)
+        self.repo.pds_endpoint
+          .get.com_atproto_repo_listRecords(
+            repo: self.repo.did,
+            collection: self.collection,
+            limit: limit,
+          )["records"]
+          .map { |record|
+          Atmosfire::Record.from_hash(record)
+        }
+      end
+
+      sig { returns(String) }
+
+      def to_s
+        "at://#{self.repo.did}/#{self.collection}"
+      end
+
+      sig { params(rkey: String).returns(T.nilable(Atmosfire::Record)) }
+
+      def [](rkey)
+        Atmosfire::Record.from_uri(
+          T.must(
+            at_uri(
+              "at://#{self.repo.did}/#{@collection}/#{rkey}"
+            )
+          ),
+          self.repo.pds
+        )
+      end
+    end
+  end
+end

data/lib/atmosfire/record.rb

@@ -0,0 +1,84 @@
+# typed: true
+module Atmosfire
+  Record = Struct.new :uri, :cid, :timestamp, :content do
+    extend T::Sig
+    class << self
+      extend T::Sig
+
+      sig { params(json_hash: Hash).returns(T.nilable(Atmosfire::Record)) }
+
+      def from_hash(json_hash)
+        timestamp = nil
+        timestamp = Time.parse json_hash["value"]["createdAt"] if json_hash["value"]["createdAt"]
+        raw_content = json_hash["value"]
+        new(AtUri.new(json_hash["uri"]), json_hash["cid"], timestamp, raw_content)
+      end
+
+      sig { params(uri: Atmosfire::AtUri, pds: String).returns(T.nilable(Atmosfire::Record)) }
+
+      def from_uri(uri, pds = "https://bsky.social")
+        self.from_hash XRPC::Client.new(pds).get.com_atproto_repo_getRecord(
+          repo: uri.repo,
+          collection: uri.collection,
+          rkey: uri.rkey,
+        )
+      end
+
+      sig { params(content_hash: Hash, session: Atmosfire::Session, rkey: T.nilable(String)).returns(T.nilable(Atmosfire::Record)) }
+
+      def create(content_hash, session, rkey = nil)
+        return nil if content_hash["$type"].nil?
+        if rkey.nil?
+          rec = from_uri(session.xrpc.post.com_atproto_repo_createRecord(
+            repo: session.did,
+            collection: content_hash["$type"],
+            record: content_hash,
+          )["uri"])
+          return rec
+        else rec = from_uri(session.xrpc.post.com_atproto_repo_createRecord(
+          repo: session.did,
+          collection: content_hash["$type"],
+          rkey: rkey,
+          record: content_hash,
+        )["uri"])
+          return rec;         end
+      end
+    end
+
+    def refresh(pds = "https://bsky.social")
+      self.class.from_uri(self.uri, pds)
+    end
+
+    sig { params(session: Atmosfire::Session).returns(T.nilable(Atmosfire::Record)) }
+
+    def update(session)
+      self.delete(session)
+      session.xrpc.post.com_atproto_repo_createRecord(
+        repo: session.did,
+        collection: self.uri.collection,
+        rkey: self.uri.rkey,
+        record: self.content,
+      )
+      self.class.from_uri(self.uri, session.pds)
+    end
+
+    def put(session)
+      session.xrpc.post.com_atproto_repo_putRecord(
+        repo: session.did,
+        collection: self.uri.collection,
+        rkey: self.uri.rkey,
+        record: self.content,
+      )
+    end
+
+    sig { params(session: Atmosfire::Session).returns(T.nilable(Integer)) }
+
+    def delete(session)
+      session.xrpc.post.com_atproto_repo_deleteRecord(
+        repo: session.did,
+        collection: self.uri.collection,
+        rkey: self.uri.rkey,
+      )
+    end
+  end
+end

data/lib/atmosfire/repo.rb

@@ -0,0 +1,46 @@
+# typed: true
+
+class Atmosfire::Repo
+  include Atmosfire::RequestUtils
+  extend T::Sig
+
+  sig { params(username: String, pds: String, open: T::Boolean, authenticate: T.nilable(Atmosfire::Session)).void }
+
+  def initialize(username, pds = "https://bsky.social", open: true, authenticate: nil)
+    @pds = pds
+    @pds_endpoint = XRPC::Client.new(pds)
+    if username.start_with?("did:")
+      @did = username
+    else
+      @did = resolve_handle(username, pds)
+    end
+    @record_list = []
+    if open == true
+      open!
+    end
+  end
+
+  def open!
+    @collections = describe_repo["collections"]
+  end
+
+  sig { returns(Hash) }
+
+  def describe_repo
+    @pds_endpoint.get.com_atproto_repo_describeRepo(repo: @did)
+  end
+
+  sig { returns(Hash) }
+
+  def did_document
+    describe_repo()["didDoc"]
+  end
+
+  sig { params(collection: String).returns(Atmosfire::Repo::Collection) }
+
+  def [](collection)
+    Collection.new(self, collection)
+  end
+
+  attr_reader :did, :record_list, :pds, :pds_endpoint
+end

data/lib/atmosfire/requests.rb

@@ -0,0 +1,73 @@
+module Atmosfire
+  class Error < StandardError; end
+
+  class HTTPError < Error; end
+
+  class UnauthorizedError < HTTPError; end
+
+  module RequestUtils # Goal is to replace with pure XRPC eventually
+    def resolve_handle(username, pds = "https://bsky.social")
+      (XRPC::Client.new(pds).get.com_atproto_identity_resolveHandle(handle: username))["did"]
+    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_session_uri(pds)
+      "#{pds}/xrpc/com.atproto.server.createSession"
+    end
+
+    def delete_session_uri(pds)
+      "#{pds}/xrpc/com.atproto.server.deleteSession"
+    end
+
+    def refresh_session_uri(pds)
+      "#{pds}/xrpc/com.atproto.server.refreshSession"
+    end
+
+    def get_session_uri(pds)
+      "#{pds}/xrpc/com.atproto.server.getSession"
+    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 mute_actor_uri(pds)
+      "#{pds}/xrpc/app.bsky.graph.muteActor"
+    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 default_authenticated_headers(session)
+      default_headers.merge({
+        Authorization: "Bearer #{session.access_token}",
+      })
+    end
+
+    def refresh_token_headers(session)
+      default_headers.merge({
+        Authorization: "Bearer #{session.refresh_token}",
+      })
+    end
+  end
+end

data/lib/atmosfire/session.rb

@@ -0,0 +1,70 @@
+# typed: true
+
+require "atmosfire/requests"
+
+module Atmosfire
+  Credentials = Struct.new :username, :pw, :pds do
+    extend T::Sig
+
+    sig { params(username: String, pw: String, pds: String).void }
+
+    def initialize(username, pw, pds = "https://bsky.social")
+      super
+      self.pds ||= "https://bsky.social"
+    end
+  end
+
+  class Session
+    include RequestUtils
+    extend T::Sig
+
+    attr_reader :pds, :access_token, :refresh_token, :did, :xrpc
+
+    sig { params(credentials: Atmosfire::Credentials, should_open: T::Boolean).void }
+
+    def initialize(credentials, should_open = true)
+      @credentials = credentials
+      @pds = credentials.pds
+      open! if should_open
+    end
+
+    def open!
+      @xrpc = XRPC::Client.new(@pds)
+      response = @xrpc.post.com_atproto_server_createSession(identifier: @credentials.username, password: @credentials.pw)
+
+      raise UnauthorizedError if response["accessJwt"].nil?
+
+      @access_token = response["accessJwt"]
+      @refresh_token = response["refreshJwt"]
+      @did = response["did"]
+
+      @xrpc = XRPC::Client.new(@pds, @access_token)
+      @refresher = XRPC::Client.new(@pds, @refresh_token)
+    end
+
+    def refresh!
+      response = @refresher.post.com_atproto_server_refreshSession
+      raise UnauthorizedError if response["accessJwt"].nil?
+      @access_token = response["accessJwt"]
+      @refresh_token = response["refreshJwt"]
+    end
+
+    sig { returns(T.nilable(Hash)) }
+
+    def get_session
+      @xrpc.get.com_atproto_server_getSession
+    end
+
+    def delete!
+      response = HTTParty.post(
+        URI(delete_session_uri(pds)),
+        headers: refresh_token_headers(self),
+      )
+      if response.code == 200
+        { success: true }
+      else
+        raise UnauthorizedError
+      end
+    end
+  end
+end

data/lib/atmosfire/version.rb

@@ -0,0 +1,3 @@
+module Atmosfire
+  VERSION = "0.0.1"
+end

data/lib/atmosfire.rb

@@ -0,0 +1,9 @@
+# typed: strict
+# frozen_string_literal: true
+require "sorbet-runtime"
+require "xrpc"
+require "atmosfire/at_uri"
+require "atmosfire/session"
+require "atmosfire/collection"
+require "atmosfire/repo"
+require "atmosfire/record"

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: Atmosfire
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Shreyan Jain
+- Tynan Burke
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: xrpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+description: A Ruby gem for interacting with atmosfire
+email:
+- shreyan.jain.9@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./lib/atmosfire.rb"
+- "./lib/atmosfire/at_uri.rb"
+- "./lib/atmosfire/collection.rb"
+- "./lib/atmosfire/record.rb"
+- "./lib/atmosfire/repo.rb"
+- "./lib/atmosfire/requests.rb"
+- "./lib/atmosfire/session.rb"
+- "./lib/atmosfire/version.rb"
+homepage: https://github.com/ShreyanJain9/atmosfire
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.15
+signing_key:
+specification_version: 4
+summary: Interact with the AT Protocol using Ruby
+test_files: []