api_maker 0.0.1 → 0.0.2

data/lib/api_maker/preloader.rb

@@ -1,62 +1,101 @@
 class ApiMaker::Preloader
-  def initialize(ability: nil, args: nil, collection:, data:, include_param:, records:, select:)
+  attr_reader :api_maker_args, :key_path, :locals, :model_class, :preload_param
+
+  def initialize(
+    ability: nil,
+    api_maker_args: nil,
+    collection:,
+    data:,
+    key_path: [],
+    locals:,
+    preload_param:,
+    model_class: nil,
+    records:,
+    select:,
+    select_columns:
+  )
     @ability = ability
-    @args = args
+    @api_maker_args = api_maker_args
     @collection = collection
     @data = data
-    @include_param = include_param
+    @key_path = key_path
+    @locals = locals
+    @preload_param = preload_param
+    @model_class = model_class || @collection.model
     @records = records
     @select = select
+    @select_columns = select_columns
   end
 
-  def fill_data
-    parsed = ApiMaker::RelationshipIncluder.parse(@include_param)
+  def fill_data # rubocop:disable Metrics/AbcSize
+    parsed = ApiMaker::RelationshipPreloader.parse(preload_param)
     return unless parsed
 
     parsed.each do |key, value|
       next unless key
 
-      reflection = @collection.model.reflections[key]
+      key_path << key
+
+      reflection = model_class.reflections[key]
       raise "Unknown reflection: #{@collection.model.name}##{key}" unless reflection
 
       fill_empty_relationships_for_key(reflection, key)
       preload_class = preload_class_for_key(reflection)
 
-      preload_result = ApiMaker::Configuration.profile("Preloading #{reflection.klass.name} with #{preload_class.name}") do
-        preload_class.new(
+      Rails.logger.debug { "API maker: Preloading #{model_class}: #{key_path.join(".")}" }
+
+      preload_result = ApiMaker::Configuration.profile(-> { "Preloading #{reflection.klass.name} with #{preload_class.name}" }) do
+        preload_class
+          .new(
+            ability: @ability,
+            api_maker_args: api_maker_args,
+            collection: @collection,
+            data: @data,
+            locals: locals,
+            records: @records,
+            reflection: reflection,
+            select: @select,
+            select_columns: @select_columns
+          )
+          .preload
+      end
+
+      if value.blank? || preload_result.empty?
+        key_path.pop
+        next
+      end
+
+      ApiMaker::Preloader
+        .new(
           ability: @ability,
-          args: @args,
-          collection: @collection,
+          api_maker_args: api_maker_args,
           data: @data,
-          records: @records,
-          reflection: reflection,
-          select: @select
-        ).preload
-      end
+          collection: preload_result,
+          key_path: key_path.dup,
+          locals: locals,
+          preload_param: value,
+          model_class: reflection.klass,
+          records: @data.fetch(:preloaded),
+          select: @select,
+          select_columns: @select_columns
+        )
+        .fill_data
 
-      next if value.blank? || preload_result.fetch(:collection).empty?
-
-      ApiMaker::Preloader.new(
-        ability: @ability,
-        args: @args,
-        data: @data,
-        collection: preload_result.fetch(:collection),
-        include_param: value,
-        records: @data.fetch(:included),
-        select: @select
-      ).fill_data
+      key_path.pop
     end
   end
 
 private
 
+  # Smoke test to make sure we aren't doing any additional and unnecessary queries
+  def check_collection_loaded!
+    raise "Collection wasn't loaded?" if @collection.is_a?(ActiveRecord::Relation) && !@collection.loaded?
+  end
+
   def fill_empty_relationships_for_key(reflection, key)
-    if @records.is_a?(Hash)
-      collection_name = ApiMaker::MemoryStorage.current.resource_for_model(reflection.active_record).collection_name
-      records_to_set = @records.fetch(collection_name).values
-    else
-      records_to_set = @records.select { |record| record.model.class == reflection.active_record }
-    end
+    check_collection_loaded!
+    collection_name = ApiMaker::MemoryStorage.current.resource_for_model(reflection.active_record).collection_name
+    records_to_set = @collection.map { |model| @records.dig(collection_name, model.id) }
 
     case reflection.macro
     when :has_many

data/lib/api_maker/preloader_base.rb

@@ -0,0 +1,108 @@
+class ApiMaker::PreloaderBase
+  attr_reader :ability, :api_maker_args, :collection, :data, :locals, :records, :reflection, :reflection_name, :select, :select_columns
+
+  def initialize(ability:, api_maker_args:, data:, collection:, locals:, records:, reflection:, select:, select_columns:)
+    @ability = ability
+    @api_maker_args = api_maker_args
+    @data = data
+    @collection = collection
+    @locals = locals
+    @reflection = reflection
+    @reflection_name = @reflection.name
+    @records = records
+    @select = select
+    @select_columns = select_columns
+  end
+
+  def collection_ids
+    @collection_ids ||= collection.map do |collection_model|
+      collection_model[reflection.active_record.primary_key]
+    end
+  end
+
+  def underscore_name
+    @underscore_name ||= ApiMaker::MemoryStorage.current.resource_for_model(reflection.active_record).underscore_name
+  end
+
+  def models_with_join
+    @models_with_join ||= reflection.klass.find_by_sql(join_query.to_sql)
+  end
+
+  # ActiveRecord might have joined the relationship by a predictable alias. If so we need to use that alias
+  def joined_name
+    "#{reflection.name.to_s.pluralize}_#{reflection.klass.name.underscore.pluralize}"
+  end
+
+  def join_query
+    if initial_join_query.to_sql.include?(joined_name)
+      collection = join_query_with_joined_name
+      table_name = joined_name
+    else
+      collection = join_query_with_normal_name
+    end
+
+    ApiMaker::SelectColumnsOnCollection.execute!(
+      collection: collection,
+      model_class: reflection.klass,
+      select_attributes: select,
+      select_columns: select_columns,
+      table_name: table_name
+    )
+  end
+
+  def initial_join_query
+    reflection.active_record.joins(reflection.name)
+  end
+
+  def join_query_with_joined_name
+    # Since the joined table is using a different name, we don't need to double join the original table with an alias like under 'join_query_with_normal_name'
+    # The "WHERE id IN sub_query version looks like this: # .where(joined_name => {reflection.klass.primary_key => accessible_query})
+
+    exists_query = accessible_query
+      .select("1")
+      .where("#{accessible_query.klass.table_name}.#{accessible_query.klass.primary_key} = #{joined_name}.#{reflection.klass.primary_key}")
+
+    initial_join_query
+      .select(reflection.active_record.arel_table[reflection.active_record.primary_key].as("api_maker_origin_id"))
+      .where(reflection.active_record.primary_key => collection_ids)
+      .where("EXISTS (#{exists_query.to_sql})")
+  end
+
+  # Join a copy of the original table to be able to access previous table (by a copy) in the accessible query
+  # This is done to avoid "WHERE id IN sub_query" which is much slower than "WHERE EXISTS sub_query"
+  # The "WHERE id IN sub_query" version looks this simple line: .where(reflection.klass.table_name => {reflection.klass.primary_key => accessible_query})
+  def join_query_with_normal_name # rubocop:disable Metrics/AbcSize
+    query = initial_join_query
+      .select(reflection.active_record.arel_table[reflection.active_record.primary_key].as("api_maker_origin_id"))
+      .where(reflection.active_record.primary_key => collection_ids)
+
+    # No reason to add all the extra SQL if the ability has unconditioned read access
+    unless unconditioned_read_access?
+      exists_query = accessible_query
+        .select("1")
+        .where("#{accessible_query.klass.table_name}.#{accessible_query.klass.primary_key} = accessible_table.#{reflection.klass.primary_key}")
+
+      query = query
+        .joins(
+          "JOIN #{reflection.klass.table_name} AS accessible_table ON " \
+            "accessible_table.id = #{reflection.klass.table_name}.#{reflection.klass.primary_key}"
+        )
+        .where("EXISTS (#{exists_query.to_sql})")
+    end
+
+    query
+  end
+
+  def unconditioned_read_access?
+    relevant_rules = ability.__send__(:relevant_rules, :read, reflection.klass)
+    relevant_rules.each do |can_can_rule|
+      return true if can_can_rule.__send__(:conditions_empty?)
+    end
+
+    false
+  end
+
+  def accessible_query
+    reflection.klass.accessible_by(ability)
+  end
+end

data/lib/api_maker/preloader_belongs_to.rb

@@ -1,58 +1,59 @@
-class ApiMaker::PreloaderBelongsTo
-  def initialize(ability:, args:, data:, collection:, records:, reflection:, select:)
-    @ability = ability
-    @args = args
-    @data = data
-    @collection = collection
-    @reflection = reflection
-    @reflection_name = @reflection.name
-    @records = records
-    @select = select
-  end
-
+class ApiMaker::PreloaderBelongsTo < ApiMaker::PreloaderBase
   def preload
     models.each do |model|
+      model_id = ApiMaker::PrimaryIdForModel.get(model)
+
       records_for_model(model).each do |record|
-        record.relationships[@reflection_name] = model.id
+        record.relationships[reflection_name] = model_id
       end
 
-      serializer = ApiMaker::Serializer.new(ability: @ability, args: @args, model: model, select: @select&.dig(model.class))
-      collection_name = serializer.resource.collection_name
+      serializer = ApiMaker::Serializer.new(ability: ability, api_maker_args: api_maker_args, locals: locals, model: model, select: select&.dig(model.class))
+      underscore_name = serializer.resource.underscore_name
 
-      @data.fetch(:included)[collection_name] ||= {}
-      @data.fetch(:included).fetch(collection_name)[model.id] ||= serializer
+      data.fetch(:preloaded)[underscore_name] ||= {}
+      data.fetch(:preloaded).fetch(underscore_name)[model_id] ||= serializer
     end
 
-    {collection: models}
+    models
   end
 
 private
 
-  def collection_name
-    @collection_name = ApiMaker::MemoryStorage.current.resource_for_model(@reflection.active_record).collection_name
-  end
-
-  def model_class
-    @model_class ||= @reflection.klass
+  # Collects all the parent foreign keys like "users.organization_id" when preloading organizations and removes the blank (if a user doesn't have an org.)
+  def look_up_values
+    @look_up_values ||= collection.map(&reflection.foreign_key.to_sym).reject(&:blank?)
   end
 
   def models
-    @models ||= begin
-      models = @reflection.klass.where(look_up_key => @collection.map(&@reflection.foreign_key.to_sym).uniq)
-      models = models.accessible_by(@ability) if @ability
-      models.load
-      models
+    @models ||= if look_up_values.empty?
+      # There is nothing to preload
+      []
+    else
+      query = reflection.klass.where(look_up_key => look_up_values)
+      query = query.instance_eval(&reflection.scope) if reflection.scope
+      query = query.accessible_by(ability) if ability
+      query = ApiMaker::SelectColumnsOnCollection.execute!(
+        collection: query,
+        model_class: reflection.klass,
+        select_attributes: select,
+        select_columns: select_columns,
+        table_name: query.klass.table_name
+      )
+
+      query.load
+      query
     end
   end
 
   def look_up_key
-    @look_up_key ||= @reflection.options[:primary_key] || @reflection.klass.primary_key
+    @look_up_key ||= reflection.options[:primary_key] || reflection.klass.primary_key
   end
 
   def records_for_model(model)
-    @records
-      .fetch(collection_name)
+    # Force to string if one column is an integer and another is a string
+    records
+      .fetch(underscore_name)
       .values
-      .select { |record| record.model.read_attribute(@reflection.foreign_key) == model.read_attribute(look_up_key) }
+      .select { |record| record.model[reflection.foreign_key].to_s == model[look_up_key].to_s }
   end
 end

data/lib/api_maker/preloader_has_many.rb

@@ -1,68 +1,74 @@
-class ApiMaker::PreloaderHasMany
-  def initialize(ability:, args:, data:, collection:, reflection:, records:, select:)
-    @ability = ability
-    @args = args
-    @data = data
-    @collection = collection
-    @reflection = reflection
-    @records = records
-    @select = select
-
-    raise "No inverse of for #{@reflection.active_record.name}##{@reflection.name}" unless @reflection.inverse_of
-  end
-
+class ApiMaker::PreloaderHasMany < ApiMaker::PreloaderBase
   def preload
     models.each do |model|
       preload_model(model)
     end
 
-    {collection: models}
+    models
   end
 
 private
 
   def models
-    @models ||= begin
-      if @reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
-        query = ApiMaker::PreloaderThrough.new(collection: @collection, reflection: @reflection).models_query_through_reflection
-      else
-        primary_key_column = @reflection.options[:primary_key]&.to_sym || @collection.primary_key.to_sym
-        query = @reflection.klass.where(@reflection.foreign_key => @collection.map(&primary_key_column))
-        query = query.joins(@reflection.inverse_of.name)
-      end
+    @models ||= if use_joined_query?
+      models_with_join
+    else
+      primary_key_arel_column = reflection.active_record.arel_table[reflection.active_record.primary_key]
 
-      query = query
-        .select(@reflection.klass.arel_table[Arel.star])
-        .select(@reflection.active_record.arel_table[@reflection.active_record.primary_key].as("api_maker_origin_id"))
-
-      query = query.accessible_by(@ability) if @ability
-      query.load
+      query = models_initial_query.select(primary_key_arel_column.as("api_maker_origin_id"))
+      query = query.instance_eval(&reflection.scope) if reflection.scope
+      query = query.accessible_by(ability) if ability
+      query = ApiMaker::SelectColumnsOnCollection.execute!(
+        collection: query,
+        model_class: reflection.klass,
+        select_attributes: select,
+        select_columns: select_columns,
+        table_name: query.klass.table_name
+      )
       query
     end
   end
 
-  def collection_name
-    @collection_name ||= ApiMaker::MemoryStorage.current.resource_for_model(@reflection.active_record).collection_name
+  def use_joined_query?
+    reflection.is_a?(ActiveRecord::Reflection::ThroughReflection) || reflection.options[:as].present?
+  end
+
+  def models_initial_query
+    raise "#{reflection.active_record.name}.#{reflection.name} didn't have an `inverse_of` instruction" unless reflection.inverse_of
+
+    query = reflection.klass.where(reflection.foreign_key => collection.map(&primary_key_column))
+    query.joins(reflection.inverse_of.name)
   end
 
   def preload_model(model)
     origin_data = find_origin_data_for_model(model)
+    model_id = ApiMaker::PrimaryIdForModel.get(model)
 
-    origin_data.fetch(:r)[@reflection.name] ||= []
-    origin_data.fetch(:r).fetch(@reflection.name) << model.id
+    reflection_data = origin_data.fetch(:r)[reflection.name] ||= []
+    reflection_data << model_id unless reflection_data.include?(model_id)
 
-    serializer = ApiMaker::Serializer.new(ability: @ability, args: @args, model: model, select: @select&.dig(model.class))
-    collection_name = serializer.resource.collection_name
+    serializer = ApiMaker::Serializer.new(ability: ability, api_maker_args: api_maker_args, locals: locals, model: model, select: select&.dig(model.class))
+    underscore_name = serializer.resource.underscore_name
 
-    @data.fetch(:included)[collection_name] ||= {}
-    @data.fetch(:included).fetch(collection_name)[model.id] ||= serializer
+    data.fetch(:preloaded)[underscore_name] ||= {}
+    data.fetch(:preloaded).fetch(underscore_name)[model_id] ||= serializer
+  end
+
+  def primary_key_column
+    @primary_key_column ||= if reflection.options[:primary_key]
+      reflection.options[:primary_key]&.to_sym
+    elsif collection.is_a?(Array)
+      collection.first.class.primary_key.to_sym
+    else
+      collection.primary_key.to_sym
+    end
   end
 
   def find_origin_data_for_model(model)
