xrpc 0.0.4 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e48e69127fd8c456bc554411ace1c1eb8226f9ccf771b678f9904e64a0effc9e
-  data.tar.gz: 34c1a233e67351045321b1548bf73c795d0ca158325b6aef8be18dffe0f1d5a8
+  metadata.gz: d7bca4020ba6ae0ace083ebbd62860273590ff6d135d712fd4c221233554913f
+  data.tar.gz: 60ed91a5872c8008a2bb6bd64ea1543e1fdf670c822752eb0b9efe99126e7f96
 SHA512:
-  metadata.gz: 4f0d689245a0db39090ed23a78f1be0c42668357cf0bddd93890dc107f899655b22473c94bf53a7b5aa31e92c818c839f57cbe9986cf0dbcefedeb3b1f581999
-  data.tar.gz: 648b7559cf78e5bd53acb20fe6b2d6abb0c9bc4462aa7a46ac752e5c22c463ebfa6f0f9fed65b318a11b8192da8c1188f695aebb5f5e217185918f0ca8dc03a7
+  metadata.gz: db08c3afd3532daf9aebc12c2bd32db20512654707a31d32068470f780eba97602e20b6b6bf052eb194bdf08f0d4f469175fe89d824d330ffcf52813c294dd17
+  data.tar.gz: c00e3688d413fceec7ea3638f78d8d6bebc234934861fd2afda79b550551b913206124e4c5dc15eeebe8aeff43a047ac3071713b6293d0113b5f198fe71bc26c

data/lib/xrpc/client.rb

@@ -1,130 +1,48 @@
-require "uri"
 require "httparty"
 require "json"
 
 module XRPC
-  class Service
-    def initialize(pds)
-      @pds = pds
-    end
-
-    def call(endpoint, params = {}, body = nil)
-      endpoint_uri = URI("#{@pds}/xrpc/#{endpoint}?#{URI.encode_www_form(params)}")
-      headers = { 'Content-Type': "application/json" }
-
-      response = if body
-          HTTParty.post(endpoint_uri, body: body.to_json, headers: headers)
-        else
-          HTTParty.get(endpoint_uri)
-        end
-
-      { encoding: response.headers["Content-Type"], body: JSON.parse(response.body) }
+  class << self
+    def client(url)
+      XRPC::Client.new(url)
     end
   end
-end
-
-module XRPC
-  class Endpoint
-    attr_reader :id, :lexicon
 
-    def initialize(id, lexicon)
-      @id = id
-      @lexicon = lexicon
-    end
+  class Client
+    attr_reader :get, :post
 
-    def call(service, params = {}, body = nil)
-      service.call(@id, params, body)
+    def initialize(base_url, token = nil)
+      @headers = { :"Content-Type" => "application/json" }
+      @headers = @headers.merge { :Authorization => "Bearer #{token}" } unless token.nil?
+      @base_url = base_url
+      @get = GetRequest.new(base_url, @headers)
+      @post = PostRequest.new(base_url, @headers)
     end
-  end
-end
 
-module XRPC
-  class Lexicon
-    def initialize(lexicon)
-      @lexicon = lexicon
-    end
+    class GetRequest
+      include HTTParty
 
-    def endpoint(id)
-      Endpoint.new(id, @lexicon)
-    end
-  end
-end
-
-module XRPC
-  class Client
-    def initialize
-      @lexicons = []
-    end
+      def initialize(base_url, headers)
+        self.class.base_uri base_url
+        @headers = headers
+      end
 
-    def add_lexicon(lexicon)
-      @lexicons << Lexicon.new(lexicon)
+      def method_missing(method_name, **params)
+        JSON.parse self.class.get("/xrpc/#{method_name.to_s.gsub("_", ".")}", query: params, headers: @headers).body
+      end
     end
 
-    def service(pds)
-      Service.new(pds)
-    end
+    class PostRequest
+      include HTTParty
 
-    def endpoint(id)
-      @lexicons.each do |lexicon|
-        endpoint = lexicon.endpoint(id)
-        return endpoint if endpoint
+      def initialize(base_url, headers)
+        self.class.base_uri base_url
+        @headers = headers
+      end
 
-        nil
+      def method_missing(method_name, **params)
+        JSON.parse self.class.post("/xrpc/#{method_name.to_s.gsub("_", ".")}", body: params.to_json, headers: @headers).body
       end
     end
   end
 end
-
-# # example usage
-# client = XRPC::Client.new
-
-# client.add_lexicon({
-#   lexicon: 1,
-#   id: 'io.example.ping',
-#   defs: {
-#     main: {
-#       type: 'query',
-#       description: 'Ping the server',
-#       parameters: {
-#         type: 'params',
-#         properties: { message: { type: 'string' } }
-#       },
-#       output: {
-#         encoding: 'application/json',
-#         schema: {
-#           type: 'object',
-#           required: ['message'],
-#           properties: { message: { type: 'string' } }
-#         }
-#       }
-#     }
-#   }
-# })
-
-# client.add_lexicon({
-#   lexicon: 1,
-#   id: 'io.example.writeJsonFile',
-#   defs: {
-#     main: {
-#       type: 'procedure',
-#       description: 'Write a JSON file',
-#       parameters: {
-#         type: 'params',
-#         properties: { fileName: { type: 'string' } }
-#       },
-#       input: {
-#         encoding: 'application/json'
-#       }
-#     }
-#   }
-# })
-
-# # call endpoint with query parameters and input body
-# res1 = client.service('https://example.com').call('io.example.writeJsonFile', { fileName: 'foo.json' }, { hello: 'world', thisIs: 'the file to write' })
-# puts res1
-# # => { encoding: 'application/json', body: nil }
-
-# # call endpoint with query parameters only
-# res2 = client.endpoint('io.example.ping').call(client.service('https://example.com'), { message: 'hello world' })
-# puts res2
-# # => { encoding: 'application/json', body: { message: 'hello world' } }

