graphiti 1.0.alpha.1

data/lib/graphiti/sideload/has_many.rb

@@ -0,0 +1,16 @@
+class Graphiti::Sideload::HasMany < Graphiti::Sideload
+  def type
+    :has_many
+  end
+
+  def load_params(parents, query)
+    query.to_hash.tap do |hash|
+      hash[:filter] ||= {}
+      hash[:filter][foreign_key] = ids_for_parents(parents)
+    end
+  end
+
+  def assign_each(parent, children)
+    children.select { |c| c.send(foreign_key) == parent.send(primary_key) }
+  end
+end

data/lib/graphiti/sideload/has_one.rb

@@ -0,0 +1,9 @@
+class Graphiti::Sideload::HasOne < Graphiti::Sideload::HasMany
+  def type
+    :has_one
+  end
+
+  def assign_each(parent, children)
+    children.find { |c| c.send(foreign_key) == parent.send(primary_key) }
+  end
+end

data/lib/graphiti/sideload/many_to_many.rb

@@ -0,0 +1,24 @@
+class Graphiti::Sideload::ManyToMany < Graphiti::Sideload
+  def type
+    :many_to_many
+  end
+
+  def through
+    foreign_key.keys.first
+  end
+
+  def true_foreign_key
+    foreign_key.values.first
+  end
+
+  def infer_foreign_key
+    raise 'You must explicitly pass :foreign_key for many-to-many relaitonships, or override in subclass to return a hash.'
+  end
+
+  def assign_each(parent, children)
+    children.select do |c|
+      match = ->(ct) { ct.send(true_foreign_key) == parent.send(primary_key) }
+      c.send(through).any?(&match)
+    end
+  end
+end

data/lib/graphiti/sideload/polymorphic_belongs_to.rb

@@ -0,0 +1,108 @@
+class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
+  class Group
+    attr_reader :name, :calls
+
+    def initialize(name)
+      @name = name
+      @calls = []
+    end
+
+    def method_missing(name, *args, &blk)
+      @calls << [name, args, blk]
+    end
+  end
+
+  class Grouper
+    attr_reader :field_name
+
+    def initialize(field_name)
+      @field_name = field_name
+      @groups = []
+    end
+
+    def on(name, &blk)
+      group = Group.new(name)
+      @groups << group
+      group.belongs_to(name.to_s.underscore.to_sym)
+      group
+    end
+
+    def apply(sideload, resource_class)
+      @groups.each do |group|
+        group.calls.each do |call|
+          args = call[1]
+          opts = args.extract_options!
+          opts.merge! as: sideload.name,
+            parent: sideload,
+            group_name: group.name,
+            polymorphic_child: true
+          if !sideload.resource.class.abstract_class?
+            opts[:foreign_key] ||= sideload.foreign_key
+            opts[:primary_key] ||= sideload.primary_key
+          end
+          args << opts
+          resource_class.send(call[0], *args, &call[2])
+        end
+      end
+    end
+  end
+
+  class_attribute :grouper
+  attr_accessor :children
+  self.grouper = Grouper.new(:default)
+
+  def type
+    :polymorphic_belongs_to
+  end
+
+  def infer_foreign_key
+    :"#{name}_id"
+  end
+
+  def self.group_by(name, &blk)
+    self.grouper = Grouper.new(name)
+    self.grouper.instance_eval(&blk)
+  end
+
+  def initialize(name, opts)
+    super
+    self.children = {}
+    grouper.apply(self, parent_resource_class)
+  end
+
+  def child_for_type(type)
+    children.values.find do |sideload|
+      sideload.resource.type == type
+    end
+  end
+
+  def resolve(parents, query)
+    parents.group_by(&grouper.field_name).each_pair do |group_name, group|
+      next if group_name.nil?
+
+      match = ->(name, sl) { sl.group_name == group_name.to_sym }
+      if child = children.find(&match)
+        sideload = child[1]
+        query = remove_invalid_sideloads(sideload.resource, query)
+        sideload.resolve(group, query)
+      else
+        err = ::Graphiti::Errors::PolymorphicChildNotFound
+        raise err.new(self, group_name)
+      end
+    end
+  end
+
+  private
+
+  # We may be requesting a relationship that some subclasses support,
+  # but not others. Remove anything we don't support.
+  def remove_invalid_sideloads(resource, query)
+    query = query.dup
+    query.sideloads.each_pair do |key, value|
+      unless resource.class.sideload(key)
+        query.sideloads.delete(key)
+      end
+    end
+    query
+  end
+end

data/lib/graphiti/stats/dsl.rb

