api_maker 0.0.1 → 0.0.2

data/lib/api_maker/collection_serializer.rb

@@ -1,66 +1,127 @@
 class ApiMaker::CollectionSerializer
-  def initialize(ability: nil, args: {}, collection:, include_param:, select: nil)
-    @ability = ability || ApiMaker::Ability.new(args: args)
-    @args = args
+  attr_reader :ability, :api_maker_args, :collection, :locals, :preload_param, :query_params, :select, :select_columns
+
+  def initialize(ability: nil, api_maker_args: {}, collection:, locals: nil, model_class: nil, query_params: nil)
+    raise "No collection was given" unless collection
+
+    @query_params = query_params || {}
+    @ability = ability || ApiMaker::Ability.new(api_maker_args: api_maker_args)
+    @api_maker_args = api_maker_args
     @collection = collection
-    @include_param = include_param
-    @select = select
+    @locals = locals || api_maker_args&.dig(:locals) || {}
+    @preload_param = @query_params[:preload]
+    @model_class = model_class
+    @select = ApiMaker::SelectParser.execute!(select: query_params[:select]) if @query_params[:select]
+    @select_columns = @query_params[:select_columns]
   end
 
   def result
     @result ||= begin
       data = {
         data: {},
-        included: {}
+        preloaded: {}
       }
 
       records = {}
+      parsed_collection.map do |model|
+        add_model_to_records(model, data, records)
+      end
 
-      ApiMaker::Configuration.profile("CollectionSerializer result collection map") do
-        @collection.map do |model|
-          serializer = ApiMaker::Serializer.new(ability: @ability, args: @args, model: model, select: select_for(model))
-          resource = serializer.resource
-          collection_name = resource.collection_name
-          id = model.id
+      preload_collection(data, records) if parsed_collection.length.positive?
+      load_abilities(data) if query_params[:abilities]
 
-          data.fetch(:included)[collection_name] ||= {}
-          data.fetch(:included)[collection_name][id] ||= serializer
+      data
+    end
+  end
 
-          data.fetch(:data)[collection_name] ||= []
-          data.fetch(:data)[collection_name] << id
+  def load_abilities(data)
+    data.fetch(:preloaded).each_value do |models|
+      next if models.empty?
 
-          records[collection_name] ||= {}
-          records[collection_name][id] ||= serializer
-        end
-      end
+      serializers = models.values
+      serializer = models.values.first
+      abilities = query_params.dig(:abilities, serializer.resource.require_name)
 
-      preload_collection(data, records) if @collection.length.positive?
+      ApiMaker::AbilitiesLoader.execute!(abilities: abilities, ability: ability, serializers: serializers) if abilities && serializers
+    end
+  end
 
-      data
+  def add_model_to_records(model, data, records)
+    serializer = serializer_for_model(model)
+    resource = serializer.resource
+    collection_name = resource.collection_name
+    records[collection_name] ||= {}
+
+    if model.new_record?
+      id = "new-#{records.fetch(collection_name).length}"
+    else
+      id = ApiMaker::PrimaryIdForModel.get(model)
     end
+
+    data.fetch(:preloaded)[collection_name] ||= {}
+    data.fetch(:preloaded)[collection_name][id] ||= serializer
+
+    data.fetch(:data)[collection_name] ||= []
+    data.fetch(:data)[collection_name] << id
+
+    records[collection_name][id] ||= serializer
   end
 
   def as_json(options = nil)
     result.as_json(options)
   end
 