data/lib/xrpc/server.rb

@@ -1,43 +1,44 @@
-require "json"
-require "rack"
-
-module XRPC
-  class Server
-    def initialize(lexicons)
-      @lexicons = lexicons
-    end
-
-    def method(id)
-      # endpoint = find_endpoint(id)
-      # raise ArgumentError, "Endpoint '#{id}' not found" unless endpoint
-
-      define_singleton_method(id) do |input, **params|
-        endpoint.call(input, params)
+require "sinatra/base"
+
+module Sinatra
+  module XRPCRoutes
+    def xrpc_get(lexicon, &block)
+      # Extract the parameter names from the block's parameters
+      parameters = block.parameters.map { |type, name| name.to_s }
+
+      # Define a new route with the provided lexicon and block
+      get "/xrpc/#{lexicon}" do
+        content_type :json
+        # Create a hash of arguments with parameter names as keys
+        args = {}
+        parameters.each do |param|
+          args[param] = params[param] if params[param]
+        end
+
+        # Call the block with the arguments
+        instance_exec(args, &block)
       end
     end
 
-    def decode_params(nsid, query_params)
-      #  logic to decode query parameters based on nsid
-      # For simplicity, let's assume no decoding is needed and return the query params as is
-      query_params
-    end
-
-    def call(nsid, input, **params)
-      endpoint = find_endpoint(nsid)
-      raise ArgumentError, "Endpoint '#{nsid}' not found" unless endpoint
-
-      endpoint.call(input, params)
-    end
-
-    private
-
-    def find_endpoint(id)
-      @lexicons.each do |lexicon|
-        endpoint = lexicon.endpoint(id)
-        return endpoint if endpoint
+    def xrpc_post(lexicon, &block)
+      # Extract the parameter names from the block's parameters
+      parameters = block.parameters.map { |type, name| name.to_s }
+
+      # Define a new route with the provided lexicon and block
+      post "/xrpc/#{lexicon}" do
+        content_type :json
+        # Create a hash of arguments with parameter names as keys
+        args = {}
+        parameters.each do |param|
+          args[param] = params[param] if params[param]
+        end
+
+        # Call the block with the arguments
+        instance_exec(args, &block)
       end
-
-      nil
     end
   end
+
+  # Register the module to make it available as a macro
+  register XRPCRoutes
 end

data/lib/xrpc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module XRPC
-  VERSION = "0.0.4"
+  VERSION = "0.1.1"
 end

data/lib/xrpc.rb

@@ -1,2 +1 @@
 require "xrpc/client"
-require "xrpc/basic"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xrpc
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.1
 platform: ruby
 authors:
 - Shreyan Jain
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-21 00:00:00.000000000 Z
+date: 2023-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -60,7 +60,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - "./lib/xrpc.rb"
-- "./lib/xrpc/basic.rb"
 - "./lib/xrpc/client.rb"
 - "./lib/xrpc/server.rb"
 - "./lib/xrpc/version.rb"
@@ -83,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.15
 signing_key:
 specification_version: 4
 summary: Interact with bsky/atproto using Ruby

data/lib/xrpc/basic.rb

@@ -1,69 +0,0 @@
-# typed: false
-require "uri"
-require "httparty"
-require "json"
-
-module XRPC
-  def request(pds, endpoint_location, params)
-    EasyEndpoint.new(pds, endpoint_location).get(params)
-  end
-
-  module_function :request
-
-  class EasyEndpoint
-    attr_reader :request_uri
-
-    def initialize(pds, endpoint_location, authenticated: false, token: nil)
-      @pds = pds
-      @endpoint_location = endpoint_location
-      @authenticated = authenticated
-      @headers = default_headers()
-      if token # Ideally, you shouldn't pass the token when creating the endpoint
-        @headers = default_authenticated_headers(token)
-      end
-    end
-
-    def default_headers
-      { "Content-Type" => "application/json" }
-    end
-
-    def authenticated?() @authenticated end
-
-    def default_authenticated_headers(access_token)
-      default_headers.merge({
-        Authorization: "Bearer #{access_token}",
-      })
-    end
-
-    def authenticate(token) # This is the proper place to authenticate with a token
-      # This is still a pretty weird way to authenticate, but it works (for now)
-      if not @authenticated == true
-        raise Error, "Non-authenticated endpoint cannot be authenticated"
-      end
-      @headers = default_authenticated_headers(token)
-    end
-
-    def get(params)
-      query_params = URI.encode_www_form(params) # e.g. "foo=bar&baz=qux" from (foo: "bar", baz: "qux")
-      @request_uri = URI("#{@pds}/xrpc/#{@endpoint_location}?#{query_params}")
-      response = HTTParty.get(@request_uri, headers: @headers)
-      JSON.parse(response.body)
-    end
-
-    def post(params)
-      @request_uri = URI("#{@pds}/xrpc/#{@endpoint_location}")
-      response = HTTParty.post(@request_uri, body: params.to_json, headers: @headers)
-
-      if response then JSON.parse(response.body) end
-    end
-
-    def post_without_response(params)
-      @request_uri = URI("#{@pds}/xrpc/#{@endpoint_location}")
-      response = HTTParty.post(@request_uri, body: params.to_json, headers: @headers)
-
-      response.body if response
-    end
-  end
-
-  class Error < StandardError; end
-end