smooth 2.0.1 → 2.0.2

data/lib/smooth/cache.rb

@@ -8,7 +8,7 @@ module Smooth
   class Cache
     include Singleton
 
-    def method_missing meth, *args, &block
+    def method_missing(meth, *args, &block)
       if defined? ::Rails
         return ::Rails.cache.send(meth, *args, &block)
       end

data/lib/smooth/command.rb

@@ -1,35 +1,131 @@
-require 'smooth/ext/mutations'
-require 'smooth/command/instrumented'
-
 class Smooth::Command < Mutations::Command
   include Instrumented
 
+  def self.as(current_user)
+    require 'smooth/command/run_proxy' unless defined?(RunProxy)
+    RunProxy.new(current_user, self)
+  end
+
+  # DSL Improvements English
+  def self.params(*args, &block)
+    send(:required, *args, &block)
+  end
+
+  def self.interface(*args, &block)
+    send(:required, *args, &block)
+  end
+
+  def self.input_argument_names
+    required_inputs.keys + optional_inputs.keys
+  end
+
+  # Commands are aware of who is running them
+  attr_accessor :current_user
+
   class_attribute :resource_name,
                   :command_action,
-                  :event_namespace
+                  :event_namespace,
+                  :model_class,
+                  :base_scope,
+                  :parent_resource
 
-  def self.scope setting
-    @@scope = setting
+  def self.base_scope
+    @base_scope || :all
   end
 
-  def self.params *args, &block
-    send(:required, *args, &block)
+  def parent_api
+    self.class.parent_api
+  end
+
+  def parent_resource
+    self.class.parent_resource
+  end
+
+  def self.belongs_to_resource(resource)
+    self.parent_resource = resource
+  end
+
+  def self.parent_api
+    parent_resource.api
+  end
+
+  # Returns the model scope for this command.  If a scope method
+  # is set on this command, it will make sure to scope the model
+  # by that method.  It will pass whatever arguments you pass to scope
+  # to the scope method.  if you pass no args, and the scope requires one,
+  # we will assume the user wants us to pass the current user of the command
+  def scope(*args)
+    @scope ||= begin
+                 meth = model_class.send(:method, self.class.base_scope)
+
+                 if meth.arity.abs >= 1
+                   args.push(current_user) if args.empty?
+                   model_class.send(self.class.base_scope, *args)
+                 else
+                   model_class.send(self.class.base_scope)
+                 end
+               end
+  end
+
+  def scope=(new_scope)
+    @scope = new_scope || scope
+  end
+
+  def self.scope(setting = nil)
+    self.base_scope = setting if setting
+    base_scope || :all
   end
 
   def self.event_namespace
-    @event_namespace || "#{ command_action }.#{ resource_name.singularize.underscore }".downcase
+    @event_namespace || "#{ command_action }.#{ resource_alias }".downcase
   end
 
-  def event_namespace; self.class.event_namespace; end
+  def self.resource_alias
+    resource_name.singularize.underscore
+  end
+
+  def self.resource_name
+    value = @resource_name.to_s
+
+    if value.empty? && model_class
+      value = model_class.to_s
+    end
+
+    value
+  end
+
+  def self.object_path
+    resource_name.downcase + '.' + command_action
+  end
+
+  def event_namespace
+    self.class.event_namespace
+  end
+
+  def object_path
+    self.class.object_path
+  end
+
+  def resource_name
+    self.class.resource_name
+  end
+
+  def resource_alias
+    self.class.resource_alias
+  end
+
+  def model_class
+    self.class.model_class
+  end
 
   # DSL Hooks
   #
   #
-  def self.configure options, resource=nil
+  def self.configure(dsl_config_object, resource = nil)
     resource ||= Smooth.current_resource
-    klass = define_or_open(options, resource)
+    klass = define_or_open(dsl_config_object, resource)
 
-    Array(options.blocks).each do |blk|
+    Array(dsl_config_object.blocks).each do |blk|
       klass.class_eval(&blk)
     end
 
@@ -41,15 +137,168 @@ class Smooth::Command < Mutations::Command
     base          = Smooth.command
 
     name = options.name.to_s.camelize
-    klass = "#{ name }#{ resource_name }"
+    klass = "#{ name }#{ resource.model_class }".gsub(/\s+/, '')
+
+    apply_options = lambda do |k|
+      k.model_class     ||= resource.model_class if resource.model_class
+
+      k.belongs_to_resource(resource)
+
+      k.resource_name   = resource.name.to_s
+      k.command_action  = options.name.to_s
+    end
 
     if command_klass = Object.const_get(klass) rescue nil
-      return command_klass
+      return command_klass.tap(&apply_options)
     end
 