-  def preload_collection(data, records)
-    ApiMaker::Configuration.profile("CollectionSerializer result preloading") do
-      preloader = ApiMaker::Preloader.new(
-        ability: @ability,
-        args: @args,
-        collection: @collection,
-        data: data,
-        include_param: @include_param,
-        records: records,
-        select: @select
+  def model_class
+    @model_class ||= if collection.is_a?(Array)
+      collection.first.class
+    else
+      resource.model_class
+    end
+  end
+
+  def resource
+    @resource ||= if collection.is_a?(Array)
+      ApiMaker::MemoryStorage.current.resource_for_model(collection.first.class)
+    else
+      ApiMaker::MemoryStorage.current.resource_for_model(collection.klass)
+    end
+  end
+
+  def parsed_collection
+    @parsed_collection ||= begin
+      new_collection = ApiMaker::SelectColumnsOnCollection.execute!(
+        collection: collection,
+        model_class: model_class,
+        select_attributes: select,
+        select_columns: select_columns
       )
-      preloader.fill_data
+      new_collection = new_collection.fix if !new_collection.is_a?(Array) && ApiMaker::DatabaseType.postgres?
+      new_collection
     end
   end
 
+  def preload_collection(data, records)
+    preloader = ApiMaker::Preloader.new(
+      ability: ability,
+      api_maker_args: api_maker_args,
+      collection: parsed_collection,
+      data: data,
+      locals: locals,
+      preload_param: preload_param,
+      model_class: model_class,
+      records: records,
+      select: select,
+      select_columns: select_columns
+    )
+    preloader.fill_data
+  end
+
   def select_for(model)
-    @select&.dig(model.class)
+    select&.dig(model.class)
+  end
+
+  def serializer_for_model(model)
+    ApiMaker::Serializer.new(ability: ability, api_maker_args: api_maker_args, locals: locals, model: model, select: select_for(model))
   end
 
   def to_json(options = nil)

data/lib/api_maker/command_spec_helper.rb

@@ -21,23 +21,53 @@ class ApiMaker::CommandSpecHelper
   end
 
   def command
-    @command ||= command_class.new(
-      ability: controller.__send__(:current_ability),
-      args: controller.__send__(:api_maker_args),
-      collection: collection,
-      commands: commands,
-      command_response: response,
-      controller: controller
-    )
+    @command ||= begin
+      raise "No commands have been added" if commands.empty?
+
+      command_id = commands.keys.first
+      command_data = commands.values.first
+
+      individual_command = ApiMaker::IndividualCommand.new(
+        args: ApiMaker::Deserializer.execute!(arg: command_data[:args]),
+        collection: collection,
+        command: self,
+        id: command_id,
+        primary_key: command_data[:primary_key],
+        response: response
+      )
+
+      command_class.new(
+        ability: controller.__send__(:current_ability),
+        api_maker_args: controller.__send__(:api_maker_args),
+        collection: collection,
+        collection_instance: collection_instance,
+        command: individual_command,
+        commands: commands,
+        command_response: response,
+        controller: controller
+      )
+    end
+  end
+
+  def collection_instance
+    @collection_instance ||= if command_class.const_defined?(:CollectionInstance)
+      command_class.const_get(:CollectionInstance).new(
+        ability: controller.__send__(:current_ability),
+        api_maker_args: controller.__send__(:api_maker_args),
+        collection: collection,
+        commands: commands,
+        command_response: response,
+        controller: controller
+      )
+    end
   end
 
   def controller
-    @controller ||= double(current_user: user)
+    @controller ||= instance_double("ApplicationController", current_user: user)
   end
 
   def execute!
-    command.execute!
-    ServicePattern::Response.new(success: true)
+    command.execute_with_response
   end
 
   def response

data/lib/api_maker/configuration.rb

@@ -1,5 +1,14 @@
 class ApiMaker::Configuration
-  attr_accessor :profiling, :react_native_path, :threadding
+  attr_accessor(
+    :ability_class_name,
+    :before_create_event_callbacks,
+    :devise_sign_in_enabled,
+    :devise_sign_out_enabled,
+    :on_thread_callbacks,
+    :profiling,
+    :react_native_path,
+    :threadding
+  )
 
   def self.current
     @current ||= ApiMaker::Configuration.new
@@ -9,23 +18,41 @@ class ApiMaker::Configuration
     yield ApiMaker::Configuration.current
   end
 
-  def self.profile(name, &blk)
+  def self.profile(name_block, &blk)
     if ApiMaker::Configuration.current.profiling
-      Rack::MiniProfiler.step("AM #{name}", &blk)
+      Rack::MiniProfiler.step("AM #{name_block.call}", &blk)
     else
       yield
     end
   end
 
   def initialize
+    self.ability_class_name = "ApiMaker::Ability"
+    self.before_create_event_callbacks = []
+    self.devise_sign_in_enabled = true
+    self.devise_sign_out_enabled = true
+    self.threadding = true
+
     @on_error = []
-    @threadding = true
+  end
+
+  def ability_class
+    ability_class_name.constantize
+  end
+
+  def before_create_event(&blk)
+    before_create_event_callbacks << blk
   end
 
   def on_error(&blk)
     @on_error << blk
   end
 
+  def on_thread(&blk)
+    @on_thread_callbacks ||= []
+    @on_thread_callbacks << blk
+  end
+
   def report_error(error)
     @on_error.each do |on_error|
       on_error.call(error)

data/lib/api_maker/expect_to_able_to_helper.rb

@@ -0,0 +1,31 @@
+module ApiMaker::ExpectToBeAbleToHelper
+  def expect_to_be_able_to(ability, model, permissions)
+    require "cancan/matchers"
+
+    permissions.each do |permission|
+      # Test access through 'can?'
+      expect(ability).to be_able_to permission, model
+
+      # Test access through 'accessible_by'
+      if model.is_a?(ActiveRecord::Base) && model.persisted?
+        readable_models = model.class.where(id: model).accessible_by(ability, permission)
+        expect(readable_models).to eq [model]
+      end
+    end
+  end
+
+  def expect_not_to_be_able_to(ability, model, permissions)
+    require "cancan/matchers"
+
+    permissions.each do |permission|
+      # Test access through 'can?'
+      expect(ability).not_to be_able_to permission, model
+
+      # Test access through 'accessible_by'
+      if model.is_a?(ActiveRecord::Base) && model.persisted?
+        readable_models = model.class.where(id: model).accessible_by(ability, permission)
+        expect(readable_models).to be_empty
+      end
+    end
+  end
+end

data/lib/api_maker/individual_command.rb

@@ -1,5 +1,7 @@
 class ApiMaker::IndividualCommand
-  attr_reader :args, :command, :id
+  class NotFoundOrNoAccessError < RuntimeError; end
+
+  attr_reader :args, :collection, :command, :id, :primary_key, :response
 
   def initialize(id:, args:, collection:, command:, primary_key: nil, response:)
     @id = id
@@ -11,27 +13,40 @@ class ApiMaker::IndividualCommand
   end
 
   def error(data = nil)
-    @response.error_for_command(@id, data)
+    response.error_for_command(id, data)
   end
 
   def fail(data = nil)
-    @response.fail_for_command(@id, data)
+    response.fail_for_command(id, data)
   end
 
   def model
-    raise "Collection wasn't set" unless @collection
+    @model ||= begin
+      raise "Collection wasn't set" unless collection
 
-    @model ||= @collection.find { |model| model.id.to_s == @primary_key.to_s }
-    raise "Couldn't find model by that ID: #{@primary_key}" unless @model
+      model ||= collection.find { |model_in_collection| model_in_collection.id.to_s == primary_key.to_s }
+      raise_model_not_found_or_no_access unless model
 
-    @model
+      model
+    end
   end
 
   def model_id
-    @primary_key
+    primary_key
+  end
+
+  def raise_model_not_found_or_no_access
+    command_name = command
+      .name
+      .delete_prefix("Commands::")
+      .gsub(/Command\Z/, "")
+
+    model_name = collection.klass.name
+
+    raise NotFoundOrNoAccessError, "Couldn't find or no access to #{model_name} #{primary_key} on the #{command_name} command"
   end
 
   def result(data = nil)
-    @response.result_for_command(@id, ApiMaker::ResultParser.parse(data, controller: @response.controller))
+    response.result_for_command(id, ApiMaker::ResultParser.parse(data, controller: response.controller))
   end
 end

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

@@ -1,10 +1,8 @@
-import BaseModel from "../base-model"
-import Collection from "../collection"
-
-export default class <%= model.name.gsub("::", "") %> extends BaseModel {
+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,
@@ -20,41 +18,64 @@ export default class <%= model.name.gsub("::", "") %> extends BaseModel {
   <% reflections.each do |reflection| %>
     <% if reflection.macro == :belongs_to %>
       <%= ApiMaker::JsMethodNamerService.execute!(name: "load_#{reflection.name}") %>() {
-        let id = this.<%= ApiMaker::JsMethodNamerService.execute!(name: reflection.foreign_key) %>()
-        let modelClass = require(`api-maker/models/<%= reflection.class_name.underscore.dasherize %>`).default
+        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) %>() {
-        let modelClass = require(`api-maker/models/<%= reflection.class_name.underscore.dasherize %>`).default
+        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) %>() {
-        let id = this.<%= ApiMaker::JsMethodNamerService.execute!(name: reflection.options[:primary_key] || reflection.active_record.primary_key) %>()
-        let modelClass = require(`api-maker/models/<%= reflection.class_name.underscore.dasherize %>`).default
+        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}") %>() {
-        let id = this.<%= reflection.active_record.primary_key %>()
-        let modelClass = require(`api-maker/models/<%= reflection.class_name.underscore.dasherize %>`).default
+        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) %>() {
-        let modelClass = require(`api-maker/models/<%= reflection.class_name.underscore.dasherize %>`).default
+        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}") %>() {
-        let id = this.<%= reflection.active_record.primary_key %>()
-        let modelClass = require(`api-maker/models/<%= reflection.class_name.underscore.dasherize %>`).default
+        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) %>() {
-        let modelClass = require(`api-maker/models/<%= reflection.class_name.underscore.dasherize %>`).default
+        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 %>
@@ -63,18 +84,11 @@ export default class <%= model.name.gsub("::", "") %> extends BaseModel {
   <% attributes.each do |attribute_data| %>
     <% methodName = ApiMaker::JsMethodNamerService.execute!(name: attribute_data.fetch(:name)) %>
     <%= methodName %>() {
-      // <%= attribute_data.fetch(:type) %>
-      <% if attribute_data.fetch(:type) == :datetime || attribute_data.fetch(:type) == :date %>
-        return this._getAttributeDateTime("<%= attribute_data.fetch(:name) %>")
-      <% elsif attribute_data.fetch(:type) == :money %>
-        return this._getAttributeMoney("<%= attribute_data.fetch(:name) %>")
-      <% else %>
-        return this._getAttribute("<%= attribute_data.fetch(:name) %>")
-      <% end %>
+      return this.readAttributeUnderscore("<%= attribute_data.fetch(:name) %>")
     }
 
     <%= ApiMaker::JsMethodNamerService.execute!(name: "has_#{attribute_data.fetch(:name)}") %>() {
-      let value = this.<%= methodName %>()
+      const value = this.<%= methodName %>()
       return this._isPresent(value)
     }
   <% end %>
@@ -99,7 +113,7 @@ export default class <%= model.name.gsub("::", "") %> extends BaseModel {
         {
           args: args,
           command: "<%= member_command %>",
-          primaryKey: this._primaryKey(),
+          primaryKey: this.primaryKey(),
           collectionName: this.modelClassData().collectionName,
           type: "member"
         },

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

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

data/lib/api_maker/loader.rb

@@ -4,7 +4,7 @@ class ApiMaker::Loader
 
     @loaded = true
 
-    resources_dir = Rails.root.join("app", "api_maker", "resources")
+    resources_dir = Rails.root.join("app/api_maker/resources")
     files = Dir.glob("#{resources_dir}/**/*.rb")
 
     files.each do |file|

data/lib/api_maker/memory_storage.rb

@@ -21,7 +21,7 @@ class ApiMaker::MemoryStorage
   end
 
   def load_all_resources
-    resources_path = Rails.root.join("app", "api_maker", "resources")
+    resources_path = Rails.root.join("app/api_maker/resources")
 
     Dir.foreach(resources_path) do |file|
       match = file.match(/\A((.+)_resource)\.rb\Z/)

data/lib/api_maker/model_extensions.rb

@@ -26,6 +26,22 @@ module ApiMaker::ModelExtensions
       end
     end
 
+    def api_maker_event(event_name, args = {})
+      channel_name = api_maker_model_class_event_name(event_name)
+      resource = ApiMaker::MemoryStorage.current.resource_for_model(self)
+      data_to_broadcast = ApiMaker::ResultParser.parse(
+        a: args,
+        e: event_name,
+        mt: resource.collection_name,
+        t: :mce
+      )
+      ActionCable.server.broadcast(channel_name, data_to_broadcast)
+    end
+
+    def api_maker_model_class_event_name(event_name)
+      "api_maker_model_class_events_#{api_maker_resource.short_name}_#{event_name}"
+    end
+
     def api_maker_resource
       @api_maker_resource ||= ApiMaker::MemoryStorage.current.resource_for_model(self)
     end
@@ -35,11 +51,11 @@ module ApiMaker::ModelExtensions
     channel_name = api_maker_event_channel_name(event_name)
     serializer = ApiMaker::Serializer.new(model: self)
     data_to_broadcast = ApiMaker::ResultParser.parse(
-      args: args,
-      event_name: event_name,
-      model_id: id,
-      model_type: serializer.resource.collection_name,
-      type: :event
+      a: args,
+      e: event_name,
+      mi: id,
+      mt: serializer.resource.collection_name,
+      t: :e
     )
     ActionCable.server.broadcast(channel_name, data_to_broadcast)
   end
@@ -51,11 +67,11 @@ module ApiMaker::ModelExtensions
   def api_maker_broadcast_create
     serializer = ApiMaker::Serializer.new(model: self)
     data_to_broadcast = ApiMaker::ResultParser.parse(
-      model: self,
-      model_class_name: self.class.name,
-      model_id: id,
-      model_type: serializer.resource.collection_name,
-      type: :create
+      m: self,
+      mcn: self.class.name,
+      mi: id,
+      mt: serializer.resource.collection_name,
+      t: :c
     )
     ActionCable.server.broadcast(self.class.api_maker_broadcast_create_channel_name, data_to_broadcast)
   end
@@ -63,10 +79,10 @@ module ApiMaker::ModelExtensions
   def api_maker_broadcast_destroy
     serializer = ApiMaker::Serializer.new(model: self)
     data_to_broadcast = ApiMaker::ResultParser.parse(
-      model: self,
-      model_id: id,
-      model_type: serializer.resource.collection_name,
-      type: :destroy
+      m: self,
+      mi: id,
+      mt: serializer.resource.collection_name,
+      t: :d
     )
     ActionCable.server.broadcast(api_maker_broadcast_destroy_channel_name, data_to_broadcast)
   end
@@ -78,10 +94,10 @@ module ApiMaker::ModelExtensions
   def api_maker_broadcast_update
     serializer = ApiMaker::Serializer.new(model: self)
     data_to_broadcast = ApiMaker::ResultParser.parse(
-      model: self,
-      model_id: id,
-      model_type: serializer.resource.collection_name,
-      type: :update
+      m: self,
+      mi: id,
+      mt: serializer.resource.collection_name,
+      t: :u
     )
     ActionCable.server.broadcast(api_maker_broadcast_update_channel_name, data_to_broadcast)
   end

data/lib/api_maker/permitted_params_argument.rb

@@ -6,7 +6,11 @@ class ApiMaker::PermittedParamsArgument
     @model = model
   end
 
+  def inspect
+    "#<#{self.class.name}:#{__id__}>"
+  end
+
   def params
-    command.args
+    @params ||= command.args&.dig(:save) || {}
   end
 end