datasource 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 617cef0cb48d4953a9da29c7476ef583c5d7487e
-  data.tar.gz: bf76cef2be532f75c71729dbf3fa11fa4022ea37
+  metadata.gz: 714357b54441eac8f8eb1c209dad82fa8c588743
+  data.tar.gz: 90cb1f1ca000d6683b234c6ccff41425b208be2c
 SHA512:
-  metadata.gz: 3d4738bb6e26eae45f63df27fdfe52a7725d49d1e20569eace2af7d71314e20529f3a29fb913979b1f88f960f337418319b2f2dd88ef978ed57d8d72cda5688e
-  data.tar.gz: 3079481e54532538dd4aeb9df57ec2abe0f412f62369caf91ec3ebe16ab5106036321f3070d02be015972a81da9f6bb087de997f38610ba94c843e9cd4425e95
+  metadata.gz: 0414aa6f0f18bdb882d9f54e558ed5301e4c52d77d417cdfd62d51fad0a51f5ebc5191d9ab86a56b6ee69d6c7c489f0c2395c10082b27381e04bfbc70152d3b9
+  data.tar.gz: 94f30d58cd6cd8cef946e87f039445910dd924638d00c40a95599d35e473e6eb840a14d4543c4dd405b953633257c3defafb33c777b0581dc2cb724bd05fa4d1

data/README.md

@@ -1 +1,212 @@
 # Datasource
+
+Automatically preload your ORM records for your serializer.
+
+## Install
+
+Add to Gemfile
+
+```
+gem 'datasource'
+```
+
+And `bundle install`.
+
+Run install generator:
+
+```
+rails g datasource:install
+```
+
+### ORM support
+
+- ActiveRecord
+- Sequel
+
+### Serializer support
+
+- active_model_serializers
+
+## Basic Usage
+
+### Attributes
+You don't have to do anything special.
+
+```ruby
+class UserSerializer < ActiveModel::Serializer
+  attributes :id, :email
+end
+```
+
+But you get an optimized query for free:
+
+```sql
+SELECT id, email FROM users
+```
+
+### Associations
+You don't have to do anything special.
+
+```ruby
+class PostSerializer < ActiveModel::Serializer
+  attributes :id, :title
+end
+
+class UserSerializer < ActiveModel::Serializer
+  attributes :id
+  has_many :posts
+end
+```
+
+But you get automatic association preloading ("includes") with optimized queries for free:
+
+```sql
+SELECT id FROM users
+SELECT id, title, user_id FROM posts WHERE id IN (?)
+```
+
+### Model Methods / Virtual Attributes
+You need to specify which database columns a method depends on to be able to use it.
+The method itself can be either in the serializer or in your model, it doesn't matter.
+
+You can list multiple dependency columns.
+
+```ruby
+class User < ActiveRecord::Base
+  datasource_module do
+    computed :first_name_initial, :first_name
+    computed :last_name_initial, :last_name
+  end
+
+  def first_name_initial
+    first_name[0].upcase
+  end
+end
+
+class UserSerializer < ActiveModel::Serializer
+  attributes :first_name_initial, :last_name_initial
+
+  def last_name_initial
+    object.last_name[0].upcase
+  end
+end
+```
+
+```sql
+SELECT first_name, last_name FROM users
+```
+
+You will be reminded with an exception if you forget to do this.
+
+### Show action
+
+You will probably want to reuse the same preloading rules in your show action.
+You just need to call `.for_serializer` on the scope. You can optionally give it
+the serializer class as an argument.
+
+```ruby
+class UsersController < ApplicationController
+  def show
+    post = Post.for_serializer.find(params[:id])
+    # also works:
+    # post = Post.for_serializer(PostSerializer).find(params[:id])
+
+    render json: post
+  end
+end
+```
+
+## Advanced Usage
+
+### Query attributes
+
+You can specify a SQL fragment for `SELECT` and use that as an attribute on your
+model. As a simple example you can concatenate 2 strings together in SQL:
+
+```ruby
+class User < ActiveRecord::Base
+  datasource_module do
+    query :full_name do
+      "users.first_name || ' ' || users.last_name"
+    end
+  end
+end
+
+class UserSerializer < ActiveModel::Serializer
+  attributes :id, :full_name
+end
+```
+
+```sql
+SELECT users.id, (users.first_name || ' ' || users.last_name) AS full_name FROM users
+```
+
+### Loaders
+
+You might want to have some more complex preloading logic. In that case you can use a loader.
+The loader will receive ids of the records, and you need to return a hash with your data.
+The key of the hash must be the id of the record for which the data is.
+
+A loader will only be executed if a computed attribute depends on it. If an attribute depends
+on multiple loaders, pass an array of loaders like so `computed :attr, loaders: [:loader1, :loader2]`.
+
+Be careful that if your hash does not contain a value for the object ID, the loaded value
+will be nil.
+
+```ruby
+class User < ActiveRecord::Base
+  datasource_module do
+    computed :post_count, loaders: :post_counts
+    loader :post_counts, array_to_hash: true do |user_ids|
+      results = Post
+        .where(user_id: user_ids)
+        .group(:user_id)
+        .pluck("user_id, COUNT(id)")
+    end
+  end
+end
+
+class UserSerializer < ActiveModel::Serializer
+  attributes :id, :post_count
+
+  def post_count
+    # Will automatically give you the value for this user's ID
+    object.loaded_values[:post_counts] || 0
+  end
+end
+```
+
+```sql
+SELECT users.id FROM users
+SELECT user_id, COUNT(id) FROM posts WHERE user_id IN (?)
+```
+
+Datasource provides shortcuts to transform your data into a hash. Here are examples:
+
+```ruby
+loader :stuff, array_to_hash: true do |ids|
+  [[1, "first"], [2, "second"]]
+  # will be transformed into
+  # { 1 => "first", 2 => "second" }
+end
+
+loader :stuff, group_by: :user_id do |ids|
+  Post.where(user_id: ids)
+  # will be transformed into
+  # { 1 => [#<Post>, #<Post>, ...], 2 => [ ... ], ... }
+end
+
+loader :stuff, group_by: :user_id, one: true do |ids|
+  Post.where(user_id: ids)
+  # will be transformed into
+  # { 1 => #<Post>, 2 => #<Post>, ... }
+end
+
+loader :stuff, group_by: "user_id", one: true do |ids|
+  # it works the same way on an array of hashes
+  # but be careful about Symbol/String difference
+  [{ "title" => "Something", "user_id" => 10 }]
+  # will be transformed into
+  # { 10 => { "title" => "Something", "user_id" => 10 } }
+end
+```

