zleb 0.1.6

data/lib/zleb/plugins/basic_restful_action.rb

@@ -0,0 +1,212 @@
+
+
+
+class Roda
+  module RodaPlugins
+    module BasicRestfulAction
+      extend Dry::Container::Mixin
+
+      def self.configure(config)
+
+      end
+  
+      def self.load_dependencies(app, _opts = OPTS)
+        app.plugin :params_check
+        app.plugin :symbolized_params
+      end
+
+      # module included in the Roda class
+      module ClassMethods
+
+      end
+
+
+      class Config
+        def initialize()
+          @config = {}
+        end
+
+        def [](name)
+          @config[name]
+        end
+
+        def method_missing(meth, *args, &block)
+          if meth =~ /(\w+)=$/
+            @config[$1.to_sym] = args[0]
+          else
+            if block
+              @config[meth] = block
+            end
+          end
+        end
+      end
+
+      # baisc_restful_action(:db_config, DBConfig) do |config|
+      #   config.create_field_checker do
+      #     required(:type).filled(:string)
+      #   end
+      #   config.unique_check_field_names = [:name]
+      #   config.more_create_properties = {user: id}
+
+      #   config.modify_field_checker do
+      #     required(:type).filled(:string)
+      #   end
+
+      #   config.more_query_properties = {user: id}
+      # end
+      
+      module InstanceMethods
+        def baisc_restful_action(name, model_class)
+          r = request
+          config = Config.new
+          yield config
+
+          begin
+            r.is do
+              #create
+              r.post do
+                desc "#{name}_create"
+                input_params = params
+                if config[:create_field_checker]
+                  params_check :"#{name}_create" do
+                    params(&config[:create_field_checker])
+                  end
+                  input_params = checked_params
+                end
+                resource_field_filter_define(config)
+                
+
+                resource_unique_check(name, config, input_params, model_class)
+
+                resouce_properties = input_params
+                if config[:more_create_properties]
+                  resouce_properties = resouce_properties.merge(config[:more_create_properties])
+                end
+
+                resouce = model_class.create(resouce_properties)
+              end
+              
+              #get all
+              r.get do
+                desc "#{name}_list"
+
+                condition = params
+                if config[:more_query_properties]
+                  condition = condition.merge(config[:more_query_properties])
+                end
+  
+                resource_field_filter_define(config, :array)
+
+                resources = model_class.where(condition).order_by(created_at: -1)
+
+                result = []
+                resources.each do |item|
+                  result << item.to_h
+                end
+                result
+              end
+            end
+    
+            r.is String do |id|
+
+              unless is_interface_info_request?
+                resource = model_class.find(id)
+                checker = config[:resource_permission_checker]
+                if checker
+                  unless checker.call(resource)
+                    response.status = 403
+                    return {error: "not allowed"}
+                  end
+                end
+              end
+
+              # delete one
+              r.delete do
+                desc "#{name}_delete"
+                output_filter do
+                  required(:success).filled(:string)
+                  required(:id).filled(:string)
+                end
+                resource.destroy
+                { success: "deleted", id: id }
+              end
+
+              # get one
+              r.get do
+                desc "#{name}_get"
+                resource_field_filter_define(config)
+                resource
+              end
+              
+              #modified one
+              r.patch do
+                desc "#{name}_modify"
+
+                input_params = params
+                if config[:modify_field_checker]
+                  params_check :"#{name}_modify" do
+                    params(&config[:modify_field_checker])
+                  end
+                  input_params = checked_params
+                end
+                resource_field_filter_define(config)
+
+                resource_unique_check(name, config, resource.to_h.merge(input_params), model_class, [id])
+                resouce_properties = input_params
+                if config[:more_update_properties]
+                  resouce_properties = resouce_properties.merge(config[:more_update_properties])
+                end
+
+                resource.update_attributes(resouce_properties)
+                resource.save
+
+                resource
+              end
+            end
+          rescue Mongoid::Errors::DocumentNotFound => doc_not_found
+            response.status = 400
+            { error: "#{name} not existed" }
+          rescue Mongo::Error::OperationFailure => op_error
+            response.status = 400
+            { error: op_error.message }
+          end
+        end
+
+        private
+
+        def resource_unique_check(resource_class_name, config, input_params, model_class, exclude_items = [])
+          if config[:unique_check_field_names]
+            unique_condition = {}
+            config[:unique_check_field_names].each do |data_name|
+              if data_name.class == Hash
+                data_name.each do |n, v|
+                  unique_condition[n] = v
+                end
+              else
+                unique_condition[data_name] = input_params[data_name]
+              end
+            end
+  
+            if model_class.not.in(id: exclude_items).where(unique_condition).first
+              response.status = 400
+              response['Content-Type'] = 'application/json'
+              response.write({ error: "#{resource_class_name} already existed: #{unique_condition}", conflict_field: unique_condition}.to_json)
+              throw :halt, response.finish
+            end
+          end
+        end
+
+        def resource_field_filter_define(config, type = :hash)
+          if config[:resource_field_filter]
+            output_filter(type, &config[:resource_field_filter])
+          end
+        end
+
+      end
+
+
+    end
+
+    register_plugin(:basic_restful_action, BasicRestfulAction)
+  end
+end

