sinatra-rest-api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 31a424922bc37c8f72631ef6c2991dd3cedb9da4
+  data.tar.gz: bf71346a4cc7b8ac29d1f3b898641d167efd9c52
+SHA512:
+  metadata.gz: dab82f312bd1357305af0d0f7a3e46f495ab55cc682862a8377d33063def1e6fa8d019887429ed7118218173a98c7eeb6b08913def902845c51370e7befa95db
+  data.tar.gz: 948816326d8837873e9c30f36992da5c7dc6ee7595759c921cd5a617fac40991db871ebdad17de2eee6bfaf55b2d16107c41c8f1660cdf15f8be636c40b9c1ab

data/lib/sinatra-rest-api.rb

@@ -0,0 +1,22 @@
+# sinatra-rest-api
+$LOAD_PATH << File.join(File.dirname(__FILE__))
+
+require 'sinatra/base'
+
+require 'sinatra-rest-api/actions'
+require 'sinatra-rest-api/adapter'
+require 'sinatra-rest-api/provider'
+require 'sinatra-rest-api/router'
+
+# Sinatra namespace
+module Sinatra
+  # RestApi module definition
+  module RestApi
+    def resource( klass, options = {}, &block )
+      Provider.new( klass, options, self, &block )
+    end
+  end
+
+  # helpers RestApi
+  register RestApi
+end

data/lib/sinatra-rest-api/actions.rb

@@ -0,0 +1,90 @@
+module Sinatra
+  module RestApi
+    # Action
+    class Actions
+      DONE = { message: :ok }.freeze
+      # REF: https://en.wikipedia.org/wiki/Representational_state_transfer#Relationship_between_URL_and_HTTP_methods
+      SCHEMA = {
+        # Member actions
+        # list:     { verb: :get,    path: '/?:format?', fields: [ :id, :title, :author_id, :category_id ] },
+        read:     { verb: :get,    path: '/:id.?:format?' },
+        update:   { verb: :put,    path: '/:id.?:format?' },
+        delete:   { verb: :delete, path: '/:id.?:format?' },
+        # Collection actions
+        list:     { verb: :get,    path: '/?.?:format?' },
+        replace:  { verb: :put,    path: '/?.?:format?' },
+        create:   { verb: :post,   path: '/?.?:format?' },
+        truncate: { verb: :delete, path: '/?.?:format?' },
+        # Member actions
+        # update: { verb: [ :post, :put ], path: '/:id.?:format?' },
+      }.freeze
+
+      def self.create( route_args, params, mapping )
+        unless route_args[:request].form_data?
+          route_args[:request].body.rewind
+          params.merge!( Provider.settings[:request_type].eql?( :json ) ? JSON.parse( route_args[:request].body.read ) : route_args[:request].body.read )
+        end
+        params[:_data] = {}
+        resource = route_args[:resource]
+        if !params[resource].nil? && params[resource].is_a?( Hash )
+          cols = mapping[:columns].call( nil ) + mapping[:relations].call( nil ).map { |rel| "#{rel}_attributes" } + mapping[:extra_fields].call( nil )
+          cols.delete( 'id' ) # TODO: option to set id field name
+          params[:_data] = params[resource].select { |key, _valye| cols.include? key }
+          # params[:_data] = params[resource]
+          params.delete( resource )
+        end
+        # params[:_data]['created_at'] = Time.now.strftime( '%F %T' ).to_s
+        # params[:_data]['updated_at'] = Time.now.strftime( '%F %T' ).to_s
+        result = mapping[:create].call( params )
+        # route_args[:response].headers['Location'] = '/' # TODO: todo
+        [ 201, result.to_json ]
+      end
+
+      def self.delete( _route_args, params, mapping )
+        mapping[:delete].call( params )
+        [ 200, DONE.to_json ]
+      end
+
+      def self.list( route_args, params, mapping )
+        # TODO: option to enable X-Total-Count ?
+        params[:_where] = params[:_where].nil? ? '1=1' : JSON.parse( params[:_where] )
+        # params[:_where] = '1=1' unless params[:_where].present?
+        route_args[:response].headers['X-Total-Count'] = mapping[:count].call( params ).to_s
+        result = mapping[:list].call( params, route_args[:fields] )
+        [ 200, result.to_json( include: mapping[:relations].call( nil ) ) ]
+      end
+
+      def self.other( _route_args, params, mapping )
+        action = params[:_action]
+        raise( APIError, 'Action not implemented' ) if mapping[action].nil?
+        ret = mapping[action].call( params )
+        [ 200, ret.nil? ? DONE.to_json : ret.to_json ]
+      end
+
+      def self.read( _route_args, params, mapping )
+        result = mapping[:read].call( params )
+        [ 200, result.to_json( include: mapping[:relations].call( nil ) ) ]
+      end
+
+      def self.update( route_args, params, mapping )
+        unless route_args[:request].form_data?
+          route_args[:request].body.rewind
+          params.merge!( Provider.settings[:request_type].eql?( :json ) ? JSON.parse( route_args[:request].body.read ) : route_args[:request].body.read )
+        end
+        params[:_data] = {}
+        resource = route_args[:resource]
+        if !params[resource].nil? && params[resource].is_a?( Hash )
+          # params[resource].delete( 'id' ) # TODO: option to set id field name
+          # params[:_data] = OpenStruct.new( params[resource] )
+          cols = mapping[:columns].call( nil ) + mapping[:relations].call( nil ).map { |rel| "#{rel}_attributes" } + mapping[:extra_fields].call( nil )
+          # TODO: consider relations _ids
+          cols.delete( 'id' ) # TODO: option to set id field name
+          params[:_data] = params[resource].select { |key, _valye| cols.include? key }
+          params.delete( resource )
+        end
+        mapping[:update].call( params )
+        [ 200, DONE.to_json ]
+      end
+    end
+  end
+end

