api_maker 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 696d6f1f8b6baa82e326b7d05f4e6f6fdd57de5a7ad9a20d7961d1d7ec361e78
-  data.tar.gz: 8960e2876a0c29d700c9c429e0153f43ea31e0839a03d423ffeeb92863f18ee2
+  metadata.gz: aef63f4583ab87d088709072259692eafee02e7715816a9495b9c7b7faeb913f
+  data.tar.gz: 01f5a369a20712666808bc579cf6f0ad80c8e12bf90035af737a0fb5eface293
 SHA512:
-  metadata.gz: c185f283cb899f81293df2e93e91c9298a4c1bfe5abbc5eb56f4fd23444ff46ce42776718cc2547e103ff511e30406fdb62761363813c68d9e67375cbcee2363
-  data.tar.gz: 40be89f333195778c4c7455d4f76ec85a1786637346e75f91dd043296870d79f340b53193bf28420962c6f7f418858697e4daa0e803684d29af20ebb6481076a
+  metadata.gz: 71f93fcd6f1311186b0c919761ab5a4ac60a6ec91a93827e321eb02c80d99ee8973fa43b06559a51631fc9d5e0352e6c74f7b51f6f4de8bb0ba50d40ed9d9765
+  data.tar.gz: 988fbd78d4a84db08f17ada016083969b93cefaf505789d74d288bc7fb4cb110af5bac3d2aaccd09d85fddcd09e04e3d5f911ad065c0724d48d4c12ef1c06f1a

data/app/channels/api_maker/subscriptions_channel.rb

@@ -26,7 +26,16 @@ class ApiMaker::SubscriptionsChannel < ApplicationCable::Channel
 private
 
   def connect_creates(model_name)
+    ability_name = :create_events
     model_class = model_for_resource_name(model_name)
+
+    unless model_class.respond_to?(:api_maker_broadcast_create_channel_name)
+      error_message = "The model #{model_class.name} doesn't support the static method 'api_maker_broadcast_create_channel_name'. " \
+        "Maybe API maker extensions haven't been included?"
+
+      raise error_message
+    end
+
     channel_name = model_class.api_maker_broadcast_create_channel_name
     stream_from(channel_name, coder: ActiveSupport::JSON) do |data|
       ApiMaker::Configuration.current.before_create_event_callbacks.each do |callback|
@@ -37,36 +46,57 @@ private
       model_class = data.fetch("mcn").safe_constantize
 
       Rails.logger.debug { "API maker: ConnectCreates for #{model_class.name}" }
-      model = model_class.accessible_by(current_ability, :create_events).find_by(model_class.primary_key => data.fetch("mi"))
+      model_exists = model_class
+        .accessible_by(current_ability, ability_name)
+        .exists?(model_class.primary_key => data.fetch("mi"))
 
       # Transmit the data to JS if its found (and thereby allowed)
-      transmit data if model
+      if model_exists
+        transmit data
+      else
+        Rails.logger.warn { "API maker: No access to connect to #{model_class.name} #{ability_name}" }
+      end
     end
   end
 
   def connect_destroys(model_name, model_ids)
+    ability_name = :destroy_events
     model_class = model_for_resource_name(model_name)
+
     Rails.logger.debug { "API maker: ConnectDestroys for #{model_class.name}" }
-    models = model_class.accessible_by(current_ability, :destroy_events).where(model_class.primary_key => model_ids)
-    models.each do |model|
-      channel_name = model.api_maker_broadcast_destroy_channel_name
+    accessible_model_ids = model_class
+      .accessible_by(current_ability, ability_name)
+      .where(model_class.primary_key => model_ids)
+      .ids
+
+    accessible_model_ids.each do |accessible_model_id|
+      channel_name = model_class.api_maker_broadcast_destroy_channel_name(accessible_model_id)
       stream_from(channel_name, coder: ActiveSupport::JSON) do |data|
         transmit data
       end
     end