-    origin_id = model.read_attribute("api_maker_origin_id")
-    origin_data = @records.fetch(collection_name).fetch(origin_id)
+    origin_id = model[:api_maker_origin_id]
+    origin_data = records.fetch(underscore_name).fetch(origin_id)
 
-    raise "Couldn't find any origin data by that type (#{collection_name}) and ID (#{origin_id})" unless origin_data
+    raise "Couldn't find any origin data by that type (#{underscore_name}) and ID (#{origin_id})" unless origin_data
 
     origin_data
   end

data/lib/api_maker/preloader_has_one.rb

@@ -1,70 +1,53 @@
-class ApiMaker::PreloaderHasOne
-  def initialize(ability:, args:, data:, collection:, reflection:, records:, select: @select)
-    @ability = ability
-    @args = args
-    @data = data
-    @collection = collection
-    @reflection = reflection
-    @records = records
-    @select = select
-
-    raise "Records was nil" unless records
-  end
-
-  def collection_name
-    @collection_name ||= ApiMaker::MemoryStorage.current.resource_for_model(@reflection.active_record).collection_name
-  end
-
+class ApiMaker::PreloaderHasOne < ApiMaker::PreloaderBase
   def preload
     models.each do |model|
-      ApiMaker::Configuration.profile("Preloading #{model.class.name}##{model.id}") do
+      model_id = ApiMaker::PrimaryIdForModel.get(model)
+
+      ApiMaker::Configuration.profile(-> { "Preloading #{model.class.name}##{model_id}" }) do
         origin_data = origin_data_for_model(model)
-        origin_data.fetch(:r)[@reflection.name] = model.id
+        origin_data.fetch(:r)[reflection.name] = model_id
 
-        serializer = ApiMaker::Serializer.new(ability: @ability, args: @args, model: model, select: @select&.dig(model.class))
-        collection_name = serializer.resource.collection_name
+        serializer = ApiMaker::Serializer.new(ability: ability, api_maker_args: api_maker_args, locals: locals, model: model, select: select&.dig(model.class))
+        underscore_name = serializer.resource.underscore_name
 
-        @data.fetch(:included)[collection_name] ||= {}
-        @data.fetch(:included).fetch(collection_name)[model.id] ||= serializer
+        data.fetch(:preloaded)[underscore_name] ||= {}
+        data.fetch(:preloaded).fetch(underscore_name)[model_id] ||= serializer
       end
     end
 
-    {collection: models}
+    models
   end
 
   def models
-    @models ||= begin
-      if @reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
-        query = query_through
-      else
-        query = query_normal
-      end
-
-      query = query.accessible_by(@ability) if @ability
-      query = query.fix
+    @models ||= if reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+      models_with_join
+    else
+      query = query_normal
+      query = query.instance_eval(&reflection.scope) if reflection.scope
+      query = query.accessible_by(ability) if ability
+      query = ApiMaker::SelectColumnsOnCollection.execute!(
+        collection: query,
+        model_class: reflection.klass,
+        select_attributes: select,
+        select_columns: select_columns,
+        table_name: query.klass.table_name
+      )
+      query = query.fix if ApiMaker::DatabaseType.postgres?
       query.load
       query
     end
   end
 
   def origin_data_for_model(model)
-    origin_id = model.read_attribute("api_maker_origin_id")
-    @data.fetch(:included).fetch(collection_name).fetch(origin_id)
-  end
-
-  def query_through
-    ApiMaker::PreloaderThrough.new(collection: @collection, reflection: @reflection).models_query_through_reflection
-      .select(@reflection.klass.arel_table[Arel.star])
-      .select(@reflection.active_record.arel_table[@reflection.active_record.primary_key].as("api_maker_origin_id"))
+    origin_id = model[:api_maker_origin_id]
+    data.dig!(:preloaded, underscore_name, origin_id)
   end
 
   def query_normal