data/lib/datasource/adapters/active_record.rb

@@ -1,116 +1,186 @@
 require 'set'
+require 'active_support/concern'
 
-ActiveRecord::Calculations
-module ActiveRecord
-  module Calculations
-    def pluck_hash(*column_names)
-      column_names.map! do |column_name|
-        if column_name.is_a?(Symbol) && attribute_alias?(column_name)
-          attribute_alias(column_name)
-        else
-          column_name.to_s
+module Datasource
+  module Adapters
+    module ActiveRecord
+      module ScopeExtensions
+        def use_datasource_serializer(value)
+          @datasource_serializer = value
+          self
         end
-      end
 
-      if has_include?(column_names.first)
-        construct_relation_for_association_calculations.pluck(*column_names)
-      else
-        relation = spawn
-        relation.select_values = column_names.map { |cn|
-          columns_hash.key?(cn) ? arel_table[cn] : cn
-        }
-        result = klass.connection.select_all(relation.arel, nil, bind_values)
-        columns = result.columns.map do |key|
-          klass.column_types.fetch(key) {
-            result.column_types.fetch(key) { result.identity_type }
-          }
+        def use_datasource(value)
+          @datasource = value
+          self
+        end
+
+        def datasource_select(*args)
+          @datasource_select = Array(@datasource_select) + args
+          self
         end
 
-        result.rows.map do |values|
-          {}.tap do |hash|
-            values.zip(columns, result.columns).each do |v|
-              single_attr_hash = { v[2] => v[0] }
-              hash[v[2]] = v[1].type_cast klass.initialize_attributes(single_attr_hash).values.first
+        def to_a
+          if @datasource
+            datasource = @datasource.new(self)
+            datasource.select(*Array(@datasource_select))
+            if @datasource_serializer
+              select = []
+              Datasource::Base.consumer_adapter.to_datasource_select(select, @datasource.orm_klass, @datasource_serializer)
+
+              datasource.select(*select)
             end
