api_maker 0.0.1

data/app/services/api_maker/create_command_service.rb

@@ -0,0 +1,18 @@
+class ApiMaker::CreateCommandService < ApiMaker::CommandService
+  def execute
+    ApiMaker::CreateCommand.execute_in_thread!(
+      ability: ability,
+      args: args,
+      collection: collection,
+      commands: commands,
+      command_response: command_response,
+      controller: controller
+    )
+
+    ServicePattern::Response.new(success: true)
+  end
+
+  def collection
+    @collection ||= model_class.accessible_by(@ability, :create)
+  end
+end

data/app/services/api_maker/destroy_command.rb

@@ -0,0 +1,39 @@
+class ApiMaker::DestroyCommand < ApiMaker::BaseCommand
+  attr_reader :command, :model, :params, :serializer
+
+  def execute!
+    each_command do |command|
+      @command = command
+      @model = command.model
+      @params = command.args || {}
+      @serializer = serialized_resource(model)
+
+      if command.model.destroy
+        success_response
+      else
+        failure_response
+      end
+    end
+
+    ServicePattern::Response.new(success: true)
+  end
+
+  def failure_response
+    command.fail(
+      model: serializer.result,
+      success: false,
+      errors: model.errors.full_messages
+    )
+  end
+
+  def serialized_resource(model)
+    ApiMaker::Serializer.new(ability: current_ability, args: api_maker_args, model: model)
+  end
+
+  def success_response
+    command.result(
+      model: serializer.result,
+      success: true
+    )
+  end
+end

data/app/services/api_maker/destroy_command_service.rb

@@ -0,0 +1,22 @@
+class ApiMaker::DestroyCommandService < ApiMaker::CommandService
+  def execute
+    ApiMaker::DestroyCommand.execute_in_thread!(
+      ability: ability,
+      args: args,
+      collection: collection,
+      commands: commands,
+      command_response: command_response,
+      controller: controller
+    )
+
+    ServicePattern::Response.new(success: true)
+  end
+
+  def collection
+    @collection ||= model_class.accessible_by(@ability, :destroy).where(model_class.primary_key => ids)
+  end
+
+  def ids
+    @commands.values.map { |command| command.fetch("primary_key") }
+  end
+end

data/app/services/api_maker/generate_react_native_api_service.rb

@@ -0,0 +1,61 @@
+class ApiMaker::GenerateReactNativeApiService < ApiMaker::ApplicationService
+  def execute
+    check_if_root_folder_defined
+    create_root_folder
+    create_model_files
+
+    ServicePattern::Response.new(success: true)
+  end
+
+  def root_folder
+    @root_folder ||= ApiMaker::Configuration.current.react_native_path
+  end
+
+  def check_if_root_folder_defined
+    raise "No root folder detected" if root_folder.blank?
+
+    Dir.mkdir(model_path) unless Dir.exist?(model_path)
+  end
+
+  def create_root_folder
+    Dir.mkdir(root_folder) unless Dir.exist?(root_folder)
+  end
+
+  def create_model_files
+    model_generator_service.models.each do |model|
+      next if model_generator_service.ignore_model?(model)
+
+      model_content_response = ApiMaker::ModelContentGeneratorService.execute!(model: model)
+
+      if model_content_response.success?
+        File.open(model_file(model), "w") { |fp| fp.write(model_content_response.result) }
+      else
+        puts model_content_response.errors.join(". ")
+      end
+    end
+  end
+
+  def model_generator_service
+    @model_generator_service ||= ApiMaker::ModelsGeneratorService.new
+  end
+
+  def model_file(model)
+    resource_class = ApiMaker::MemoryStorage.current.resource_for_model(model)
+    File.join(model_path, "#{resource_class.short_name.underscore.dasherize}.js")
+  end
+
+  def model_path
+    @model_path ||= File.join(root_folder, "models")
+  end
+
+  def copy_base_model
+    files = %w[
+      api.js base-model.js cable-connection-pool.js cable-subscription.js cable-subscription-pool.js
+      collection.js commands-pool.js devise.js event-listener.jsx error-logger.js form-data-to-object.js logger.js
+      model-name.js models-response-reader.js result.js event-connection.jsx
+    ]
+    path = File.join(__dir__, "..", "..", "..", "lib", "api_maker", "javascript")
+
+    copy_base_files(files, path, root_folder)
+  end
+end

data/app/services/api_maker/index_command.rb

