datasource 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 107812940a2c8fc80ebec710b0ebd63c5f710fd4
-  data.tar.gz: b0d4b77a9cace8c1f559d39738065cfe69930c55
+  metadata.gz: 89a34ecb59d8f4183295c43b4badd33aca5f5e62
+  data.tar.gz: b408320273ce49236bd022d7db00c1fce06bdfd5
 SHA512:
-  metadata.gz: 960aa77805c5fe4e0a2c1ac658956bf0c2b4d8e81769c96850a012b5e95facac053ba6407f1b8d88ec65749b7ecc813fb6229502302ea4d070873b4483d8113f
-  data.tar.gz: 22dad36f267317cb360ffc30d035b8efd3074faa3ae801e26bbef76c3b9c9d358f417f8a0dee31cf37ea9a49c92e33afe472a753b2d86276e13319cf72b057e8
+  metadata.gz: 0db668df6f4ae71223655a544d59b805e6bdd2694ab540f37dacc7962700d427799f00308d0cdf03a180a7e45f7d3891ff795e73def10c180bf9df5d92942df3
+  data.tar.gz: c69ae3fe12467516c7f24d090e7240a398e9e7d341dd82a1c54b459c57dd4fb2f9c796a6180a85e02fc304ea45bbf96361579af3249974df4fd73cc0a02dd997

data/README.md

@@ -18,12 +18,12 @@ Run install generator:
 rails g datasource:install
 ```
 
-### ORM support
+#### ORM support
 
 - ActiveRecord
 - Sequel
 
-### Serializer support
+#### Serializer support
 
 - active_model_serializers
 
@@ -66,18 +66,16 @@ 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.
+You need to use `computed` in a `datasource_module` block to specify what a method depends on. It can depend on database columns, other computed attributes or loaders.
 
 ```ruby
 class User < ActiveRecord::Base
   datasource_module do
     computed :first_name_initial, :first_name
-    computed :last_name_initial, :last_name
+    computed :both_initials, :first_name, :last_name
   end
 
+  # method can be in model
   def first_name_initial
     first_name[0].upcase
   end
@@ -86,8 +84,9 @@ end
 class UserSerializer < ActiveModel::Serializer
   attributes :first_name_initial, :last_name_initial
 
-  def last_name_initial
-    object.last_name[0].upcase
+  # method can also be in serializer
+  def both_initials
+    object.last_name[0].upcase + object.last_name[0].upcase
   end
 end
 ```
@@ -100,15 +99,15 @@ 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.
+You will probably want to reuse the same preloading logic in your show action.
+You will need to call `for_serializer` on the scope before you call `find`.
+You can optionally give it the serializer class as an argument.
 
 ```ruby
-class UsersController < ApplicationController
+class PostsController < ApplicationController
   def show
     post = Post.for_serializer.find(params[:id])
-    # also works:
+    # more explicit:
     # post = Post.for_serializer(PostSerializer).find(params[:id])
 
     render json: post
@@ -116,9 +115,22 @@ class UsersController < ApplicationController
 end
 ```
 
+You can also use it on an existing record, but doing it this way may result in
+an additional SQL query (for example if you use query attributes).
+
+```ruby
+class UsersController < ApplicationController
+  def show
+    user = current_user.for_serializer
+
+    render json: user
+  end
+end
+```
+
 ## Advanced Usage
 
-### Query attributes
+### Query attribute
 
 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:
@@ -141,11 +153,13 @@ end
 SELECT users.id, (users.first_name || ' ' || users.last_name) AS full_name FROM users
 ```
 
-### Loaders
+Note: If you need data from another table, use a join in a loader (see below).
+
+### Loader
 
 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 receive ids of the records, and needs to return a hash.
+The key of the hash must be the id of the record for which the value 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]`.
@@ -156,7 +170,7 @@ will be nil. However you can use the `default` option for such cases (see below
 ```ruby
 class User < ActiveRecord::Base
   datasource_module do