data/lib/sinatra-rest-api/adapter.rb

@@ -0,0 +1,168 @@
+require 'pry'
+
+module Sinatra
+  module RestApi
+    # ORM Mapping
+    class Adapter
+      TYPES = %w(ActiveRecord Mongoid Sequel).freeze
+      NOT_FOUND = [ 'ActiveRecord::RecordNotFound', 'Mongoid::Errors::DocumentNotFound', 'Sequel::NoMatchingRow' ].freeze
+
+      attr_reader :mapping, :model_singular
+
+      def initialize( provider )
+        @provider = provider
+        @klass = @provider.klass
+        parents = @klass.ancestors.map( &:to_s ) # List of super classes
+        if parents.include? 'ActiveRecord::Base'
+          @type = 'ActiveRecord'
+          @mapping = setup_activerecord
+        elsif parents.include? 'Mongoid::Document'
+          @type = 'Mongoid'
+          @mapping = setup_mongoid
+        elsif parents.include? 'Sequel::Model'
+          @type = 'Sequel'
+          @mapping = setup_sequel
+        else
+          @type = nil
+          @mapping = {}
+        end
+        @model_singular = provider.klass.to_s.split( '::' ).last.gsub( /([A-Z]+)([A-Z][a-z])/, '\1_\2' ).gsub( /([a-z\d])([A-Z])/, '\1_\2' ).tr( '-', '_' ).downcase
+      end
+
+      protected
+
+      ## Sample setup method
+      # def setup
+      #   {
+      #     # Collection actions
+      #     list: ->( _params ) { '' },
+      #     create: ->( _params ) { { id: 0 } },
+      #     truncate: ->( _params ) { '' },
+      #     # Member actions
+      #     read: ->( _params ) { '' },
+      #     update: ->( _params ) { '' },
+      #     delete: ->( _params ) { '' },
+      #     # Other actions
+      #     columns: ->( _params ) { [] },
+      #     count: ->( _params ) { 0 },
+      #     extra_fields: ->( _params ) { [] },
+      #     relations: ->( _params ) { [] }
+      #   }
+      # end
+
+      def setup_activerecord
+        {
+          # Collection actions
+          list: ->( params, fields ) { @klass.select( fields ).where( params[:_where] ).offset( params[:offset].to_i ).limit( params[:limit].nil? ? -1 : params[:limit].to_i ) },
+          # replace: { verb: :put,    path: '/?' },
+          create: lambda do |params|
+            item = @klass.new( params[:_data] )
+            item.save!
+            { id: item.id }
+          end,
+          truncate: ->( _params ) { @klass.delete_all },
+          # Member actions
+          read: ->( params ) { @klass.find( params[:id] ) },
+          update: lambda do |params|
+            row = @klass.find( params[:id] ) # Same as read
+            row.update!( params[:_data] )
+          end,
+          delete: lambda do |params|
+            row = @klass.find( params[:id] ) # Same as read
+            row.destroy
+          end,
+          # Other actions
+          columns:   ->( _params ) { @columns ||= @klass.column_names },
+          count:     ->(  params ) { @klass.where( params[:_where] ).count },
+          extra_fields: lambda do |_params|
+            @extra_fields ||= @klass.reflections.map do |_key, value|
+              Provider.klasses[value.class_name][:model_singular] + '_ids' if value.class.to_s == 'ActiveRecord::Reflection::HasManyReflection' || value.class.to_s == 'ActiveRecord::Reflection::HasAndBelongsToManyReflection'
+            end.compact
+          end,
+          relations: ->( _params ) { @relations ||= @klass.reflections.keys }
+        }
+      end
+
+      def setup_mongoid
+        {
+          # Collection actions
+          # list: ->( _params ) { @klass.all },
+          list: lambda do |params, fields|
+            if fields.nil?
+              @klass.all.skip( params[:offset].to_i ).limit( params[:limit].nil? ? 0 : params[:limit].to_i )
+            else
+              @klass.all.only( fields ).skip( params[:offset].to_i ).limit( params[:limit].nil? ? 0 : params[:limit].to_i )
+            end
+          end,
+          create: lambda do |params|
+            row = @klass.create!( params[:_data] )
+            { id: row.id }
+          end,
+          truncate: ->( _params ) { @klass.delete_all },
+          # Member actions
+          read: ->( params ) { @klass.find( params[:id] ) },
+          update: lambda do |params|
+            row = @klass.find( params[:id] ) # Same as read
+            row.update!( params[:_data] )
+          end,
+          delete: lambda do |params|
+            row = @klass.find( params[:id] ) # Same as read
+            row.destroy
+          end,
+          # Other actions
+          columns: ->( _params ) { @columns ||= @klass.attribute_names },
+          count: ->( _params ) { @klass.count },
+          extra_fields: ->( _params ) { [] },
+          relations: ->( _params ) { @relations ||= @klass.relations.keys }
+          # params: ->( _params ) { @params ||= @klass.attribute_names },   # TODO: try this way
+        }
+      end
+
+      def setup_sequel
+        {
+          # Collection actions
+          list: ->( params, fields ) { @klass.select( *fields ).where( params[:_where] ).offset( params[:offset].to_i ).limit( params[:limit].nil? ? nil : params[:limit].to_i ) },
+          # create: ->( params ) { @klass.insert( params[:_data] ) },
+          create: lambda do |params|
+            # Search nested ids
+            ids = {}
+            params[:_data].keys.reject { |k| !k.end_with?( '_ids' ) }.each do |k|
+              nk = k.sub( /_ids$/, '_pks' )
+              ids[nk] = params[:_data].delete k
+            end
+            # Create a new record
+            row = @klass.new( params[:_data] )
+            row.save
+            # Update ids
+            row.update( ids ) unless ids.empty?
+            { id: row.id }
+          end,
+          truncate: ->( _params ) { @klass.truncate },
+          # Member actions
+          read: ->( params ) { @klass.with_pk!( params[:id] ) },
+          update: lambda do |params|
+            row = @klass.with_pk!( params[:id] ) # Same as read
+            # Adjust nested ids
+            params[:_data].keys.reject { |k| !k.end_with?( '_ids' ) }.each do |k|
+              nk = k.sub( /_ids$/, '_pks' )
+              params[:_data][nk] = params[:_data].delete k
+            end
+            row.update( params[:_data] )
+          end,
+          delete: lambda do |params|
+            row = @klass.with_pk!( params[:id] ) # Same as read
+            row.delete
+          end,
+          # Other actions
+          columns:   ->( _params ) { @columns ||= @klass.columns.map( &:to_s ) },
+          count:     ->(  params ) { @klass.where( params[:_where] ).count },
+          extra_fields: lambda do |_params|
+            @extra_fields ||= @klass.association_reflections.map { |_key, value| Provider.klasses[value[:class_name].split( '::' ).last][:model_singular] + '_ids' if value[:type] == :one_to_many || value[:type] == :many_to_many }.compact
+          end,
+          # extra_fields: ->( _params ) { [] },
+          relations: ->( _params ) { @relations ||= @klass.associations }
+        }
+      end
+    end
+  end
+end