+
+            datasource.results
+          else
+            super
           end
         end
       end
-    end
-  end
-end
 
-module Datasource
-  module Adapters
-    module ActiveRecord
-      ID_KEY = "id"
+      module Model
+        extend ActiveSupport::Concern
 
-      def to_query(scope)
-        ActiveRecord::Base.uncached do
-          scope.select(*get_select_values(scope)).to_sql
+        included do
+          attr_accessor :loaded_values
+        end
+
+        module ClassMethods
+          def for_serializer(serializer = nil)
+            scope = if all.respond_to?(:use_datasource_serializer)
+              all
+            else
+              all.extending(ScopeExtensions).use_datasource(default_datasource)
+            end
+            scope.use_datasource_serializer(serializer || Datasource::Base.consumer_adapter.get_serializer_for(Adapters::ActiveRecord.scope_to_class(scope)))
+          end
+
+          def with_datasource(datasource = nil)
+            scope = if all.respond_to?(:use_datasource)
+              all
+            else
+              all.extending(ScopeExtensions)
+            end
+            scope.use_datasource(datasource || default_datasource)
+          end
+
+          def default_datasource
+            @default_datasource ||= Class.new(Datasource::From(self))
+          end
+
+          def datasource_module(&block)
+            default_datasource.instance_exec(&block)
+          end
+        end
+      end
+
+      def self.association_reflection(klass, name)
+        if reflection = klass.reflections[name]
+          {
+            klass: reflection.klass,
+            macro: reflection.macro,
+            foreign_key: reflection.try(:foreign_key)
+          }
         end
       end
 
-      def get_rows(scope)
-        scope.pluck_hash(*get_select_values(scope))
+      def self.get_table_name(klass)
+        klass.table_name.to_sym
       end
 
-      def included_datasource_rows(att, datasource_data, rows)
-        ds_select = datasource_data[:select]
-        unless ds_select.include?(att[:foreign_key])
-          ds_select += [att[:foreign_key]]
-        end
-        ds_scope = datasource_data[:scope]
-        column = "#{ds_scope.klass.table_name}.#{att[:foreign_key]}"
-        ds_scope = ds_scope.where("#{column} IN (?)",
-            rows.map { |row| row[att[:id_key]] })
-        grouped_results = att[:klass].new(ds_scope)
-        .select(ds_select)
-        .results.group_by do |row|
-          row[att[:foreign_key]]
-        end
-        unless datasource_data[:select].include?(att[:foreign_key])
-          grouped_results.each_pair do |k, rows|
-            rows.each do |row|
-              row.delete(att[:foreign_key])
-            end
+      def self.is_scope?(obj)
+        obj.kind_of?(::ActiveRecord::Relation)
+      end
+
+      def self.scope_to_class(scope)
+        scope.klass
+      end
+
+      def self.association_klass(reflection)
+        if reflection.macro == :belongs_to && reflection.options[:polymorphic]
+          fail Datasource::Error, "polymorphic belongs_to not supported, write custom loader"
+        else
+          reflection.klass
+        end
+      end
+
+      def self.preload_association(records, name)
+        return if records.empty?
+        return if records.first.association(name.to_sym).loaded?
+        klass = records.first.class
+        if reflection = klass.reflections[name.to_sym]
+          assoc_class = association_klass(reflection)
+          datasource_class = assoc_class.default_datasource
+          # TODO: extract serializer_class from parent serializer association
+          serializer_class = Datasource::Base.consumer_adapter.get_serializer_for(assoc_class)
+
+          # TODO: can we make it use datasource scope (with_serializer)? like Sequel
+          scope = assoc_class.all
+          datasource = datasource_class.new(scope)
+          datasource_select = serializer_class._attributes.dup
+          Datasource::Base.reflection_select(Adapters::ActiveRecord.association_reflection(klass, name.to_sym), [], datasource_select)
+          datasource.select(*datasource_select)
+          select_values = datasource.get_select_values
+
+          begin
+            ::ActiveRecord::Associations::Preloader
+              .new.preload(records, name, assoc_class.select(*select_values))
+          rescue ArgumentError
+            ::ActiveRecord::Associations::Preloader
+              .new(records, name, assoc_class.select(*select_values)).run
           end