@@ -0,0 +1,96 @@
+class ApiMaker::IndexCommand < ApiMaker::BaseCommand
+  attr_reader :params
+
+  def execute!
+    ApiMaker::Configuration.profile("IndexCommand execute") do
+      each_command do |command|
+        @params = command.args || {}
+
+        set_collection
+
+        if params[:count]
+          count = @query.count
+          count = count.length if count.is_a?(Hash)
+
+          command.result(count: count)
+        else
+          collection = collection_from_query(@query.fix)
+          response = collection.as_json
+          include_pagination_data(response, @query)
+
+          command.result(response)
+        end
+      end
+    end
+
+    ServicePattern::Response.new(success: true)
+  end
+
+  def filter_custom_accessible_by(collection)
+    return collection if params[:accessible_by].blank?
+
+    collection.accessible_by(current_ability, params[:accessible_by].to_sym)
+  end
+
+  def collection_from_query(collection)
+    ApiMaker::Configuration.profile("IndexCommand collection_from_query") do
+      select = parse_select(params[:select]&.permit!&.to_hash) if params[:select]
+
+      ApiMaker::CollectionSerializer.new(
+        ability: current_ability,
+        args: api_maker_args,
+        collection: collection,
+        include_param: params[:include],
+        select: select
+      ).result
+    end
+  end
+
+  def include_pagination_data(response, collection)
+    return if params[:page].blank?
+
+    response[:meta] = {
+      currentPage: collection.current_page,
+      totalCount: collection.try(:total_count) || collection.try(:total_entries),
+      totalPages: collection.total_pages
+    }
+  end
+
+  def manage_through_relationship
+    return if params[:through].blank?
+
+    model_class = params[:through][:model].safe_constantize
+    through_model = model_class.accessible_by(current_ability).find(params[:through][:id])
+    association = ActiveRecord::Associations::Association.new(through_model, model_class.reflections.fetch(params[:through][:reflection]))
+
+    query_through = association.scope
+    query_through = query_through.accessible_by(current_ability)
+    query_through = filter_custom_accessible_by(query_through)
+    query_through
+  end
+
+  # This converts the list of attributes to a hash that contains the data needed for the serializer (so the serializer doesn't have to do it for each model)
+  def parse_select(select)
+    new_select = {}
+
+    select.each do |model_collection_name, attributes|
+      model_class = model_collection_name.underscore.singularize.camelize
+      resource = "Resources::#{model_class}Resource".safe_constantize
+      raise "Resource not found for: #{model_collection_name}" unless resource
+
+      new_attributes = resource._attributes.select { |key| attributes.include?(key.to_s) }
+      new_select[resource.model_class] = new_attributes
+    end
+
+    new_select
+  end
+
+  def set_collection
+    @query = manage_through_relationship || collection
+    @query = @query.distinct if params[:distinct]
+    @query = @query.ransack(params[:q]).result
+    @query = @query.limit(params[:limit]) if params[:limit].present?
+    @query = @query.page(params[:page]) if params[:page].present?
+    @query = filter_custom_accessible_by(@query)
+  end
+end

data/app/services/api_maker/index_command_service.rb

@@ -0,0 +1,22 @@
+class ApiMaker::IndexCommandService < ApiMaker::CommandService
+  def execute
+    ApiMaker::IndexCommand.execute_in_thread!(
+      ability: ability,
+      args: args,
+      collection: collection,
+      commands: commands,
+      command_response: command_response,
+      controller: controller
+    )
+
+    ServicePattern::Response.new(success: true)
+  end
+
+  def collection
+    @collection ||= model_class.accessible_by(@ability)
+  end
+
+  def ids
+    @ids ||= @commands.values.map { |command| command.fetch("primary_key") }
+  end
+end

data/app/services/api_maker/js_method_namer_service.rb

@@ -0,0 +1,11 @@
+class ApiMaker::JsMethodNamerService < ApiMaker::ApplicationService
+  def initialize(name:)
+    @name = name
+  end
+
+  def execute
+    camelized = @name.to_s.camelize
+    new_name = "#{camelized[0..0].downcase}#{camelized[1..camelized.length]}"
+    ServicePattern::Response.new(result: new_name)
+  end
+end

data/app/services/api_maker/member_command_service.rb

