memori-client 0.1.9 → 0.2.2

data/lib/memori_client/resource.rb

@@ -1,57 +1,205 @@
 class MemoriClient::Resource
-  def self.build_arguments(the_binding)
-    the_binding.local_variables.each_with_object({}) do |key, acc|
-      value = the_binding.local_variable_get(key)
-      acc[key] = value
+  attr_reader :operations
+
+  def initialize(key, api_root:, version:)
+    @key = key
+    @api_root = api_root
+    @version = version
+    @operations = {}
+  end
+
+  def register_operation(item)
+    method_name = item[:method_name]
+    @operations[method_name] ||= MemoriClient::Operation.new(item, version: @version, key: @key)
+  end
+
+  def markdown_documentation
+    <<~MARKDOWN
+      # #{@version}.#{@key.downcase}
+
+      #{@operations.map { |key, operation| operation.markdown_documentation }.join("\n")}
+    MARKDOWN
+  end
+
+  def method_missing(method, *args, &block)
+    if @operations.key?(method.to_s)
+      invoke_endpoint(method, *args, &block)
+    elsif method.to_s.end_with?('_documentation')
+      documentation = @operations[method.to_s.chomp('_documentation')]
+
+      # Add the request body schema to the documentation
+      schema_ref = documentation[:spec]['requestBody']['content']['application/json']['schema']['$ref']
+      key = schema_ref.split('/').last
+      schema = Swagger::SchemaStore.instance.get(key)
+      documentation[:request_body_schema] = schema
+
+      documentation
+    else
+      super
     end
   end
 
-  def self.exec_http_request(method, path, args)
-    headers = args[:headers] || {}
+  private
+
+  def build_path(spec, args)
     stop = false
     processed_tokens = []
-    path.split('/').each do |token|
+    spec[:path].split('/').each do |token|
       break if stop == true
       if token =~ /^{.*}$/
         param_name = token.match(/^{(.*)}$/).captures.first
-        if args[param_name.to_sym].blank?
+        param_value = args[param_name.to_sym]
+        if param_value.nil? || param_value.empty?
           stop = true
         else
-          processed_tokens << args[param_name.to_sym]
+          processed_tokens << param_value
         end
       else
         processed_tokens << token
       end
     end
 
-    url = processed_tokens.join('/')
-    url = build_url(url)
+    processed_tokens.join('/')
+  end
+
+  def build_url(path)
+    [@api_root, path].join('')
+  end
+
+  def invoke_endpoint(method_name, *args, &block)
+    operation = @operations[method_name.to_s]
+    spec = operation.spec
+    parameters, payload = validate_input!(spec, args)
+
+    path = build_path(spec, parameters)
+    headers = args[0][:headers] || {}
+    url = build_url(path)
     http = MemoriClient::HttpClient.new
 
-    case method
+    http_method = spec[:method]
+    case http_method
     when 'get'
-      status, body = http.get(url, headers: headers)
+      http.get(url, headers: headers)
     else
-      status, body = http.send(method, url, payload: args[:payload], headers: headers)
+      payload = payload
+      http.send(http_method, url, payload: payload, headers: headers)
     end
-
-    [status, body]
   end
 
-  def self.build_url(_url)
-    raise NotImplementedError
-  end
+  def validate_input!(spec, args)
+    args = [{}] if args.size == 0
+    input_payload = args[0][:payload] || {}
+    input_parameters = args[0].with_indifferent_access
+
+    parameters = spec[:spec]['parameters'] || []
 
-  def self.validate_payload!(payload, keys:, required:)
-    bad_names = []
-    payload.each do |k, v|
-      unless keys.include?(k.to_s)
-        bad_names << k
+    parameters_map = {}
+    required_parameters = []
+    parameters.each do |parameter|
+      key = parameter['name']
+      parameters_map[key] = parameter
+      required_parameters << key if parameter['required'] == true
+    end
+
+    missing_parameters = required_parameters - input_parameters.keys
+    if missing_parameters.size > 0
+      raise ArgumentError.new "Missing required parameters: #{missing_parameters.join(', ')}"
+    end
+
+    unknown_parameters = []
+    skippable_parameters = [:payload, :headers, 'payload', 'headers']
+    input_parameters.each do |key, value|
+      next if skippable_parameters.include?(key)
+
+      if parameters_map[key].nil?
+        unknown_parameters << key
+      end
+    end
+
+    if unknown_parameters.size > 0
+      raise ArgumentError.new "Unknown parameters: #{unknown_parameters.join(', ')}"
+    end
+
+    # But watch out, payload is not here!
+    payload_keys = []
+    payload_required_keys = []
+    required_keys = []
+    if spec[:spec]['requestBody']
+      request_body_schema_ref = spec[:spec]['requestBody']['content']['application/json']['schema']['$ref']
+      key = request_body_schema_ref.split('/').last
+      schema = MemoriClient::Swagger::SchemaStore.instance.get(key)
+      
+      required_keys = schema['required'] || []
+
+      schema['properties'].each do |key, value|
+        required = value['nullable'] == false || required_keys.include?(key)
+        payload_keys << key
+        payload_required_keys << key if required
       end
     end
 
