openapi_rest 0.0.1

data/lib/openapi_rest/api_doc_parser.rb

@@ -0,0 +1,110 @@
+module OpenAPIRest
+  ###
+  # Api doc parser based on OpenAPI 2.0 specs
+  #
+  class ApiDocParser
+    attr_reader :method
+    attr_reader :document
+
+    def initialize(openapi_path)
+      @document = OpenAPIRest::ApiDoc.document
+      @route = openapi_path[:path]
+      @method = openapi_path[:method]
+      @method = 'patch' if @method == 'put'
+    end
+
+    def definitions
+      @current_step = document.fetch('definitions', {})
+      self
+    end
+
+    def parameters
+      @current_step = document.fetch('parameters', {})
+      self
+    end
+
+    def paths
+      @current_step = document.fetch('paths', {})
+      self
+    end
+
+    def find(key)
+      @current_step = @current_step.fetch(key, {})
+      self
+    end
+
+    def base_path
+      document.fetch('basePath', {})
+    end
+
+    def find_path
+      paths.find(@route.sub(base_path, '')).find(method)
+    end
+
+    def properties
+      @current_step = @current_step.fetch('properties', {})
+      self
+    end
+
+    def schema
+      @current_step = @current_step.fetch('schema', {})
+
+      if !@current_step['$ref'].nil?
+        if @current_step['$ref'].include?('#/definitions/')
+          str = @current_step['$ref'].gsub('#/definitions/', '')
+          return definitions.find(str)
+        end
+      elsif !@current_step['items'].nil?
+        if @current_step['items']['$ref'].include?('#/definitions/')
+          str = @current_step['items']['$ref'].gsub('#/definitions/', '')
+          return definitions.find(str)
+        end
+      end
+
+      self
+    end
+
+    def find_parameters
+      return if @current_step['parameters'].nil?
+
+      params = {}
+      ref_params = []
+      @current_step['parameters'].each do |parameter|
+        next if parameter['in'] == 'path'
+        if parameter['in'] == 'query' || parameter['in'] == 'body'
+          params[parameter['name']] = parameter['name']
+          next
+        end
+
+        if !parameter['$ref'].nil? && parameter['$ref'].include?('#/parameters/')
+          param = parameter['$ref'].gsub('#/parameters/', '')
+          ref_params << document.fetch('parameters', {}).fetch(param, {})
+        end
+      end
+
+      if ref_params.length > 0
+        params.merge!(ref_params.compact.map { |param| param.fetch('schema', {}).fetch('properties', {}) }.first)
+      end
+
+      params
+    end
+
+    def responses
+      @current_step = @current_step.fetch('responses', {})
+      self
+    end
+
+    def keys
+      @current_step.keys
+    end
+
+    def [](key)
+      @current_step = @current_step.fetch(key, {})
+      self
+    end
+
+    def to_s
+      @current_step
+    end
+  end
+end

data/lib/openapi_rest/api_model.rb

@@ -0,0 +1,36 @@
+module OpenAPIRest
+  ###
+  # Rest Api Model
+  #
+  class ApiModel
+    attr_reader :type
+    attr_accessor :model
+
+    def initialize(type)
+      @type = type
+      @model = type.to_s.capitalize!.constantize
+    end
+
+    def build(params, args = {}, &block)
+      native_query(params.merge(operation: :create), args, &block)
+    end
+
+    def where(params, args = {}, &block)
+      native_query(params.merge(operation: :query), args, &block)
+    end
+
+    def find(params, args = {}, &block)
+      native_query(params.merge(operation: :squery), args, &block)
+    end
+
+    private
+
+    def native_query(params, args)
+      query_builder = OpenAPIRest::QueryBuilder.new(self, params.merge(query: args))
+
+      yield(self) if block_given?
+
+      query_builder.response
+    end
+  end
+end

data/lib/openapi_rest/api_parameters.rb

