api_maker 0.0.1

data/lib/api_maker/preloader_has_many.rb

@@ -0,0 +1,69 @@
+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
+
+  def preload
+    models.each do |model|
+      preload_model(model)
+    end
+
+    {collection: 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
+
+      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
+    end
+  end
+
+  def collection_name
+    @collection_name ||= ApiMaker::MemoryStorage.current.resource_for_model(@reflection.active_record).collection_name
+  end
+
+  def preload_model(model)
+    origin_data = find_origin_data_for_model(model)
+
+    origin_data.fetch(:r)[@reflection.name] ||= []
+    origin_data.fetch(:r).fetch(@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
+
+    @data.fetch(:included)[collection_name] ||= {}
+    @data.fetch(:included).fetch(collection_name)[model.id] ||= serializer
+  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)
+
+    raise "Couldn't find any origin data by that type (#{collection_name}) and ID (#{origin_id})" unless origin_data
+
+    origin_data
+  end
+end

data/lib/api_maker/preloader_has_one.rb

@@ -0,0 +1,70 @@
+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
+
+  def preload
+    models.each do |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
+
+        serializer = ApiMaker::Serializer.new(ability: @ability, args: @args, model: model, select: @select&.dig(model.class))
+        collection_name = serializer.resource.collection_name
+
+        @data.fetch(:included)[collection_name] ||= {}
+        @data.fetch(:included).fetch(collection_name)[model.id] ||= serializer
+      end
+    end
+
+    {collection: 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
+      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"))
+  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
+
+  def resource
+    @resource ||= ApiMaker::MemoryStorage.current.resource_for_model(@reflection.klass)
+  end
+end

data/lib/api_maker/preloader_through.rb

@@ -0,0 +1,101 @@
+class ApiMaker::PreloaderThrough
+  def initialize(collection:, reflection:)
+    @collection = collection
+    @reflection = reflection
+  end
+
+  def models_query_through_reflection
+    last_reflection = @reflection.through_reflection.inverse_of
+
+    if last_reflection
+      table_name = last_reflection.table_name
+      primary_key = last_reflection.klass.primary_key
+    else
+      table_name = @reflection.through_reflection.active_record.model_name.plural
+      primary_key = @reflection.through_reflection.active_record.primary_key
+    end
+
+    joins_hash = joins_array_to_hash(joins_for_reflection(@reflection))
+
+    @reflection.klass.joins(joins_hash)
+      .where(table_name => {primary_key => @collection.map(&:id)})
+  end
+
+  def joins_for_reflection(current_reflection)
+    joins = []
+
+    loop do
+      # Resolve if the through relationship is through multiple other through relationships
+      current_reflection = resolve_through(current_reflection)
+
+      macro = current_reflection.through_reflection.macro
+      inverse_name = current_reflection.through_reflection.__send__(:inverse_name)
+
+      if inverse_name
+        joins << inverse_name
+      elsif macro == :has_many
+        joins << current_reflection.through_reflection.name
+      elsif macro == :belongs_to || macro == :has_one
+        joins << current_reflection.through_reflection.active_record.model_name.plural.to_sym
+      else
+        raise "Unknown class: #{current_reflection.through_reflection.class.name}"
+      end
+
+      current_reflection = next_reflection_for(current_reflection)
+
+      unless current_reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+        joins.append(append_name_for_current_reflection(current_reflection))
+        break
+      end
+    end
+
+    joins
+  end
+
+  def append_name_for_current_reflection(current_reflection)
+    singular_name = current_reflection.__send__(:inverse_name)&.to_s || current_reflection.active_record.model_name.param_key
+    return singular_name.to_sym if @reflection.klass.reflections.key?(singular_name)
+
+    plural_name = singular_name.pluralize
+    return plural_name.to_sym if @reflection.klass.reflections.key?(plural_name)
+
+    raise "Couldn't find a reflection name #{singular_name} or #{plural_name} on #{@reflection.klass.name}"
+  end
+
+  def joins_array_to_hash(array)
+    array = array.clone
+
+    result = {}
+    work_result = result
+
+    while array.any?
+      element = array.pop
+
+      if array.length == 1
+        work_result[element] = array.pop
+      else
+        work_result[element] = {}
+      end
+
+      work_result = work_result[element]
+    end
+
+    result
+  end
+
+  def next_reflection_for(current_reflection)
+    reflection_name = (current_reflection.source_reflection_name || @reflection.name).to_s
+
+    new_reflection = current_reflection.through_reflection.klass.reflections[reflection_name.pluralize]
+    new_reflection ||= current_reflection.through_reflection.klass.reflections[reflection_name.singularize]
+
+    raise "No such reflection: #{current_reflection.through_reflection.klass.name}##{reflection_name}" unless new_reflection
+
+    new_reflection
+  end
+
+  def resolve_through(current_reflection)
+    current_reflection = current_reflection.through_reflection while current_reflection.through_reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+    current_reflection
+  end
+end

data/lib/api_maker/railtie.rb

@@ -0,0 +1,14 @@
+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
+  end
+end

data/lib/api_maker/relationship_includer.rb

@@ -0,0 +1,42 @@
+class ApiMaker::RelationshipIncluder
+  def self.parse(include_param)
+    if include_param.nil?
+      nil
+    elsif include_param.is_a?(String)
+      ApiMaker::RelationshipIncluder.parse_string(include_param)
+    elsif include_param.is_a?(Array)
+      ApiMaker::RelationshipIncluder.parse_array(include_param)
+    else
+      raise "Unexpected parameter given (#{include_param.class.name}): #{include_param}"
+    end
+  end
+
+  def self.parse_string(include_param)
+    splitted = include_param.split(".")
+    initial = splitted.shift
+    rest = splitted.join(".")
+    {initial => rest}
+  end
+
+  def self.parse_array(include_param)
+    result = {}
+    include_param.each do |include_param_i|
+      parsed = ApiMaker::RelationshipIncluder.parse(include_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

@@ -0,0 +1,8 @@
+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
+    end
+  end
+end

data/lib/api_maker/result_parser.rb

@@ -0,0 +1,50 @@
+class ApiMaker::ResultParser
+  attr_reader :ability, :args
+
+  def self.parse(*args)
+    ApiMaker::ResultParser.new(*args).result
+  end
+
+  def initialize(object, ability: nil, args: nil, controller: nil)
+    @object = object
+    @ability = ability || controller&.__send__(:current_ability)
+    @args = args || controller&.__send__(:api_maker_args) || {}
+  end
+
+  def result
+    parse_object(@object)
+  end
+
+private
+
+  def parse_object(object)
+    if object.is_a?(Hash)
+      result = {}
+      object.each do |key, value|
+        result[key] = parse_object(value)
+      end
+
+      result
+    elsif object.is_a?(Array)
+      object.map { |value| parse_object(value) }
+    elsif object.class.name == "Money"
+      {api_maker_type: :money, amount: object.cents, currency: object.currency.iso_code}
+    elsif object.is_a?(Date)
+      object.iso8601
+    elsif object.is_a?(Time)
+      object.utc.iso8601
+    elsif object.is_a?(ApiMaker::CollectionSerializer) || object.is_a?(ApiMaker::Serializer)
+      parse_object(object.as_json)
+    elsif object.is_a?(ActiveRecord::Base)
+      serializer = ApiMaker::Serializer.new(ability: ability, args: args, model: object)
+
+      {
+        api_maker_type: :model,
+        model_name: serializer.resource.collection_name,
+        serialized: parse_object(serializer.as_json)
+      }
+    else
+      object
+    end
+  end
+end

data/lib/api_maker/serializer.rb

@@ -0,0 +1,86 @@
+class ApiMaker::Serializer
+  attr_reader :ability, :args, :model
+
+  def self.resource_for(klass)
+    ApiMaker::MemoryStorage.current.resource_for_model(klass)
+  rescue NameError
+    nil
+  end
+
+  def self.resource_for!(klass)
+    ApiMaker::MemoryStorage.current.resource_for_model(klass)
+  end
+
+  def initialize(ability: nil, args: {}, model:, select: nil)
+    @args = args
+    @model = model
+    @ability = ability
+    @select = select
+  end
+
+  def attributes
+    ApiMaker::Configuration.profile("attributes") do
+      result = {}
+      attributes_to_read.each do |attribute, data|
+        if (if_name = data.dig(:args, :if))
+          condition_result = attribute_value(if_name)
+          next unless condition_result
+        end
+
+        result[attribute] = attribute_value(attribute)
+      end
+
+      result
+    end
+  end
+
+  def attributes_to_read
+    @attributes_to_read ||= @select || resource.default_select
+  end
+
+  def attribute_value(attribute)
+    if resource_instance.respond_to?(attribute)
+      resource_instance.__send__(attribute)
+    else
+      model.__send__(attribute)
+    end
+  end
+
+  def fetch(*args, &blk)
+    result.fetch(*args, &blk)
+  end
+
+  def relationships
+    @relationships ||= {}
+  end
+
+  def resource
+    @resource ||= ApiMaker::MemoryStorage.current.resource_for_model(model.class)
+  end
+
+  def resource_instance
+    @resource_instance ||= resource.new(ability: ability, args: args, model: model)
+  end
+
+  def result
+    @result ||= begin
+      result = {a: attributes}
+      result[:r] = @relationships if @relationships # Only include relationships if set
+      result
+    end
+  end
+
+  def as_json(_options = nil)
+    result
+  end
+
+  def to_json(_options = nil)
+    JSON.generate(as_json)
+  end
+
+  def inspect
+    "<ApiMaker::Serializer id=\"#{model.id}\" model=\"#{model.class.name}\" relationships=\"#{relationships}\">"
+  end
+
+  alias to_s inspect
+end