at_protocol 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 88028815424d12616955d54125fb23ad627812290c2c52a8d491bb108ebd54fa
+  data.tar.gz: d68b5af3850c75174ef573809f2d87a4012c707d82079601cdd3351da5c317ed
+SHA512:
+  metadata.gz: 37cdd260697f6461ed9215f4d06b932988a292a5fc53afde8d555a1dc04c5355819026742528997d5c2d476a9618ddf396a972f794c73cab11784e6fff39c520
+  data.tar.gz: 5cd9f10e044b3edfdc37ce71abd01ae53fd66bfe4fa9669157d0a2f507e5d6190f3ed4b89490fb012dc9868ac2c7e2722fa35967428934cf1efec697c6def618

data/lib/at_protocol/at_uri.rb

@@ -0,0 +1,99 @@
+# typed: false
+
+module ATProto
+  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")
+      AtUriParser.parse(url, AtUriParser::RuleSets, pds: atp_host)
+    end
+
+    module_function :at_uri
+  end
+end
+
+module ATProto
+  CID = Skyfall::CID
+
+  module AtUriParser
+    extend T::Sig
+
+    class << self
+      include RequestUtils
+    end
+
+    Rule = Struct.new(:pattern, :transform)
+
+    sig { params(url: T.any(String, AtUri), rulesets: T::Array[Rule], pds: String).returns(T.nilable(AtUri)) }
+    def self.parse(url, rulesets, pds: "https://bsky.social")
+      return url if url.is_a?(AtUri)
+      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
+    RuleSets = [
+      AtUriParser.create_rule(%r{^#{Regexp.escape("https://")}(bsky\.app)/profile/(.+)/post/([\w]+)$}) do |_, handle, rkey, pds|
+        handle.start_with?("did:") ? did = handle : did = resolve_handle(handle, pds)
+        AtUri.new(repo: did, collection: "app.bsky.feed.post", rkey: rkey)
+      end,
+
+      AtUriParser.create_rule(%r{^#{Regexp.escape("https://")}(bsky\.app)/profile/(.+)$}) do |_, handle, pds|
+        handle.start_with?("did:") ? did = handle : did = resolve_handle(handle, pds)
+        AtUri.new(repo: did)
+      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(repo: did, collection: collection, rkey: rkey)
+      end,
+      AtUriParser.create_rule(%r{^at://(.+)/(.+)$}) do |handle, collection, pds|
+        handle.start_with?("did:") ? did = handle : did = resolve_handle(handle, pds)
+        AtUri.new(repo: did, collection: collection)
+      end,
+      AtUriParser.create_rule(%r{^at://(.+)$}) do |handle, pds|
+        handle.start_with?("did:") ? did = handle : did = resolve_handle(handle, pds)
+        AtUri.new(repo: did)
+      end,
+
+    ]
+  end
+
+  class AtUri < T::Struct
+    extend T::Sig
+    const :repo, T.any(ATProto::Repo, String)
+    const :collection, T.nilable(T.any(ATProto::Repo::Collection, String))
+    const :rkey, T.nilable(String)
+
+    def resolve(pds: "https://bsky.social")
+      if @collection.nil?
+        Repo.new(@repo.to_s, pds)
+      elsif @rkey.nil?
+        Repo::Collection.new(Repo.new(@repo.to_s, pds), @collection.to_s, pds)
+      else
+        Record.from_uri(self, pds)
+      end
+    end
+
+    sig { returns(String) }
+
+    def to_s
+      "at://#{@repo}/#{@collection.nil? ? "" : "#{@collection}/"}#{@rkey}"
+    end
+  end
+end

data/lib/at_protocol/collection.rb

@@ -0,0 +1,62 @@
+# typed: true
+module ATProto
+  class Repo
+    class Collection < T::Struct
+      include RequestUtils
+      include Enumerable
+      extend T::Sig
+
+      const(:repo, ATProto::Repo)
+      const(:collection, String)
+
+      sig { params(limit: Integer).returns(T::Array[ATProto::Record]) }
+
+      def list(limit = 10)
+        self.repo.xrpc
+          .get.com_atproto_repo_listRecords(
+            repo: self.repo.did,
+            collection: self.collection,
+            limit: limit,
+          )["records"]
+          .map { |record|
+          ATProto::Record.from_hash(record)
+        }
+      end
+
+      def list_all()
+        T.must(get_paginated_data(self.repo, :com_atproto_repo_listRecords.to_s, key: "records", params: { repo: self.repo.to_s, collection: self.to_s }, cursor: nil) do |record|
+          ATProto::Record.from_hash(record)
+        end)
+      end
+
+      sig { returns(String) }
+
+      def to_uri
+        "at://#{self.repo.did}/#{self.collection}/"
+      end
+
+      sig { returns(String) }
+
+      def to_s
+        @collection
+      end
+
+      sig { params(rkey: String).returns(T.nilable(ATProto::Record)) }
+
+      def [](rkey)
+        ATProto::Record.from_uri(
+          T.must(
+            at_uri(
+              "at://#{self.repo.did}/#{@collection}/#{rkey}"
+            )
+          ),
+          self.repo.pds
+        )
+      end
+
+      def each(&block)
+        list_all.each(&block)
+      end
+    end
+  end
+end

data/lib/at_protocol/record.rb

@@ -0,0 +1,90 @@
+# typed: false
+module ATProto
+  class Record < T::Struct
+    const(:uri, ATProto::AtUri)
+    const(:cid, Skyfall::CID)
+    const(:timestamp, T.untyped)
+    prop(:content, Hash)
+    extend T::Sig
+    class << self
+      extend T::Sig
+      include RequestUtils
+
+      sig { params(json_hash: Hash).returns(T.nilable(ATProto::Record)) }
+
+      def from_hash(json_hash)
+        return nil if json_hash["value"].nil?
+        timestamp = nil
+        timestamp = Time.parse json_hash["value"]["createdAt"] if json_hash["value"] && json_hash["value"]["createdAt"]
+        raw_content = json_hash["value"]
+        new(
+          uri: at_uri(
+            T.must(json_hash["uri"])
+          ),
+          cid: CID.from_json(json_hash["cid"]),
+          timestamp: timestamp, content: raw_content,
+        )
+      end
+
+      sig { params(uri: ATProto::AtUri, pds: String).returns(T.nilable(ATProto::Record)) }
+
+      def from_uri(uri, pds = "https://bsky.social")
+        from_hash(XRPC::Client.new(pds).get.com_atproto_repo_getRecord(
+          repo: uri.repo.to_s,
+          collection: "#{uri.collection}",
+          rkey: uri.rkey,
+        ))
+      end
+
+      sig { params(content_hash: Hash, session: ATProto::Session, rkey: T.nilable(String)).returns(T.nilable(ATProto::Record)) }
+
+      def create(content_hash, session, rkey = nil)
+        return nil if content_hash["$type"].nil?
+        params = {
+          repo: session.did,
+          collection: content_hash["$type"],
+          record: content_hash,
+        }
+        params[:rkey] = rkey unless rkey.nil?
+        from_uri(at_uri(session.xrpc.post.com_atproto_repo_createRecord(params)["uri"]))
+      end
+    end
+    dynamic_attr_reader(:to_uri) { "at://#{self.uri.repo}/#{self.uri.collection}/#{self.uri.rkey}" }
+    dynamic_attr_reader(:strongref) { StrongRef.new(uri: self.uri, cid: self.cid) }
+
+    def refresh(pds = "https://bsky.social")
+      self.class.from_uri(self.uri, pds)
+    end
+
+    sig { params(session: ATProto::Session).returns(T.nilable(ATProto::Record)) }
+
+    def put(session)
+      session.then(&to_write(:update)).uri.resolve(pds: session.pds)
+    end
+
+    sig { params(session: ATProto::Session).returns(T.nilable(Integer)) }
+
+    def delete(session)
+      session.then(&to_write)
+    end
+
+    sig { params(type: Symbol).returns(ATProto::Writes::Write) }
+
+    def to_write(type = :delete)
+      ATProto::Writes::Write.new(
+        {
+          action: Writes::Write::Action.deserialize(type),
+          value: (self.content if type == :update),
+          collection: self.uri.collection,
+          rkey: self.uri.rkey,
+        }.compact
+      )
+    end
+
+    sig { params(other: ATProto::Record).returns(T::Boolean) }
+
+    def ==(other)
+      self.cid.to_s == other.cid.to_s
+    end
+  end
+end

data/lib/at_protocol/repo.rb

@@ -0,0 +1,67 @@
+# typed: true
+
+class ATProto::Repo
+  include ATProto::RequestUtils
+  extend T::Sig
+
+  sig { params(username: String, pds: String, open: T::Boolean, authenticate: T.nilable(ATProto::Session)).void }
+
+  # @param username [String] The username or DID (Decentralized Identifier) to use.
+  # @param pds [String] The URL of the personal data server (default: "https://bsky.social").
+  # @param open [Boolean] Whether to open the repository or not (default: true).
+  # @param authenticate [NilClass, Object] Additional authentication data (default: nil).
+
+  def initialize(username, pds = "https://bsky.social", open: true, authenticate: nil)
+    @pds = T.let pds, String
+    @xrpc = T.let(XRPC::Client.new(pds), XRPC::Client)
+    if username.start_with?("did:")
+      @did = T.let(username, String)
+    else
+      @did = T.let(resolve_handle(username, pds), String)
+    end
+    @record_list = []
+    if open == true
+      open!
+    end
+  end
+
+  def open!
+    @collections = describe_repo["collections"]
+  end
+
+  sig { returns(String) }
+
+  def to_uri
+    "at://#{@did}/"
+  end
+
+  sig { returns(String) }
+
+  def to_s
+    @did
+  end
+
+  sig { returns(Hash) }
+
+  def describe_repo
+    @xrpc.get.com_atproto_repo_describeRepo(repo: @did)
+  end
+
+  sig { returns(Hash) }
+
+  def did_document
+    describe_repo()["didDoc"]
+  end
+
+  sig { params(collection: String).returns(ATProto::Repo::Collection) }
+
+  def [](collection)
+    Collection.new(repo: self, collection: collection)
+  end
+
+  def inspect
+    "Repo(#{@did})"
+  end
+
+  attr_reader :did, :record_list, :pds, :xrpc
+end

data/lib/at_protocol/requests.rb

@@ -0,0 +1,125 @@
+# typed: true
+module ATProto
+  class Error < StandardError; end
+
+  class HTTPError < Error; end
+
+  class UnauthorizedError < HTTPError; end
+
+  module RequestUtils # Goal is to replace with pure XRPC eventually
+    extend T::Sig
+
+    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 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
+
+    sig {
+      params(
+        session: T.any(ATProto::Session, ATProto::Repo),
+        method: String,
+        key: String,
+        params: Hash,
+        cursor: T.nilable(
+          String
+        ),
+        map_block: T.nilable(Proc),
+      )
+        .returns(T
+          .nilable(
+            Array
+          ))
+    }
+
+    def get_paginated_data(session, method, key:, params:, cursor: nil, &map_block)
+      params.merge({ limit: 100, cursor: cursor }).then do |send_data|
+        session.xrpc.get.public_send(method, **send_data).then do |response|
+          response.dig(key).then do |data|
+            if data.nil? || data.empty?
+              return []
+            end
+
+            if block_given?
+              data.map(&map_block).then do |results|
+                response.dig("cursor").then do |next_cursor|
+                  if next_cursor.nil?
+                    return results
+                  else
+                    get_paginated_data(session, method, key: key, params: params, cursor: next_cursor, &map_block).then do |next_results|
+                      return results + next_results
+                    end
+                  end
+                end
+              end
+            else
+              response.dig("cursor").then do |next_cursor|
+                if next_cursor.nil?
+                  return data
+                else
+                  get_paginated_data(session, method, key: key, params: params, cursor: next_cursor, &map_block).then do |next_results|
+                    return data + next_results
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/at_protocol/session.rb

@@ -0,0 +1,88 @@
+# typed: true
+
+module ATProto
+  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: ATProto::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"]
+      @xrpc = XRPC::Client.new(@pds, @access_token)
+      @refresher = XRPC::Client.new(@pds, @refresh_token)
+    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
+
+module ATProto
+  class TokenSession < Session
+    extend T::Sig
+
+    sig { params(token: String, pds: String).void }
+
+    def initialize(token, pds = "https://bsky.social")
+      @token = token
+      @pds = pds
+      open!
+    end
+
+    def open!
+      @xrpc = XRPC::Client.new(@pds, @token)
+    end
+  end
+end

data/lib/at_protocol/version.rb

@@ -0,0 +1,4 @@
+# typed: strict
+module ATProto
+  VERSION = "0.0.4"
+end

data/lib/at_protocol/writes.rb

@@ -0,0 +1,155 @@
+# typed: true
+module ATProto
+  class Writes < T::Struct
+    class Write < T::Struct
+      class Action < T::Enum
+        enums do
+          Create = new(:create)
+          Update = new(:update)
+          Delete = new(:delete)
+        end
+      end
+
+      extend T::Sig
+      prop(:action, Action)
+      prop(:value, T.nilable(Hash))
+      prop(:collection, String)
+      prop(:rkey, T.nilable(String))
+
+      sig { returns(T::Hash[Symbol, T.any(String, Symbol, Hash)]) }
+
+      def to_h
+        {
+          :"$type" => "com.atproto.repo.applyWrites##{self.action.serialize}",
+          action: self.action.serialize,
+          value: self.value || nil,
+          collection: self.collection,
+          rkey: self.rkey || nil,
+        }.compact
+      end
+
+      ## If you want to use with individual actions instead of applyWrites:
+      def endpoint_name
+        case self.action
+        when Action::Create
+          "com_atproto_repo_createRecord"
+        when Action::Update
+          "com_atproto_repo_putRecord"
+        when Action::Delete
+          "com_atproto_repo_deleteRecord"
+        end
+      end
+
+      def to_individual_hash(session)
+        case self.action
+        when Action::Create
+          {
+            repo: session.did,
+            collection: self.collection.to_s,
+            record: self.value,
+            rkey: self.rkey || nil,
+          }.compact
+        when Action::Update
+          {
+            repo: session.did,
+            collection: self.collection.to_s,
+            rkey: self.rkey,
+            record: self.value,
+          }.compact
+        when Action::Delete
+          {
+            repo: session.did,
+            collection: self.collection.to_s,
+            rkey: self.rkey,
+          }.compact
+        end
+      end
+
+      def to_proc
+        ->session {
+          session.xrpc.post.send(self.endpoint_name, **self.to_individual_hash(session)).then do |response|
+            if response.is_a?(Numeric)
+              response
+            elsif response.is_a?(Hash)
+              ATProto::Record::StrongRef.new(
+                uri: RequestUtils.at_uri(response["uri"]),
+                cid: Skyfall::CID.from_json(response["cid"]),
+              )
+            end
+          end
+        }
+      end
+    end
+
+    extend T::Sig
+    prop(:writes, T::Array[Write])
+    prop(:repo, ATProto::Repo)
+    prop(:session, ATProto::Session)
+
+    sig { returns(Hash) }
+
+    def to_h
+      {
+        writes: self.writes.map(&:to_h).compact,
+        repo: self.repo.to_s,
+      }.compact
+    end
+
+    def apply
+      self.session.xrpc.post.com_atproto_repo_applyWrites(**to_h)
+    end
+
+    class << self
+      extend T::Sig
+      sig { params(block: Proc).returns(T::Array[Write]) }
+
+      def generate(&block)
+        Collector.new.instance_eval(&block)
+      end
+    end
+  end
+
+  class Writes
+    class Collector
+      include RequestUtils
+      extend T::Sig
+
+      def initialize
+        @writes = []
+      end
+
+      sig { params(hash: Hash).returns(T::Array[Write]) }
+
+      def create(hash)
+        @writes << Write.new({
+          action: Write::Action::Create,
+          value: hash,
+          collection: hash["$type"] || hash[:"$type"],
+        })
+      end
+
+      sig { params(uri: T.any(String, ATProto::AtUri), hash: Hash).returns(T::Array[Write]) }
+
+      def update(uri, hash)
+        aturi = at_uri(uri)
+        @writes << Write.new({
+          action: Write::Action::Update,
+          value: hash,
+          collection: T.must(aturi).collection.to_s,
+          rkey: T.must(aturi).rkey,
+        })
+      end
+
+      sig { params(uri: T.any(String, ATProto::AtUri)).returns(T::Array[Write]) }
+
+      def delete(uri)
+        aturi = at_uri(uri)
+        @writes << Write.new({
+          action: Write::Action::Delete,
+          collection: T.must(aturi).collection.to_s,
+          rkey: T.must(aturi).rkey,
+        })
+      end
+    end
+  end
+end

data/lib/at_protocol.rb

@@ -0,0 +1,27 @@
+# typed: true
+# frozen_string_literal: true
+require "sorbet-runtime"
+
+class Class
+  def dynamic_attr_reader(attr_name, &block)
+    define_method(attr_name) do
+      instance_variable = "@#{attr_name}"
+      if instance_variable_defined?(instance_variable)
+        instance_variable_get(instance_variable)
+      else
+        instance_variable_set(instance_variable, instance_eval(&block))
+      end
+    end
+  end
+end
+
+require :"skyfall/cid".to_s
+require "xrpc"
+require "at_protocol/requests"
+require "at_protocol/session"
+require "at_protocol/repo"
+require "at_protocol/collection"
+require "at_protocol/at_uri"
+require "at_protocol/writes"
+require "at_protocol/record"
+require "at_protocol/helpers/strongref"

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: at_protocol
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Shreyan Jain
+- Tynan Burke
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-08-16 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 AT Protocol
+email:
+- shreyan.jain.9@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./lib/at_protocol.rb"
+- "./lib/at_protocol/at_uri.rb"
+- "./lib/at_protocol/collection.rb"
+- "./lib/at_protocol/record.rb"
+- "./lib/at_protocol/repo.rb"
+- "./lib/at_protocol/requests.rb"
+- "./lib/at_protocol/session.rb"
+- "./lib/at_protocol/version.rb"
+- "./lib/at_protocol/writes.rb"
+homepage: https://github.com/ShreyanJain9/at_protocol
+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: []