@@ -0,0 +1,89 @@
+module Graphiti
+  module Stats
+    # Provides an easier interface to stats scoping.
+    #
+    # Used within Resource DSL:
+    #
+    #   allow_stat total: [:count] do
+    #     # ... eval'd in Stats::DSL context! ...
+    #   end
+    #
+    # This allows us to define arbitrary stats:
+    #
+    #   allow_stat total: [:count] do
+    #     standard_deviation { |scope, attr| ... }
+    #   end
+    #
+    # And use convenience methods:
+    #
+    #   allow_stat :rating do
+    #     count!
+    #     average!
+    #   end
+    #
+    # @see Resource.allow_stat
+    # @attr_reader [Symbol] name the stat, e.g. :total
+    # @attr_reader [Hash] calculations procs for various metrics
+    class DSL
+      attr_reader :name, :calculations
+
+      # @param [Adapters::Abstract] adapter the Resource adapter
+      # @param [Symbol, Hash] config example: +:total+ or +{ total: [:count] }+
+      def initialize(adapter, config)
+        config = { config => [] } if config.is_a?(Symbol)
+
+        @adapter = adapter
+        @calculations = {}
+        @name = config.keys.first
+        Array(config.values.first).each { |c| send(:"#{c}!") }
+      end
+
+      # Used for defining arbitrary stats within the DSL:
+      #
+      #   allow_stat :total do
+      #     standard_deviation { |scope, attr| ... }
+      #   end
+      #
+      # ...will hit +method_missing+ and store the proc for future reference.
+      # @api private
+      def method_missing(meth, *args, &blk)
+        @calculations[meth] = blk
+      end
+
+      # Grab a calculation proc. Raises error if no corresponding stat
+      # has been configured.
+      #
+      # @param [String, Symbol] name the name of the calculation, e.g. +:total+
+      # @return [Proc] the proc to run the calculation
+      def calculation(name)
+        callable = @calculations[name] || @calculations[name.to_sym]
+        callable || raise(Errors::StatNotFound.new(@name, name))
+      end
+
+      # Convenience method for default :count proc
+      def count!
+        @calculations[:count] = @adapter.method(:count)
+      end
+
+      # Convenience method for default :sum proc
+      def sum!
+        @calculations[:sum] = @adapter.method(:sum)
+      end
+
+      # Convenience method for default :average proc
+      def average!
+        @calculations[:average] = @adapter.method(:average)
+      end
+
+      # Convenience method for default :maximum proc
+      def maximum!
+        @calculations[:maximum] = @adapter.method(:maximum)
+      end
+
+      # Convenience method for default :minimum proc
+      def minimum!
+        @calculations[:minimum] = @adapter.method(:minimum)
+      end
+    end
+  end
+end

data/lib/graphiti/stats/payload.rb

@@ -0,0 +1,49 @@
+module Graphiti
+  module Stats
+    # Generate the stats payload so we can return it in the response.
+    #
+    #   {
+    #     data: [...],
+    #     meta: { stats: the_generated_payload }
+    #   }
+    #
+    # For example:
+    #
+    #   {
+    #     data: [...],
+    #     meta: { stats: { total: { count: 100 } } }
+    #   }
+    class Payload
+      def initialize(resource, query, scope)
+        @resource   = resource
+        @query      = query
+        @scope      = scope
+      end
+
+      # Generate the payload for +{ meta: { stats: { ... } } }+
+      # Loops over all calculations, computes then, and gives back
+      # a hash of stats and their results.
+      # @return [Hash] the generated payload
+      def generate
+        {}.tap do |stats|
+          @query.stats.each_pair do |name, calculation|
+            stats[name] = {}
+
+            each_calculation(name, calculation) do |calc, function|
+              stats[name][calc] = function.call(@scope, name)
+            end
+          end
+        end
+      end
+
+      private
+
+      def each_calculation(name, calculations)
+        calculations.each do |calc|
+          function = @resource.stat(name, calc)
+          yield calc, function
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/types.rb