data/lib/sinatra-rest-api/provider.rb

@@ -0,0 +1,77 @@
+module Sinatra
+  module RestApi
+    # Prodiver
+    class Provider
+      OPTIONS = [ :actions, :plural, :singular ].freeze
+      REQUEST = {
+        # content_types: [ :formdata, :json, :multipart, :www_form ]
+        content_types: [ :json, :www_form ]
+      }.freeze
+      RESPONSE = {}.freeze
+
+      attr_reader :adapter, :app, :klass, :options, :router
+
+      @@klasses = {}
+      @@settings = {
+        request_type: :www_form
+      }
+
+      def initialize( klass, opts, app, &block )
+        @klass = klass
+        @options = opts
+        @app = app
+        instance_eval( &block ) if block_given?
+        init_settings
+        @adapter = Adapter.new( self )
+        @router = Router.new( self )
+        @router.generate_routes
+        klass_name = klass.to_s.split( '::' ).last
+        @@klasses[klass_name] = { class: klass, model_singular: @adapter.model_singular }
+        decorate_model
+      end
+
+      def method_missing( name, *args, &block )
+        super unless OPTIONS.include? name
+        @options[name] = args[0]
+      end
+
+      def respond_to_missing?( name, include_all = false )
+        super unless OPTIONS.include? name
+        true
+      end
+
+      def self.klasses
+        @@klasses
+      end
+
+      def self.settings
+        @@settings
+      end
+
+      private
+
+      def decorate_model
+        # Attach meta data to model
+        @klass.class.module_eval { attr_accessor :restapi }
+        @klass.restapi = {}
+        @klass.restapi[:model_singular] = @adapter.model_singular
+        # @klass.restapi[:model_plural] = @router.plural
+        @klass.restapi[:path_singular] = @router.path_singular
+        @klass.restapi[:path_plural] = @router.plural
+        # @klass.restapi_routes = routes
+        # @klass.association_reflections[:chapters][:class_name].split( '::' ).last
+        # => Chapter
+        # @@klasses['Book'][:model_singular]
+        # => book
+      end
+
+      def init_settings
+        @@settings[:request_type] = @app.restapi_request_type if defined?( @app.restapi_request_type ) && REQUEST[:content_types].include?( @app.restapi_request_type )
+      end
+    end
+
+    # API Exception class
+    class APIError < StandardError
+    end
+  end
+end

