sp-job 0.2.3 → 0.3.22

data/lib/sp/jsonapi/adapters/db.rb

@@ -0,0 +1,26 @@
+module SP
+  module JSONAPI
+    module Adapters
+
+      class Db < RawDb
+
+        protected
+
+          def get_error_response(path, error) ; HashWithIndifferentAccess.new(error_response(path, error)) ; end
+
+        private
+
+          def is_error?(result) ; !result[:errors].blank? ; end
+
+          def process_result(result)
+            result = HashWithIndifferentAccess.new(result)
+            result[:response] = JSON.parse(result[:response])
+            raise SP::JSONAPI::Exceptions::GenericModelError.new(result[:response]) if is_error?(result[:response])
+            [ result[:http_status], result[:response] ]
+          end
+
+      end
+
+    end
+  end
+end

data/lib/sp/jsonapi/adapters/raw_db.rb

@@ -0,0 +1,96 @@
+module SP
+  module JSONAPI
+    module Adapters
+
+      class RawDb < Base
+
+        protected
+
+          def unwrap_response(response)
+            # As the method request() is EXACTLY the same as request!(), and it cannot be reverted without affecting lots of changes already made in the app's controllers...
+            # Allow for response being both a [ status, result ] pair (as of old) OR a single result (as of now)
+            if response.is_a?(Array)
+              status = response[0].to_i
+              result = response[1]
+              raise SP::JSONAPI::Exceptions::GenericModelError.new(result) if status != SP::JSONAPI::Status::OK
+              result
+            else
+              # No raise here, we do not know the status...
+              response
+            end
+          end
+
+          def get_error_response(path, error) ; error_response(path, error).to_json ; end
+
+          def do_request(method, path, params)
+            process_result(do_request_on_the_db(method, path, params))
+          end
+
+          def explicit_do_request(exp_subentity_schema, exp_subentity_prefix, method, path, params)
+            process_result(explicit_do_request_on_the_db(exp_subentity_schema, exp_subentity_prefix, method, path, params))
+          end
+
+          def specific_service_do_request(method, path, params, service_params)
+            process_result(specific_service_do_request_on_the_db(method, path, params, service_params))
+          end
+
+        private
+          def user_id          ; "'#{service.parameters.user_id}'" ; end
+          def entity_id        ; "'#{service.parameters.entity_id}'" ; end
+          def entity_schema    ; service.parameters.entity_schema.nil? ? 'NULL' : "'#{service.parameters.entity_schema}'" ; end
+          def sharded_schema   ; service.parameters.sharded_schema.nil? ? 'NULL' : "'#{service.parameters.sharded_schema}'" ; end
+          def subentity_schema ; service.parameters.subentity_schema.nil? ? 'NULL' : "'#{service.parameters.subentity_schema}'" ; end
+          def subentity_prefix ; service.parameters.subentity_prefix.nil? ? 'NULL' : "'#{service.parameters.subentity_prefix}'" ; end
+
+          def process_result(result)
+            raise SP::JSONAPI::Exceptions::GenericModelError.new(result) if is_error?(result)
+            [ SP::JSONAPI::Status::OK, result ]
+          end
+
+          # Implement the JSONAPI request by direct querying of the JSONAPI function in the database
+          def do_request_on_the_db(method, path, params)
+            jsonapi_query = if method == 'GET'
+              %Q[ SELECT * FROM public.jsonapi('#{method}', '#{url_with_params_for_query(path, params)}', '', #{user_id}, #{entity_id}, #{entity_schema}, #{sharded_schema}, #{subentity_schema}, #{subentity_prefix}) ]
+            else
+              %Q[ SELECT * FROM public.jsonapi('#{method}', '#{url(path)}', '#{params_for_body(params)}', #{user_id}, #{entity_id}, #{entity_schema}, #{sharded_schema}, #{subentity_schema}, #{subentity_prefix}) ]
+            end
+            response = service.connection.exec jsonapi_query
+            response.first if response.first
+          end
+
+          def explicit_do_request_on_the_db(exp_subentity_schema, exp_subentity_prefix, method, path, params)
+            _subentity_schema = "'#{exp_subentity_schema}'"
+            _subentity_prefix = "'#{exp_subentity_prefix}'"
+
+            jsonapi_query = if method == 'GET'
+              %Q[ SELECT * FROM public.jsonapi('#{method}', '#{url_with_params_for_query(path, params)}', '', #{user_id}, #{entity_id}, #{entity_schema}, #{sharded_schema}, #{_subentity_schema}, #{_subentity_prefix}) ]
+            else
+              %Q[ SELECT * FROM public.jsonapi('#{method}', '#{url(path)}', '#{params_for_body(params)}', #{user_id}, #{entity_id}, #{entity_schema}, #{sharded_schema}, #{_subentity_schema}, #{_subentity_prefix}) ]
+            end
+            response = service.connection.exec jsonapi_query
+            response.first if response.first
+          end
+
+          def specific_service_do_request_on_the_db(method, path, params, service_params)
+            _user_id          = "'"+service_params["user_id"]+"'"
+            _entity_id        = "'"+service_params["entity_id"]+"'"
+            _entity_schema    = service_params["entity_schema"].blank? ? 'NULL' : "'"+service_params["entity_schema"]+"'"
+            _sharded_schema   = service_params["sharded_schema"].blank? ? 'NULL' : "'"+service_params["sharded_schema"]+"'"
+            _subentity_schema = service_params["subentity_schema"].blank? ? 'NULL' : "'"+service_params["subentity_schema"]+"'"
+            _subentity_prefix = service_params["subentity_prefix"].blank? ? 'NULL' : "'"+service_params["subentity_prefix"]+"'"
+
+            jsonapi_query = if method == 'GET'
+              %Q[ SELECT * FROM public.jsonapi('#{method}', '#{url_with_params_for_query(path, params)}', '', #{_user_id}, #{_entity_id}, #{_entity_schema}, #{_sharded_schema}, #{_subentity_schema}, #{_subentity_prefix}) ]
+            else
+              %Q[ SELECT * FROM public.jsonapi('#{method}', '#{url(path)}', '#{params_for_body(params)}', #{_user_id}, #{_entity_id}, #{_entity_schema}, #{_sharded_schema}, #{_subentity_schema}, #{_subentity_prefix}) ]
+            end
+            response = service.connection.exec jsonapi_query
+            response.first if response.first
+          end
+
+          def is_error?(result) ; result =~ /^\s*{\s*"errors"\s*:/ ; end
+      end
+
+    end
+  end
+end

data/lib/sp/jsonapi/exceptions.rb

@@ -0,0 +1,54 @@
+module SP
+  module JSONAPI
+    module Exceptions
+
+      # JSONAPI service and configuration errors
+
+      class ServiceSetupError < StandardError ; ; end
+      class ServiceProtocolError < StandardError ; ; end
+      class InvalidResourceConfigurationError < StandardError ; ; end
+      class InvalidResourcePublisherError < StandardError ; ; end
+      class DuplicateResourceError < StandardError ; ; end
+      class SaveConfigurationError < StandardError ; ; end
+      class InvalidJSONAPIKeyError < StandardError ; ; end
+
+      # JSONAPI model querying errors
+
+      class GenericModelError < StandardError
+
+        attr_reader :id
+        attr_reader :status
+        attr_reader :result
+
+        def initialize(result, nested = $!)
+          @result = result
+          errors = get_result_errors()
+          @status = (errors.map { |error| error[:status].to_i }.max) || 403
+          message = errors.first[:detail]
+          super(message, nested)
+        end
+
+        def internal_error
+          errors = get_result_errors()
+          if errors.length != 1
+            @result.to_json
+          else
+            errors.first[:meta]['internal-error'] if errors.first[:meta]
+          end
+        end
+
+        def inspect()
+          description = super()
+          description = description + " (#{internal_error})" if internal_error
+          description
+        end
+
+        private
+
+          def get_result_errors() ; (result.is_a?(Hash) ? result : HashWithIndifferentAccess.new(JSON.parse(result)))[:errors] ; end
+
+      end
+
+    end
+  end
+end

data/lib/sp/jsonapi/model/base.rb

@@ -0,0 +1,31 @@
+require 'sp/jsonapi/model/concerns/model'
+
+module SP
+  module JSONAPI
+    module Model
+
+      class Base
+        include SP::JSONAPI::Model::Concerns::Model
+
+        @@adapter = nil
+        @@include_root_in_json = true
+
+        def self.adapter ; @@adapter ; end
+        def self.adapter=(value) ; @@adapter = value ; end
+
+        def self.include_root_in_json ; @@include_root_in_json ; end
+        def self.include_root_in_json=(value) ; @@include_root_in_json = value ; end
+
+        def self.inherited(child)
+          child.resource_name = child.name.demodulize.underscore.pluralize
+          child.autogenerated_id = true
+        end
+
+        def self.i18n_scope
+          :activerecord
+        end
+      end
+
+    end
+  end
+end

data/lib/sp/jsonapi/model/concerns/attributes.rb

@@ -0,0 +1,91 @@
+module SP
+  module JSONAPI
+    module Model
+      module Concerns
+        module Attributes
+          def self.included(base)
+            base.extend ClassMethods
+          end
+
+          module ClassMethods
+
+            def attributes
+              if !@attributes && superclass.respond_to?(:attributes)
+                @attributes = []
+                @attributes += superclass.attributes
+              end
+              @attributes = [] if !@attributes
+              @attributes
+            end
+
+            def attr_accessible(name)
+              attributes << name if !attributes.include?(name)
+              attr_accessor name
+            end
+          end
+
+          def initialize(new_attributes = nil)
+            assign_attributes(new_attributes) if new_attributes
+            yield self if block_given?
+          end
+
+          def attributes=(new_attributes)
+            return unless new_attributes.is_a?(Hash)
+            assign_attributes(new_attributes)
+          end
+
+          private
+
+            def assign_attributes(new_attributes)
+              return if new_attributes.blank?
+
+              new_attributes = new_attributes.stringify_keys
+              nested_parameter_attributes = []
+
+              new_attributes.each do |k, v|
+                if respond_to?("#{k}=")
+                  if v.is_a?(Hash)
+                    nested_parameter_attributes << [ k, v ]
+                  else
+                    send("#{k}=", v)
+                  end
+                # else
+                #   raise(ActiveRecord::UnknownAttributeError, "unknown attribute: #{k}")
+                end
+              end
+
+              # Assign any deferred nested attributes after the base attributes have been set
+              nested_parameter_attributes.each do |k,v|
+                send("#{k}=", v)
+              end
+            end
+
+            # Returns an <tt>#inspect</tt>-like string for the value of the
+            # attribute +attr_name+. String attributes are truncated upto 50
+            # characters, and Date and Time attributes are returned in the
+            # <tt>:db</tt> format. Other attributes return the value of
+            # <tt>#inspect</tt> without modification.
+            #
+            #   person = Person.create!(:name => "David Heinemeier Hansson " * 3)
+            #
+            #   person.attribute_for_inspect(:name)
+            #   # => '"David Heinemeier Hansson David Heinemeier Hansson D..."'
+            #
+            #   person.attribute_for_inspect(:created_at)
+            #   # => '"2009-01-12 04:48:57"'
+            def attribute_for_inspect(name)
+              value = self.send(name)
+              if value.is_a?(String) && value.length > 50
+                "#{value[0..50]}...".inspect
+              elsif value.is_a?(Date) || value.is_a?(Time)
+                %("#{value.to_s(:db)}")
+              else
+                value.inspect
+              end
+            end
+
+        end
+      end
+    end
+  end
+end

data/lib/sp/jsonapi/model/concerns/model.rb

@@ -0,0 +1,39 @@
+require 'sp/jsonapi/model/concerns/attributes'
+require 'sp/jsonapi/model/concerns/serialization'
+require 'sp/jsonapi/model/concerns/persistence'
+
+module SP
+  module JSONAPI
+    module Model
+      module Concerns
+        module Model
+
+          def self.included klass
+            klass.extend ClassMethods
+
+            klass.class_eval do
+              include Attributes
+              include Serialization
+              include Persistence
+            end
+          end
+
+          module ClassMethods
+
+            def inspect
+              "#{super}(#{self.attributes.join(', ')})"
+            end
+          end
+
+          # Returns the contents of the record as a nicely formatted string.
+          def inspect
+            # attrs = self.class.attributes
+            inspection = self.class.attributes.collect { |name| "#{name}: #{attribute_for_inspect(name)}" }.compact.join(", ")
+            "#<#{self.class} #{inspection}>"
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/sp/jsonapi/model/concerns/persistence.rb

@@ -0,0 +1,212 @@
+module SP
+  module JSONAPI
+    module Model
+      module Concerns
+        module Persistence
+
+          def self.included(base)
+            base.extend ClassMethods
+          end
+
+          module ClassMethods
+
+            # Define resource configuration accessors at the class (and subclass) level (static).
+            # These attribute values are NOT inherited by subclasses, each subclass MUST define their own.
+            # Instances can access these attributes at the class level only.
+            attr_accessor :resource_name
+            attr_accessor :autogenerated_id
+            attr_accessor :non_persistent_attributes
+
+            def find!(id, conditions = nil) ; get(id, conditions) ; end
+
+            def find_explicit!(exp_subentity_schema, exp_subentity_prefix, id, conditions = nil)
+              get_explicit(exp_subentity_schema, exp_subentity_prefix, id, conditions)
+            end
+
+            def find(id, conditions = nil)
+              begin
+                get(id, conditions)
+              rescue Exception => e
+                return nil
+              end
+            end
+
+            def query!(condition) ; get_all(condition) ; end
+            def query_explicit!(exp_subentity_schema, exp_subentity_prefix, condition) ; get_all_explicit(exp_subentity_schema, exp_subentity_prefix, condition) ; end
+
+            def query(condition)
+              begin
+                get_all(condition)
+              rescue Exception => e
+                nil
+              end
+            end
+
+            def first!(condition = "")
+              condition += (condition.blank? ? "" : "&") + "page[size]=1"
+              get_all(condition).first
+            end
+
+            def first(condition = "")
+              begin
+                condition += (condition.blank? ? "" : "&") + "page[size]=1"
+                get_all(condition).first
+              rescue Exception => e
+                nil
+              end
+            end
+
+            def all! ; get_all("") ; end
+
+            def all
+              begin
+                get_all("")
+              rescue Exception => e
+                nil
+              end
+            end
+
+            private
+
+              def get_explicit(exp_subentity_schema, exp_subentity_prefix, id, conditions = nil)
+                result = self.adapter.get_explicit!(exp_subentity_schema, exp_subentity_prefix, "#{self.resource_name}/#{id.to_s}", conditions)
+                jsonapi_result_to_instance(result[:data], result)
+              end
+
+              def get(id, conditions = nil)
+                result = self.adapter.get("#{self.resource_name}/#{id.to_s}", conditions)
+                jsonapi_result_to_instance(result[:data], result)
+              end
+
+              def get_all(condition)
+                got = []
+                result = self.adapter.get(self.resource_name, condition)
+                if result
+                  got = result[:data].map do |item|
+                    data = { data: item }
+                    data.merge(included: result[:included]) if result[:included]
+                    jsonapi_result_to_instance(item, data)
+                  end
+                end
+                got
+              end
+
+              def get_all_explicit(exp_subentity_schema, exp_subentity_prefix, condition)
+                got = []
+                result = self.adapter.get_explicit!(exp_subentity_schema, exp_subentity_prefix, self.resource_name, condition)
+                if result
+                  got = result[:data].map do |item|
+                    data = { data: item }
+                    data.merge(included: result[:included]) if result[:included]
+                    jsonapi_result_to_instance(item, data)
+                  end
+                end
+                got
+              end
+
+              def jsonapi_result_to_instance(result, data)
+                if result
+                  instance = self.new(result.merge(result[:attributes]).except(:attributes))
+                  instance.send :_data=, data
+                end
+                instance
+              end
+          end
+
+          # Instance methods
+
+          def new_record?
+            if self.class.autogenerated_id || self.id.nil?
+              self.id.nil?
+            else
+              self.class.find(self.id).nil?
+            end
+          end
+
+          def save!
+            if new_record?
+              create!
+            else
+              update!
+            end
+          end
+
+          def save_explicit!(exp_subentity_schema, exp_subentity_prefix)
+            if new_record?
+              create!(exp_subentity_schema, exp_subentity_prefix)
+            else
+              update!(exp_subentity_schema, exp_subentity_prefix)
+            end
+          end
+
+          def destroy!
+            if !new_record?
+              self.class.adapter.delete(path_for_id)
+            end
+          end
+
+          def destroy_explicit!(exp_subentity_schema, exp_subentity_prefix)
+            if !new_record?
+              self.class.adapter.delete_explicit!(exp_subentity_schema, exp_subentity_prefix, path_for_id)
+            end
+          end
+
+          alias :delete! :destroy!
+
+          def create!(exp_subentity_schema = nil, exp_subentity_prefix = nil)
+            if self.class.autogenerated_id
+              params = {
+                data: {
+                  type: self.class.resource_name,
+                  attributes: get_persistent_json.reject { |k,v| k == :id || v.nil? }
+                }
+              }
+            else
+              params = {
+                data: {
+                  type: self.class.resource_name,
+                  attributes: get_persistent_json.reject { |k,v| v.nil? }
+                }
+              }
+            end
+            result = if !exp_subentity_schema.blank? || !exp_subentity_prefix.blank?
+              self.class.adapter.post_explicit!(exp_subentity_schema, exp_subentity_prefix, self.class.resource_name, params)
+            else
+              self.class.adapter.post(self.class.resource_name, params)
+            end
+            # Set the id to the newly created id
+            self.id = result[:data][:id]
+          end
+
+          def update!(exp_subentity_schema = nil, exp_subentity_prefix = nil)
+            params = {
+              data: {
+                type: self.class.resource_name,
+                id: self.id.to_s,
+                attributes: get_persistent_json.reject { |k,v| k == :id }
+              }
+            }
+            result = if !exp_subentity_schema.blank? || !exp_subentity_prefix.blank?
+              self.class.adapter.patch_explicit!(exp_subentity_schema, exp_subentity_prefix, path_for_id, params)
+            else
+              self.class.adapter.patch(path_for_id, params)
+            end
+          end
+
+          def get_persistent_json
+            as_json.reject { |k| !self.class.attributes.include?(k) || (self.class.non_persistent_attributes || []).include?(k) }
+          end
+
+          protected
+
+            attr_accessor :_data
+
+          private
+
+            def path_for_id ; "#{self.class.resource_name}/#{self.id.to_s}" ; end
+
+        end
+      end
+    end
+  end
+end