-    computed :post_count, loaders: :post_counts
+    computed :post_count, loader: :post_counts
     loader :post_counts, array_to_hash: true, default: 0 do |user_ids|
       results = Post
         .where(user_id: user_ids)
@@ -210,3 +224,58 @@ loader :stuff, group_by: "user_id", one: true do |ids|
   # { 10 => { "title" => "Something", "user_id" => 10 } }
 end
 ```
+
+### Loaded
+
+Loaded is the same as loader, but it also creates a computed attribute and defines
+a method with the same name on your model.
+
+Here is the previous example with `loaded` instead of `loader`:
+
+```ruby
+class User < ActiveRecord::Base
+  datasource_module do
+    loaded :post_count, array_to_hash: true, default: 0 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
+  # Note that the User now has a generated post_count method
+end
+```
+
+When using `loaded`, if you already have the method with this name defined in your
+model, datasource will automatically create a 'wrapper' method that will use the
+loaded value if available (when you are using a serializer/datasource), otherwise
+it will fallback to your original method. This way you can still use the same
+method when you are not using a serializer/datasource. For example:
+
+```ruby
+class User < ActiveRecord::Base
+  datasource_module do
+    loaded :post_count, array_to_hash: true, default: 0 do |user_ids|
+      results = Post
+        .where(user_id: user_ids)
+        .group(:user_id)
+        .pluck("user_id, COUNT(id)")
+    end
+
+    def post_count
+      posts.count
+    end
+  end
+end
+
+class UserSerializer < ActiveModel::Serializer
+  attributes :id, :post_count # <- post_count will be read from loaded_values
+end
+
+User.first.post_count # <- your method will be called
+
+```

data/lib/datasource/adapters/active_record.rb

@@ -20,17 +20,22 @@ module Datasource
           self
         end
 
+        def get_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, nil, datasource.adapter)
+
+            datasource.select(*select)
+          end
+          datasource
+        end
+
       private
         def exec_queries
           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, nil, datasource.adapter)
-
-              datasource.select(*select)
-            end
+            datasource = get_datasource
 
             @loaded = true
             @records = datasource.results
@@ -47,6 +52,22 @@ module Datasource
           attr_accessor :loaded_values
         end
 
+        def for_serializer(serializer = nil)
+          datasource_class = self.class.default_datasource
+          pk = datasource_class.primary_key.to_sym
+
+          scope = self.class
+          .with_datasource(datasource_class)
+          .for_serializer(serializer).where(pk => send(pk))
+
+          datasource = scope.get_datasource
+          if datasource.can_upgrade?(self)
+            datasource.upgrade_records(self).first
+          else
+            scope.first
+          end
+        end
+
         module ClassMethods
           def for_serializer(serializer = nil)
             scope = if all.respond_to?(:use_datasource_serializer)
@@ -67,7 +88,7 @@ module Datasource
           end
 
           def default_datasource
-            @default_datasource ||= Class.new(Datasource::From(self))
+            @default_datasource ||= Datasource::From(self)
           end
 
           def datasource_module(&block)
@@ -103,6 +124,10 @@ module Datasource
         scope.loaded?
       end
 
+      def has_attribute?(record, name)
+        record.attributes.key?(name.to_s)
+      end
+
       def association_klass(reflection)
         if reflection.macro == :belongs_to && reflection.options[:polymorphic]
           fail Datasource::Error, "polymorphic belongs_to not supported, write custom loader"
@@ -111,7 +136,7 @@ module Datasource
         end
       end
 
-      def preload_association(records, name)
+      def load_association(records, name)
         return if records.empty?
         return if records.first.association(name.to_sym).loaded?
         klass = records.first.class
@@ -125,7 +150,7 @@ module Datasource
           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::Base.reflection_select(association_reflection(klass, name.to_sym), [], datasource_select)
           datasource.select(*datasource_select)
           select_values = datasource.get_select_values
 
@@ -139,7 +164,7 @@ module Datasource
 
           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)
+            load_association(assoc_records, assoc_name)
           end
           datasource.results(assoc_records)
         end
@@ -161,10 +186,21 @@ module Datasource
         ds.scope.select(*ds.get_select_values)
       end
 
+      def upgrade_records(ds, records)
+        load_associations(ds, records)
+        ds.results(records)
+      end
+
+      def load_associations(ds, records)
+        ds.expose_associations.each_pair do |assoc_name, assoc_select|
+          load_association(records, assoc_name)
+        end
+      end
+
       def get_rows(ds)
         append_select = []
         ds.expose_associations.each_pair do |assoc_name, assoc_select|
-          if reflection = Adapters::ActiveRecord.association_reflection(ds.class.orm_klass, assoc_name.to_sym)
+          if reflection = association_reflection(ds.class.orm_klass, assoc_name.to_sym)
             Datasource::Base.reflection_select(reflection, append_select, [])
           end
         end
@@ -176,9 +212,7 @@ module Datasource
         end
         scope.includes_values = []
         scope.to_a.tap do |records|
-          ds.expose_associations.each_pair do |assoc_name, assoc_select|
-            Adapters::ActiveRecord.preload_association(records, assoc_name)
-          end
+          load_associations(ds, records)
         end
       end
 
@@ -214,7 +248,7 @@ module Datasource
                 Datasource::Adapters::ActiveRecord
               end
 
-              define_method(:primary_key) do
+              define_singleton_method(:primary_key) do
                 klass.primary_key.to_sym
               end
             end

data/lib/datasource/adapters/sequel.rb

@@ -14,6 +14,18 @@ module Datasource
           self
         end
 
+        def get_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, nil, datasource.adapter)
+
+            datasource.select(*select)
+          end
+          datasource
+        end
+
         def datasource_select(*args)
           @datasource_select = Array(@datasource_select) + args
           self
@@ -21,14 +33,7 @@ module Datasource
 
         def each(&block)
           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, nil, datasource.adapter)
-
-              datasource.select(*select)
-            end
+            datasource = get_datasource
 
             datasource.results.each(&block)
           else
@@ -64,9 +69,25 @@ module Datasource
           end
         end
 
+        def for_serializer(serializer = nil)
+          datasource_class = self.class.default_datasource
+          pk = datasource_class.primary_key.to_sym
+
+          scope = self.class
+          .with_datasource(datasource_class)
+          .for_serializer(serializer).where(pk => send(pk))
+
+          datasource = scope.get_datasource
+          if datasource.can_upgrade?(self)
+            datasource.upgrade_records(self).first
+          else
+            scope.first
+          end
+        end
+
         module ClassMethods
           def default_datasource
-            @default_datasource ||= Class.new(Datasource::From(self))
+            @default_datasource ||= Datasource::From(self)
           end
 
           def datasource_module(&block)
@@ -113,8 +134,12 @@ module Datasource
         false
       end
 
+      def has_attribute?(record, name)
+        record.values.key?(name.to_sym)
+      end
+
       def get_assoc_eager_options(klass, name, assoc_select, append_select)
-        if reflection = Adapters::Sequel.association_reflection(klass, name)
+        if reflection = association_reflection(klass, name)
           self_append_select = []
           Datasource::Base.reflection_select(reflection, append_select, self_append_select)
           assoc_class = reflection[:klass]
@@ -144,7 +169,12 @@ module Datasource
         ds.scope.select(*get_sequel_select_values(ds.get_select_values))
       end
 
-      def get_rows(ds)
+      def upgrade_records(ds, records)
+        get_final_scope(ds).send :post_load, records
+        ds.results(records)
+      end
+
+      def get_final_scope(ds)
         eager = {}
         append_select = []
         ds.expose_associations.each_pair do |assoc_name, assoc_select|
@@ -158,7 +188,11 @@ module Datasource
         end
         scope
         .select_append(*get_sequel_select_values(append_select.map { |v| primary_scope_table(ds) + ".#{v}" }))
-        .eager(eager).all
+        .eager(eager)
+      end
+
+      def get_rows(ds)
+        get_final_scope(ds).all
       end
 
       def primary_scope_table(ds)
@@ -187,7 +221,7 @@ module Datasource
                 Datasource::Adapters::Sequel
               end
 
-              define_method(:primary_key) do
+              define_singleton_method(:primary_key) do
                 klass.primary_key
               end
             end

data/lib/datasource/attributes/computed_attribute.rb

@@ -2,16 +2,23 @@ module Datasource
   module Attributes
     class ComputedAttribute
       class << self
-        attr_accessor :_depends
+        attr_accessor :_depends, :_loader_depends
 
         def inherited(base)
           base._depends = (_depends || {}).dup # TODO: deep dup?
+          base._loader_depends = (_loader_depends || []).dup # TODO: deep dup?
         end
 
         def depends(*args)
           args.each do |dep|
             _depends.deep_merge!(dep)
           end
+          _depends.delete_if do |key, value|
+            if [:loaders, :loader].include?(key.to_sym)
+              self._loader_depends += Array(value).map(&:to_sym)
+              true
+            end
+          end
         end
       end
     end

data/lib/datasource/attributes/loader.rb

@@ -65,5 +65,22 @@ module Datasource
       end
       @_loaders[name.to_sym] = klass
     end
+
+    def self.loaded(name, _options = {}, &block)
+      loader(name, _options, &block)
+      renamed_existing_method = :"#{name}_without_datasource"
+      orm_klass.class_eval do
+        alias_method renamed_existing_method, name if method_defined?(name)
+        fail "#{name} already defined on #{to_s}, would be overridden by datasource loaded method" if method_defined?(name)
+        define_method name do |*args, &block|
+          if loaded_values || !method_defined?(renamed_existing_method)
+            loaded_values[name.to_sym]
+          else
+            send(renamed_existing_method, *args, &block)
+          end
+        end
+      end
+      computed name, loader: name
+    end
   end
 end

data/lib/datasource/base.rb

@@ -24,6 +24,10 @@ module Datasource
         fail Datasource::Error, "Model class not set for #{name}. You should define it:\nclass YourDatasource\n  @orm_klass = MyModelClass\nend"
       end
 
+      def primary_key
+        :id
+      end
+
       def reflection_select(reflection, parent_select, assoc_select)
         # append foreign key depending on assoication
         if reflection[:macro] == :belongs_to
@@ -81,16 +85,14 @@ module Datasource
       @expose_associations = {}
     end
 
-    def primary_key
-      :id
-    end
-
     def select_all
       @expose_attributes = self.class._attributes.keys.dup
     end
 
     def select(*names)
       failure = ->(name) { fail Datasource::Error, "attribute or association #{name} doesn't exist for #{self.class.orm_klass.name}, did you forget to call \"computed :#{name}, <dependencies>\" in your datasource_module?" }
+      newly_exposed_attributes = []
+      missing_attributes = []
       names.each do |name|
         if name.kind_of?(Hash)
           name.each_pair do |assoc_name, assoc_select|
@@ -100,53 +102,80 @@ module Datasource
               @expose_associations[assoc_name] += Array(assoc_select)
               @expose_associations[assoc_name].uniq!
             else
+              missing_attributes << assoc_name
               failure.call(assoc_name)
             end
           end
         else
           name = name.to_s
           if self.class._attributes.key?(name)
-            @expose_attributes.push(name)
+            unless @expose_attributes.include?(name)
+              @expose_attributes.push(name)
+              newly_exposed_attributes.push(name)
+            end
           else
+            missing_attributes << name
             failure.call(name)
           end
         end
       end
-      @expose_attributes.uniq!
+      update_dependencies(newly_exposed_attributes) unless newly_exposed_attributes.empty?
+      fail_missing_attributes(missing_attributes) unless missing_attributes.blank?
       self
     end
 
+    def fail_missing_attributes(names)
+      message = if names.size > 1
+        "attributes or associations #{names.join(', ')} don't exist "
+      else
+        "attribute or association #{names.first} doesn't exist "
+      end
+      message += "for #{self.class.orm_klass.name}, "
+      message += "did you forget to call \"computed :#{name}, <dependencies>\" in your datasource_module?"
+      fail Datasource::Error, message
+    end
+
+    def update_dependencies(names)
+      scope_table = adapter.primary_scope_table(self)
+
+      self.class._attributes.values.each do |att|
+        next unless names.include?(att[:name])
+        next unless att[:klass]
+
+        if att[:klass].ancestors.include?(Attributes::ComputedAttribute)
+          att[:klass]._depends.each_pair do |key, value|
+            if key.to_s == scope_table
+              select(*value)
+            else
+              select(key => value)
+            end
+          end
+        elsif att[:klass].ancestors.include?(Attributes::QueryAttribute)
+          att[:klass]._depends.each do |name|
+            next if name == scope_table
+            adapter.ensure_table_join!(self, name, att)
+          end
+        end
+      end
+    end
+
     def get_select_values
       scope_table = adapter.primary_scope_table(self)
+
+      # SQL select values
       select_values = Set.new
-      select_values.add("#{scope_table}.#{primary_key}")
+      select_values.add("#{scope_table}.#{self.class.primary_key}")
 
       self.class._attributes.values.each do |att|
         if attribute_exposed?(att[:name])
           if att[:klass] == nil
             select_values.add("#{scope_table}.#{att[:name]}")
-          elsif att[:klass].ancestors.include?(Attributes::ComputedAttribute)
-            att[:klass]._depends.keys.map(&:to_s).each do |name|
-              next if name == scope_table
-              next if name == "loaders"
-              adapter.ensure_table_join!(self, name, att)
-            end
-            att[:klass]._depends.each_pair do |table, names|
-              next if table.to_sym == :loaders
-              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].select_value}) as #{att[:name]}")
-            att[:klass]._depends.each do |name|
-              next if name == scope_table
-              adapter.ensure_table_join!(self, name, att)
-            end
           end
         end
       end
+
       select_values.to_a
     end
 
@@ -154,6 +183,27 @@ module Datasource
       @expose_attributes.include?(name.to_s)
     end
 
+    # assume records have all attributes selected (default ORM record)
+    def can_upgrade?(records)
+      query_attributes = @expose_attributes.select do |name|
+        klass = self.class._attributes[name][:klass]
+        if klass
+          klass.ancestors.include?(Attributes::QueryAttribute)
+        end
+      end
+
+      return true if query_attributes.empty?
+      Array(records).all? do |record|
+        query_attributes.all? do |name|
+          adapter.has_attribute?(record, name)
+        end
+      end
+    end
+
+    def upgrade_records(records)
+      adapter.upgrade_records(self, Array(records))
+    end
+
     def results(rows = nil)
       rows ||= adapter.get_rows(self)
 
@@ -166,23 +216,20 @@ module Datasource
         next if rows.empty?
 
         if att[:klass].ancestors.include?(Attributes::ComputedAttribute)
-          loaders = att[:klass]._depends[:loaders]
-          if loaders
-            Array(loaders).each do |name|
-              if loader = self.class._loaders[name]
-                if loaded_values = loader.load(rows.map(&primary_key), rows, @scope)
-                  unless rows.first.loaded_values
-                    rows.each do |row|
-                      row.loaded_values = {}
-                    end
-                  end
+          att[:klass]._loader_depends.each do |name|
+            if loader = self.class._loaders[name]
+              if loaded_values = loader.load(rows.map(&self.class.primary_key), rows, @scope)
+                unless rows.first.loaded_values
                   rows.each do |row|
-                    row.loaded_values[name] = loaded_values[row.send(primary_key)] || loader.default_value
+                    row.loaded_values = {}
                   end
                 end
-              else
-                raise Datasource::Error, "loader with name :#{name} could not be found"
+                rows.each do |row|
+                  row.loaded_values[name] = loaded_values[row.send(self.class.primary_key)] || loader.default_value
+                end
               end
+            else
+              raise Datasource::Error, "loader with name :#{name} could not be found"
             end
           end
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datasource
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Jan Berdajs