+
+          assoc_records = records.flat_map { |record| record.send(name) }.compact
+          serializer_class._associations.each_pair do |assoc_name, options|
+            preload_association(assoc_records, assoc_name)
+          end
+          datasource.results(assoc_records)
+        end
+      rescue Exception => ex
+        if ex.is_a?(SystemStackError) || ex.is_a?(Datasource::RecursionError)
+          fail Datasource::RecursionError, "recursive association (involving #{name})"
+        else
+          raise
         end
-        grouped_results
       end
 
-      def get_select_values(scope)
-        select_values = Set.new
-        select_values.add("#{scope.klass.table_name}.#{self.class.adapter::ID_KEY}")
-
-        self.class._attributes.each do |att|
-          if attribute_exposed?(att[:name])
-            if att[:klass] == nil
-              select_values.add("#{scope.klass.table_name}.#{att[:name]}")
-            elsif att[:klass].ancestors.include?(Attributes::ComputedAttribute)
-              att[:klass]._depends.keys.map(&:to_s).each do |name|
-                next if name == scope.klass.table_name
-                ensure_table_join!(scope, name, att)
-              end
-              att[:klass]._depends.each_pair do |table, names|
-                Array(names).each do |name|
-                  select_values.add("#{table}.#{name}")
-                end
-                # TODO: handle depends on virtual attribute
-              end
-            elsif att[:klass].ancestors.include?(Attributes::QueryAttribute)
-              select_values.add("(#{att[:klass].new.select_value}) as #{att[:name]}")
-              att[:klass]._depends.each do |name|
-                next if name == scope.klass.table_name
-                ensure_table_join!(scope, name, att)
-              end
-            end
+      def to_query
+        ::ActiveRecord::Base.uncached do
+          @scope.select(*get_select_values).to_sql
+        end
+      end
+
+      def select_scope
+        @scope.select(*get_select_values)
+      end
+
+      def get_rows
+        append_select = []
+        @expose_associations.each_pair do |assoc_name, assoc_select|
+          if reflection = Adapters::ActiveRecord.association_reflection(self.class.orm_klass, assoc_name.to_sym)
+            Datasource::Base.reflection_select(reflection, append_select, [])
           end
         end
-        select_values.to_a
+        select(*append_select)
+
+        scope = select_scope
+        if scope.respond_to?(:use_datasource)
+          scope = scope.spawn.use_datasource(nil)
+        end
+        scope.includes_values = []
+        scope.to_a.tap do |records|
+          @expose_associations.each_pair do |assoc_name, assoc_select|
+            Adapters::ActiveRecord.preload_association(records, assoc_name)
+          end
+        end
+      end
+
+      def primary_scope_table(scope)
+        scope.klass.table_name
       end
 
-      def ensure_table_join!(scope, name, att)
-        join_value = scope.joins_values.find do |value|
+      def ensure_table_join!(name, att)
+        join_value = @scope.joins_values.find do |value|
           if value.is_a?(Symbol)
             value.to_s == att[:name]
           elsif value.is_a?(String)
@@ -119,8 +189,37 @@ module Datasource
             end
           end
         end
-        raise "Given scope does not join on #{name}, but it is required by #{att[:name]}" unless join_value
+        fail Datasource::Error, "given scope does not join on #{name}, but it is required by #{att[:name]}" unless join_value
+      end
+
+      module DatasourceGenerator
+        def From(klass)
+          if klass.ancestors.include?(::ActiveRecord::Base)
+            Class.new(Datasource::Base) do
+              attributes *klass.column_names
+              associations *klass.reflections.keys
+
+              define_singleton_method(:orm_klass) do
+                klass
+              end
+
+              define_method(:primary_key) do
+                klass.primary_key.to_sym
+              end
+            end
+          else
+            super if defined?(super)
+          end
+        end
       end
     end
   end
+
+  extend Adapters::ActiveRecord::DatasourceGenerator
+end
+
+if not(::ActiveRecord::Base.respond_to?(:datasource_module))
+  class ::ActiveRecord::Base
+    include Datasource::Adapters::ActiveRecord::Model
+  end
 end