sinja 1.1.0.pre4 → 1.2.0.pre2

data/extensions/sequel/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'sinja-sequel'
+
+# 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/extensions/sequel/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/extensions/sequel/lib/sinatra/jsonapi/sequel.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+require 'sinja/sequel'
+require 'sinatra/jsonapi'
+
+module Sinatra
+  register JSONAPI::Sequel
+end

data/extensions/sequel/lib/sinja-sequel.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+require 'sinja/sequel'

data/extensions/sequel/lib/sinja/sequel.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+require 'sinja/sequel/helpers'
+require 'sinja/sequel/version'
+
+module Sinja
+  module Sequel
+    def self.registered(app)
+      app.helpers Helpers
+    end
+
+    def resource(res, try_convert=:to_i, &block)
+      klass = res.to_s.classify.constantize
+
+      super(res) do
+        register Resource
+
+        helpers do
+          def find(id)
+            klass[id.send(try_convert)]
+          end
+        end
+
+        show
+
+        show_many do |ids|
+          klass.where(klass.primary_key=>ids.map(&try_convert)).all
+        end
+
+        index do
+          klass.dataset
+        end
+
+        create do |attr|
+          tmp = klass.new
+          if respond_to?(:settable_fields)
+            tmp.set_fields(attr, settable_fields)
+          else
+            tmp.set(attr)
+          end
+          tmp.save(:validate=>false)
+          next_pk tmp
+        end
+
+        update do |attr|
+          if respond_to?(:settable_fields)
+            resource.update_fields(attr, settable_fields, :validate=>false, :missing=>:skip)
+          else
+            resource.set(attr)
+            resource.save_changes(:validate=>false)
+          end
+        end
+
+        destroy do
+          resource.destroy
+        end
+
+        instance_eval(&block) if block
+      end
+    end
+
+    module Resource
+      def has_one(rel, &block)
+        super(rel) do
+          pluck do
+            resource.send(rel)
+          end
+
+          prune(:sideload_on=>:update) do
+            resource.send("#{rel}=", nil)
+            resource.save_changes
+          end
+
+          graft(:sideload_on=>%i[create update]) do |rio|
+            klass = resource.class.association_reflection(rel).associated_class
+            resource.send("#{rel}=", klass.with_pk!(rio[:id]))
+            resource.save_changes(:validate=>!sideloaded?)
+          end
+
+          instance_eval(&block) if block
+        end
+      end
+
+      def has_many(rel, &block)
+        super(rel) do
+          fetch do
+            resource.send("#{rel}_dataset")
+          end
+
+          clear(:sideload_on=>:update) do
+            resource.send("remove_all_#{rel}")
+          end
+
+          replace(:sideload_on=>:update) do |rios|
+            add_remove(rel, rios)
+          end
+
+          merge(:sideload_on=>:create) do |rios|
+            add_missing(rel, rios)
+          end
+
+          subtract do |rios|
+            remove_present(rel, rios)
+          end
+
+          instance_eval(&block) if block
+        end
+      end
+    end
+  end
+end

data/extensions/sequel/lib/sinja/sequel/core.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+require 'forwardable'
+require 'sequel'
+
+module Sinja
+  module Sequel
+    module Core
+      extend Forwardable
+
+      def self.prepended(base)
+        base.sinja do |c|
+          c.conflict_exceptions << ::Sequel::ConstraintViolation
+          c.not_found_exceptions << ::Sequel::NoMatchingRow
+          c.validation_exceptions << ::Sequel::ValidationFailed
+          c.validation_formatter = ->(e) { e.errors.keys.zip(e.errors.full_messages) }
+        end
+
+        base.include Pagination if ::Sequel::Database::EXTENSIONS.key?(:pagination)
+      end
+
+      def_delegator ::Sequel::Model, :db, :database
+
+      def_delegator :database, :transaction
+
+      define_method :filter, proc(&:where)
+
+      def sort(collection, fields)
+        collection.order(*fields.map { |k, v| ::Sequel.send(v, k) })
+      end
+
+      define_method :finalize, proc(&:all)
+
+      def validate!
+        raise ::Sequel::ValidationFailed, resource unless resource.valid?
+      end
+    end
+
+    module Pagination
+      def self.included(base)
+        base.sinja { |c| c.page_using = {
+          :number=>1,
+          :size=>10,
+          :record_count=>nil
+        }}
+      end
+
+      def page(collection, opts)
+        collection = collection.dataset unless collection.respond_to?(:paginate)
+
+        opts = settings._sinja.page_using.merge(opts)
+        collection = collection.paginate opts[:number].to_i, opts[:size].to_i,
+          (opts[:record_count].to_i if opts[:record_count])
+
+        # Attributes common to all pagination links
+        base = {
+          :size=>collection.page_size,
+          :record_count=>collection.pagination_record_count
+        }
+
+        pagination = {
+          :first=>base.merge(:number=>1),
+          :self=>base.merge(:number=>collection.current_page),
+          :last=>base.merge(:number=>collection.page_count)
+        }
+        pagination[:next] = base.merge(:number=>collection.next_page) if collection.next_page
+        pagination[:prev] = base.merge(:number=>collection.prev_page) if collection.prev_page
+
+        return collection, pagination
+      end
+    end
+  end
+end