+
+    report_unaccessible_model_ids(model_class, model_ids, accessible_model_ids, ability_name)
   end
 
   def connect_event(model_name, model_ids, event_name)
     ability_name = "event_#{event_name}".to_sym
     model_class = model_for_resource_name(model_name)
+
     Rails.logger.debug { "API maker: ConnectEvents for #{model_class.name} #{event_name}" }
-    models = model_class.accessible_by(current_ability, ability_name).where(model_class.primary_key => model_ids)
-    models.each do |model|
-      channel_name = model.api_maker_event_channel_name(event_name)
+    accessible_model_ids = model_class
+      .accessible_by(current_ability, ability_name)
+      .where(model_class.primary_key => model_ids)
+      .ids
+
+    accessible_model_ids.each do |accessible_model_id|
+      channel_name = model_class.api_maker_event_channel_name(accessible_model_id, event_name)
       stream_from(channel_name, coder: ActiveSupport::JSON) do |data|
         transmit data
       end
     end
+
+    report_unaccessible_model_ids(model_class, model_ids, accessible_model_ids, ability_name)
   end
 
   def connect_model_class_event(model_name, event_name)
@@ -86,22 +116,39 @@ private
   end
 
   def connect_updates(model_name, model_ids)
+    ability_name = :update_events
     model_class = model_for_resource_name(model_name)
+
     Rails.logger.debug { "API maker: ConnectUpdates for #{model_class.name}" }
+    accessible_model_ids = model_class
+      .accessible_by(current_ability, ability_name)
+      .where(model_class.primary_key => model_ids)
+      .ids
 
-    models = model_class.accessible_by(current_ability, :update_events).where(model_class.primary_key => model_ids)
-    models.each do |model|
-      channel_name = model.api_maker_broadcast_update_channel_name
+    accessible_model_ids.each do |accessible_model_id|
+      channel_name = model_class.api_maker_broadcast_update_channel_name(accessible_model_id)
       stream_from(channel_name, coder: ActiveSupport::JSON) do |data|
         transmit data
       end
     end
+
+    report_unaccessible_model_ids(model_class, model_ids, accessible_model_ids, ability_name)
   end
 
   def model_for_resource_name(resource_name)
     resource_for_resource_name(resource_name).model_class
   end
 
+  def report_unaccessible_model_ids(model_class, model_ids, accessible_model_ids, ability_name)
+    model_ids = model_ids.map(&:to_s)
+    accessible_model_ids = accessible_model_ids.map(&:to_s)
+    unaccessible_model_ids = model_ids - accessible_model_ids
+
+    if unaccessible_model_ids.any?
+      Rails.logger.warn { "API maker: No access to connect to #{model_class.name} #{ability_name} for IDs: #{unaccessible_model_ids.join(", ")}" }
+    end
+  end
+
   def resource_for_resource_name(resource_name)
     resource = "Resources::#{resource_name}Resource".safe_constantize
     raise "Cannot find resource by resource name: #{resource_name}" unless resource

data/app/services/api_maker/collection_loader.rb

@@ -99,7 +99,8 @@ class ApiMaker::CollectionLoader < ApiMaker::ApplicationService
 
     return if through_model.nil?
 
-    association = ActiveRecord::Associations::Association.new(through_model, through_model_class.reflections.fetch(params[:through][:reflection]))
+    reflection = through_model_class.reflections.fetch(params[:through][:reflection])
+    association = ActiveRecord::Associations::Association.new(through_model, reflection)
 
     query_through = association.scope
     query_through = query_through.accessible_by(ability)

data/app/services/api_maker/model_classes_java_script_generator_service.rb

@@ -1,37 +1,17 @@
 class ApiMaker::ModelClassesJavaScriptGeneratorService < ApiMaker::ApplicationService
   def perform
-    javascript_code = ""
-    resource_names = []
+    result = {
+      models: {}
+    }
 
-    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
+    resources.each do |resource|
+      result[:models][resource.short_name] = ApiMaker::ModelContentGeneratorService.execute!(resource: resource)
     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")