@@ -0,0 +1,25 @@
+class ApiMaker::MemberCommandService < ApiMaker::CommandService
+  def execute
+    ability_name = @command_name.to_sym
+    collection = model_class.accessible_by(@ability, ability_name).where(model_class.primary_key => ids)
+
+    constant.execute_in_thread!(
+      ability: ability,
+      args: args,
+      collection: collection,
+      commands: commands,
+      command_response: command_response,
+      controller: controller
+    )
+
+    ServicePattern::Response.new(success: true)
+  end
+
+  def constant
+    @constant ||= "Commands::#{namespace}::#{@command_name.camelize}".constantize
+  end
+
+  def ids
+    @commands.values.map { |command| command.fetch("primary_key") }
+  end
+end

data/app/services/api_maker/model_content_generator_service.rb

@@ -0,0 +1,108 @@
+class ApiMaker::ModelContentGeneratorService < ApiMaker::ApplicationService
+  attr_reader :model
+
+  def initialize(model:)
+    @model = model
+  end
+
+  def execute
+    if resource
+      ServicePattern::Response.new(result: model_content)
+    else
+      ServicePattern::Response.new(errors: ["No resource defined for #{model.name}"])
+    end
+  end
+
+private
+
+  def attributes
+    resource._attributes.map do |attribute, _data|
+      {name: attribute, type: model_type(attribute)}
+    end
+  end
+
+  def collection_commands
+    ApiMaker::Loader.load_everything
+    ApiMaker::MemoryStorage.current.storage_for(resource, :collection_commands)
+  end
+
+  def member_commands
+    ApiMaker::Loader.load_everything
+    ApiMaker::MemoryStorage.current.storage_for(resource, :member_commands)
+  end
+
+  def model_content
+    erb = ERB.new(File.read(model_template_path))
+    erb.filename = File.realpath(model_template_path)
+    erb.result(binding)
+  end
+
+  def model_template_path
+    File.join(__dir__, "..", "..", "..", "lib", "api_maker", "javascript", "model-template.js.erb")
+  end
+
+  def model_type(attribute_name)
+    model_type = model.columns_hash[attribute_name.to_s]&.type
+    model_type = :money if monetized_attributes.include?(attribute_name.to_s)
+    model_type ||= :unknown
+    model_type
+  end
+
+  def monetized_attributes
+    @monetized_attributes ||= @model.try(:monetized_attributes).try(:map) { |attribute| attribute[0] } || []
+  end
+
+  def reflections
+    @reflections ||= resource._relationships.map do |name, _data|
+      reflection = model.reflections.values.find { |reflection_i| reflection_i.name == name }
+      raise "Couldnt find reflection by that name: #{name}" unless reflection
+
+      reflection
+    end
+  end
+
+  def reflection_has_many_parameters(reflection)
+    {
+      reflectionName: reflection.name,
+      model: "{{this}}",
+      modelName: reflection.class_name,
+      modelClass: "{{modelClass}}",
+      targetPathName: "/api_maker/#{reflection.klass.model_name.route_key}"
+    }
+  end
+
+  def reflection_has_many_parameters_query(reflection)
+    if reflection.options[:through]
+      {
+        params: {
+          through: {
+            model: model.name,
+            id: "{{id}}",
+            reflection: reflection.name
+          }
+        }
+      }
+    else
+      {
+        ransack: {
+          "#{reflection.foreign_key}_eq" => "{{id}}"
+        }
+      }
+    end
+  end
+
+  def reflections_for_model_class_data
+    @reflections_for_model_class_data ||= reflections.map do |reflection|
+      {
+        className: reflection.class_name,
+        collectionName: ApiMaker::MemoryStorage.current.resource_for_model(reflection.klass).collection_name,
+        name: reflection.name,
+        macro: reflection.macro
+      }
+    end
+  end
+
+  def resource
+    @resource ||= ApiMaker::MemoryStorage.current.resource_for_model(@model)
+  end
+end

data/app/services/api_maker/models_finder_service.rb