-    if bad_names.size > 0
-      raise ArgumentError.new "Found invalid keys: #{bad_names.join(', ')}"
+    missing_payload_keys = payload_required_keys - input_payload.keys
+    puts "missing_payload_keys: #{missing_payload_keys} => #{payload_required_keys} - #{input_payload.keys}"
+    if missing_payload_keys.size > 0
+      raise ArgumentError.new "Missing required payload keys: #{missing_payload_keys.join(', ')}"
     end
+
+    [input_parameters, input_payload]
   end
+
+  # def self.build_arguments(the_binding)
+  #   the_binding.local_variables.each_with_object({}) do |key, acc|
+  #     value = the_binding.local_variable_get(key)
+  #     acc[key] = value
+  #   end
+  # end
+
+  # def self.exec_http_request(method, path, args)
+  #   headers = args[:headers] || {}
+  #   stop = false
+  #   processed_tokens = []
+  #   path.split('/').each do |token|
+  #     break if stop == true
+  #     if token =~ /^{.*}$/
+  #       param_name = token.match(/^{(.*)}$/).captures.first
+  #       if args[param_name.to_sym].blank?
+  #         stop = true
+  #       else
+  #         processed_tokens << args[param_name.to_sym]
+  #       end
+  #     else
+  #       processed_tokens << token
+  #     end
+  #   end
+
+  #   url = processed_tokens.join('/')
+  #   url = build_url(url)
+  #   http = MemoriClient::HttpClient.new
+
+  #   case method
+  #   when 'get'
+  #     status, body = http.get(url, headers: headers)
+  #   else
+  #     status, body = http.send(method, url, payload: args[:payload], headers: headers)
+  #   end
+
+  #   [status, body]
+  # end
+
+  # def self.build_url(_url)
+  #   raise NotImplementedError
+  # end
+
+  # def self.validate_payload!(payload, keys:, required:)
+  #   bad_names = []
+  #   payload.each do |k, v|
+  #     unless keys.include?(k.to_s)
+  #       bad_names << k
+  #     end
+  #   end
+
+  #   if bad_names.size > 0
+  #     raise ArgumentError.new "Found invalid keys: #{bad_names.join(', ')}"
+  #   end
+  # end
 end

data/lib/memori_client/resource_proxy.rb

@@ -0,0 +1,25 @@
+module MemoriClient
+  class ResourceProxy
+    attr_reader :resources
+
+    def initialize(api_root:, version:)
+      @api_root = api_root
+      @version = version
+      @resources = {}
+    end
+
+    def register_resource(klass)
+      @resources[klass] ||= MemoriClient::Resource.new(klass, api_root: @api_root, version: @version)
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      if @resources.key?(method.to_s)
+        @resources[method.to_s]
+      else
+        super
+      end
+    end
+  end
+end

data/lib/memori_client/response.rb

@@ -0,0 +1,48 @@
+# Wraps the response from the API
+module MemoriClient
+  class Response
+    def initialize(response, request: nil)
+      @response = response
+      @request = request
+    end
+
+    def as_json
+      {
+        status: status,
+        success: success?,
+        error: error?,
+        parsed_body: parsed_body
+      }
+    end
+
+    def status
+      @response.code.to_i
+    end
+
+    def success?
+      @response.code.to_i == 200
+    end
+
+    def error?
+      !success?
+    end
+
+    def parsed_body
+      return @parsed_body if @parsed_body
+      
+      body = @response.read_body
+
+      if @request['Content-Type'] == 'application/json' || @response.content_type == 'application/json'
+        if body.nil? || body == ''
+          @parsed_body = {}
+        else
+          @parsed_body = JSON.parse(body)
+        end
+      else
+        @parsed_body = body
+      end
+
+      @parsed_body
+    end
+  end
+end

