api_maker 0.0.1 → 0.0.2

data/app/services/api_maker/locals_from_controller.rb

@@ -0,0 +1,14 @@
+class ApiMaker::LocalsFromController < ApiMaker::ApplicationService
+  attr_reader :controller
+
+  def initialize(controller:)
+    @controller = controller
+  end
+
+  def perform
+    variable_name = :@api_maker_locals
+    controller.instance_variable_set(variable_name, {}) unless controller.instance_variable_defined?(variable_name)
+    variable = controller.instance_variable_get(variable_name)
+    succeed! variable
+  end
+end

data/app/services/api_maker/member_command_service.rb

@@ -1,22 +1,24 @@
 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)
+  def perform
+    ApiMaker::Configuration.profile(-> { "MemberCommand execute: #{model_class.name}##{command_name}" }) do
+      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
-    )
+      constant.execute_in_thread!(
+        ability: ability,
+        api_maker_args: api_maker_args,
+        collection: collection,
+        commands: commands,
+        command_response: command_response,
+        controller: controller
+      )
 
-    ServicePattern::Response.new(success: true)
+      succeed!
+    end
   end
 
   def constant
-    @constant ||= "Commands::#{namespace}::#{@command_name.camelize}".constantize
+    @constant ||= "Commands::#{namespace}::#{command_name.camelize}".constantize
   end
 
   def ids

data/app/services/api_maker/model_classes_java_script_generator_service.rb

@@ -0,0 +1,37 @@
+class ApiMaker::ModelClassesJavaScriptGeneratorService < ApiMaker::ApplicationService
+  def perform
+    javascript_code = ""
+    resource_names = []
+
+    models.each do |model|
+      next if ignore_model?(model)
+
+      javascript_code << ApiMaker::ModelContentGeneratorService.execute!(model: model)
+      javascript_code << "\n\n"
+
+      resource = resource_for_model(model)
+      resource_names << resource.short_name
+    end
+
+    javascript_code << "export {#{resource_names.sort.join(", ")}}\n"
+
+    succeed! javascript_code
+  end
+
+  def ignore_model?(model)
+    model.name.end_with?("::Translation", "::ApplicationRecord")
+  end
+
+  def models
+    @models ||= ApiMaker::ModelsFinderService.execute!
+  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
+
+  def resource_for_model(model)
+    ApiMaker::MemoryStorage.current.resource_for_model(model)
+  end
+end

data/app/services/api_maker/model_content_generator_service.rb

@@ -5,11 +5,11 @@ class ApiMaker::ModelContentGeneratorService < ApiMaker::ApplicationService
     @model = model
   end
 
-  def execute
+  def perform
     if resource
-      ServicePattern::Response.new(result: model_content)
+      succeed! model_content
     else
-      ServicePattern::Response.new(errors: ["No resource defined for #{model.name}"])
+      fail! "No resource defined for #{model.name}"
     end
   end
 
@@ -17,7 +17,7 @@ private
 
   def attributes
     resource._attributes.map do |attribute, _data|
-      {name: attribute, type: model_type(attribute)}
+      {name: attribute}
     end
   end
 
@@ -41,13 +41,6 @@ private
     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
@@ -55,7 +48,10 @@ private
   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
+
+      unless reflection
+        raise "Couldnt find reflection by that name: #{name} on the model: #{model.name}. Reflections found: #{model.reflections.keys.join(", ")}"
+      end
 
       reflection
     end
@@ -66,8 +62,7 @@ private
       reflectionName: reflection.name,
       model: "{{this}}",
       modelName: reflection.class_name,
-      modelClass: "{{modelClass}}",
-      targetPathName: "/api_maker/#{reflection.klass.model_name.route_key}"
+      modelClass: "{{modelClass}}"
     }
   end
 
@@ -83,21 +78,22 @@ private
         }
       }
     else
-      {
-        ransack: {
-          "#{reflection.foreign_key}_eq" => "{{id}}"
-        }
-      }
+      ransack = {"#{reflection.foreign_key}_eq" => "{{id}}"}
+      ransack["#{reflection.options[:as]}_type_eq"] = reflection.active_record.name if reflection.options[:as]
+      {ransack: ransack}
     end
   end
 
   def reflections_for_model_class_data
     @reflections_for_model_class_data ||= reflections.map do |reflection|