+    succeed! result
   end
 
-  def resource_for_model(model)
-    ApiMaker::MemoryStorage.current.resource_for_model(model)
+  def resources
+    @resources ||= ApiMaker::ModelsFinderService.execute!
   end
 end

data/app/services/api_maker/model_content_generator_service.rb

@@ -1,87 +1,116 @@
 class ApiMaker::ModelContentGeneratorService < ApiMaker::ApplicationService
-  attr_reader :model
+  attr_reader :resource
 
-  def initialize(model:)
-    @model = model
+  delegate :model_class, to: :resource
+
+  def initialize(resource:)
+    @resource = resource
   end
 
   def perform
-    if resource
-      succeed! model_content
-    else
-      fail! "No resource defined for #{model.name}"
-    end
+    succeed! model_content
   end
 
 private
 
   def attributes
+    attributes = {}
     resource._attributes.map do |attribute, _data|
-      {name: attribute}
+      attributes[attribute] = {name: attribute}
     end
+    attributes
   end
 
   def collection_commands
-    ApiMaker::Loader.load_everything
-    ApiMaker::MemoryStorage.current.storage_for(resource, :collection_commands)
+    ApiMaker::Loader.load_resources
+
+    result = {}
+    collection_commands = ApiMaker::MemoryStorage.current.storage_for(resource, :collection_commands)
+    collection_commands.each_key do |collection_command_name|
+      result[collection_command_name] = {name: collection_command_name}
+    end
+
+    result
   end
 
   def member_commands
-    ApiMaker::Loader.load_everything
-    ApiMaker::MemoryStorage.current.storage_for(resource, :member_commands)
+    ApiMaker::Loader.load_resources
+
+    result = {}
+    member_commands = ApiMaker::MemoryStorage.current.storage_for(resource, :member_commands)
+    member_commands.each_key do |member_command_name|
+      result[member_command_name] = {name: member_command_name}
+    end
+
+    result
   end
 
   def model_content
-    erb = ERB.new(File.read(model_template_path))
-    erb.filename = File.realpath(model_template_path)
-    erb.result(binding)
+    {
+      attributes: attributes,
+      collection_commands: collection_commands,
+      member_commands: member_commands,
+      model_class_data: model_class_data,
+      monetized_attributes: monetized_attributes,
+      relationships: relationships
+    }
   end
 
-  def model_template_path
-    File.join(__dir__, "..", "..", "..", "lib", "api_maker", "javascript", "model-template.js.erb")
+  def model_class_data
+    {
+      attributes: attributes,
+      className: model_class.name,
+      collectionKey: model_class.model_name.collection,
+      collectionName: resource.collection_name,
+      i18nKey: model_class.model_name.i18n_key,
+      name: resource.short_name,
+      pluralName: model_class.model_name.plural,
+      relationships: reflections_for_model_class_data,
+      paramKey: model_class.model_name.param_key,
+      primaryKey: model_class.primary_key
+    }
   end
 
   def monetized_attributes
-    @monetized_attributes ||= @model.try(:monetized_attributes).try(:map) { |attribute| attribute[0] } || []
+    @monetized_attributes ||= model_class.try(:monetized_attributes).try(:map) { |attribute| {name: attribute[0]} } || []
   end
 
   def reflections
     @reflections ||= resource._relationships.map do |name, _data|
-      reflection = model.reflections.values.find { |reflection_i| reflection_i.name == name }
+      reflection = model_class.reflections.values.find { |reflection_i| reflection_i.name == name }
 
       unless reflection
-        raise "Couldnt find reflection by that name: #{name} on the model: #{model.name}. Reflections found: #{model.reflections.keys.join(", ")}"
+        raise "Couldnt find reflection by that name: #{name} on the model: #{model_class.name}. Reflections found: #{model_class.reflections.keys.join(", ")}"
       end
 
       reflection
     end
   end
 