data/extensions/sequel/lib/sinja/sequel/helpers.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+require 'sinja/sequel/core'
+
+module Sinja
+  module Sequel
+    module Helpers
+      def self.included(base)
+        base.prepend Core
+      end
+
+      def next_pk(resource, opts={})
+        [resource.pk, resource, opts]
+      end
+
+      def add_remove(association, rios, try_convert=:to_i)
+        meth_suffix = association.to_s.singularize
+        add_meth = "add_#{meth_suffix}".to_sym
+        remove_meth = "remove_#{meth_suffix}".to_sym
+
+        dataset = resource.send("#{association}_dataset")
+        klass = dataset.association_reflection.associated_class
+
+        # does not / will not work with composite primary keys
+        new_ids = rios.map { |rio| rio[:id].send(try_convert) }
+        transaction do
+          resource.lock!
+          old_ids = dataset.select_map(klass.primary_key)
+          in_common = old_ids & new_ids
+
+          (new_ids - in_common).each do |id|
+            subresource = klass.with_pk!(id)
+            resource.send(add_meth, subresource) \
+              unless block_given? && !yield(subresource)
+          end
+
+          (old_ids - in_common).each do |id|
+            subresource = klass.with_pk!(id)
+            resource.send(remove_meth, subresource) \
+              unless block_given? && !yield(subresource)
+          end
+
+          resource.reload
+        end
+      end
+
+      def add_missing(*args, &block)
+        add_or_remove(:add, :-, *args, &block)
+      end
+
+      def remove_present(*args, &block)
+        add_or_remove(:remove, :&, *args, &block)
+      end
+
+      private
+
+      def add_or_remove(meth_prefix, operator, association, rios, try_convert=:to_i)
+        meth = "#{meth_prefix}_#{association.to_s.singularize}".to_sym
+        transaction do
+          resource.lock!
+          venn(operator, association, rios, try_convert) do |subresource|
+            resource.send(meth, subresource) \
+              unless block_given? && !yield(subresource)
+          end
+          resource.reload
+        end
+      end
+
+      def venn(operator, association, rios, try_convert)
+        dataset = resource.send("#{association}_dataset")
+        klass = dataset.association_reflection.associated_class
+        # does not / will not work with composite primary keys
+        rios.map { |rio| rio[:id].send(try_convert) }
+          .send(operator, dataset.select_map(klass.primary_key))
+          .each { |id| yield klass.with_pk!(id) }
+      end
+    end
+  end
+end

data/extensions/sequel/lib/sinja/sequel/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Sinja
+  module Sequel
+    VERSION = '0.1.0'
+  end
+end

data/extensions/sequel/sinja-sequel.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sinja/sequel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sinja-sequel'
+  spec.version       = Sinja::Sequel::VERSION
+  spec.authors       = ['Mike Pastore']
+  spec.email         = ['mike@oobak.org']
+
+  spec.summary       = 'Sequel-specific Helpers and DSL for Sinja'
+  spec.homepage      = 'https://github.com/mwpastore/sinja/tree/master/extensions/sequel'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = %w[lib]
+
+  spec.required_ruby_version = '>= 2.3.0'
+
+  spec.add_dependency 'sequel', '~> 4.0'
+  spec.add_dependency 'sinja', '>= 1.2.0.pre2', '< 2'
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'minitest', '~> 5.9'
+  spec.add_development_dependency 'rake', '~> 12.0'
+end