-    Object.const_set(klass, Class.new(base)).tap do |k|
-      k.resource_name = resource.name.to_s
-      k.command_action  = options.name.to_s
+    parent_klass = Class.new(base)
+
+    begin
+      Object.const_set(klass, parent_klass).tap(&apply_options)
+    rescue => ex
+      puts ex.message
+      puts "Error setting #{ klass } #{ base }. klass is a #{ klass.class }"
+    end
+
+    parent_klass
+  end
+
+  # Interface Documentation
+  #
+  def interface_for(filter)
+    self.class.interface_description.filters.send(filter)
+  end
+
+  def self.interface_description
+    interface_documentation
+  end
+
+  def self.interface_documentation
+    optional_inputs = input_filters.optional_inputs
+    required_inputs = input_filters.required_inputs
+
+    data = {
+      required: required_inputs.keys,
+      optional: optional_inputs.keys,
+      filters: {}
+    }
+
+    blk = lambda do |memo, parts, required|
+      key, filter = parts
+
+      type        = filter.class.name[/^Mutations::([a-zA-Z]*)Filter$/, 1].underscore
+      options     = filter.options.merge(required: required)
+
+      value = memo[key] = {
+        type: type,
+        options: options.reject { |_k, v| v.nil? },
+        description: input_descriptions[key]
+      }
+
+      if options[:faker]
+        value[:example] = Smooth.faker(options[:faker])
+      end
+
+      memo
+    end
+
+    required_inputs.reduce(data[:filters]) do |memo, parts|
+      blk.call(memo, parts, true)
+    end
+
+    optional_inputs.reduce(data[:filters]) do |memo, parts|
+      blk.call(memo, parts, false)
+    end
+
+    data.to_mash
+  end
+
+  def self.filter_for_param(param)
+    optional_inputs[param] || required_inputs[param]
+  end
+
+  def self.filter_options_for_param(param)
+    filter_for_param(param).try(:options)
+  end
+
+  def self.response_class
+    Smooth::Response
+  end
+
+  # Creates a new instance of the Smooth::Command::Response
+  # class in response to a request from the Router.  It is
+  # assumed that a request object responds to: user, and params
+  def self.respond_to_request(request_object, options = {})
+    klass = self
+
+    outcome = options.fetch(:outcome) do
+      klass.as(request_object.user).run(request_object.params)
+    end
+
+    response_class.new(outcome, serializer_options).tap do |response|
+      response.request_headers = request_object.headers
+      response.serializer = find_serializer_for(request_object)
+      response.event_namespace = event_namespace
+      response.command_action = command_action
+      response.current_user = request_object.user
+    end
+  end
+
+  def self.find_serializer_for(_request_object)
+    resource = Smooth.resource(resource_name)
+    resource ||= Smooth.resource("#{ resource_name }".pluralize)
+
+    # TODO
+    # We can make the preferred format something you can
+    # specify via a header or parameter.  We can also restrict
+    # certain serializers from certain policies.
+    preferred_format = :default
+
+    resource.fetch(:serializer, preferred_format)
+  end
+
+  def self.serializer_options
+    {}
+  end
+
+  # Allows for defining common execution pattern methods
+  # mostly for standard CRUD against scoped models
+  def self.execute(execution_pattern = nil, &block)
+    send :define_method, :execute, (block || get_execution_pattern(execution_pattern))
+  end
+
+  Patterns = {}
+
+  Patterns[:update] = lambda do
+    scoped_find_object.update_attributes(inputs)
+    scoped_find_object
+  end
+
+  Patterns[:create] = lambda do
+    scope.create(inputs)
+  end
+
+  Patterns[:destroy] = lambda do
+    scoped_find_object.destroy
+    scoped_find_object
+  end
+
+  def scoped_find_object
+    @scoped_find ||= if scope.respond_to?(:find) && found = (scope.find(id) rescue nil)
+                       found
+    else
+      add_error(:id, :not_found, "could not find a #{ resource_name } model with that id")
+    end
+  end
+
+  def self.get_execution_pattern(pattern_name)
+    if respond_to?("#{ pattern_name }_execution_pattern")
+      return method("#{ pattern_name }_execution_pattern").to_proc
+    elsif Patterns.key?(pattern_name.to_sym)
+      Patterns.fetch(pattern_name.to_sym)
+    else
+      return method(:execute).to_proc
     end
   end
 end

data/lib/smooth/command/async_worker.rb

@@ -0,0 +1,27 @@
+module Smooth
+  class Command::AsyncWorker
+    unless Smooth.config.async_provider
+      fail 'Must specify an async provider. e.g. Sidekiq::Worker on Smooth.config.async_provider'
+    end
+
+    def self.options(*args)
+      send(:sidekiq_options, *args) if defined?(Sidekiq)
+    end
+
+    def perform(serialized_payload)
+      if hash = memory_store.read(serialized_payload)
+        api, object_path, payload = hash.values_at('api', 'object_path', 'payload')
+        current_user = payload['current_user'] || hash['current_user']
+
+        chain = Smooth(api).lookup_object_by(object_path)
+        chain = chain.as(current_user) if current_user
+
+        chain.run(payload)
+      end
+    end
+
+    def memory_store
+      Smooth.config.memory_store
+    end
+  end
+end

