xrpc 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd2edff5dc4387dbbfeb6ecf00860e265cc93ed214eb2f7fb1f2fc8c192a1949
-  data.tar.gz: f07553b8c5d1d4e80e4a4f4e22b9e1b3871808f717e308432d9ba68cf51ae75b
+  metadata.gz: 6f4c7af719721f6960936c4dd967a7ff407460ab99adf73168c0abdeec609c7a
+  data.tar.gz: 9a366f9b9bf327101e18d94ae1413106f8d6b3404b6b638c12447bc0a2d66795
 SHA512:
-  metadata.gz: 5366e5bf46e307c3d7eebd426c79aa488cc8741797a9feedbd58891dc1a21b8ef308e1d03d7d2eeae2e5e948e29ef78ed1223fe96ba7d355ef861e240af9d2a5
-  data.tar.gz: f01c679d2164544877f8338a107966953756818e8d3e7fdcec2fd765a76fbd03dd04c812370ea632799ed4994d89c810e2a8fac69e7077acd45d18cf7b0067b6
+  metadata.gz: a3861268b173caae679601b7962da6add63a17d51f17f8f3baac5994befac5be1880c0b031e295b18579f018823a2d0f6d878ea9d17dc27588f41249050e7edb
+  data.tar.gz: a133c6ed0e072e161b18e47e382cd19309ca122e99816705b3120091d26ea438e64af1f588eaf9ca827a039e03bf216ae91b22d4b4f2bf5718ce97f8d3e9279d

data/lib/xrpc/basic.rb

@@ -0,0 +1,61 @@
+# 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

data/lib/xrpc/client.rb

@@ -0,0 +1,130 @@
+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) }
+    end
+  end
+end
+
+module XRPC
+  class Endpoint
+    attr_reader :id, :lexicon
+
+    def initialize(id, lexicon)
+      @id = id
+      @lexicon = lexicon
+    end
+
+    def call(service, params = {}, body = nil)
+      service.call(@id, params, body)
+    end
+  end
+end
+
+module XRPC
+  class Lexicon
+    def initialize(lexicon)
+      @lexicon = lexicon
+    end
+
+    def endpoint(id)
+      Endpoint.new(id, @lexicon)
+    end
+  end
+end
+
+module XRPC
+  class Client
+    def initialize
+      @lexicons = []
+    end
+
+    def add_lexicon(lexicon)
+      @lexicons << Lexicon.new(lexicon)
+    end
+
+    def service(pds)
+      Service.new(pds)
+    end
+
+    def endpoint(id)
+      @lexicons.each do |lexicon|
+        endpoint = lexicon.endpoint(id)
+        return endpoint if endpoint
+
+        nil
+      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

@@ -0,0 +1,43 @@
+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)
+      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
+      end
+
+      nil
+    end
+  end
+end

data/lib/xrpc/version.rb

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

data/lib/xrpc.rb

@@ -1,55 +1,2 @@
-# typed: false
-require "uri"
-require "httparty"
-require "json"
-
-module XRPC
-  def request(pds, endpoint_location, params)
-    Endpoint.new(pds, endpoint_location).get(params)
-  end
-
-  module_function :request
-
-  class Endpoint
-    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
-  end
-
-  class Error < StandardError; end
-end
+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.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Shreyan Jain
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-16 00:00:00.000000000 Z
+date: 2023-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -60,6 +60,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - "./lib/xrpc.rb"
+- "./lib/xrpc/basic.rb"
+- "./lib/xrpc/client.rb"
+- "./lib/xrpc/server.rb"
 - "./lib/xrpc/version.rb"
 homepage: https://github.com/ShreyanJain9/xrpc
 licenses: