safrano 0.6.7 → 0.7.0

data/lib/safrano/rack_app.rb

@@ -6,143 +6,33 @@ require_relative 'request'
 require_relative 'response'
 
 module Safrano
-  # handle GET PUT etc
-  module MethodHandlers
-    def odata_options
-      @walker.finalize.tap_error { |err| return err.odata_get(@request) }
-             .if_valid do |_context|
-        # cf. stackoverflow.com/questions/22924678/sinatra-delete-response-headers
-        headers.delete('Content-Type')
-        @response.headers.delete('Content-Type')
-        @response.headers['Content-Type'] = ''
-        [200, EMPTY_HASH, '']
-      end
-    end
-
-    def odata_delete
-      @walker.finalize.tap_error { |err| return err.odata_get(@request) }
-             .if_valid { |context| context.odata_delete(@request) }
-    end
-
-    def odata_put
-      @walker.finalize.tap_error { |err| return err.odata_get(@request) }
-             .if_valid { |context| context.odata_put(@request) }
-    end
-
-    def odata_patch
-      @walker.finalize.tap_error { |err| return err.odata_get(@request) }
-             .if_valid { |context| context.odata_patch(@request) }
-    end
-
-    def odata_get
-      @walker.finalize.tap_error { |err| return err.odata_get(@request) }
-             .if_valid { |context| context.odata_get(@request) }
-    end
-
-    def odata_post
-      @walker.finalize.tap_error { |err| return err.odata_get(@request) }
-             .if_valid { |context| context.odata_post(@request) }
-    end
-
-    def odata_head
-      [200, EMPTY_HASH, [EMPTY_STRING]]
-    end
-  end
-
-  # the main Rack server app. Source: the Rack docu/examples and partly
-  # inspired from Sinatra
+  # Note there is a strong 1 to 1 relation between an app instance
+  # and a published service. --> actually means also
+  # we only support on service per App-class because publishing is
+  # made on app class level
   class ServerApp
-    METHODS_REGEXP = Regexp.new('HEAD|OPTIONS|GET|POST|PATCH|MERGE|PUT|DELETE').freeze
-    NOCACHE_HDRS = { 'Cache-Control' => 'no-cache',
-                     'Expires' => '-1',
-                     'Pragma' => 'no-cache' }.freeze
-    DATASERVICEVERSION = 'DataServiceVersion'
-    include MethodHandlers
-
-    def before
-      @request.service_base = self.class.get_service_base
-
-      @request.negotiate_service_version.tap_valid do
-        myhdrs = NOCACHE_HDRS.dup
-        myhdrs[DATASERVICEVERSION] = @request.service.data_service_version
-        headers myhdrs
-      end
-    end
-
-    # dispatch for all methods requiring parsing of the path
-    # with walker (ie. allmost all excepted HEAD)
-    def dispatch_with_walker
-      @walker = @request.create_odata_walker
-      case @request.request_method
-      when 'GET'
-        odata_get
-      when 'POST'
-        odata_post
-      when 'DELETE'
-        odata_delete
-      when 'OPTIONS'
-        odata_options
-      when 'PUT'
-        odata_put
-      when 'PATCH', 'MERGE'
-        odata_patch
-      else
-        raise Error
-      end
-    end
-
-    def dispatch_error(err)
-      @response.status, rsph, @response.body = err.odata_get(@request)
-      headers rsph
-    end
-
-    def dispatch
-      req_ret = if @request.request_method !~ METHODS_REGEXP
-                  [404, EMPTY_HASH, ['Did you get lost?']]
-                elsif @request.request_method == 'HEAD'
-                  odata_head
-                else
-                  dispatch_with_walker
-                end
-      @response.status, rsph, @response.body = req_ret
-      headers rsph
+    def initialize
+      # just get back the service base instance object
+      # that was saved on class level and save it here
+      # so it's not needed to call self.class.service
+      @service_base = self.class.get_service_base
     end
 
     def call(env)
-      # for thread safety
-      dup._call(env)
-    end
-
-    def _call(env)
-      begin
-        @request = Safrano::Request.new(env)
-        @response = Safrano::Response.new
-
-        before.tap_error { |err| dispatch_error(err) }
-              .tap_valid { |_res| dispatch }
-
-      # handle remaining Sequel errors that we couldnt prevent with our
-      # own pre-checks
-      rescue Sequel::Error => e
-        dispatch_error(SequelExceptionError.new(e))
-      end
-      @response.finish
-    end
-
-    # Set multiple response headers with Hash.
-    def headers(hash = nil)
-      @response.headers.merge! hash if hash
-      @response.headers
+      Safrano::Request.new(env, @service_base).process
     end
 
+    #  needed for testing only ? try to remove this
     def self.enable_batch
       @service_base.enable_batch
     end
 
+    # needed for testing only ? try to remove this
     def self.path_prefix(path_pr)
       @service_base.path_prefix path_pr
     end
 
+    # needed for testing only ? try to remove this
     def self.get_service_base
       @service_base
     end
@@ -157,6 +47,7 @@ module Safrano
       sbase = Safrano::ServiceBase.new
       sbase.instance_eval(&block) if block_given?
       sbase.finalize_publishing
+      # save published service base instance on App-Class level
       set_servicebase(sbase)
     end
   end

data/lib/safrano/request.rb

@@ -4,6 +4,49 @@ require 'rack'
 require 'rfc2047'
 
 module Safrano
+  # handle GET PUT etc
+  module MethodHandlers
+    def odata_options
+      @walker.finalize.tap_error { |err| return err.odata_get(self) }
+             .if_valid do |_context|
+        # cf. stackoverflow.com/questions/22924678/sinatra-delete-response-headers
+        headers.delete('Content-Type')
+        @response.headers.delete('Content-Type')
+        @response.headers['Content-Type'] = ''
+        [200, EMPTY_HASH, '']
+      end
+    end
+
+    def odata_delete
+      @walker.finalize.tap_error { |err| return err.odata_get(self) }
+             .if_valid { |context| context.odata_delete(self) }
+    end
+
+    def odata_put
+      @walker.finalize.tap_error { |err| return err.odata_get(self) }
+             .if_valid { |context| context.odata_put(self) }
+    end
+
+    def odata_patch
+      @walker.finalize.tap_error { |err| return err.odata_get(self) }
+             .if_valid { |context| context.odata_patch(self) }
+    end
+
+    def odata_get
+      @walker.finalize.tap_error { |err| return err.odata_get(self) }
+             .if_valid { |context| context.odata_get(self) }
+    end
+
+    def odata_post
+      @walker.finalize.tap_error { |err| return err.odata_get(self) }
+             .if_valid { |context| context.odata_post(self) }
+    end
+
+    def odata_head
+      [200, EMPTY_HASH, [EMPTY_STRING]]
+    end
+  end
+
   # monkey patch deactivate Rack/multipart because it does not work on simple
   # OData $batch requests when the content-length
   # is not passed
@@ -13,6 +56,12 @@ module Safrano
     HEADER_VAL_WITH_PAR = /(?:#{HEADER_VAL_RAW})\s*(?:;#{HEADER_PARAM})*/.freeze
     ON_CGST_ERROR = (proc { |r| raise(Sequel::Rollback) if r.in_changeset })
 
+    METHODS_REGEXP = Regexp.new('HEAD|OPTIONS|GET|POST|PATCH|MERGE|PUT|DELETE').freeze
+    NOCACHE_HDRS = { 'Cache-Control' => 'no-cache',
+                     'Expires' => '-1',
+                     'Pragma' => 'no-cache' }.freeze
+    DATASERVICEVERSION = 'DataServiceVersion'
+
     # borowed from Sinatra
     class AcceptEntry
       attr_accessor :params
@@ -31,10 +80,6 @@ module Safrano
         @q = @params.delete('q') { 1.0 }.to_f
       end
 
-      def method_missing(*args, &block)
-        to_str.send(*args, &block)
-      end
-
       def <=>(other)
         other.priority <=> priority
       end
@@ -48,10 +93,6 @@ module Safrano
         super || to_str.respond_to?(*args)
       end
 
-      def to_s(full = false)
-        full ? entry : to_str
-      end
-
       def to_str
         @type
       end
@@ -87,6 +128,82 @@ module Safrano
     # content-id references map
     attr_accessor :content_id_references
 
+    include MethodHandlers
+
+    def initialize(env, service_base)
+      super(env)
+      @service_base = service_base
+    end
+
+    # process the request and return finished response
+    def process
+      begin
+        @response = Safrano::Response.new
+
+        before.tap_error { |err| dispatch_error(err) }
+              .tap_valid { |_res| dispatch }
+
+      # handle remaining Sequel errors that we couldnt prevent with our
+      # own pre-checks
+      rescue Sequel::Error => e
+        dispatch_error(SequelExceptionError.new(e))
+      end
+      @response.finish
+    end
+
+    def before
+      negotiate_service_version.tap_valid do
+        myhdrs = NOCACHE_HDRS.dup
+        myhdrs[DATASERVICEVERSION] = @service.data_service_version
+        headers myhdrs
+      end
+    end
+
+    # dispatch for all methods requiring parsing of the path
+    # with walker (ie. allmost all excepted HEAD)
+    def dispatch_with_walker
+      @walker = create_odata_walker
+      case request_method
+      when 'GET'
+        odata_get
+      when 'POST'
+        odata_post
+      when 'DELETE'
+        odata_delete
+      when 'OPTIONS'
+        odata_options
+      when 'PUT'
+        odata_put
+      when 'PATCH', 'MERGE'
+        odata_patch
+      else
+        raise Error
+      end
+    end
+
+    def dispatch_error(err)
+      @response.status, rsph, @response.body = err.odata_get(self)
+      headers rsph
+    end
+
+    def dispatch
+      req_ret = if request_method !~ METHODS_REGEXP
+                  [404, EMPTY_HASH, ['Did you get lost?']]
+                elsif request_method == 'HEAD'
+                  odata_head
+                else
+                  dispatch_with_walker
+                end
+      @response.status, rsph, @response.body = req_ret
+      headers rsph
+    end
+
+    # Set multiple response headers with Hash.
+    def headers(hash = nil)
+      @response.headers.merge! hash if hash
+      @response.headers
+    end
+
     # stores the newly created entity for the current content-id of
     # the processed request
     def register_content_id_ref(new_entity)
@@ -213,6 +330,7 @@ module Safrano
     MIN_DTSV_PARSE_ERROR = Safrano::BadRequestError.new(
       'MinDataServiceVersion could not be parsed'
     ).freeze
+
     def get_minversion
       if (rqv = env['HTTP_MINDATASERVICEVERSION'])
         if (m = DATASERVICEVERSION_RGX.match(rqv))
@@ -234,6 +352,7 @@ module Safrano
     MAX_LT_MIN_DTSV_ERROR = Safrano::BadRequestError.new(
       'MinDataServiceVersion is larger as MaxDataServiceVersion'
     ).freeze
+
     def negotiate_service_version
       get_maxversion.if_valid do |maxv|
         get_minversion.if_valid do |minv|

data/lib/safrano/service.rb

@@ -257,7 +257,7 @@ module Safrano
     #  * Single/Multi PK
     #  * Media/Non-Media entity
     # Putting this logic here in modules loaded once on start shall result in less runtime overhead
-    def register_model(modelklass, entity_set_name = nil, is_media = false)
+    def register_model(modelklass, entity_set_name = nil, is_media: false)
       # check that the provided klass is a Sequel Model
 
       raise(Safrano::API::ModelNameError, modelklass) unless modelklass.is_a? Sequel::Model::ClassMethods
@@ -314,7 +314,7 @@ module Safrano
     end
 
     def publish_media_model(modelklass, entity_set_name = nil, &block)
-      register_model(modelklass, entity_set_name, true)
+      register_model(modelklass, entity_set_name, is_media: true)
       # we need to execute the passed block in a deferred step
       # after all models have been registered (due to rel. dependancies)
       #      modelklass.instance_eval(&block) if block_given?
@@ -450,7 +450,7 @@ module Safrano
       end
 
       # check function import definition
-      function_imports.each_value { |func| func.check_definition }
+      function_imports.each_value(&:check_definition)
     end
 
     def execute_deferred_iblocks

data/lib/safrano/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Safrano
-  VERSION = '0.6.7'
+  VERSION = '0.7.0'
 end

data/lib/sequel/plugins/join_by_paths.rb

@@ -99,6 +99,8 @@ class JoinByPathsHelper < Set
       @result << iset
     end
 
+    many_to_many_count = 0 # counter for differing multiple
+    # many_to_many through alias
     @result.map! do |jseg|
       jseg.map  do |seg|
         leftm = seg.first.model_class
@@ -122,29 +124,65 @@ class JoinByPathsHelper < Set
           lks = [leftm.primary_key].flatten
           rks = [assoc[:key]].flatten
 
-          # TODO
-          # when         # :many_to_many :: A join table is used that has a foreign key that points
+        when :many_to_many, :one_through_one
+          #  :many_to_many :: A join table is used that has a foreign key that points
           #                  to this model's primary key and a foreign key that points to the
           #                  associated model's primary key.  Each current model object can be
           #                  associated with many associated model objects, and each associated
           #                  model object can be associated with many current model objects.
+          # TODO: testcase for  :one_through_one 
           # when    # :one_through_one :: Similar to many_to_many in terms of foreign keys, but only one object
           #                     is associated to the current object through the association.
           #                     Provides only getter methods, no setter or modification methods.
 
+          result_ = []
+
+          # in case of multiple many_to_many rels, we need differing through aliases
+          many_to_many_count = many_to_many_count + 1
+          through_alias = "t#{many_to_many_count}".to_sym
+
+          # For many_to_many first we add the join with assigment table
+          lks_ = [assoc[:left_primary_key]].flatten
+          rks_ = [assoc[:left_key]].flatten
+
+          lks_.map! { |k| Sequel[seg.first.alias_sym][k] } unless seg.first.empty?
+          rks_.map! { |k| Sequel[through_alias][k] }
+
+          result_ << {
+            type: assoc[:type],
+            left: leftm.table_name,
+            right: assoc[:join_table],
+            alias: through_alias,
+            cond: rks_.zip(lks_).to_h
+          }
+
+          # then we add the join with with target table (right)
+          lks = [assoc[:right_key]].flatten
+          rks = [assoc.right_primary_key].flatten
+
+          lks.map! { |k| Sequel[through_alias][k] }
+          rks.map! { |k| Sequel[seg.last.alias_sym][k] }
+
+          result_ << {
+            type: assoc[:type],
+            left: assoc[:join_table],
+            right: rightm.table_name,
+            alias: seg.last.alias_sym,
+            cond: rks.zip(lks).to_h
+          }
+
+          next result_
+
+
         end
 
         lks.map! { |k| Sequel[seg.first.alias_sym][k] } unless seg.first.empty?
-
         rks.map! { |k| Sequel[seg.last.alias_sym][k] }
 
         { type: assoc[:type],
-          segment: seg,
           left: leftm.table_name,
           right: rightm.table_name,
           alias: seg.last.alias_sym,
-          left_keys: lks,
-          right_keys: rks,
           cond: rks.zip(lks).to_h }
       end
     end
@@ -159,11 +197,14 @@ class JoinByPathsHelper < Set
     return start_dataset if empty?
 
     build_unique_join_segments
-    @result.flatten.inject(start_dataset) do |dt, jo|
+    need_distinct = false
+    ret = @result.flatten.inject(start_dataset) do |dt, jo|
+      need_distinct = true if jo[:type] == :many_to_many
       dt.left_join(Sequel[jo[:right]].as(jo[:alias]),
                    jo[:cond],
                    implicit_qualifier: jo[:left])
     end
+    need_distinct ? ret.distinct : ret
   end
 
   def join_by_paths_helper(*pathlist)

metadata

@@ -1,43 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: safrano
 version: !ruby/object:Gem::Version
-  version: 0.6.7
+  version: 0.7.0
 platform: ruby
 authors:
 - oz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-11 00:00:00.000000000 Z
+date: 2023-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: rack-cors
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rfc2047
   requirement: !ruby/object:Gem::Requirement