data/lib/memori_client/swagger/errors.rb

@@ -0,0 +1,5 @@
+module MemoriClient
+  module Swagger
+    class MethodCollisionError < StandardError; end
+  end
+end

data/lib/memori_client/swagger/get_module_and_method.rb

@@ -0,0 +1,44 @@
+module MemoriClient 
+  module Swagger
+    class GetModuleAndMethod
+      def initialize(namespace, method, path, endpoint_data)
+        @endpoint_data = endpoint_data
+        @namespace = namespace
+        @method = method
+        @path = path
+      end
+
+      def call
+        # Load using gem path as root
+        gem_path = Gem.loaded_specs['memori-client'].full_gem_path
+        # Not sure if this is visible after gem release.
+        overrides_path = File.join(gem_path, "#{@namespace}_overrides.jsonc")
+        if File.exist?(overrides_path)
+          overrides = JSON.parse(File.open(overrides_path).read)
+        else
+          raise "No overrides found for #{@namespace}"
+        end
+        # overrides = JSON.parse(File.open("#{@namespace}_overrides.jsonc").read)
+        key = [@method, @path].join(' ')
+        if overrides.key?(key)
+          # puts "THERE IS AN OVERRIDE FOR #{key}. Operation id is #{@endpoint_data['operationId']}"
+          value = overrides[key]
+          return value.split('#')
+        end
+
+        if @endpoint_data.key?('operationId')
+          version = @path.split('/').find { |t| t =~ /v\d+/ }
+          controller, action = @endpoint_data['operationId'].split('-')
+          mod = [
+            'MemoriClient',
+            @namespace.titleize,
+            version.upcase,
+            controller.singularize
+          ].join('::')
+
+          return [mod, action.underscore]
+        end
+      end
+    end
+  end 
+end

data/lib/memori_client/swagger/process_specification.rb

@@ -0,0 +1,125 @@
+module MemoriClient
+  module Swagger
+    class ProcessSpecification
+      attr_reader :swagger_spec
+      def initialize(uri:, kind:)
+        @uri = uri
+        @kind = kind
+        @result = {}
+        @endpoints = {}
+        @methods = {}
+        @methods_collisions = []
+      end
+
+      def call
+        data = URI.open(@uri).read
+        parsed = JSON.parse(data)
+        @swagger_spec = parsed
+        paths = parsed['paths']
+        # routes = collect_routes(paths)
+        # puts JSON.pretty_generate(routes)
+        paths.each do |path, path_data|
+          path_data.each do |method, endpoint|
+            module_name, info = analyze_path(method, path, endpoint)
+            unless module_name.nil?
+              @result[module_name] ||= []
+              @result[module_name] << info
+            end
+          end
+        end
+
+        # Verify collisions
+        @methods.keys.sort.each do |m|
+          @methods_collisions << m if @methods[m].size > 1
+        end
+
+        if @methods_collisions.any?
+          details = @methods_collisions.map do |m|
+            endpoints = @methods[m].map { |e| "      #{e}" }.join("\n")
+            "  - #{m} (#{@methods[m].size} endpoints):\n#{endpoints}"
+          end.join("\n")
+
+          raise MemoriClient::Swagger::MethodCollisionError, <<~MSG
+            Cannot process '#{@kind}' spec from #{@uri}: #{@methods_collisions.size} method collision(s) detected.
+            Two or more endpoints generate the same method name. Add an override entry in
+            '#{@kind}_overrides.jsonc' with key "<http_method> <path>" and value "Module#method"
+            to disambiguate one of the conflicting endpoints.
+            Collisions detected:
+            #{details}
+          MSG
+        end
+
+        @result
+      end
+
+      private
+
+      def analyze_path(method, path, endpoint_data)
+        re = /\/(memori|api)\/(v\d+)\/.*$/
+        version = path.match(re).captures[1].upcase
+
+        # cleaned_path = get_cleaned_path(path)
+
+        endpoint_key = [method, path].join(' ')
+        @endpoints[endpoint_key] ||= 0
+        @endpoints[endpoint_key] += 1
+
+        module_name, method_name = GetModuleAndMethod.new(@kind, method, path, endpoint_data).call
+        return if module_name.nil?
+
+        method_qname = [module_name, method_name].join('.')
+        @methods[method_qname] ||= []
+        @methods[method_qname] << endpoint_key
+
+        params = {}
+        unless endpoint_data['parameters'].nil?
+          endpoint_data['parameters'].each do |param|
+            k = param['name']
+            params[k] = param['required'] == true
+          end
+        end
+
+        data = {
+          method: method,
+          version: version,
+          path: path,
+          module: module_name,
+          method_name: method_name,
+          params: params,
+          request_body: !endpoint_data['requestBody'].nil?,
+          summary: endpoint_data['summary'],
+          spec: endpoint_data
+        }
+
+        if endpoint_data['requestBody']
+          request_body_schema_ref = endpoint_data['requestBody']['content']['application/json']['schema']['$ref']
+          key = request_body_schema_ref.split('/').last
+          schema = @swagger_spec['components']['schemas'][key]
+
+          SchemaStore.instance.add(key, schema)
+        end
+
+        [module_name, data]
+      end
+
+      def collect_routes(paths)
+        routes = {}
+        paths.each do |path, path_data|
+          path_data.each do |method, endpoint|
+            k = [method, path].join(' ')
+
+            re = /\/(memori|api)\/(v\d+)\/.*$/
+            tag = endpoint['tags'].first.singularize
+            puts path.inspect
+            version = path.match(re).captures[1].upcase
+            next if version == 'v1'
+
+            main = path.split('/')[3].underscore
+            routes[k] = "MemoriClient::#{@kind.titleize}::#{version}::#{tag}##{main}"
+          end
+        end
+        routes
+      end
+    end
+  end
+end