@@ -0,0 +1,76 @@
+module OpenAPIRest
+  ###
+  # Rest Api Parameters
+  #
+  class ApiParameters
+    attr_reader :allowed_params, :validation_errors
+
+    def initialize(args)
+      @params = args.fetch(:params, {})
+      @model_class = args.fetch(:api_model).model
+      @doc_parser = OpenAPIRest::ApiDocParser.new(args.fetch(:openapi_path, {}))
+    end
+
+    def valid?
+      @validation_errors = []
+
+      validate
+
+      @validation_errors.empty?
+    end
+
+    def response_permitted_params
+      @doc_parser.find_path.responses.find(response_code).schema.properties.keys.collect(&:to_sym)
+    end
+
+    private
+
+    def response_code
+      return 204 if @doc_parser.method.to_sym == :patch || @doc_parser.method.to_sym == :delete
+      return 201 if @doc_parser.method.to_sym == :post
+      200
+    end
+
+    def validate
+      if !@params.include?(property_param) || @params[property_param].empty?
+        @validation_errors << ["Missing Parameter: #{property_param}"]
+        return @validation_errors
+      end
+
+      @allowed_params = @params.require(property_param).permit(save_permitted_params)
+      @validation_errors = @allowed_params.keys.map do |key|
+        OpenAPIRest::ApiValidator.new(root_parameters[key.to_s]).evaluate(key, @allowed_params)
+      end.compact
+    end
+
+    def save_permitted_params
+      root_parameters.keys.collect(&:to_sym)
+    end
+
+    def root_parameters
+      params = @doc_parser.find_path.find_parameters
+      puts 'ERROR: parameters not found' if params.nil?
+      params
+    end
+
+    def property
+      @model_class.name.demodulize
+    end
+
+    def property_param
+      if @model_class.name.nil?
+        @model_class.class.name.demodulize.downcase.to_sym
+      else
+        @model_class.name.demodulize.downcase.to_sym
+      end
+    end
+
+    def api_parameters(key)
+      @doc_parser.document.parameters.find(key)
+    end
+
+    def api_definitions(key)
+      @doc_parser.document.definitions.find(key)
+    end
+  end
+end

data/lib/openapi_rest/api_validator.rb

@@ -0,0 +1,20 @@
+module OpenAPIRest
+  ###
+  # Rest api validator
+  #
+  class ApiValidator
+    def initialize(parameter)
+      @parameter = parameter
+    end
+
+    def evaluate(key, value)
+      if @parameter['format'].present?
+        validator = OpenAPIRest::Validators::Format.new(@parameter['format'], value[key])
+        return validator.error(key) unless validator.valid?
+      elsif @parameter['pattern'].present?
+        validator = OpenAPIRest::Validators::Pattern.new(@parameter['pattern'], value[key])
+        return validator.error(key) unless validator.valid?
+      end
+    end
+  end
+end

data/lib/openapi_rest/extension.rb

@@ -0,0 +1,35 @@
+module OpenAPIRest
+  ###
+  # Rest Extension
+  #
+  module Extension
+    module ClassMethods #:nodoc:
+      def self.included(clazz)
+        clazz.send(:before_filter, :retrieve_openapi_path)
+      end
+
+      attr_reader :openapi_path
+
+      def retrieve_openapi_path
+        all_routes = Rails.application.routes.routes
+        path = request.path
+        nspace = ''
+        all_routes.each do |r|
+          next unless r.defaults.fetch(:openapi, false) && Regexp.new(r.verb).match(request.method)
+
+          match = Regexp.new(r.path.source).match(request.path)
+          next unless match
+
+          nspace = r.defaults.fetch(:namespace, '')
+          match.captures.each_with_index { |c, i| path.gsub!(c, "{#{r.path.names[i]}}") unless c.nil? }
+        end
+        @openapi_path = { method: request.method.downcase, path: path, namespace: "#{nspace}_" }
+        params.merge!(openapi_path: @openapi_path)
+      end
+
+      def render_rest(response)
+        OpenAPIRest::RestRenderer.new(controller: self, response: response).render
+      end
+    end
+  end
+end

data/lib/openapi_rest/operations/filter.rb

@@ -0,0 +1,24 @@
+module OpenAPIRest
+  module Operations
+    ###
+    # Rest filter operation
+    #
+    class Filter
+      def initialize(query_builder)
+        @query_builder = query_builder
+      end
+
+      def execute
+        return if @query_builder.query.count.zero?
+
+        unlocked_params = ActiveSupport::HashWithIndifferentAccess.new(@query_builder.query)
+
+        @query_builder.api_model.model = if @query_builder.single?
+                                           @query_builder.api_model.model.find_by(unlocked_params)
+                                         else
+                                           @query_builder.api_model.model.where(unlocked_params)
+                                         end
+      end
+    end
+  end
+end

data/lib/openapi_rest/operations/paginate.rb

@@ -0,0 +1,19 @@
+module OpenAPIRest
+  module Operations
+    ###
+    # Rest paginate operation
+    #
+    class Paginate
+      def initialize(query_builder)
+        @query_builder = query_builder
+      end
+
+      def execute
+        return if @query_builder.single?
+
+        @query_builder.api_model.model = @query_builder.api_model.model.limit(@query_builder.limit)
+                                                                       .offset(@query_builder.offset)
+      end
+    end
+  end
+end

data/lib/openapi_rest/operations/sort.rb

