sinja 0.1.0.beta1

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default=>:spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'sinatra/jsonapi/resource'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require 'pry'
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/sinatra/jsonapi.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+require 'set'
+require 'sinatra/base'
+require 'sinatra/namespace'
+
+require 'sinja'
+require 'sinja/version'
+
+require 'sinatra/jsonapi/config'
+require 'sinatra/jsonapi/helpers/serializers'
+require 'sinatra/jsonapi/resource'
+
+module Sinatra::JSONAPI
+  def resource(resource_name, konst=nil, &block)
+    abort "Must supply proc constant or block for `resource'" \
+      unless block = konst and konst.is_a?(Proc) or block
+
+    sinja_config.resource_roles[resource_name.to_sym] # trigger default proc
+
+    namespace "/#{resource_name.to_s.tr('_', '-')}" do
+      define_singleton_method(:can) do |action, roles|
+        sinja_config.resource_roles[resource_name.to_sym].merge!(action=>roles)
+      end
+
+      helpers do
+        define_method(:can?) do |*args|
+          super(resource_name.to_sym, *args)
+        end
+      end
+
+      register Resource
+
+      instance_eval(&block)
+    end
+  end
+
+  def sinja
+    if block_given?
+      yield sinja_config
+    else
+      sinja_config
+    end
+  end
+
+  alias_method :configure_jsonapi, :sinja
+  def freeze_jsonapi
+    sinja_config.freeze
+  end
+
+  def self.registered(app)
+    app.register Sinatra::Namespace
+
+    app.disable :protection, :static
+    app.set :sinja_config, Sinatra::JSONAPI::Config.new
+    app.configure(:development) do |c|
+      c.set :show_exceptions, :after_handler
+    end
+
+    app.set :actions do |*actions|
+      condition do
+        actions.each do |action|
+          halt 403, 'You are not authorized to perform this action' unless can?(action)
+          halt 405, 'Action or method not implemented or supported' unless respond_to?(action)
+        end
+        true
+      end
+    end
+
+    app.set :nullif do |nullish|
+      condition { nullish.(data) }
+    end
+
+    app.mime_type :api_json, MIME_TYPE
+
+    app.helpers Helpers::Serializers do
+      def can?(resource_name, action)
+        roles = settings.sinja_config.resource_roles[resource_name][action]
+        roles.nil? || roles.empty? || Set[*role].intersect?(roles)
+      end
+
+      def data
+        @data ||= deserialized_request_body[:data]
+      end
+
+      def normalize_params!
+        # TODO: halt 400 if other params, or params not implemented?
+        {
+          :fields=>{}, # passthru
+          :include=>[], # passthru
+          :filter=>{},
+          :page=>{},
+          :sort=>''
+        }.each { |k, v| params[k] ||= v }
+      end
+
+      def role
+        nil
+      end
+
+      def transaction
+        yield
+      end
+    end
+
+    app.before do
+      halt 406 unless request.preferred_type.entry == MIME_TYPE
+      halt 415 unless request.media_type == MIME_TYPE
+      halt 415 if request.media_type_params.keys.any? { |k| k != 'charset' }
+
+      content_type :api_json
+
+      normalize_params!
+    end
+
+    app.after do
+      body serialized_response_body if response.ok?
+    end
+
+    app.error 400...600, nil do
+      serialized_error
+    end
+  end
+end
+
+module Sinatra
+  register JSONAPI
+end