data/lib/memori_client/swagger/schema_store.rb

@@ -0,0 +1,26 @@
+# Holds the schema for the swagger spec
+#
+# It is used to validate the payload against the schema
+#
+# It is also used to generate the documentation
+
+require 'singleton'
+module MemoriClient
+  module Swagger
+    class SchemaStore
+      include Singleton
+
+    def initialize
+      @schemas = {}
+    end
+
+    def add(key, schema)
+      @schemas[key] = schema
+    end
+
+    def get(key)
+      @schemas[key]
+      end
+    end
+  end
+end

data/lib/memori_client.rb

@@ -1,48 +1,17 @@
 module MemoriClient
-  module Backend
-    module V1
-
-    end
-
-    module V2
-      
-    end
-  end
-
   module Engine
-    module V1
-
-    end
-
-    module V2
-      module Private
-
-      end
-    end
   end
 
-  class << self
-    # Instantiate the Configuration singleton
-    # or return it. Remember that the instance
-    # has attribute readers so that we can access
-    # the configured values
-    def configuration
-      @configuration ||= Configuration.new
-    end
+  module Proxy
+  end
 
-    # This is the configure block definition.
-    # The configuration method will return the
-    # Configuration singleton, which is then yielded
-    # to the configure block. Then it's just a matter
-    # of using the attribute accessors we previously defined
-    def configure
-      yield(configuration)
-    end
+  module Swagger
   end
 end
 
 require 'securerandom'
 require 'uri'
+require 'open-uri'
 require 'json'
 
 if defined?(::Rails)
@@ -50,16 +19,20 @@ if defined?(::Rails)
   require 'memori_client/railtie'
 end
 
-require 'memori_client/configuration'
+require 'memori_client/swagger/errors'
+require 'memori_client/swagger/process_specification'
+require 'memori_client/swagger/get_module_and_method'
+require 'memori_client/swagger/schema_store'
+
+require 'memori_client/client_factory'
+require 'memori_client/client'
 require "memori_client/http_client"
+require "memori_client/response"
 require "memori_client/resource"
-require "memori_client/backend/resource"
-require "memori_client/backend/resources"
+require "memori_client/resource_proxy"
+require "memori_client/operation"
 require "memori_client/engine/hmac_helper"
-require "memori_client/engine/resource"
-require "memori_client/engine/resources"
+require "memori_client/proxy/client"
 
-require "memori_client/engine/v2/private/memori"
-require "memori_client/engine/v2/private/memori_block"
 
 

data/lib/tasks/memori_client.rake

@@ -5,11 +5,4 @@ namespace :memori_client do
       MemoriClient::Utils::Rails.copy_docs
     end
   end
-
-  namespace :config do
-    desc "Copy MemoriClient initializer to Rails config/initializers"
-    task :copy_initializer do
-      MemoriClient::Utils::Rails.copy_initializer
-    end
-  end
 end