@@ -0,0 +1,172 @@
+module Graphiti
+  class Types
+    def self.create(primitive, &blk)
+      definition = Dry::Types::Definition.new(primitive)
+      definition.constructor(&blk)
+    end
+
+    WriteDateTime = create(::DateTime) do |input|
+      if input.is_a?(::Date) || input.is_a?(::Time)
+        input = ::DateTime.parse(input.to_s)
+      end
+      input = Dry::Types['json.date_time'][input]
+      Dry::Types['strict.date_time'][input] if input
+    end
+
+    ReadDateTime = create(::DateTime) do |input|
+      if input.is_a?(::Date) || input.is_a?(::Time)
+        input = ::DateTime.parse(input.to_s)
+      end
+      input = Dry::Types['json.date_time'][input]
+      Dry::Types['strict.date_time'][input].iso8601 if input
+    end
+
+    PresentParamsDateTime = create(::DateTime) do |input|
+      input = Dry::Types['params.date_time'][input]
+      Dry::Types['strict.date_time'][input]
+    end
+
+    Date = create(::Date) do |input|
+      input = ::Date.parse(input.to_s) if input.is_a?(::Time)
+      input = Dry::Types['json.date'][input]
+      Dry::Types['strict.date'][input] if input
+    end
+
+    PresentDate = create(::Date) do |input|
+      input = ::Date.parse(input.to_s) if input.is_a?(::Time)
+      input = Dry::Types['json.date'][input]
+      Dry::Types['strict.date'][input]
+    end
+
+    Bool = create(nil) do |input|
+      input = Dry::Types['params.bool'][input]
+      Dry::Types['strict.bool'][input] if input
+    end
+
+    PresentBool = create(nil) do |input|
+      input = Dry::Types['params.bool'][input]
+      Dry::Types['strict.bool'][input]
+    end
+
+    Integer = create(::Integer) do |input|
+      Dry::Types['coercible.integer'][input] if input
+    end
+
+    # The Float() check here is to ensure we have a number
+    # Otherwise BigDecimal('foo') *will return a decimal*
+    ParamDecimal = create(::BigDecimal) do |input|
+      Float(input)
+      input = Dry::Types['coercible.decimal'][input]
+      Dry::Types['strict.decimal'][input]
+    end
+
+    PresentInteger = create(::Integer) do |input|
+      Dry::Types['coercible.integer'][input]
+    end
+
+    Float = create(::Float) do |input|
+      Dry::Types['coercible.float'][input] if input
+    end
+
+    PresentParamsHash = create(::Hash) do |input|
+      Dry::Types['params.hash'][input].deep_symbolize_keys
+    end
+
+    def self.map
+      @map ||= begin
+        hash = {
+          integer_id: {
+            canonical_name: :integer,
+            params: Dry::Types['coercible.integer'],
+            read: Dry::Types['coercible.string'],
+            write: Dry::Types['coercible.integer']
+          },
+          string: {
+            params: Dry::Types['coercible.string'],
+            read: Dry::Types['coercible.string'],
+            write: Dry::Types['coercible.string']
+          },
+          integer: {
+            params: PresentInteger,
+            read: Integer,
+            write: Integer
+          },
+          big_decimal: {
+            params: ParamDecimal,
+            read: Dry::Types['json.decimal'],
+            write: Dry::Types['json.decimal']
+          },
+          float: {
+            params: Dry::Types['coercible.float'],
+            read: Float,
+            write: Float
+          },
+          boolean: {
+            params: PresentBool,
+            read: Bool,
+            write: Bool
+          },
+          date: {
+            params: PresentDate,
+            read: Date,
+            write: Date
+          },
+          datetime: {
+            params: PresentParamsDateTime,
+            read: ReadDateTime,
+            write: WriteDateTime
+          },
+          hash: {
+            params: PresentParamsHash,
+            read: Dry::Types['strict.hash'],
+            write: Dry::Types['strict.hash']
+          },
+          array: {
+            params: Dry::Types['strict.array'],
+            read: Dry::Types['strict.array'],
+            write: Dry::Types['strict.array']
+          }
+        }
+
+        hash.each_pair do |k, v|
+          hash[k][:canonical_name] ||= k
+        end
+
+        arrays = {}
+        hash.each_pair do |name, map|
+          arrays[:"array_of_#{name.to_s.pluralize}"] = {
+            canonical_name: name,
+            params: Dry::Types['strict.array'].of(map[:params]),
+            read: Dry::Types['strict.array'].of(map[:read]),
+            test: Dry::Types['strict.array'].of(map[:test]),
+            write: Dry::Types['strict.array'].of(map[:write])
+          }
+        end
+        hash.merge!(arrays)
+
+        hash
+      end
+    end
+
+    def self.[](key)
+      map[key.to_sym]
+    end
+
+    def self.[]=(key, value)
+      unless value.is_a?(Hash)
+        value = {
+          read: value,
+          params: value,
+          test: value
+        }
+      end
+      map[key.to_sym] = value
+    end
+
+    def self.name_for(key)
+      key = key.to_sym
+      type = map[key]
+      type[:canonical_name]
+    end
+  end
+end