data/lib/smooth/command/instrumented.rb

@@ -29,15 +29,17 @@ module Smooth
         end
       end
 
-      def run_with_instrumentation
+      def run_with_instrumentation(event_prefix = nil)
         outcome = run_with_outcome
 
+        event_prefix = "#{ event_prefix }." if event_prefix
+
         if outcome.success?
           result = outcome.result
-          track_event("#{ event_namespace }", result: result, inputs: inputs)
-          result
+          track_event("#{ event_prefix }#{ event_namespace }", result: result, inputs: inputs, current_user: current_user)
+          outcome
         else
-          track_event("errors/#{ event_namespace }", errors: outcome.errors, inputs: inputs)
+          track_event("errors/#{ event_prefix }#{ event_namespace }", errors: outcome.errors, inputs: inputs, current_user: current_user)
           outcome
         end
       end

data/lib/smooth/command/run_proxy.rb

@@ -0,0 +1,21 @@
+# Internal class to provide current user awareness to the
+module Smooth
+  class Command < Mutations::Command
+    class RunProxy
+      attr_accessor :current_user, :cmd
+
+      def initialize(current_user, cmd)
+        @current_user = current_user
+        @cmd = cmd
+      end
+
+      def run!(*args)
+        cmd.new(*args).tap { |c| c.current_user = current_user }.run!
+      end
+
+      def run(*args)
+        cmd.new(*args).tap { |c| c.current_user = current_user }.run
+      end
+    end
+  end
+end

data/lib/smooth/configuration.rb

@@ -1,5 +1,3 @@
-require 'singleton'
-
 module Smooth
   class Configuration
     include Singleton
@@ -7,18 +5,75 @@ module Smooth
     cattr_accessor :query_class,
                    :command_class,
                    :serializer_class,
-                   :enable_events
+                   :object_path_separator,
+                   :enable_events,
+                   :definition_folders,
+                   :eager_load_app_folders,
+                   :active_record_config,
+                   :models_path,
+                   :schema_file,
+                   :migrations_path,
+                   :root,
+                   :include_root_in_json,
+                   :auth_token_column,
+                   :enable_factories,
+                   :async_provider,
+                   :memory_store,
+                   :embed_relationships_as
+
+    @@query_class               = Smooth::Query
+    @@command_class             = Smooth::Command
+    @@serializer_class          = defined?(ApplicationSerializer) ? ApplicationSerializer : Smooth::Serializer
+    @@enable_events             = true
+    @@eager_load_app_folders    = true
+    @@models_path               = 'app/models'
+    @@object_path_separator     = '.'
+    @@definition_folders        = %w(app/models app/apis app/queries app/commands app/serializers app/resources)
+    @@include_root_in_json      = true
+    @@enable_factories          = true
 
-    @@query_class       = Smooth::Query
-    @@command_class     = Smooth::Command
-    @@serializer_class  = defined?(ApplicationSerializer) ? ApplicationSerializer : Smooth::Serializer
-    @@enable_events     = true
+    @@active_record_config      = 'config/database.yml'
+    @@schema_file               = 'db/schema.rb'
+    @@migrations_path           = 'db/migrate'
+    @@root                      = Dir.pwd
+    @@auth_token_column         = :authentication_token
+    @@async_provider            = Sidekiq::Worker if defined?(Sidekiq)
+    @@memory_store              = Smooth.cache
+
+    @@embed_relationships_as    = :ids
+
+    def active_record
+      return active_record_config if active_record_config.is_a?(Hash)
+      file = root.join(active_record_config)
+      fail 'The config file does not exist at ' + file.to_s unless file.exist?
+      YAML.load(file.open).fetch(Smooth.env)
+    end
 
     def enable_event_tracking?
       !!@@enable_events
     end
 
-    def self.method_missing meth, *args, &block
+    def root
+      Pathname(@@root)
+    end
+
+    def app_folder_paths
+      Array(definition_folders).map { |f| root.join(f) }
+    end
+
+    def models_path
+      root.join(@@models_path)
+    end
+
+    def method_missing(meth, *args, &block)
+      if meth.to_s.match(/(\w+)\?$/)
+        !!(send(Regexp.last_match[1], *args, &block)) if respond_to?(Regexp.last_match[1])
+      else
+        super
+      end
+    end
+
+    def self.method_missing(meth, *args, &block)
       instance.send(meth, *args, &block)
     end
   end