pluckr 0.1.0

data/lib/pluckr/query.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+module Pluckr
+  # Subclass this to declare a read model:
+  #
+  #   class UserSummary < Pluckr::Query
+  #     source User
+  #
+  #     schema do
+  #       field :id
+  #       field :email
+  #       one :subscription do
+  #         field :name
+  #       end
+  #       exists :photos
+  #       count :videos
+  #     end
+  #   end
+  class Query
+    class << self
+      # ------------------------------------------------------------- DSL --
+
+      def source(model)
+        unless model.is_a?(Class) && model < ActiveRecord::Base
+          raise ConfigurationError, "`source` expects an ActiveRecord model, got #{model.inspect}"
+        end
+
+        @source_model = model
+      end
+
+      def schema(&block)
+        @pluckr_schema = Schema::Definition.build(source_model, &block)
+        reset_compilation!
+        @pluckr_schema
+      end
+
+      # Declared on this class, or inherited from the query it subclasses.
+      def source_model
+        @source_model || inherited_from_query(:source_model)
+      end
+
+      def pluckr_schema
+        declared_schema || raise(ConfigurationError, "#{name} has no `schema` block")
+      end
+
+      # The schema declared here or by a query this one subclasses, or nil.
+      # Kept separate from `pluckr_schema` so the error names the class that was
+      # actually used, not an intermediate base class.
+      def declared_schema
+        @pluckr_schema || inherited_from_query(:declared_schema)
+      end
+
+      # Source-rooted queries return rows; aggregate-only queries return one object.
+      def source_rooted?
+        !source_model.nil?
+      end
+
+      # ---------------------------------------------------------- querying --
+
+      def all
+        raise MissingSource, "#{name} has no `source` model to query" unless source_rooted?
+
+        Relation.new(self, source_model.all)
+      end
+
+      def where(...)
+        all.where(...)
+      end
+
+      def order(...)
+        all.order(...)
+      end
+
+      def limit(value)
+        all.limit(value)
+      end
+
+      def offset(value)
+        all.offset(value)
+      end
+
+      def find(...)
+        all.find(...)
+      end
+
+      def find_by(...)
+        all.find_by(...)
+      end
+
+      def find_by!(...)
+        all.find_by!(...)
+      end
+
+      # `COUNT(*)`/`SELECT 1` over the root rows, not a fetch counted in Ruby.
+      def count(...)
+        all.count(...)
+      end
+      alias_method :size, :count
+
+      def exists?(...)
+        all.exists?(...)
+      end
+
+      def any?(...)
+        all.any?(...)
+      end
+
+      def none?(...)
+        all.none?(...)
+      end
+
+      def empty?
+        all.empty?
+      end
+
+      def find_each(...)
+        all.find_each(...)
+      end
+
+      def in_batches(...)
+        all.in_batches(...)
+      end
+
+      # Read models for records already in memory. One statement for a collection.
+      #
+      #   UserCard.for(user)     # one object, like find(user.id)
+      #   UserCard.for(users)    # array, same order, one SQL
+      #   UserCard.for(scope)    # an unloaded relation stays a subquery
+      #   UserCard.for(scope.limit(2)) # a page: its keys first, then one read
+      def for(records)
+        all.for(records)
+      end
+
+      def first(...)
+        all.first(...)
+      end
+
+      def first!
+        all.first!
+      end
+
+      def last(...)
+        all.last(...)
+      end
+
+      def last!
+        all.last!
+      end
+
+      def take(...)
+        all.take(...)
+      end
+
+      def take!
+        all.take!
+      end
+
+      def one?(...)
+        all.one?(...)
+      end
+
+      def many?(...)
+        all.many?(...)
+      end
+
+      def fetch
+        source_rooted? ? all.fetch : fetch_aggregates
+      end
+
+      def to_sql
+        source_rooted? ? all.to_sql : compiler.aggregate_only_sql
+      end
+
+      def explain(...)
+        all.explain(...)
+      end
+
+      # ---------------------------------------------------------- internals --
+
+      def compiler
+        @compiler ||= Compiler::Sql.new(schema: pluckr_schema, source_model: source_model)
+      end
+
+      def result_builder
+        @result_builder ||= Result::Builder.new(pluckr_schema, label: name || "Pluckr::Result")
+      end
+
+      private
+
+      def inherited_from_query(reader)
+        return nil unless superclass.respond_to?(reader) && superclass <= Query && superclass != Query
+
+        superclass.public_send(reader)
+      end
+
+      def fetch_aggregates
+        row = Pluckr.select_all(compiler.connection, to_sql, name: name).first
+        result_builder.build(row)
+      end
+
+      def reset_compilation!
+        @compiler = nil
+        @result_builder = nil
+      end
+    end
+  end
+end