-  def reflection_has_many_parameters(reflection)
-    {
-      reflectionName: reflection.name,
-      model: "{{this}}",
-      modelName: reflection.class_name,
-      modelClass: "{{modelClass}}"
-    }
-  end
-
-  def reflection_has_many_parameters_query(reflection)
-    if reflection.options[:through]
-      {
-        params: {
-          through: {
-            model: model.name,
-            id: "{{id}}",
-            reflection: reflection.name
-          }
-        }
+  def relationships
+    relationships = {}
+    reflections.each do |reflection|
+      relationships[reflection.name] = {
+        active_record: {
+          name: reflection.active_record.name,
+          primary_key: reflection.active_record.primary_key
+        },
+        class_name: reflection.class_name,
+        foreign_key: reflection.foreign_key,
+        klass: {
+          primary_key: reflection.klass.primary_key
+        },
+        options: {
+          as: reflection.options[:as],
+          primary_key: reflection.options[:primary_key],
+          through: reflection.options[:through]
+        },
+        resource_name: ApiMaker::MemoryStorage.current.resource_for_model(reflection.klass).short_name,
+        type: reflection.macro
       }
-    else
-      ransack = {"#{reflection.foreign_key}_eq" => "{{id}}"}
-      ransack["#{reflection.options[:as]}_type_eq"] = reflection.active_record.name if reflection.options[:as]
-      {ransack: ransack}
     end
+
+    relationships
   end
 
   def reflections_for_model_class_data
@@ -97,8 +126,4 @@ private
       }
     end
   end
-
-  def resource
-    @resource ||= ApiMaker::MemoryStorage.current.resource_for_model(@model)
-  end
 end

data/app/services/api_maker/models_finder_service.rb

@@ -14,7 +14,7 @@ private
       next if path_name == "application_resource"
 
       resource_class = "Resources::#{path_name.classify}".constantize
-      result << resource_class.model_class
+      result << resource_class
     end
 
     result

data/app/services/api_maker/models_generator_service.rb

@@ -1,8 +1,5 @@
 class ApiMaker::ModelsGeneratorService < ApiMaker::ApplicationService
   def perform
-    create_base_structure
-    copy_base_model
-
     ApiMaker::GenerateReactNativeApiService.execute! if ApiMaker::Configuration.current.react_native_path.present?
     succeed!
   end
@@ -11,28 +8,8 @@ class ApiMaker::ModelsGeneratorService < ApiMaker::ApplicationService
     model.name.end_with?("::Translation", "::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_model
-    files = %w[models.js.erb]
-    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)
@@ -57,11 +34,4 @@ private
       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(controller_path) unless File.exist?(controller_path)
-  end
 end

data/app/services/api_maker/translated_collections.rb

@@ -0,0 +1,66 @@
+class ApiMaker::TranslatedCollections
+  def self.add(blk:, collection_name:, model_class:)
+    @translated_collections ||= {}
+    collections = {}
+    model_class_name = model_class.name
+    collection_values = nil
+
+    I18n.available_locales.each do |locale|
+      I18n.with_locale(locale) do
+        collection = blk.call.freeze
+        collections[locale.to_s] = {
+          collection: collection,
+          collection_array: collection.map { |translation, value| [translation: translation, value: value] }.flatten,
+          inverted_collection: collection.invert
+        }
+        collection_values = collection.values.clone.freeze if collection_values.nil?
+      end
+    end
+
+    @translated_collections[model_class_name] ||= {}
+    @translated_collections[model_class_name][collection_name] ||= collections
+
+    plural_name = collection_name.to_s.pluralize
+    inverted_translated_collection_name = "translated_#{plural_name}_inverted"
+
+    add_translated_collection_method(model_class, plural_name, collections)
+    add_translated_inverted_collection_method(model_class, inverted_translated_collection_name, collections)
+    add_collection_values_method(model_class, plural_name, collection_values)
+    add_translated_method(model_class, collection_name, inverted_translated_collection_name)
+
+    model_class.validates collection_name, inclusion: {in: collection_values}
+  end
+
+  def self.add_translated_collection_method(model_class, plural_name, collections)
+    model_class.define_singleton_method("translated_#{plural_name}") do
+      collections.fetch(I18n.locale.to_s).fetch(:collection)
+    end
+  end
+
+  def self.add_translated_inverted_collection_method(model_class, inverted_translated_collection_name, collections)
+    model_class.define_singleton_method(inverted_translated_collection_name) do
+      collections.fetch(I18n.locale.to_s).fetch(:inverted_collection)
+    end
+  end
+
+  def self.add_collection_values_method(model_class, plural_name, collection_values)
+    model_class.define_singleton_method(plural_name) do
+      collection_values
+    end
+  end
+
+  def self.add_translated_method(model_class, collection_name, inverted_translated_collection_name)
+    model_class.define_method("translated_#{collection_name}") do
+      current_value = __send__(collection_name)
+      inverted_translated_collection = self.class.__send__(inverted_translated_collection_name)
+      inverted_translated_collection.fetch(current_value)
+    end
+  end
+
+  def self.translated_collections
+    ApiMaker::Loader.load_models
+
+    @translated_collections ||= {}
+    @translated_collections
+  end
+end

