xrpc 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f4c7af719721f6960936c4dd967a7ff407460ab99adf73168c0abdeec609c7a
-  data.tar.gz: 9a366f9b9bf327101e18d94ae1413106f8d6b3404b6b638c12447bc0a2d66795
+  metadata.gz: 173fc491f2988e7fd7a41435171cd60ec05e3116b838ab4c0257039788e0392a
+  data.tar.gz: 1afb3fa818ae58646e293afa6f97891fbf32ead4e9cd8be68d5ca8ca38db6c44
 SHA512:
-  metadata.gz: a3861268b173caae679601b7962da6add63a17d51f17f8f3baac5994befac5be1880c0b031e295b18579f018823a2d0f6d878ea9d17dc27588f41249050e7edb
-  data.tar.gz: a133c6ed0e072e161b18e47e382cd19309ca122e99816705b3120091d26ea438e64af1f588eaf9ca827a039e03bf216ae91b22d4b4f2bf5718ce97f8d3e9279d
+  metadata.gz: a543fa05e7bcebac74107e6eaf2f655d4e5e37458e7a61e5d8a824760a009baf1b18eefd19c7c0559e3029c5b33a9f4464e11cbcfd92687a3ddb8242e17fbe42
+  data.tar.gz: 571c2af3661344e704023c444a28f1578d896820f58424b8e9f50118517d51aae92341d21440a5391019461388cc6ae69cf618b5a7db5ab8846c02b99ea57389

data/lib/xrpc/client.rb

@@ -1,130 +1,44 @@
-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)
+      @base_url = base_url
+      @get = GetRequest.new(base_url)
+      @post = PostRequest.new(base_url)
     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)
+        self.class.base_uri base_url
+      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).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)
+        self.class.base_uri base_url
+      end
 
-        nil
+      def method_missing(method_name, **params)
+        JSON.parse self.class.post("/xrpc/#{method_name.to_s.gsub("_", ".")}", body: params).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.3"
+  VERSION = "0.1.0"
 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.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Shreyan Jain
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-21 00:00:00.000000000 Z
+date: 2023-07-02 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,61 +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
-  end
-
-  class Error < StandardError; end
-end