@@ -0,0 +1,22 @@
+class ApiMaker::ModelsFinderService < ApiMaker::ApplicationService
+  def execute
+    ServicePattern::Response.new(result: models)
+  end
+
+private
+
+  def models
+    result = []
+    Dir.glob(Rails.root.join("app", "api_maker", "resources", "**", "*.rb")) do |model_path|
+      next unless model_path.start_with?(Rails.root.to_s)
+
+      path_name = model_path.gsub(/\A#{Regexp.escape(Rails.root.to_s)}\/app\/api_maker\/resources\//, "").gsub(/\.rb\Z/, "")
+      next if path_name == "application_resource"
+
+      resource_class = "Resources::#{path_name.classify}".constantize
+      result << resource_class.model_class
+    end
+
+    result
+  end
+end

data/app/services/api_maker/models_generator_service.rb

@@ -0,0 +1,104 @@
+class ApiMaker::ModelsGeneratorService < ApiMaker::ApplicationService
+  def execute
+    create_base_structure
+    copy_base_model
+    copy_base_controllers
+
+    models.each do |model|
+      next if ignore_model?(model)
+
+      model_content_response = ApiMaker::ModelContentGeneratorService.execute(model: model)
+
+      if model_content_response.success?
+        File.open(model_file(model), "w") { |fp| fp.write(model_content_response.result) }
+      else
+        puts model_content_response.errors.join(". ")
+      end
+    end
+
+    ApiMaker::GenerateReactNativeApiService.execute! if ApiMaker::Configuration.current.react_native_path.present?
+    ServicePattern::Response.new(success: true)
+  end
+
+  def ignore_model?(model)
+    model.name.end_with?("::Translation") ||
+      model.name.start_with?("ActiveStorage::") ||
+      model.name.end_with?("::ApplicationRecord")
+  end
+
+  def models
+    ApiMaker::ModelsFinderService.execute!
+  end
+
+private
+
+  def api_maker_root_path
+    Rails.root.join("app", "javascript", "api-maker")
+  end
+
+  def controller_path
+    Rails.root.join("app", "controllers", "api_maker")
+  end
+
+  def copy_base_controllers
+    files = %w[devise_controller.rb]
+    path = File.join(__dir__, "..", "..", "controllers", "api_maker")
+    target_path = Rails.root.join("app", "controllers", "api_maker")
+
+    copy_base_files(files, path, target_path)
+  end
+
+  def copy_base_model
+    files = %w[
+      api.js base-model.js cable-connection-pool.js cable-subscription.js cable-subscription-pool.js collection.js
+      commands-pool.js event-created.jsx custom-error.js deserializer.js devise.js event-destroyed.jsx event-emitter-listener.jsx event-listener.jsx
+      event-updated.jsx error-logger.js form-data-to-object.js included.js key-value-store.js logger.js model-name.js models-response-reader.js
+      params.js result.js event-connection.jsx paginate.jsx sort-link.jsx updated-attribute.jsx resource-routes.jsx resource-route.jsx
+      session-status-updater.js bootstrap/attribute-row.jsx bootstrap/attribute-rows.jsx bootstrap/card.jsx
+      bootstrap/checkbox.jsx bootstrap/checkboxes.jsx bootstrap/money-input.jsx bootstrap/radio-buttons.jsx
+      bootstrap/select.jsx bootstrap/string-input.jsx bootstrap/live-table.jsx
+    ]
+    path = File.join(__dir__, "..", "..", "..", "lib", "api_maker", "javascript")
+    target_path = api_maker_root_path
+
+    copy_base_files(files, path, target_path)
+  end
+
+  def copy_base_files(files, path, target_path)
+    files.each do |file|
+      base_model_source_path = File.join(path, file)
+      base_model_target_path = File.join(target_path, file)
+
+      base_model_target_dir = File.dirname(base_model_target_path)
+      FileUtils.mkdir_p(base_model_target_dir) unless File.exist?(base_model_target_dir)
+
+      if File.exist?(base_model_source_path)
+        content = File.read(base_model_source_path)
+      else
+        base_model_source_path << ".erb"
+        erb = ERB.new(File.read(base_model_source_path))
+        erb.filename = base_model_source_path
+        content = erb.result(binding)
+      end
+
+      base_model_target_path = File.join(target_path, file)
+
+      File.open(base_model_target_path, "w") do |fp|
+        fp.write(content)
+      end
+    end
+  end
+
+  def create_base_structure
+    # Dont remove all the files. It messes up running Webpack Dev Servers which forces you to restart all the time.
+    # FileUtils.rm_rf(api_maker_root_path) if File.exist?(api_maker_root_path)
+
+    FileUtils.mkdir_p(api_maker_root_path.join("models"))
+    FileUtils.mkdir_p(controller_path) unless File.exist?(controller_path)
+  end
+
+  def model_file(model)
+    resource_class = ApiMaker::MemoryStorage.current.resource_for_model(model)
+    api_maker_root_path.join("models", "#{resource_class.short_name.underscore.dasherize}.js")
+  end
+end