data/lib/api_maker/loader.rb

@@ -1,12 +1,20 @@
 class ApiMaker::Loader
-  def self.load_everything
-    return if @loaded
+  def self.load_resources
+    load_dir(Rails.root.join("app/api_maker/resources"))
+  end
+
+  def self.load_models
+    load_dir(Rails.root.join("app/models"))
+  end
+
+  def self.load_dir(dir)
+    @dirs_loaded ||= {}
 
-    @loaded = true
+    return if @dirs_loaded.key?(dir)
 
-    resources_dir = Rails.root.join("app/api_maker/resources")
-    files = Dir.glob("#{resources_dir}/**/*.rb")
+    @dirs_loaded[dir] = true
 
+    files = Dir.glob("#{dir}/**/*.rb")
     files.each do |file|
       require file
     end

data/lib/api_maker/model_extensions.rb

@@ -14,6 +14,18 @@ module ApiMaker::ModelExtensions
       @api_maker_broadcast_create_channel_name ||= "api_maker_creates_#{api_maker_resource.short_name}"
     end
 
+    def api_maker_broadcast_destroy_channel_name(id)
+      "api_maker_destroys_#{api_maker_resource.short_name}_#{id}"
+    end
+
+    def api_maker_event_channel_name(id, event_name)
+      "api_maker_events_#{api_maker_resource.short_name}_#{id}_#{event_name}"
+    end
+
+    def api_maker_broadcast_update_channel_name(id)
+      "api_maker_updates_#{api_maker_resource.short_name}_#{id}"
+    end
+
     def api_maker_broadcast_updates
       after_commit on: :update do |model| # rubocop:disable Style/SymbolProc
         model.api_maker_broadcast_update
@@ -45,6 +57,14 @@ module ApiMaker::ModelExtensions
     def api_maker_resource
       @api_maker_resource ||= ApiMaker::MemoryStorage.current.resource_for_model(self)
     end
+
+    def translated_collection(collection_name, &blk)
+      ApiMaker::TranslatedCollections.add(
+        blk: blk,
+        collection_name: collection_name,
+        model_class: self
+      )
+    end
   end
 
   def api_maker_event(event_name, args = {})
@@ -61,7 +81,7 @@ module ApiMaker::ModelExtensions
   end
 
   def api_maker_event_channel_name(event_name)
-    "api_maker_events_#{api_maker_resource.short_name}_#{id}_#{event_name}"
+    self.class.api_maker_event_channel_name(id, event_name)
   end
 
   def api_maker_broadcast_create
@@ -88,7 +108,7 @@ module ApiMaker::ModelExtensions
   end
 
   def api_maker_broadcast_destroy_channel_name