+      resource = ApiMaker::MemoryStorage.current.resource_for_model(reflection.klass)
+
       {
         className: reflection.class_name,
-        collectionName: ApiMaker::MemoryStorage.current.resource_for_model(reflection.klass).collection_name,
+        collectionName: resource.collection_name,
         name: reflection.name,
-        macro: reflection.macro
+        macro: reflection.macro,
+        resource_name: resource.short_name
       }
     end
   end

data/app/services/api_maker/models/save.rb

@@ -0,0 +1,29 @@
+class ApiMaker::Models::Save < ApiMaker::ApplicationService
+  attr_reader :models, :simple_model_errors
+
+  def initialize(models:, simple_model_errors: false)
+    @models = models
+    @simple_model_errors = simple_model_errors
+  end
+
+  def perform
+    errors = []
+
+    models.first.transaction do
+      models.each do |model|
+        next if model.save
+
+        if simple_model_errors
+          errors += ApiMaker::SimpleModelErrors.execute!(model: model)
+        else
+          errors += models.map(&:errors).map(&:full_messages).flatten
+        end
+
+        raise ActiveRecord::Rollback if errors.any?
+      end
+    end
+
+    fail! errors.uniq if errors.any?
+    succeed!
+  end
+end

data/app/services/api_maker/models_finder_service.rb

@@ -1,5 +1,5 @@
 class ApiMaker::ModelsFinderService < ApiMaker::ApplicationService
-  def execute
+  def perform
     ServicePattern::Response.new(result: models)
   end
 
@@ -7,7 +7,7 @@ private
 
   def models
     result = []
-    Dir.glob(Rails.root.join("app", "api_maker", "resources", "**", "*.rb")) do |model_path|
+    files.each 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/, "")
@@ -19,4 +19,8 @@ private
 
     result
   end
+
+  def files
+    @files ||= Dir.glob(Rails.root.join("app/api_maker/resources/**/*_resource.rb"))
+  end
 end

data/app/services/api_maker/models_generator_service.rb

@@ -1,29 +1,14 @@
 class ApiMaker::ModelsGeneratorService < ApiMaker::ApplicationService
-  def execute
+  def perform
     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)
+    succeed!
   end
 
   def ignore_model?(model)
-    model.name.end_with?("::Translation") ||
-      model.name.start_with?("ActiveStorage::") ||
-      model.name.end_with?("::ApplicationRecord")
+    model.name.end_with?("::Translation", "::ApplicationRecord")
   end
 
   def models
@@ -33,31 +18,15 @@ class ApiMaker::ModelsGeneratorService < ApiMaker::ApplicationService
 private
 
   def api_maker_root_path
-    Rails.root.join("app", "javascript", "api-maker")
+    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)
+    Rails.root.join("app/controllers/api_maker")
   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
-    ]
+    files = %w[models.js.erb]
     path = File.join(__dir__, "..", "..", "..", "lib", "api_maker", "javascript")
     target_path = api_maker_root_path
 
@@ -93,12 +62,6 @@ private
     # 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

data/app/services/api_maker/move_components_to_routes.rb

@@ -0,0 +1,50 @@
+class ApiMaker::MoveComponentsToRoutes < ApplicationService
+  attr_reader :prepend_path, :routes_path
+
+  def initialize(prepend_path:, routes_path:)
+    @prepend_path = prepend_path
+    @routes_path = routes_path
+  end
+
+  def perform
+    routes.each do |route|
+      path = "#{prepend_path}#{route.fetch("component")}"
+      full_path = "app/javascript/components/#{path}"
+      new_path = "app/javascript/routes/#{path}"
+
+      full_path_with_jsx = "#{full_path}.jsx"
+      new_path_with_jsx = "#{new_path}.jsx"
+
+      if !File.exist?(full_path_with_jsx) && File.exist?("#{full_path}/index.jsx")
+        full_path_with_jsx = "#{full_path}/index.jsx"
+        new_path_with_jsx = "#{new_path}/index.jsx"
+      end
+
+      if File.exist?(full_path_with_jsx)
+        new_dir = File.dirname(new_path_with_jsx)
+        FileUtils.mkdir_p(new_dir) unless File.exist?(new_dir)
+        File.rename(full_path_with_jsx, new_path_with_jsx)
+      end
+
+      old_dir = File.dirname(full_path_with_jsx)
+
+      Dir.unlink(old_dir) if File.exist?(old_dir) && dir_empty?(old_dir)
+    end
+
+    succeed!
+  end
+
+  def routes
+    @routes = JSON.parse(File.read(routes_path)).fetch("routes")
+  end
+
+  def dir_empty?(path)
+    Dir.foreach(path) do |file|
+      next if file == "." || file == ".."
+
+      return false
+    end
+
+    true
+  end
+end