data/extensions/sequel/test/test_helper.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+require 'bundler/setup'
+require 'minitest/autorun'

data/lib/sinja.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
+require 'set'
+
 require 'active_support/inflector'
 require 'mustermann'
 require 'sinatra/base'
 require 'sinatra/namespace'
 
-require 'set'
 require 'sinja/config'
 require 'sinja/errors'
 require 'sinja/helpers/serializers'
@@ -220,8 +221,11 @@ module Sinja
       end
 
       def filter_by?(action)
-        return true if settings.resource_config[action][:filter_by].empty? ||
-          params[:filter].keys.to_set.subset?(settings.resource_config[action][:filter_by])
+        return if params[:filter].empty?
+
+        return params[:filter] \
+          if settings.resource_config[action][:filter_by].empty? ||
+            params[:filter].keys.to_set.subset?(settings.resource_config[action][:filter_by])
 
         raise BadRequestError, "Invalid `filter' query parameter(s)"
       end
@@ -239,8 +243,11 @@ module Sinja
       end
 
       def sort_by?(action)
-        return true if settings.resource_config[action][:sort_by].empty? ||
-          params[:sort].keys.to_set.subset?(settings.resource_config[action][:sort_by])
+        return if params[:sort].empty?
+
+        return params[:sort] \
+          if settings.resource_config[action][:sort_by].empty? ||
+            params[:sort].keys.to_set.subset?(settings.resource_config[action][:sort_by])
 
         raise BadRequestError, "Invalid `sort' query parameter(s)"
       end
@@ -257,25 +264,36 @@ module Sinja
       end
 
       def page_using?
-        return true if params[:page].keys.to_set.subset?(settings._sinja.page_using.keys.to_set)
+        return if params[:page].empty?
+
+        return params[:page] \
+          if params[:page].keys.to_set.subset?(settings._sinja.page_using.keys.to_set)
 
         raise BadRequestError, "Invalid `page' query parameter(s)"
       end
 
       def filter_sort_page?(action)
-        filter_by?(action) unless params[:filter].empty?
-        sort_by?(action) unless params[:sort].empty?
-        page_using? unless params[:page].empty?
-      end
+        return enum_for(__callee__, action).to_h unless block_given?
+
+        if filter = filter_by?(action)
+          yield :filter, filter
+        end
+
+        if sort = sort_by?(action)
+          yield :sort, sort
+        end
 
-      def filter_sort_page(collection)
-        collection = filter(collection, params[:filter]) unless params[:filter].empty?
-        collection = sort(collection, params[:sort]) unless params[:sort].empty?
-        collection, pagination = page(collection, params[:page]) unless params[:page].empty?
+        if page = page_using?
+          yield :page, page
+        end
+      end
 
-        collection = finalize(collection) if respond_to?(:finalize)
+      def filter_sort_page(collection, opts)
+        collection = filter(collection, opts[:filter]) if opts.key?(:filter)
+        collection = sort(collection, opts[:sort]) if opts.key?(:sort)
+        collection, pagination = page(collection, opts[:page]) if opts.key?(:page)
 
-        return collection, pagination
+        return respond_to?(:finalize) ? finalize(collection) : collection, pagination
       end
 
       def halt(code, body=nil)
@@ -306,10 +324,10 @@ module Sinja
 
       def sanity_check!(resource_name, id=nil)
         raise ConflictError, 'Resource type in payload does not match endpoint' \
-          if data[:type].to_sym != resource_name
+          unless data[:type] && data[:type].to_sym == resource_name
 
         raise ConflictError, 'Resource ID in payload does not match endpoint' \
-          if id && data[:id].to_s != id.to_s
+          unless id.nil? || data[:id] && data[:id].to_s == id.to_s
       end
 
       def transaction
@@ -332,6 +350,10 @@ module Sinja
       body serialize_response_body if response.ok? || response.created?
     end
 
+    app.not_found do
+      serialize_errors(&settings._sinja.error_logger)
+    end
+
     app.error 400...600 do
       serialize_errors(&settings._sinja.error_logger)
     end