-    @reflection.klass.where(@reflection.foreign_key => @collection.map(&:id))
-      .select(@reflection.klass.arel_table[Arel.star])
-      .select(@reflection.klass.arel_table[@reflection.foreign_key].as("api_maker_origin_id"))
-  end
+    query = reflection.klass.where(reflection.foreign_key => collection.map(&:id))
+      .select(reflection.klass.arel_table[reflection.foreign_key].as("api_maker_origin_id"))
 
-  def resource
-    @resource ||= ApiMaker::MemoryStorage.current.resource_for_model(@reflection.klass)
+    query = query.where("#{reflection.options.fetch(:as)}_type" => reflection.active_record.name) if reflection.options[:as]
+    query
   end
 end

data/lib/api_maker/railtie.rb

@@ -1,14 +1,6 @@
 class ApiMaker::Railtie < Rails::Railtie
-  initializer "watch routes.json for changes and reload Rails routes if changed" do |app|
-    file_path = Rails.root.join("app", "javascript", "shared", "routes.json")
-
-    reloader = app.config.file_watcher.new([file_path]) do
-      app.reload_routes!
-    end
-
-    app.reloaders << reloader
-    app.reloader.to_run do
-      reloader.execute_if_updated
-    end
+  initializer "watch routes.json for changes and reload Rails routes if changed" do |_app|
+    file_path = Rails.root.join("app/javascript/shared/routes.json")
+    ApiMaker::RoutesFileReloader.execute!(file_paths: [file_path]) if File.exist?(file_path)
   end
 end

data/lib/api_maker/relationship_preloader.rb

@@ -0,0 +1,42 @@
+class ApiMaker::RelationshipPreloader
+  def self.parse(preload_param)
+    if preload_param.nil?
+      nil
+    elsif preload_param.is_a?(String)
+      ApiMaker::RelationshipPreloader.parse_string(preload_param)
+    elsif preload_param.is_a?(Array)
+      ApiMaker::RelationshipPreloader.parse_array(preload_param)
+    else
+      raise "Unexpected parameter given (#{preload_param.class.name}): #{preload_param}"
+    end
+  end
+
+  def self.parse_string(preload_param)
+    splitted = preload_param.split(".")
+    initial = splitted.shift
+    rest = splitted.join(".")
+    {initial => rest}
+  end
+
+  def self.parse_array(preload_param)
+    result = {}
+    preload_param.each do |preload_param_i|
+      parsed = ApiMaker::RelationshipPreloader.parse(preload_param_i)
+      parsed.each do |key, value|
+        if result.key?(key)
+          if result[key].is_a?(String)
+            result[key] = [result[key], value]
+          elsif result[key].is_a?(Array)
+            result[key] << value
+          else
+            raise "Unknown object: #{result[key].class.name}"
+          end
+        else
+          result[key] = value
+        end
+      end
+    end
+
+    result
+  end
+end

data/lib/api_maker/resource_routing.rb

@@ -1,8 +1,22 @@
 class ApiMaker::ResourceRouting
-  def self.install_resource_routes(rails_routes, layout: "react", routes: nil)
-    routes ||= JSON.parse(File.read(Rails.root.join("app", "javascript", "shared", "routes.json")))
-    routes.fetch("routes").each do |route|
-      rails_routes.get route.fetch("path") => "#{layout}#show", as: route.fetch("name").to_sym
+  def self.install_resource_routes(rails_routes, layout: "react", route_definitions:)
+    rails_routes.instance_variable_set(:@api_maker_installed_routes, {}) unless rails_routes.instance_variable_get(:@api_maker_installed_routes)
+    installed_routes = rails_routes.instance_variable_get(:@api_maker_installed_routes)
+
+    route_definitions.fetch("routes").each do |route|
+      route_name = route.fetch("name").to_sym
+      route_as = route_name
+      route_path = route.fetch("path")
+
+      if installed_routes.key?(route_name)
+        route_duplicate_count = installed_routes.fetch(route_name)
+        route_as = "#{route_as}_duplicate_#{route_duplicate_count}"
+      end
+
+      rails_routes.get route_path => "#{layout}#show", as: route_as
+
+      installed_routes[route_name] ||= 0
+      installed_routes[route_name] += 1
     end
   end
 end