data/lib/sinatra-rest-api/router.rb

@@ -0,0 +1,116 @@
+module Sinatra
+  module RestApi
+    # Router
+    class Router
+      EXTS = [ 'json' ].freeze # TODO: load valid exts from an option
+      VERBS = [ :get, :post, :put, :patch, :delete, :options, :link, :unlink ].freeze
+
+      attr_reader :path_singular, :plural
+
+      @@all_routes = []
+
+      def initialize( provider )
+        @provider = provider
+        options = @provider.options
+        @path_singular = options[:singular].nil? ? provider.adapter.model_singular : options[:singular].downcase
+        @plural = options[:plural].nil? ? Router.pluralize( @path_singular ) : options[:plural].downcase
+        @routes = {}
+        routes = options[:actions].nil? ? Actions::SCHEMA.keys : options[:actions]
+        list = routes.delete :list
+        if routes.is_a?( Array )
+          # Move list action to the end to lower its priority
+          routes.push list unless list.nil?
+          routes.each { |route| init_route route, Actions::SCHEMA[route] if Actions::SCHEMA.include? route }
+        elsif routes.is_a?( Hash )
+          routes.each { |route, data| init_route route, data }
+          # Process list action in the end
+          init_route :list, list unless list.nil?
+        end
+      end
+
+      def generate_routes
+        @routes.each do |route, data|
+          path = "/#{@plural}#{data[:path]}"
+          if data[:verb].is_a?( Array )
+            data[:verb].each do |verb|
+              prepare_route( route: route, resource: @path_singular, verb: verb, path: path, fields: data[:fields], mapping: @provider.adapter.mapping )
+            end
+          else
+            prepare_route( route: route, resource: @path_singular, verb: data[:verb], path: path, fields: data[:fields], mapping: @provider.adapter.mapping )
+          end
+        end
+        @routes
+      end
+
+      def self.pluralize( string )
+        case string
+        when /(s|x|z|ch)$/
+          "#{string}es"
+        when /(a|e|i|o|u)y$/
+          "#{string}s"
+        when /y$/
+          "#{string[0..-2]}ies"
+        when /f$/
+          "#{string[0..-2]}ves"
+        when /fe$/
+          "#{string[0..-3]}ves"
+        else
+          "#{string}s"
+        end
+      end
+
+      def self.list_routes
+        @@all_routes
+      end
+
+      def self.on_error( e )
+        ret = 500
+        if e.class == APIError
+          ret = 400 # API error
+        elsif Adapter::NOT_FOUND.include? e.class.to_s
+          ret = 404 # Item not found
+        elsif Adapter::TYPES.include?( e.class.to_s.split( '::' )[0] ) || e.class == JSON::ParserError
+          ret = 400 # Invalid request
+        else
+          raise e
+        end
+        [ ret, { error: e.class.to_s, message: e.message }.to_json ]
+      end
+
+      private
+
+      def init_route( route, data )
+        return unless Actions::SCHEMA.include? route # Invalid action
+        @routes[route] = Actions::SCHEMA[route] unless data.is_a?( FalseClass )
+        return unless data.is_a?( Hash )
+        @routes[route][:verb] = data[:verb] unless data[:verb].nil?
+        @routes[route][:path] = data[:path] unless data[:path].nil?
+      end
+
+      def prepare_route( route_args )
+        if VERBS.include? route_args[:verb]
+          @@all_routes.push "#{route_args[:verb].upcase}: #{route_args[:path]}"
+          @provider.app.send( route_args[:verb], route_args[:path] ) do
+            # app = self
+            begin
+              raise( APIError, 'Invalid request format' ) if !params[:format].nil? && !EXTS.include?( params[:format] )
+              route_args[:request] = request
+              route_args[:response] = response
+              if Actions.respond_to? route_args[:route]
+                Actions.send( route_args[:route], route_args, params, route_args[:mapping] )
+              else
+                params[:_action] = route_args[:route]
+                Actions.other( route_args, params, route_args[:mapping] )
+              end
+            rescue StandardError => e
+              Router.on_error e
+            end
+          end
+        else
+          # logger.error "Invalid verb: #{verb}"
+          puts "Invalid verb: #{verb}" # TODO: use logger
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: sinatra-rest-api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mattia Roccoberton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.4.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.4.7
+description: 'Sinatra REST API generator: CRUD actions, nested resources, supports
+  ActiveRecord, Sequel and Mongoid'
+email: mat@blocknot.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sinatra-rest-api.rb
+- lib/sinatra-rest-api/actions.rb
+- lib/sinatra-rest-api/adapter.rb
+- lib/sinatra-rest-api/provider.rb
+- lib/sinatra-rest-api/router.rb
+homepage: https://github.com/blocknotes/sinatra-rest-api
+licenses:
+- ISC
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Sinatra REST API generator
+test_files: []