data/lib/sinatra/jsonapi/config.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+require 'forwardable'
+require 'set'
+
+require 'sinatra/jsonapi/relationship_routes/has_many'
+require 'sinatra/jsonapi/relationship_routes/has_one'
+require 'sinatra/jsonapi/resource_routes'
+
+module Sinatra::JSONAPI
+  module ConfigUtils
+    def deep_copy(c)
+      Marshal.load(Marshal.dump(c))
+    end
+
+    def deep_freeze(c)
+      c.tap { |i| i.values.each(&:freeze) }.freeze
+    end
+  end
+
+  class Config
+    include ConfigUtils
+    extend Forwardable
+
+    DEFAULT_SERIALIZER_OPTS = {
+      :jsonapi=>{ :version=>'1.0' }.freeze
+    }.freeze
+
+    DEFAULT_OPTS = {
+      :logger_progname=>'sinja',
+      :json_generator=>(Sinatra::Base.development? ? :pretty_generate : :generate),
+      :json_error_generator=>(Sinatra::Base.development? ? :pretty_generate : :fast_generate)
+    }.freeze
+
+    attr_reader \
+      :default_roles,
+      :resource_roles,
+      :conflict_actions,
+      :conflict_exceptions,
+      :serializer_opts
+
+    def initialize
+      @default_roles = RolesConfig.new
+      @resource_roles = Hash.new { |h, k| h[k] = @default_roles.dup }
+
+      self.conflict_actions = [
+        ResourceRoutes::CONFLICT_ACTIONS,
+        RelationshipRoutes::HasMany::CONFLICT_ACTIONS,
+        RelationshipRoutes::HasOne::CONFLICT_ACTIONS
+      ].reduce([], :concat)
+      self.conflict_exceptions = []
+
+      @opts = deep_copy(DEFAULT_OPTS)
+      self.serializer_opts = {}
+    end
+
+    def conflict_actions=(e=[])
+      @conflict_actions = Set[*e]
+    end
+
+    def conflict_exceptions=(e=[])
+      @conflict_exceptions = Set[*e]
+    end
+
+    def conflict?(action, exception_class)
+      @conflict_actions.include?(action) &&
+      @conflict_exceptions.include?(exception_class)
+    end
+
+    def_delegator :@default_roles, :merge!, :default_roles=
+
+    def serializer_opts=(h={})
+      @serializer_opts = deep_copy(DEFAULT_SERIALIZER_OPTS).merge!(h)
+    end
+
+    DEFAULT_OPTS.keys.each do |k|
+      define_method(k) { @opts[k] }
+      define_method("#{k}=") { |v| @opts[k] = v }
+    end
+
+    def freeze
+      @default_roles.freeze
+      @resource_roles.default_proc = nil
+      deep_freeze(@resource_roles)
+      @conflict_actions.freeze
+      @conflict_exceptions.freeze
+      deep_freeze(@serializer_opts)
+      @opts.freeze
+      super
+    end
+  end
+
+  class RolesConfig
+    include ConfigUtils
+    extend Forwardable
+
+    def initialize
+      @data = [
+        ResourceRoutes::ACTIONS,
+        RelationshipRoutes::HasMany::ACTIONS,
+        RelationshipRoutes::HasOne::ACTIONS
+      ].reduce([], :concat).map { |action| [action, Set.new] }.to_h
+    end
+
+    def_delegator :@data, :[]
+
+    def merge!(h={})
+      h.each do |action, roles|
+        abort "Unknown or invalid action helper `#{action}' in configuration" \
+          unless @data.key?(action)
+        @data[action].replace(Set[*roles])
+      end
+      @data
+    end
+
+    def initialize_copy(other)
+      super
+      @data = deep_copy(other.instance_variable_get(:@data))
+    end
+
+    def freeze
+      deep_freeze(@data)
+      super
+    end
+  end
+end

data/lib/sinatra/jsonapi/helpers/relationships.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require 'json'
+
+module Sinatra::JSONAPI
+  module Helpers
+    module Relationships
+      def dispatch_relationship_request(id, path, **opts)
+        fake_env = env.merge 'PATH_INFO'=>"/#{id}/relationships/#{path}"
+        fake_env['REQUEST_METHOD'] = opts[:method].to_s.tap(&:upcase!) if opts[:method]
+        fake_env['rack.input'] = StringIO.new(JSON.fast_generate(opts[:body])) if opts.key?(:body)
+        call(fake_env) # TODO: we may need to bypass postprocessing here
+      end
+
+      def dispatch_relationship_requests!(id, **opts)
+        data.fetch(:relationships, {}).each do |path, body|
+          response = dispatch_relationship_request(id, path, opts.merge(:body=>body))
+          # TODO: Gather responses and report all errors instead of only first?
+          halt(*response) unless (200...300).cover?(response[0])
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/jsonapi/helpers/sequel.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+require 'sequel/model/inflections'
+
+module Sinatra::JSONAPI
+  module Helpers
+    module Sequel
+      include ::Sequel::Inflections
+
+      def self.config(c)
+        c.conflict_exceptions = [::Sequel::ConstraintViolation]
+        #c.not_found_exceptions = [::Sequel::RecordNotFound]
+        #c.validation_exceptions = [::Sequel::ValidationVailed], proc do
+        #  format exception to json:api source.pointer and detail
+        #end
+      end
+
+      def database
+        ::Sequel::DATABASES.first
+      end
+
+      def transaction(&block)
+        database.transaction(&block)
+      end
+
+      def next_pk(resource, **opts)
+        [resource.pk, resource, opts]
+      end
+
+      def add_missing(association, *args)
+        meth = "add_#{singularize(association)}".to_sym
+        transaction do
+          resource.lock!
+          venn(:-, association, *args) do |subresource|
+            resource.send(meth, subresource)
+          end
+          resource.reload
+        end
+      end
+
+      def remove_present(association, *args)
+        meth = "remove_#{singularize(association)}".to_sym
+        transaction do
+          resource.lock!
+          venn(:&, association, *args) do |subresource|
+            resource.send(meth, subresource)
+          end
+          resource.reload
+        end
+      end
+
+      private
+
+      def venn(operator, association, rios)
+        klass = resource.class.association_reflection(association) # get e.g. ProductType for :types
+        dataset = resource.send("#{association}_dataset")
+        rios.map { |rio| rio[:id] }.tap(&:uniq!) # unique PKs in request payload
+          .send(operator, dataset.select_map(klass.primary_key)) # set operation with existing PKs in dataset
+          .each { |id| yield klass.with_pk!(id) } # TODO: return 404 if not found?
+      end
+    end
+  end
+end