data/app/services/api_maker/primary_id_for_model.rb

@@ -0,0 +1,6 @@
+class ApiMaker::PrimaryIdForModel
+  # Hack to get the primary ID or fail to make up for if the attribute wasn't selected
+  def self.get(model)
+    model.id || raise("No attribute called '#{model.class.primary_key}' given on #{model.class.name}")
+  end
+end

data/app/services/api_maker/reset_indexed_db_service.rb

@@ -0,0 +1,36 @@
+class ApiMaker::ResetIndexedDbService < ApiMaker::ApplicationService
+  attr_reader :context
+
+  delegate :browser_firefox?, :browser_logs, :execute_script, to: :context
+
+  def initialize(context:)
+    @context = context
+  end
+
+  def perform
+    # Firefox doesnt support 'indexedDB.databases()'
+    reset_indexed_db unless browser_firefox?
+
+    succeed!
+  end
+
+  def reset_indexed_db
+    execute_script "
+      indexedDB.databases().then(function(databases) {
+        var promises = []
+        for(var database of databases) {
+          promises.push(indexedDB.deleteDatabase(database.name))
+        }
+
+        Promise.all(promises).then(function() {
+          console.error('All databases were deleted')
+        })
+      })
+    "
+
+    WaitUtil.wait_for_condition("databases to be deleted", delay_sec: 0.2, timeout_sec: 6) do
+      logs_text = browser_logs.map(&:message).join("\n")
+      logs_text.include?("\"All databases were deleted\"")
+    end
+  end
+end

data/app/services/api_maker/routes_file_reloader.rb

@@ -0,0 +1,20 @@
+class ApiMaker::RoutesFileReloader < ApiMaker::ApplicationService
+  attr_reader :file_paths
+
+  def initialize(file_paths:)
+    @file_paths = file_paths
+  end
+
+  def perform
+    reloader = Rails.application.config.file_watcher.new(file_paths) do
+      Rails.application.reload_routes!
+    end
+
+    Rails.application.reloaders << reloader
+    Rails.application.reloader.to_run do
+      reloader.execute_if_updated
+    end
+
+    succeed!
+  end
+end

data/app/services/api_maker/select_columns_on_collection.rb

@@ -0,0 +1,78 @@
+class ApiMaker::SelectColumnsOnCollection < ApiMaker::ApplicationService
+  attr_reader :collection, :model_class, :select_attributes, :select_columns, :table_name
+
+  def initialize(collection:, model_class: nil, select_attributes:, select_columns:, table_name: nil)
+    raise "No collection was given" unless collection
+
+    @collection = collection
+    @model_class = model_class || collection.model
+    @select_attributes = select_attributes&.dig(@model_class)
+    @select_columns = select_columns
+    @table_name = table_name || @model_class.table_name
+  end
+
+  def perform
+    new_collection = collection
+    return succeed! new_collection if new_collection.is_a?(Array)
+
+    arel_table = Arel::Table.new(@table_name)
+
+    if selected_columns
+      all_columns_to_select.each do |column_name|
+        validate_column_name!(column_name)
+        new_collection = new_collection.select(arel_table[column_name])
+      end
+    else
+      new_collection = prepend_table_wildcard(new_collection) unless table_wildcard_prepended?(new_collection)
+    end
+
+    succeed! new_collection
+  end
+
+  # Selected attributes might require columns to be selected which is automatically resolved here
+  def all_columns_to_select
+    required_columns = []
+
+    select_attributes&.each_value do |attribute_args|
+      requires_columns = attribute_args.dig(:args, :requires_columns)
+      required_columns += requires_columns if requires_columns
+    end
+
+    (selected_columns + required_columns).map(&:to_s).uniq
+  end
+
+  def param_name
+    @param_name ||= model_class.model_name.param_key
+  end
+
+  # Prepends 'table_name.*' to the query. It needs to be pre-pended in case a `COUNT` or another aggregate function has been added to work with `DISTINCT`.
+  def prepend_table_wildcard(query)
+    old_select = query.values[:select] || []
+    old_select = old_select.keep_if { |select_statement| select_statement != select_table_wildcard_sql }
+
+    query = query.except(:select).select(select_table_wildcard_sql)
+
+    old_select.each do |select_statement|
+      query = query.select(select_statement)
+    end
+
+    query
+  end
+
+  def selected_columns
+    @selected_columns ||= select_columns&.dig(param_name)
+  end
+
+  def select_table_wildcard_sql
+    @select_table_wildcard_sql ||= "#{table_name}.*"
+  end
+
+  def table_wildcard_prepended?(query)
+    query.values[:select]&.first == select_table_wildcard_sql
+  end
+
+  # Checks that the given column exists to avoid injections
+  def validate_column_name!(column_name)
+    raise "Invalid column on #{model_class.name}: #{column_name}" unless model_class.columns_hash.key?(column_name.to_s)
+  end
+end