data/lib/pluckr/reflection/association.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Pluckr
+  module Reflection
+    # Thin wrapper over ActiveRecord association reflection.
+    #
+    # Everything Pluckr knows about tables, keys and join direction comes from
+    # here - developers never spell out foreign keys in the DSL.
+    class Association
+      SINGULAR_MACROS = %i[belongs_to has_one].freeze
+
+      attr_reader :owner, :name, :reflection
+
+      # @param owner [Class<ActiveRecord::Base>]
+      # @param name [Symbol] association name
+      def self.for(owner, name)
+        raise MissingSource, "Cannot resolve association `#{name}` without a `source` model" if owner.nil?
+
+        reflection = owner.reflect_on_association(name)
+        unless reflection
+          raise UnknownAssociation, "#{owner.name} does not have association `#{name}`"
+        end
+
+        new(owner, name, reflection)
+      end
+
+      def initialize(owner, name, reflection)
+        @owner = owner
+        @name = name.to_sym
+        @reflection = reflection
+        validate_supported!
+        freeze
+      end
+
+      def macro
+        reflection.macro
+      end
+
+      def klass
+        reflection.klass
+      end
+
+      def table_name
+        klass.table_name
+      end
+
+      def primary_key
+        klass.primary_key
+      end
+
+      def singular?
+        SINGULAR_MACROS.include?(macro)
+      end
+
+      def collection?
+        macro == :has_many
+      end
+
+      # Column on the association's own table used in the join.
+      def association_key
+        reflection.join_primary_key.to_s
+      end
+
+      # Column on the owner's table used in the join.
+      def owner_key
+        reflection.join_foreign_key.to_s
+      end
+
+      # Column holding the owner's type for `has_many/has_one ..., as: :thing`.
+      def type_column
+        reflection.type
+      end
+
+      # ON clause for `owner_table` LEFT JOIN `association_table`.
+      def join_condition(association_table, owner_table)
+        condition = association_table[association_key].eq(owner_table[owner_key])
+        return condition unless type_column
+
+        # `has_many :likes, as: :likeable` also matches on likes.likeable_type.
+        condition.and(association_table[type_column].eq(owner.polymorphic_name))
+      end
+
+      private
+
+      def validate_supported!
+        if reflection.polymorphic?
+          raise UnsupportedAssociation,
+                "`#{owner.name}##{name}` is polymorphic, which Pluckr does not support yet"
+        end
+
+        if reflection.through_reflection?
+          raise UnsupportedAssociation,
+                "`#{owner.name}##{name}` is a :through association, which Pluckr does not support yet"
+        end
+
+        if klass.default_scopes.any?
+          raise UnsupportedAssociation,
+                "`#{owner.name}##{name}` targets #{klass.name}, which has a default_scope " \
+                "that Pluckr does not apply yet"
+        end
+
+        if reflection.scope
+          raise UnsupportedAssociation,
+                "`#{owner.name}##{name}` has a scope, which Pluckr does not apply yet"
+        end
+      end
+    end
+  end
+end