data/lib/sinatra/jsonapi/helpers/serializers.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+require 'json'
+require 'jsonapi-serializers'
+require 'set'
+
+module Sinatra::JSONAPI
+  module Helpers
+    module Serializers
+      def deserialized_request_body
+        return {} unless request.body.respond_to?(:size) && request.body.size > 0
+
+        request.body.rewind
+        JSON.parse(request.body.read, :symbolize_names=>true)
+      rescue JSON::ParserError
+        halt 400, 'Malformed JSON in the request body'
+      end
+
+      def serialized_response_body
+        JSON.send settings.sinja_config.json_generator, response.body
+      rescue JSON::GeneratorError
+        halt 400, 'Unserializable entities in the response body'
+      end
+
+      def exclude!(options)
+        included, excluded = options.delete(:include), options.delete(:exclude)
+
+        included = Set.new(included.is_a?(Array) ? included : included.split(','))
+        excluded = Set.new(excluded.is_a?(Array) ? excluded : excluded.split(','))
+
+        included.delete_if do |termstr|
+          terms = termstr.split('.')
+          terms.length.times.any? do |i|
+            excluded.include?(terms.take(i.succ).join('.'))
+          end
+        end
+
+        options[:include] = included.to_a unless included.empty?
+      end
+
+      def serialize_model(model=nil, options={})
+        options[:is_collection] = false
+        options[:skip_collection_check] = defined?(::Sequel) && model.is_a?(::Sequel::Model)
+        options[:include] ||= params[:include] unless params[:include].empty?
+        options[:fields] ||= params[:fields] unless params[:fields].empty?
+
+        exclude!(options) if options[:include] && options[:exclude]
+
+        ::JSONAPI::Serializer.serialize model,
+          settings.sinja_config.serializer_opts.merge(options)
+      end
+
+      def serialize_model?(model=nil, options={})
+        if model
+          body serialize_model(model, options)
+        elsif options.key?(:meta)
+          body serialize_model(nil, :meta=>options[:meta])
+        else
+          status 204
+        end
+      end
+
+      def serialize_models(models=[], options={})
+        options[:is_collection] = true
+        options[:include] ||= params[:include] unless params[:include].empty?
+        options[:fields] ||= params[:fields] unless params[:fields].empty?
+
+        exclude!(options) if options[:include] && options[:exclude]
+
+        ::JSONAPI::Serializer.serialize [*models],
+          settings.sinja_config.serializer_opts.merge(options)
+      end
+
+      def serialize_models?(models=[], options={})
+        if [*models].any?
+          body serialize_models(models, options)
+        elsif options.key?(:meta)
+          body serialize_models([], :meta=>options[:meta])
+        else
+          status 204
+        end
+      end
+
+      def serialize_linkage(options={})
+        options = settings.sinja_config.serializer_opts.merge(options)
+        linkage.tap do |c|
+          c[:meta] = options[:meta] if options.key?(:meta)
+          c[:jsonapi] = options[:jsonapi] if options.key?(:jsonapi)
+        end
+      end
+
+      def serialize_linkage?(updated=false, options={})
+        body updated ? serialize_linkage(options) : serialize_model?(nil, options)
+      end
+
+      def serialize_linkages?(updated=false, options={})
+        body updated ? serialize_linkage(options) : serialize_models?([], options)
+      end
+
+      def normalized_error
+        return body if body.is_a?(Hash)
+
+        if not_found? && detail = [*body].first
+          title = 'Not Found'
+          detail = nil if detail == '<h1>Not Found</h1>'
+        elsif env.key?('sinatra.error')
+          title = 'Unknown Error'
+          detail = env['sinatra.error'].message
+        elsif detail = [*body].first
+        end
+
+        { title: title, detail: detail }
+      end
+
+      def error_hash(title: nil, detail: nil, source: nil)
+        { id: SecureRandom.uuid }.tap do |hash|
+          hash[:title] = title if title
+          hash[:detail] = detail if detail
+          hash[:status] = status.to_s if status
+          hash[:source] = source if source
+        end
+      end
+
+      def serialized_error
+        hash = error_hash(normalized_error)
+        logger.error(settings.sinja_config.logger_progname) { hash }
+        JSON.send settings.sinja_config.json_error_generator,
+          ::JSONAPI::Serializer.serialize_errors([hash])
+      end
+    end
+  end
+end