-    @api_maker_broadcast_destroy_channel_name ||= "api_maker_destroys_#{api_maker_resource.short_name}_#{id}"
+    @api_maker_broadcast_destroy_channel_name ||= self.class.api_maker_broadcast_destroy_channel_name(id)
   end
 
   def api_maker_broadcast_update
@@ -103,7 +123,7 @@ module ApiMaker::ModelExtensions
   end
 
   def api_maker_broadcast_update_channel_name
-    @api_maker_broadcast_update_channel_name ||= "api_maker_updates_#{api_maker_resource.short_name}_#{id}"
+    self.class.api_maker_broadcast_update_channel_name(id)
   end
 
   def api_maker_resource

data/lib/api_maker/spec_helper.rb

@@ -81,6 +81,10 @@ module ApiMaker::SpecHelper # rubocop:disable Metrics/ModuleLength
     page.execute_script("document.querySelector(#{element_id.to_json}).value = #{with.to_json}")
   end
 
+  def model_column_selector(model, identifier)
+    ".#{model.model_name.singular.dasherize}-row[data-model-id='#{model.id}'] .live-table-column[data-identifier='#{identifier}']"
+  end
+
   def model_row_selector(model)
     ".#{model.model_name.singular.dasherize}-row[data-model-id='#{model.id}']"
   end
@@ -117,7 +121,7 @@ module ApiMaker::SpecHelper # rubocop:disable Metrics/ModuleLength
 
     tr_selector = ".component-api-maker-attribute-row"
     tr_selector << "[data-attribute='#{attribute.camelize(:lower)}']" if attribute
-    tr_selector << "[data-identifier='#{identifier.camelize}']" if identifier
+    tr_selector << "[data-identifier='#{identifier}']" if identifier
 
     wait_for_selector "#{tr_selector} > .attribute-row-label", exact_text: label, **opts if label
     wait_for_selector "#{tr_selector} > .attribute-row-value", exact_text: value, **opts if value

data/lib/api_maker/version.rb

@@ -1,3 +1,3 @@
 module ApiMaker
-  VERSION = "0.0.2".freeze
+  VERSION = "0.0.3".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: api_maker
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - kaspernj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-04 00:00:00.000000000 Z
+date: 2021-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -136,6 +136,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_translations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.60
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.60
 - !ruby/object:Gem::Dependency
   name: best_practice_project
   requirement: !ruby/object:Gem::Requirement
@@ -406,16 +420,16 @@ dependencies:
   name: selenium-webdriver
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.1.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.1.1
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -527,6 +541,7 @@ files:
 - app/services/api_maker/service_command.rb
 - app/services/api_maker/service_command_service.rb
 - app/services/api_maker/simple_model_errors.rb
+- app/services/api_maker/translated_collections.rb
 - app/services/api_maker/update_command.rb
 - app/services/api_maker/update_command_service.rb
 - app/services/api_maker/valid_command.rb
@@ -548,8 +563,6 @@ files:
 - lib/api_maker/engine.rb
 - lib/api_maker/expect_to_able_to_helper.rb
 - lib/api_maker/individual_command.rb
-- lib/api_maker/javascript/model-template.js.erb
-- lib/api_maker/javascript/models.js.erb
 - lib/api_maker/loader.rb
 - lib/api_maker/memory_storage.rb
 - lib/api_maker/model_extensions.rb

data/lib/api_maker/javascript/model-template.js.erb