@@ -0,0 +1,27 @@
+module OpenAPIRest
+  module Operations
+    ###
+    # Rest sort operation
+    #
+    class Sort
+      def initialize(query_builder)
+        @query_builder = query_builder
+      end
+
+      def execute
+        return if @query_builder.single? || !@query_builder.sort.present?
+
+        sorts = @query_builder.sort.split(',')
+        order = sorts.map do |s|
+          if URI.encode_www_form_component(s)[0] == '+'
+            "#{s[1..s.length]} ASC"
+          else
+            "#{s[1..s.length]} DESC"
+          end
+        end.join(',')
+
+        @query_builder.api_model.model = @query_builder.api_model.model.order(order)
+      end
+    end
+  end
+end

data/lib/openapi_rest/query_builder.rb

@@ -0,0 +1,70 @@
+module OpenAPIRest
+  ###
+  # Rest Query Builder
+  #
+  class QueryBuilder
+    attr_reader :query
+    attr_reader :sort
+    attr_reader :limit
+    attr_reader :offset
+    attr_reader :fields
+    attr_reader :api_model
+    attr_reader :params
+    attr_reader :openapi_path
+
+    def initialize(api_model, params)
+      @fields = params.fetch(:fields, '')
+      @offset = params.fetch(:offset, 0)
+      @limit = params.fetch(:limit, 10)
+      @sort = params[:sort]
+      @embed = params[:embed]
+      @query = params.fetch(:query, {})
+      @openapi_path = params.fetch(:openapi_path)
+      @single = params[:operation] == :squery
+      @params = params
+      @api_model = api_model
+
+      set_fields
+
+      unless creating?
+        [OpenAPIRest::Operations::Filter.new(self),
+         OpenAPIRest::Operations::Sort.new(self),
+         OpenAPIRest::Operations::Paginate.new(self)].each { |operations| operations.execute }
+      end
+    end
+
+    def response
+      @response ||= OpenAPIRest::QueryResponse.new(self)
+      @response
+    end
+
+    def single_result?
+      creating? || @single
+    end
+    alias_method :single?, :single_result?
+
+    def resource
+      entity.to_s.singularize
+    end
+
+    def entity
+      @api_model.type.to_s.downcase.pluralize
+    end
+
+    def raw_model
+      @api_model.model
+    end
+
+    private
+
+    def creating?
+      @params[:operation] == :create
+    end
+
+    def set_fields
+      permitted = OpenAPIRest::ApiParameters.new(api_model: @api_model,
+                                                 openapi_path: @openapi_path).response_permitted_params
+      @fields = fields.length > 0 ? fields.split(',').select { |s| permitted.include?(s.to_sym) } : permitted
+    end
+  end
+end

data/lib/openapi_rest/query_response.rb

@@ -0,0 +1,89 @@
+module OpenAPIRest
+  ###
+  # Rest Query Response
+  #
+  class QueryResponse
+    attr_reader :query_builder
+    attr_reader :errors
+
+    delegate :single?, to: :query_builder
+    delegate :resource, to: :query_builder
+    delegate :entity, to: :query_builder
+    delegate :fields, to: :query_builder
+
+    def initialize(query_builder)
+      @query_builder = query_builder
+      @errors = []
+    end
+
+    def create_resource
+      @operation = :post
+
+      api_params = OpenAPIRest::ApiParameters.new(api_model: @query_builder.api_model,
+                                                  params: @query_builder.params,
+                                                  openapi_path: @query_builder.openapi_path)
+      unless api_params.valid?
+        @errors = api_params.validation_errors
+        return
+      end
+
+      create_params = api_params.allowed_params.merge!(@query_builder.query)
+      @model = @query_builder.raw_model.new(create_params)
+
+      return if @model.valid? && @model.save
+
+      build_errors
+    end
+
+    def update_resource
+      @operation = :patch
+
+      api_params = OpenAPIRest::ApiParameters.new(api_model: @query_builder.api_model,
+                                                  params: @query_builder.params,
+                                                  openapi_path: @query_builder.openapi_path)
+
+      unless api_params.valid?
+        @errors = api_params.validation_errors
+        return
+      end
+
+      @model = @query_builder.raw_model
+
+      return if !@model.nil? && @model.update(api_params.allowed_params)
+
+      build_errors
+    end
+
+    def delete_resource
+      @operation = :delete
+      @model = @query_builder.raw_model
+      return if !@model.nil? && @model.destroy
+
+      build_errors
+    end
+
+    def results?
+      if single?
+        !results.nil?
+      else
+        results.count > 0
+      end
+    end
+
+    def results
+      @model ||= @query_builder.raw_model
+    end
+
+    def errors?
+      !@errors.empty?
+    end
+
+    private
+
+    def build_errors
+      return if @model.nil?
+
+      @errors = @model.errors.keys.map { |k| { k => @model.errors[k].first } }
+    end
+  end
+end