data/app/services/api_maker/select_parser.rb

@@ -0,0 +1,32 @@
+class ApiMaker::SelectParser < ApiMaker::ApplicationService
+  attr_reader :select
+
+  def initialize(select:)
+    @select = select
+  end
+
+  def perform
+    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
+
+      selects = {}
+      new_select[resource.model_class] ||= selects
+      resource_attributes = resource._attributes_with_string_keys
+
+      attributes.each do |attribute|
+        resource_attribute = resource_attributes[attribute]
+        raise "Attribute not found on the #{resource.short_name} resource: #{attribute}" unless resource_attribute
+
+        selects[attribute.to_sym] = resource_attribute
+      end
+
+      new_select[resource.model_class] = selects
+    end
+
+    succeed! new_select
+  end
+end

data/app/services/api_maker/service_command.rb

@@ -0,0 +1,27 @@
+class ApiMaker::ServiceCommand < ApiMaker::BaseCommand
+  def execute!
+    service_name = args.fetch(:service_name)
+
+    ApiMaker::Configuration.profile(-> { "ServiceCommand: #{service_name}" }) do
+      service_constant_name = "Services::#{service_name}"
+      service_constant = service_constant_name.constantize
+      service_args = args.fetch(:service_args)&.permit!&.to_h
+      response = service_constant.execute(
+        ability: current_ability,
+        args: service_args,
+        api_maker_args: api_maker_args,
+        controller: controller
+      )
+
+      if response.success?
+        succeed!(response.result)
+      else
+        errors = response.errors.map do |error|
+          {message: error.message, type: error.type}
+        end
+
+        fail!(errors: errors)
+      end
+    end
+  end
+end

data/app/services/api_maker/service_command_service.rb

@@ -0,0 +1,14 @@
+class ApiMaker::ServiceCommandService < ApiMaker::CommandService
+  def perform
+    ApiMaker::ServiceCommand.execute_in_thread!(
+      ability: ability,
+      api_maker_args: api_maker_args,
+      collection: nil,
+      commands: commands,
+      command_response: command_response,
+      controller: controller
+    )
+
+    succeed!
+  end
+end

data/app/services/api_maker/simple_model_errors.rb

@@ -0,0 +1,52 @@
+class ApiMaker::SimpleModelErrors < ApiMaker::ApplicationService
+  attr_reader :additional_attributes, :errors, :model, :models_inspected
+
+  def initialize(additional_attributes: [], model:)
+    @additional_attributes = additional_attributes
+    @model = model
+    @errors = []
+    @models_inspected = []
+  end
+
+  def perform
+    inspect_model(model)
+    succeed! errors
+  end
+
+  def inspect_model(model_to_inspect)
+    return if models_inspected.include?(model_to_inspect)
+
+    model_to_inspect.valid? if model_to_inspect.errors.empty? # Generates the errors on the model so we can detect them
+    models_inspected << model_to_inspect
+
+    model_to_inspect.errors.messages.each do |attribute_name, attribute_errors|
+      if attribute_name == :base
+        @errors += attribute_errors
+      else
+        next if model_to_inspect.attribute_names.exclude?(attribute_name.to_s) && additional_attributes.exclude?(attribute_name)
+
+        attribute_errors.each do |message|
+          errors << "#{model_to_inspect.class.human_attribute_name(attribute_name)} #{message}"
+        end
+      end
+    end
+
+    collect_errors_from_associations(model_to_inspect)
+  end
+
+private
+
+  def collect_errors_from_associations(model_to_scan_reflections_on)
+    model_to_scan_reflections_on._reflections.each_key do |association_name|
+      target = model_to_scan_reflections_on.association(association_name.to_sym).target
+
+      if target.is_a?(ActiveRecord::Base)
+        inspect_model(target)
+      else
+        target&.each do |sub_model|
+          inspect_model(sub_model)
+        end
+      end
+    end
+  end
+end