@@ -1,124 +0,0 @@
-class <%= resource.short_name %> extends BaseModel {
-  static modelClassData() {
-    return <%= {
-      attributes: attributes,
-      className: model.name,
-      collectionKey: model.model_name.collection,
-      collectionName: resource.collection_name,
-      i18nKey: model.model_name.i18n_key,
-      name: resource.short_name,
-      pluralName: model.model_name.plural,
-      relationships: reflections_for_model_class_data,
-      paramKey: model.model_name.param_key,
-      path: "/api_maker/#{model.model_name.route_key}",
-      primaryKey: model.primary_key
-    }.to_json %>
-  }
-
-  <% reflections.each do |reflection| %>
-    <% if reflection.macro == :belongs_to %>
-      <%= ApiMaker::JsMethodNamerService.execute!(name: "load_#{reflection.name}") %>() {
-        const id = this.<%= ApiMaker::JsMethodNamerService.execute!(name: reflection.foreign_key) %>()
-        const resourceName = "<%= ApiMaker::MemoryStorage.current.resource_for_model(reflection.klass).short_name %>"
-        const modelClass = digg(require("api-maker/models"), resourceName)
-        return this._loadBelongsToReflection(<%= api_maker_json("reflectionName" => reflection.name, "model" => "{{this}}", "modelClass" => "{{modelClass}}") %>, <%= api_maker_json("ransack" => {"#{reflection.options[:primary_key] || reflection.klass.primary_key}_eq" => "{{id}}"}) %>)
-      }
-
-      <%= ApiMaker::JsMethodNamerService.execute!(name: reflection.name) %>() {
-        const resourceName = "<%= ApiMaker::MemoryStorage.current.resource_for_model(reflection.klass).short_name %>"
-        const modelClass = digg(require("api-maker/models"), resourceName)
-        return this._readBelongsToReflection(<%= api_maker_json("reflectionName" => reflection.name, "model" => "{{this}}", "modelClass" => "{{modelClass}}") %>)
-      }
-    <% elsif reflection.macro == :has_many %>
-      <% if reflection.options[:through] %>
-        <%= ApiMaker::JsMethodNamerService.execute!(name: "load_#{reflection.name}") %>() {
-          const id = this.<%= reflection.active_record.primary_key %>()
-          const resourceName = "<%= ApiMaker::MemoryStorage.current.resource_for_model(reflection.klass).short_name %>"
-          const modelClass = digg(require("api-maker/models"), resourceName)
-          return this._loadHasManyReflection(<%= api_maker_json("reflectionName" => reflection.name, "model" => "{{this}}", "modelClass" => "{{modelClass}}") %>, <%= api_maker_json("params": {"through" => {"model" => model.model_name, "id" => "{{id}}", "reflection" => reflection.name}}) %>)
-        }
-      <% else %>
-        <%= ApiMaker::JsMethodNamerService.execute!(name: "load_#{reflection.name}") %>() {
-          const id = this.<%= reflection.active_record.primary_key %>()
-          const resourceName = "<%= ApiMaker::MemoryStorage.current.resource_for_model(reflection.klass).short_name %>"
-          const modelClass = digg(require("api-maker/models"), resourceName)
-          return this._loadHasManyReflection(<%= api_maker_json("reflectionName" => reflection.name, "model" => "{{this}}", "modelClass" => "{{modelClass}}") %>, <%= api_maker_json("ransack" => {"#{reflection.foreign_key}_eq" => "{{id}}"}) %>)
-        }
-      <% end %>
-
-      <%= ApiMaker::JsMethodNamerService.execute!(name: reflection.name) %>() {
-        const id = this.<%= ApiMaker::JsMethodNamerService.execute!(name: reflection.options[:primary_key] || reflection.active_record.primary_key) %>()
-        const resourceName = "<%= ApiMaker::MemoryStorage.current.resource_for_model(reflection.klass).short_name %>"
-        const modelClass = digg(require("api-maker/models"), resourceName)
-        return new Collection(<%= api_maker_json(reflection_has_many_parameters(reflection)) %>, <%= api_maker_json(reflection_has_many_parameters_query(reflection)) %>)
-      }
-    <% elsif reflection.macro == :has_one && reflection.options[:through] %>
-      <%= ApiMaker::JsMethodNamerService.execute!(name: "load_#{reflection.name}") %>() {
-        const id = this.<%= reflection.active_record.primary_key %>()
-        const resourceName = "<%= ApiMaker::MemoryStorage.current.resource_for_model(reflection.klass).short_name %>"
-        const modelClass = digg(require("api-maker/models"), resourceName)
-        return this._loadHasOneReflection(<%= api_maker_json("reflectionName" => reflection.name, "model" => "{{this}}", "modelClass" => "{{modelClass}}") %>, <%= api_maker_json("params": {"through" => {"model" => model.model_name, "id" => "{{id}}", "reflection" => reflection.name}}) %>)
-      }
-
-      <%= ApiMaker::JsMethodNamerService.execute!(name: reflection.name) %>() {
-        const resourceName = "<%= ApiMaker::MemoryStorage.current.resource_for_model(reflection.klass).short_name %>"
-        const modelClass = digg(require("api-maker/models"), resourceName)
-        return this._readHasOneReflection(<%= api_maker_json("reflectionName" => reflection.name, "model" => "{{this}}", "modelClass" => "{{modelClass}}") %>)
-      }
-    <% elsif reflection.macro == :has_one %>
-      <%= ApiMaker::JsMethodNamerService.execute!(name: "load_#{reflection.name}") %>() {
-        const id = this.<%= reflection.active_record.primary_key %>()
-        const resourceName = "<%= ApiMaker::MemoryStorage.current.resource_for_model(reflection.klass).short_name %>"
-        const modelClass = digg(require("api-maker/models"), resourceName)
-        return this._loadHasOneReflection(<%= api_maker_json("reflectionName" => reflection.name, "model" => "{{this}}", "modelClass" => "{{modelClass}}") %>, <%= api_maker_json("ransack" => {"#{reflection.foreign_key}_eq" => "{{id}}"}) %>)
-      }
-
-      <%= ApiMaker::JsMethodNamerService.execute!(name: reflection.name) %>() {
-        const resourceName = "<%= ApiMaker::MemoryStorage.current.resource_for_model(reflection.klass).short_name %>"
-        const modelClass = digg(require("api-maker/models"), resourceName)
-        return this._readHasOneReflection(<%= api_maker_json("reflectionName" => reflection.name, "model" => "{{this}}", "modelClass" => "{{modelClass}}") %>)
-      }
-    <% end %>
-  <% end %>
-
-  <% attributes.each do |attribute_data| %>
-    <% methodName = ApiMaker::JsMethodNamerService.execute!(name: attribute_data.fetch(:name)) %>
-    <%= methodName %>() {
-      return this.readAttributeUnderscore("<%= attribute_data.fetch(:name) %>")
-    }
-
-    <%= ApiMaker::JsMethodNamerService.execute!(name: "has_#{attribute_data.fetch(:name)}") %>() {
-      const value = this.<%= methodName %>()
-      return this._isPresent(value)
-    }
-  <% end %>
-
-  <% collection_commands.each do |collection_command, data| %>
-    static <%= ApiMaker::JsMethodNamerService.execute!(name: collection_command) %>(args, commandArgs = {}) {
-      return this._callCollectionCommand(
-        {
-          args: args,
-          command: "<%= collection_command %>",
-          collectionName: this.modelClassData().collectionName,
-          type: "collection"
-        },
-        commandArgs
-      )
-    }
-  <% end %>
-
-  <% member_commands.each do |member_command, data| %>
-    <%= ApiMaker::JsMethodNamerService.execute!(name: member_command) %>(args, commandArgs = {}) {
-      return this._callMemberCommand(
-        {
-          args: args,
-          command: "<%= member_command %>",
-          primaryKey: this.primaryKey(),
-          collectionName: this.modelClassData().collectionName,
-          type: "member"
-        },
-        commandArgs
-      )
-    }
-  <% end %>
-}

data/lib/api_maker/javascript/models.js.erb

@@ -1,6 +0,0 @@
-/* rails-erb-loader-dependencies api_maker/resources/ */
-
-import {BaseModel, Collection} from "@kaspernj/api-maker"
-import {digg} from "@kaspernj/object-digger"
-
-<%= ApiMaker::ModelClassesJavaScriptGeneratorService.execute! %>