data/lib/zleb/plugins/dry_schema_enhance.rb

@@ -0,0 +1,44 @@
+require "dry/schema"
+
+# module Dry
+#   module Schema
+#     module Macros
+#       class Key < DSL
+#         def desc(*args)
+#           #just solution for call error
+#         end
+#       end
+#     end
+#   end
+# end
+
+module Dry
+  module Schema
+    module Messages
+      class Abstract
+        # Abstract class for message backends
+        #
+        # @api public
+        def get_message_for_key(predicate, options)
+          options = { locale: default_locale, **options }
+          opts = options.reject { |k, | config.lookup_options.include?(k) }
+          path = lookup_paths(predicate, options).detect { |key| key?(key, opts) }
+
+          return unless path
+
+          result = get(path, opts)
+        end
+      end
+    end
+  end
+end
+
+
+class Dry::Schema::Macros::DSL
+  def default(value)
+    schema_dsl.before(:rule_applier) do |result|
+      result.update(name => value) if result.output && !result[name]
+    end
+    self
+  end
+end

data/lib/zleb/plugins/http_auth.rb

@@ -0,0 +1,70 @@
+# from gem 'roda-http-auth'
+# plugin :http_auth, authenticator: ->(user, pass) { [user, pass] == %w[foo bar] },
+#                    realm: 'Restricted Area', # default
+#                    schemes: %w[basic] # default
+
+module Roda::RodaPlugins
+  module HttpAuth
+    DEFAULTS = {
+      realm: "Restricted Area",
+      unauthorized_headers: ->(opts) do
+        { 'WWW-Authenticate' => ('Basic realm="%s"' % opts[:realm]) }
+      end,
+      unauthorized: ->(r) {},
+      schemes: %w[basic]
+    }
+
+    def self.configure(app, opts={})
+      plugin_opts = (app.opts[:http_auth] ||= DEFAULTS)
+      app.opts[:http_auth] = plugin_opts.merge(opts)
+      app.opts[:http_auth].freeze
+    end
+
+    module InstanceMethods
+      def http_auth(opts={}, &authenticator)
+        auth_opts = request.roda_class.opts[:http_auth].merge(opts)
+        authenticator ||= auth_opts[:authenticator]
+
+        raise "Must provide an authenticator block" if authenticator.nil?
+
+        auth = Rack::Auth::Basic::Request.new(env)
+
+        unless auth.provided? && auth_opts[:schemes].include?(auth.scheme)
+          unauthorized(auth_opts)
+        end
+
+        credentials = if auth.basic?
+                        auth.credentials
+                      elsif auth.scheme == 'bearer'
+                        [env['HTTP_AUTHORIZATION'].split(' ', 2).last]
+                      else
+                        http_auth = env['HTTP_AUTHORIZATION'].split(' ', 2)
+                                                             .last
+
+                        creds = !http_auth.include?('=') ? http_auth :
+                                  Rack::Auth::Digest::Params.parse(http_auth)
+
+                        [auth.scheme, creds]
+                      end
+
+        if authenticator.call(*credentials)
+          env['REMOTE_USER'] = auth.username
+        else
+          unauthorized(auth_opts)
+        end
+      end
+
+      private
+
+      def unauthorized(opts)
+        response.status = 401
+        response.headers.merge!(opts[:unauthorized_headers].call(opts))
+
+        request.block_result(instance_exec(request, &opts[:unauthorized]))
+        request.halt response.finish
+      end
+    end
+  end
+
+  register_plugin(:http_auth, HttpAuth)
+end

data/lib/zleb/plugins/method_route.rb

@@ -0,0 +1,59 @@
+require 'semantic_logger'
+
+class Roda
+  module RodaPlugins
+    module MethodRoute
+
+
+      def self.load_dependencies(app, _opts = OPTS)
+        app.plugin :hash_routes
+        app.plugin :json_parser
+      end
+      
+      module InstanceMethods
+        include SemanticLogger::Loggable
+        
+      end
+
+      module RequestMethods
+        def method_to(mod)
+          r_path = remaining_path
+          method_name = nil
+          result = nil
+          if r_path != ""
+            segments = r_path.split("/")
+            segments.shift
+            first_seg = segments.shift
+            first_seg[0] = first_seg[0].upcase
+            begin 
+              klass = mod.const_get(first_seg, false)
+            rescue NameError => e
+              return
+            end
+            segments.unshift(request_method.downcase)
+            method_name = segments.join("_").to_sym
+
+            processer = klass.new({request: self, response: response, headers: headers, params: params, scope: scope})
+            if processer.respond_to?(:init)
+              processer.init
+            end
+            if processer.respond_to?(method_name)
+              result = processer.send(method_name)
+            else
+              return
+            end
+            block_result(result)
+            halt
+          end
+        end
+
+      end
+
+      module ClassMethods
+        include SemanticLogger::Loggable
+      end
+    end
+
+    register_plugin(:method_route, MethodRoute)
+  end
+end

data/lib/zleb/plugins/params_check.rb

@@ -0,0 +1,312 @@
+require 'dry-container'
+require 'dry-validation'
+require_relative 'schema_compiler'
+
+
+class Hash
+  def select_items(*keys)
+      result = {}
+      keys.each do |k|
+          if has_key?(k)
+              result[k] = self[k]
+          end
+      end
+      result
+  end
+
+  def reject_items(*keys)
+      result = self.clone
+      keys.each do |k|
+          result.delete(k)
+      end
+      result
+  end
+  def deep_merge(second)
+      merger = proc { |_, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : Array === v1 && Array === v2 ? v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2 }
+      merge(second.to_h, &merger)
+  end
+end
+
+
+
+class Roda
+  module RodaPlugins
+    module ParamsCheck
+
+
+      module RequestCheckerContainer
+        extend Dry::Container::Mixin
+      end
+
+      module ResponseEntityFilterContainer
+        extend Dry::Container::Mixin
+      end
+
+      def self.configure(config)
+
+      end
+
+      def self.load_dependencies(app, _opts = OPTS)
+        app.plugin :request_headers
+      end
+
+
+      # build-in types
+      # Types::Nominal::Any
+      # Types::Nominal::Nil
+      # Types::Nominal::Symbol
+      # Types::Nominal::Class
+      # Types::Nominal::True
+      # Types::Nominal::False
+      # Types::Nominal::Bool
+      # Types::Nominal::Integer
+      # Types::Nominal::Float
+      # Types::Nominal::Decimal
+      # Types::Nominal::String
+      # Types::Nominal::Date
+      # Types::Nominal::DateTime
+      # Types::Nominal::Time
+      # Types::Nominal::Array
+      # Types::Nominal::Hash
+
+      #添加类型
+      module Types
+        include Dry::Types()
+      
+        StrippedString = Types::String.constructor(&:strip)
+      end
+      TypeContainer = Dry::Schema::TypeContainer.new
+      TypeContainer.register('params.stripped_string', Types::StrippedString)
+
+
+
+
+      #定义contract 来校验
+      class ApplicationContract < Dry::Validation::Contract
+        config.messages.default_locale = :cn
+        config.messages.load_paths <<  File.join(__dir__, "..", "..", "..", 'config', 'errors.yml') 
+
+        def self.params(&block)
+          add_config_block = Proc.new do
+            config.types = TypeContainer
+            self.instance_eval(&block)
+          end
+
+          param_schema = Dry::Schema.Params(&add_config_block)
+          extended_info = DrySchemaExtend::SchemaExtendEdInfo.define(&block)
+          
+          schema_info = DrySchemaExtend::SchemaInfoCompiler.new(param_schema)
+          schema_info.call
+          schema_info = schema_info.to_h
+          
+          @schema_info = extended_info.get_desc.deep_merge(schema_info[:children])
+          
+          super(&add_config_block)
+        end
+
+        def self.schema_info
+          @schema_info
+        end
+
+      end
+
+      module ClassMethods
+
+        def def_checker(&block)
+          block
+        end
+
+        def def_pub_checker(name, &block)
+          if !(RequestCheckerContainer.key?(name))
+            contract = Class.new(ApplicationContract, &block)
+            RequestCheckerContainer.register(name, contract.new)
+          end
+        end
+      end
+
+      OutputEncloseName = :output 
+
+
+      module InstanceMethods
+
+        def params_check(name=nil, &block)
+          if name == nil
+            name = "#{request.request_method} #{request.path}"
+          end 
+          if !(RequestCheckerContainer.key?(name))
+            contract = Class.new(ApplicationContract, &block)
+            begin
+              RequestCheckerContainer.register(name, contract.new)
+            rescue Dry::Container::Error => e
+              puts e.message
+            end
+          end
+          @input_checkers ||= []
+          checker = RequestCheckerContainer.resolve(name)
+          @input_checkers << checker
+
+          interface_info_flag = request.headers["Interface-Info"]
+          if interface_info_flag
+            input_params_schema_info = {}
+            @input_checkers.each do |ch|
+              input_params_schema_info = input_params_schema_info.deep_merge(ch.class.schema_info)
+            end
+            interface_info[:input_schema] = input_params_schema_info
+
+            return
+          end
+
+          result = checker.(request.params)
+          if (result.failure?)
+            response.status = 400
+            response['Content-Type'] = 'application/json'
+            response.write({error: result.errors.to_h }.to_json)
+            throw :halt, response.finish
+          end
+          @_checked_params = result
+        end
+
+        def process(&block)
+          if is_interface_info_request?
+            interface_info
+          else
+            self.instance_exec &block
+          end
+        end
+
+
+        def is_interface_info_request?
+          request.headers["Interface-Info"] != nil
+        end
+
+        def output_filter(type = :hash, safe = true, name = nil, &block)
+          request.output_entity_filter_safe = safe
+          if name == nil
+            name = "#{request.request_method} #{request.matched_path}"
+          end
+          if type == :array
+            contract_block = Proc.new do
+              params do
+                required(OutputEncloseName).array(:hash, &block)
+              end
+            end
+          else
+            contract_block = Proc.new do
+              params do
+                required(OutputEncloseName).hash(&block)
+              end
+            end
+          end
+          if !(ResponseEntityFilterContainer.key?(name))
+            contract = Class.new(ApplicationContract, &contract_block)
+            ResponseEntityFilterContainer.register(name, contract.new)
+          end
+          filter = ResponseEntityFilterContainer.resolve(name)
+
+          interface_info_flag = request.headers["Interface-Info"]
+          if interface_info_flag
+            output_entity_schema_info = filter.class.schema_info
+            interface_info[:output_schema] = output_entity_schema_info
+
+            response.status = 200
+            response['Content-Type'] = 'application/json'
+
+            res_data = nil
+            if interface_info_flag == 'output'
+              res_data = {output_schema: output_entity_schema_info}
+            elsif interface_info_flag == 'input'
+              res_data = {input_schema: @interface_info[:input_schema]}
+            elsif interface_info_flag == 'mock'
+              res_data = mock_data_extract(output_entity_schema_info)[OutputEncloseName]
+            elsif interface_info_flag == 'all'
+              res_data = @interface_info
+            else
+              res_data = {}
+            end
+            
+            response.write(res_data.to_json)
+            throw :halt, response.finish
+          end
+
+          @output_entity_filter = filter
+          request.output_entity_filter = filter
+        end
+
+        def desc(description)
+          @interface_info = {desc: description}
+        end
+
+        def def_checker(&block)
+          block
+        end
+
+        def checked_params
+          @_checked_params.to_h
+        end
+
+        private
+
+        def interface_info
+          @interface_info ||= {}
+        end
+
+        def mock_data_extract(schema_data)
+          result = {}
+          schema_data.each do |name, value|
+            if value[:member]
+              result[name] = [mock_data_extract(value[:member][:children])]
+            elsif value[:children]
+              result[name] = mock_data_extract(value[:children])
+            else
+              if value[:desc]
+                result[name] = value[:desc][:value]
+              end
+            end
+          end
+          result
+        end
+      end
+
+      module RequestMethods
+
+        def output_entity_filter=(output_entity_filter)
+          @output_entity_filter = output_entity_filter
+        end
+
+        def output_entity_filter_safe=(safe)
+          @output_entity_filter_safe = safe
+        end
+
+        private
+        # If the result is an instance of one of the json_result_classes,
+        # convert the result to json and return it as the body, using the
+        # application/json content-type.
+        def block_result_body(result)
+          
+          if @output_entity_filter and (response.status == nil or response.status < 300)
+            filter_data = @output_entity_filter.({OutputEncloseName => result})
+            if (filter_data.failure? and @output_entity_filter_safe == true)
+              response.status = 417
+              response['Content-Type'] = 'application/json'
+              response.write({error: filter_data.errors.to_h}.to_json)
+              throw :halt, response.finish
+            else
+              if filter_data.failure?
+                result = result
+              else
+                result = filter_data[OutputEncloseName]
+              end
+            end
+          end
+
+          super(result)
+        end
+      end
+
+    end
+
+    register_plugin(:params_check, ParamsCheck)
+  end
+end
+
+