safrano 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 497482614bfc6a87f8a42b9378a4fc8099ddb5b4f180d747b3717a6952f027b0
-  data.tar.gz: cd5236302671643fd9fbd9bcd200034f305ce7069e5d56ab2db2225dcfb4ce87
+  metadata.gz: 88f62ce611a5030382ea19c2e7c22b47f454b85c51261e5bad060d82e4680dff
+  data.tar.gz: '088e66ed4a107a3bef8dd6db68c8ca626f7d3acef6ed2e58eb53d871e6349613'
 SHA512:
-  metadata.gz: 4415ca4dc24362f3c179f0cc40f1d73fac6fb7207c0571ef63f1af318fc345e0be8043d8aa1b5ab48e0ead1f5c904dcab07b84061b3ca47f6b7d3c38696d4ae8
-  data.tar.gz: 6646d12aadb3827b43c013a3da6c6223d072e5676f8676eac0db59ad8e3ac80d1a64ceb0f5e87d52bb75e5b556eecda701e2d473c4bdd3b650cb680b6ce19b96
+  metadata.gz: 2d719e317178a4baebc2e40cc50b95559921fe2936a6a03437f7f92714d173ef6160b10620ce5476ea54a7433b3dd1366b49ec37a48b121b8f808ad030e2c364
+  data.tar.gz: 535ee0f1d4fed30a0c94918c31149a2e95fce90051548a2ccca6bffb71930c0767543255695496c3623249070b5efb1b6a203a1dae6f868c1e4da9a126a85346

data/lib/core_ext/Dir/iter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# needed for ruby < 2.5
+module Safrano
+  module CoreExt
+    module Dir
+      module Iter
+        def each_child(dir)
+          ::Dir.foreach(dir) do |x|
+            next if (x == '.') || (x == '..')
+
+            yield x
+          end
+        end unless ::Dir.respond_to? :each_child
+      end
+    end
+  end
+end

data/lib/core_ext/Hash/transform.rb

@@ -0,0 +1,21 @@
+# picked from activsupport; needed for ruby < 2.5
+# Destructively converts all keys using the +block+ operations.
+# Same as +transform_keys+ but modifies +self+.
+module Safrano
+  module CoreIncl
+    module Hash
+      module Transform
+        def transform_keys!
+          keys.each do |key|
+            self[yield(key)] = delete(key)
+          end
+          self
+        end unless method_defined? :transform_keys!
+
+        def symbolize_keys!
+          transform_keys! { |key| key.to_sym rescue key }
+        end
+      end
+    end
+  end
+end

data/lib/core_ext/Integer/edm.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Safrano
+  module CoreExt
+    module Integer
+      module Edm
+        def type_name
+          'Edm.Int32'
+        end
+      end
+    end
+  end
+end

data/lib/core_ext/REXML/Document/output.rb

@@ -0,0 +1,16 @@
+module Safrano
+  module CoreIncl
+    module REXML
+      module Document
+        module Output
+          def to_pretty_xml
+            formatter = ::REXML::Formatters::Pretty.new(2)
+            formatter.compact = true
+            formatter.write(root, strio = '')
+            strio
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core_ext/String/convert.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Safrano
+  module CoreIncl
+    module String
+      module Convert
+        # thanks https://stackoverflow.com/questions/1448670/ruby-stringto-class
+        def constantize
+          names = split('::')
+          names.shift if names.empty? || names.first.empty?
+
+          const = Object
+          names.each do |name|
+            const = if const.const_defined?(name)
+                      const.const_get(name)
+                    else
+                      const.const_missing(name)
+                    end
+          end
+          const
+        end
+      end
+    end
+  end
+end

data/lib/core_ext/String/edm.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Safrano
+  module CoreExt
+    module String
+      module Edm
+        def type_name
+          'Edm.String'
+        end
+      end
+    end
+  end
+end

data/lib/core_ext/dir.rb

@@ -0,0 +1,3 @@
+require_relative 'Dir/iter'
+
+Dir.extend Safrano::CoreExt::Dir::Iter

data/lib/core_ext/hash.rb

@@ -0,0 +1,3 @@
+require_relative 'Hash/transform'
+
+Hash.include Safrano::CoreIncl::Hash::Transform

data/lib/core_ext/integer.rb

@@ -0,0 +1,3 @@
+require_relative 'Integer/edm'
+
+Integer.extend Safrano::CoreExt::Integer::Edm

data/lib/core_ext/rexml.rb

@@ -0,0 +1,3 @@
+require_relative 'REXML/Document/output'
+
+REXML::Document.include Safrano::CoreIncl::REXML::Document::Output

data/lib/core_ext/string.rb

@@ -0,0 +1,5 @@
+require_relative 'String/edm'
+require_relative 'String/convert'
+
+String.extend Safrano::CoreExt::String::Edm
+String.include Safrano::CoreIncl::String::Convert

data/lib/odata/attribute.rb

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 require 'json'
 require_relative '../safrano/core.rb'
 require_relative './entity.rb'
 
-module OData
+module Safrano
   # Represents a named and valued attribute of an Entity
   class Attribute
     attr_reader :name
     attr_reader :entity
+
     def initialize(entity, name)
       @entity = entity
       @name = name
@@ -30,7 +33,8 @@ module OData
       if req.walker.raw_value
         [200, CT_TEXT, value.to_s]
       elsif req.accept?(APPJSON)
-        [200, CT_JSON, to_odata_json(service: req.service)]
+        # json is default content type so we dont need to specify it here again
+        [200, EMPTY_HASH, to_odata_json(service: req.service)]
       else # TODO: other formats
         406
       end

data/lib/odata/batch.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require_relative '../safrano/rack_app.rb'
 require_relative '../safrano/core.rb'
 require 'rack/body_proxy'
 require_relative './common_logger.rb'
 
-module OData
+module Safrano
   # Support for OData multipart $batch Requests
   class Request
     def create_batch_app
@@ -20,7 +22,7 @@ module OData
 
   module Batch
     # Mayonaise
-    class MyOApp < OData::ServerApp
+    class MyOApp < Safrano::ServerApp
       attr_reader :full_req
       attr_reader :response
       attr_reader :db
@@ -41,8 +43,8 @@ module OData
         env = batch_env(part_req)
         env['HTTP_HOST'] = @full_req.env['HTTP_HOST']
         began_at = Rack::Utils.clock_time
-        @request = OData::Request.new(env)
-        @response = OData::Response.new
+        @request = Safrano::Request.new(env)
+        @response = Safrano::Response.new
 
         if part_req.level == 2
           @request.in_changeset = true
@@ -98,7 +100,7 @@ module OData
       end
 
       def transition_end(_match_result)
-        [nil, :end]
+        Safrano::Transition::RESULT_END
       end
     end
     # jaune d'oeuf
@@ -126,13 +128,13 @@ module OData
       def odata_post(req)
         @request = req
 
-        if @request.media_type == OData::MP_MIXED
+        if @request.media_type == Safrano::MP_MIXED
 
           batcha = @request.create_batch_app
           @mult_request = @request.parse_multipart
 
           @mult_request.prepare_content_id_refs
-          @mult_response = OData::Response.new
+          @mult_response = Safrano::Response.new
 
           resp_hdrs, @mult_response.body = @mult_request.get_http_resp(batcha)
 

data/lib/odata/collection.rb

@@ -1,708 +1,202 @@
-# Design: Collections are nothing more as Sequel based model classes that have
-# somehow the character of an array (Enumerable)
-# Thus Below we have called that "EntityClass". It's meant as "Collection"
-
-require 'json'
-require 'rexml/document'
-require_relative '../safrano/core.rb'
-require_relative 'error.rb'
-require_relative 'collection_filter.rb'
-require_relative 'collection_order.rb'
-require_relative 'expand.rb'
-require_relative 'select.rb'
-require_relative 'url_parameters.rb'
-require_relative 'collection_media.rb'
-
-# small helper method
-# http://stackoverflow.com/
-#        questions/24980295/strictly-convert-string-to-integer-or-nil
-def number_or_nil(str)
-  num = str.to_i
-  num if num.to_s == str
-end
+# frozen_string_literal: true
 
-# another helper
-# thanks https://stackoverflow.com/questions/1448670/ruby-stringto-class
-class String
-  def constantize
-    names = split('::')
-    names.shift if names.empty? || names.first.empty?
-
-    const = Object
-    names.each do |name|
-      const = if const.const_defined?(name)
-                const.const_get(name)
-              else
-                const.const_missing(name)
-              end
-    end
-    const
-  end
-end
+require_relative 'model_ext'
 
-module OData
-  # class methods. They Make heavy use of Sequel::Model functionality
-  # we will add this to our Model classes with "extend" --> self is the Class
-  module EntityClassBase
-    SINGLE_PK_URL_REGEXP = /\A\(\s*'?([\w\s]+)'?\s*\)(.*)/.freeze
-    ONLY_INTEGER_RGX = /\A[+-]?\d+\z/.freeze
-
-    attr_reader :nav_collection_url_regexp
-    attr_reader :nav_entity_url_regexp
-    attr_reader :entity_id_url_regexp
-    attr_reader :nav_collection_attribs
-    attr_reader :nav_entity_attribs
-    attr_reader :data_fields
-    attr_reader :inlinecount
-    attr_reader :default_template
-    attr_reader :uri
-    attr_reader :time_cols
-
-    # Sequel associations pointing to this model. Sequel provides association
-    # reflection information on the "from" side. But in some cases
-    # we will need the reverted way
-    # finally not needed and not used yet
-    # attr_accessor :assocs_to
-
-    # set to parent entity in case the collection is a nav.collection
-    # nil otherwise
-    attr_reader :nav_parent
-
-    attr_accessor :namespace
-
-    # dataset
-    attr_accessor :cx
-
-    # url params
-    attr_reader :params
-
-    # url parameters processing object (mostly covert to sequel exprs).
-    # exposed for testing only
-    attr_reader :uparms
-
-    # initialising block of code to be executed at end of
-    # ServerApp.publish_service after all model classes have been registered
-    # (without the associations/relationships)
-    # typically the block should contain the publication of the associations
-    attr_accessor :deferred_iblock
-
-    # convention: entityType is the Ruby Model class --> name is just to_s
-    # Warning: for handling Navigation relations, we use anonymous collection classes
-    # dynamically subtyped from a Model class, and in such an anonymous class
-    # the class-name is not the OData Type. In these subclass we redefine "type_name"
-    # thus when we need the Odata type name, we shall use this method instead of just the collection class name
-    def type_name
-      @type_name
-    end
+module Safrano
+  module OData
+    class Collection
+      attr_accessor :cx
 
-    def build_type_name
-      @type_name = to_s
-    end
+      # url params
+      attr_reader :params
 
-    # convention: default for entity_set_name is the type name
-    def entity_set_name
-      @entity_set_name = (@entity_set_name || type_name)
-    end
+      # url parameters processing object (mostly convert to sequel exprs).
+      # exposed for testing only
+      attr_reader :uparms
 
-    def reset
-      # TODO: automatically reset all attributes?
-      @deferred_iblock = nil
-      @entity_set_name = nil
-      @uri = nil
-      @uparms = nil
-      @params = nil
-      @cx = nil
-      @@time_cols = nil
-    end
+      attr_reader :inlinecount
 
-    def build_uri(uribase)
-      @uri = "#{uribase}/#{entity_set_name}"
-    end
+      attr_reader :modelk
 
-    def execute_deferred_iblock
-      instance_eval { @deferred_iblock.call } if @deferred_iblock
-    end
-
-    # Factory json-> Model Object instance
-    def new_from_hson_h(hash)
-      enty = new
-      enty.set_fields(hash, @data_fields, missing: :skip)
-      enty
-    end
-
-    CREATE_AND_SAVE_ENTY_AND_REL = lambda do |new_entity, assoc, parent|
-      # in-changeset requests get their own transaction
-      case assoc[:type]
-      when :one_to_many, :one_to_one
-        OData.create_nav_relation(new_entity, assoc, parent)
-        new_entity.save(transaction: false)
-      when :many_to_one
-        new_entity.save(transaction: false)
-        OData.create_nav_relation(new_entity, assoc, parent)
-        parent.save(transaction: false)
-        # else # not supported
+      def initialize(modelk)
+        @modelk = modelk
       end
-    end
-    def odata_create_save_entity_and_rel(req, new_entity, assoc, parent)
-      if req.in_changeset
-        # in-changeset requests get their own transaction
-        CREATE_AND_SAVE_ENTY_AND_REL.call(new_entity, assoc, parent)
-      else
-        db.transaction do
-          CREATE_AND_SAVE_ENTY_AND_REL.call(new_entity, assoc, parent)
-        end
-      end
-    end
-
-    def odata_get_inlinecount_w_sequel
-      return unless (icp = @params['$inlinecount'])
-
-      @inlinecount = if icp == 'allpages'
-                       if is_a? Sequel::Model::ClassMethods
-                         @cx.count
-                       else
-                         @cx.dataset.count
-                       end
-                     end
-    end
-
-    def attrib_path_valid?(path)
-      @attribute_path_list.include? path
-    end
-
-    def odata_get_apply_params
-      @cx = @uparms.apply_to_dataset(@cx)
-      odata_get_inlinecount_w_sequel
-
-      @cx = @cx.offset(@params['$skip']) if @params['$skip']
-      @cx = @cx.limit(@params['$top']) if @params['$top']
-      @cx
-    end
-
-    # url params validation methods.
-    # nil is the expected return for no errors
-    # an error class is returned in case of errors
-    # this way we can combine multiple validation calls with logical ||
-    def check_u_p_top
-      return unless @params['$top']
-
-      itop = number_or_nil(@params['$top'])
-      return BadRequestError if itop.nil? || itop.zero?
-    end
-
-    def check_u_p_skip
-      return unless @params['$skip']
-
-      iskip = number_or_nil(@params['$skip'])
-      return BadRequestError if iskip.nil? || iskip.negative?
-    end
-
-    def check_u_p_inlinecount
-      return unless (icp = @params['$inlinecount'])
-
-      return BadRequestInlineCountParamError unless (icp == 'allpages') || (icp == 'none')
 
-      nil
-    end
-
-    def check_u_p_filter
-      @uparms.check_filter
-    end
-
-    def check_u_p_orderby
-      @uparms.check_order
-    end
-
-    def check_u_p_expand
-      @uparms.check_expand
-    end
-
-    def build_attribute_path_list
-      @attribute_path_list = attribute_path_list
-    end
-
-    MAX_DEPTH = 6
-    def attribute_path_list(depth = 0)
-      ret = @columns.map(&:to_s)
-      # break circles
-      return ret if depth > MAX_DEPTH
-
-      depth += 1
-
-      @nav_entity_attribs&.each do |a, k|
-        ret.concat(k.attribute_path_list(depth).map { |kc| "#{a}/#{kc}" })
-      end
-      @nav_collection_attribs&.each do |a, k|
-        ret.concat(k.attribute_path_list(depth).map { |kc| "#{a}/#{kc}" })
+      def allowed_transitions
+        @modelk.allowed_transitions
       end
-      ret
-    end
-
-    def check_url_params
-      return nil unless @params
-
-      check_u_p_top || check_u_p_skip || check_u_p_orderby ||
-        check_u_p_filter || check_u_p_expand || check_u_p_inlinecount
-    end
-
-    def initialize_dataset
-      @cx = self
-      @cx = navigated_dataset if @cx.nav_parent
-      @model = if @cx.respond_to? :model
-                 @cx.model
-               else
-                 @cx
-               end
-      @uparms = UrlParameters4Coll.new(@model, @params)
-    end
 
-    # finally return the requested output according to format, options etc
-    def odata_get_output(req)
-      return @error.odata_get(req) if @error
-
-      if req.walker.do_count
-        [200, CT_TEXT, @cx.count.to_s]
-      elsif req.accept?(APPJSON)
-        if req.walker.do_links
-          [200, CT_JSON, [to_odata_links_json(service: req.service)]]
-        else
-          [200, CT_JSON, [to_odata_json(service: req.service)]]
-        end
-      else # TODO: other formats
-        406
+      def transition_end(_match_result)
+        Safrano::Transition::RESULT_END
       end
-    end
-
-    # validation/error handling methods.
-    # normal processing is done in the passed proc
 
-    def with_validated_get(req)
-      begin
-        initialize_dataset
-        return yield unless (@error = check_url_params)
-      rescue OData::Filter::Parser::ErrorWrongColumnName
-        @error = BadRequestFilterParseError
-      rescue OData::Filter::Parser::ErrorFunctionArgumentType
-        @error = BadRequestFilterParseError
-      rescue OData::Filter::FunctionNotImplemented => e
-        @error = e.odata_error
-      rescue OData::Filter::Parser::ErrorInvalidFunction => e
-        @error = e.odata_error
+      def transition_count(_match_result)
+        [self, :end_with_count]
       end
 
-      @error.odata_get(req) if @error
-    end
-
-    # on model class level we return the collection
-    def odata_get(req)
-      @params = req.params
-
-      with_validated_get(req) do
-        odata_get_apply_params
-        odata_get_output(req)
+      ###########################################################
+      # this is redefined in NavigatedCollection
+      def dataset
+        @modelk.dataset
       end
-    end
-
-    def odata_post(req)
-      odata_create_entity_and_relation(req, @navattr_reflection, @nav_parent)
-    end
 
-    # add metadata xml to the passed REXML schema object
-    def add_metadata_rexml(schema)
-      enty = if @media_handler
-               schema.add_element('EntityType', 'Name' => to_s, 'HasStream' => 'true')
-             else
-               schema.add_element('EntityType', 'Name' => to_s)
-             end
-      # with their properties
-      db_schema.each do |pnam, prop|
-        if prop[:primary_key] == true
-          enty.add_element('Key').add_element('PropertyRef',
-                                              'Name' => pnam.to_s)
+      def transition_id(match_result)
+        if (rawid = match_result[1])
+          @modelk.parse_odata_key(rawid).tap_error do
+            return Safrano::Transition::RESULT_BAD_REQ_ERR
+          end.if_valid do |casted_id|
+            (y = find_by_odata_key(casted_id)) ? [y, :run] : Safrano::Transition::RESULT_NOT_FOUND_ERR
+          end
+        else
+          Safrano::Transition::RESULT_SERVER_TR_ERR
         end
-        attrs = { 'Name' => pnam.to_s,
-                  'Type' => OData.get_edm_type(db_type: prop[:db_type]) }
-        attrs['Nullable'] = 'false' if prop[:allow_null] == false
-        enty.add_element('Property', attrs)
       end
-      enty
-    end
 
-    # metadata REXML data  for a single Nav attribute
-    def metadata_nav_rexml_attribs(assoc, to_klass, relman, xnamespace)
-      from = type_name
-      to = to_klass.type_name
-      relman.get_metadata_xml_attribs(from,
-                                      to,
-                                      association_reflection(assoc.to_sym)[:type],
-                                      xnamespace,
-                                      assoc)
-    end
-
-    # and their Nav attributes == Sequel Model association
-    def add_metadata_navs_rexml(schema_enty, relman, xnamespace)
-      @nav_entity_attribs&.each do |ne, klass|
-        nattr = metadata_nav_rexml_attribs(ne,
-                                           klass,
-                                           relman,
-                                           xnamespace)
-        schema_enty.add_element('NavigationProperty', nattr)
+      # pkid can be a single value for single-pk models,  or an array.
+      # type checking/convertion is done in check_odata_key_type
+      def find_by_odata_key(pkid)
+        lkup = @modelk.pk_lookup_expr(pkid)
+        dataset[lkup]
       end
 
-      @nav_collection_attribs&.each do |nc, klass|
-        nattr = metadata_nav_rexml_attribs(nc,
-                                           klass,
-                                           relman,
-                                           xnamespace)
-        schema_enty.add_element('NavigationProperty', nattr)
+      def initialize_dataset(dtset = nil)
+        @cx = dtset || @modelk
+        @uparms = UrlParameters4Coll.new(@cx, @params)
       end
-    end
 
-    D = 'd'.freeze
-    DJ_OPEN = '{"d":'.freeze
-    DJ_CLOSE = '}'.freeze
-    def to_odata_links_json(service:)
-      innerj = service.get_coll_odata_links_h(array: @cx.all,
-                                              icount: @inlinecount).to_json
-      "#{DJ_OPEN}#{innerj}#{DJ_CLOSE}"
-    end
-
-    #    def output_template(expand: nil, select: nil)
-    def output_template(uparms)
-      #      output_template_deep(expand_list: expand_list, select: select)
-      output_template_deep(expand_list: uparms.expand.template, select: uparms.select)
-    end
-
-    # Recursive
-    def output_template_deep(expand_list:, select: OData::SelectBase::ALL)
-      return default_template if expand_list.empty? && select.all_props?
-
-      template = {}
-      expand_e = {}
-      expand_c = {}
-      deferr = []
-
-      # 1. handle non-navigation properties, only consider $select
-      # 2. handle navigations properties, need to check $select and $expand
-      if select.all_props?
-        template[:all_values] = EMPTYH
-        # include all nav attributes -->
-        @nav_entity_attribs&.each do |attr, klass|
-          if expand_list.key?(attr)
-            expand_e[attr] = klass.output_template_deep(expand_list: expand_list[attr])
-          else
-            deferr << attr
-          end
-        end
-
-        @nav_collection_attribs&.each do |attr, klass|
-          if expand_list.key?(attr)
-            expand_c[attr] = klass.output_template_deep(expand_list: expand_list[attr])
-          else
-            deferr << attr
+      def odata_get_apply_params
+        @uparms.apply_to_dataset(@cx).map_result! do |dataset|
+          @cx = dataset
+          odata_get_inlinecount_w_sequel
+          if (skipp = @params['$skip'])
+            @cx = @cx.offset(skipp) if skipp != '0'
           end
-        end
+          @cx = @cx.limit(@params['$top']) if @params['$top']
 
-      else
-        template[:selected_vals] = @columns.map(&:to_s) & select.props
-        # include only selected nav attribs-->need additional intersection step
-        if @nav_entity_attribs
-          selected_nav_e = @nav_entity_attribs.keys & select.props
-
-          selected_nav_e&.each do |attr|
-            if expand_list.key?(attr)
-              klass = @nav_entity_attribs[attr]
-              expand_e[attr] = klass.output_template_deep(expand_list: expand_list[attr])
-            else
-              deferr << attr
-            end
-          end
-        end
-        if @nav_collection_attribs
-          selected_nav_c = @nav_collection_attribs.keys & select.props
-          selected_nav_c&.each do |attr|
-            if expand_list.key?(attr)
-              klass = @nav_collection_attribs[attr]
-              expand_c[attr] = klass.output_template_deep(expand_list: expand_list[attr])
-            else
-              deferr << attr
-            end
-          end
+          @cx
         end
       end
-      template[:expand_e] = expand_e if expand_e
-      template[:expand_c] = expand_c if expand_c
-      template[:deferr] = deferr if deferr
-      template
-    end
 
-    def to_odata_json(service:)
-      template = output_template(@uparms)
-      innerj = service.get_coll_odata_h(array: @cx.all,
-                                        template: template,
-                                        icount: @inlinecount).to_json
-      "#{DJ_OPEN}#{innerj}#{DJ_CLOSE}"
-    end
+      D = 'd'.freeze
+      DJ_OPEN = '{"d":'.freeze
+      DJ_CLOSE = '}'.freeze
+      EMPTYH = {}.freeze
 
-    # this functionally similar to the Sequel Rels (many_to_one etc)
-    # We need to base this on the Sequel rels, or extend them
-    def add_nav_prop_collection(assoc_symb, attr_name_str = nil)
-      @nav_collection_attribs = (@nav_collection_attribs || {})
-      # DONE: Error handling. This requires that associations
-      # have been properly defined with Sequel before
-      assoc = all_association_reflections.find do |a|
-        a[:name] == assoc_symb && a[:model] == self
+      def to_odata_json(request:)
+        template = @modelk.output_template(expand_list: @uparms.expand.template,
+                                           select: @uparms.select)
+        innerj = request.service.get_coll_odata_h(array: @cx.all,
+                                                  template: template,
+                                                  icount: @inlinecount).to_json
+        "#{DJ_OPEN}#{innerj}#{DJ_CLOSE}"
       end
 
-      raise OData::API::ModelAssociationNameError.new(self, assoc_symb) unless assoc
-
-      attr_class = assoc[:class_name].constantize
-      lattr_name_str = (attr_name_str || assoc_symb.to_s)
-      @nav_collection_attribs[lattr_name_str] = attr_class
-      @nav_collection_url_regexp = @nav_collection_attribs.keys.join('|')
-    end
-
-    def add_nav_prop_single(assoc_symb, attr_name_str = nil)
-      @nav_entity_attribs = (@nav_entity_attribs || {})
-      # DONE: Error handling. This requires that associations
-      # have been properly defined with Sequel before
-      assoc = all_association_reflections.find do |a|
-        a[:name] == assoc_symb && a[:model] == self
+      def to_odata_links_json(service:)
+        innerj = service.get_coll_odata_links_h(array: @cx.all,
+                                                icount: @inlinecount).to_json
+        "#{DJ_OPEN}#{innerj}#{DJ_CLOSE}"
       end
 
-      raise OData::API::ModelAssociationNameError.new(self, assoc_symb) unless assoc
-
-      attr_class = assoc[:class_name].constantize
-      lattr_name_str = (attr_name_str || assoc_symb.to_s)
-      @nav_entity_attribs[lattr_name_str] = attr_class
-      @nav_entity_url_regexp = @nav_entity_attribs.keys.join('|')
-    end
+      def odata_get_inlinecount_w_sequel
+        return unless (icp = @params['$inlinecount'])
 
-    EMPTYH = {}.freeze
-
-    def build_default_template
-      template = { all_values: EMPTYH }
-      if @nav_entity_attribs || @nav_collection_attribs
-        template[:deferr] = (@nav_entity_attribs&.keys || []) + (@nav_collection_attribs&.keys || EMPTY_ARRAY)
+        @inlinecount = if icp == 'allpages'
+                         if @modelk.is_a? Sequel::Model::ClassMethods
+                           @cx.count
+                         else
+                           @cx.dataset.count
+                         end
+                       end
       end
-      template
-    end
-    # old names...
-    #    alias_method :add_nav_prop_collection, :addNavCollectionAttrib
-    #    alias_method :add_nav_prop_single, :addNavEntityAttrib
-
-    def finalize_publishing
-      build_type_name
 
-      # finalize media handler
-      @media_handler.register(self) if @media_handler
-
-      # build default output template structure
-      @default_template = build_default_template
-
-      # Time columns
-      @time_cols = db_schema.select { |c, v| v[:type] == :datetime }.map { |c, v| c }
-
-      # and finally build the path list and allowed tr's
-      build_attribute_path_list
+      # finally return the requested output according to format, options etc
+      def odata_get_output(req)
+        output = if req.walker.do_count
+                   [200, CT_TEXT, @cx.count.to_s]
+                 elsif req.accept?(APPJSON)
+                   # json is default content type so we dont need to specify it here again
+                   if req.walker.do_links
+                     [200, EMPTYH, [to_odata_links_json(service: req.service)]]
+                   else
+                     [200, EMPTYH, [to_odata_json(request: req)]]
+                   end
+                 else # TODO: other formats
+                   406
+                 end
+        Contract.valid(output)
+      end
+
+      # on model class level we return the collection
+      def odata_get(req)
+        @params = req.params
+        initialize_dataset
 
-      build_allowed_transitions
-      build_entity_allowed_transitions
-    end
+        @uparms.check_all.if_valid { |_ret|
+          odata_get_apply_params.if_valid { |_ret|
+            odata_get_output(req)
+          }
+        }.tap_error { |e| return e.odata_get(req) }.result
+      end
 
-    def prepare_pk
-      if primary_key.is_a? Array
-        @pk_names = []
-        primary_key.each { |pk| @pk_names << pk.to_s }
-        # TODO: better handle quotes based on type
-        # (stringlike--> quote, int-like --> no quotes)
-
-        iuk = @pk_names.map { |pk| "#{pk}='?(\\w+)'?" }
-        @iuk_rgx = /\A#{iuk.join(',\s*')}\z/
-
-        iuk = @pk_names.map { |pk| "#{pk}='?\\w+'?" }
-        @entity_id_url_regexp = /\A\(\s*(#{iuk.join(',\s*')})\s*\)(.*)/
-      else
-        @pk_names = [primary_key.to_s]
-        @entity_id_url_regexp = SINGLE_PK_URL_REGEXP
+      def odata_post(req)
+        @modelk.odata_create_entity_and_relation(req)
       end
     end
 
-    def prepare_fields
-      @data_fields = db_schema.map do |col, cattr|
-        cattr[:primary_key] ? nil : col
-      end.select { |col| col }
-    end
+    class NavigatedCollection < Collection
+      include Safrano::NavigationInfo
 
-    def invalid_hash_data?(data)
-      data.keys.map(&:to_sym).find { |ksym| !(@columns.include? ksym) }
-    end
+      def initialize(childattrib, parent)
+        childklass = parent.class.nav_collection_attribs[childattrib]
 
-    ## A regexp matching all allowed attributes of the Entity
-    ## (eg ID|name|size etc... ) at start position and returning the rest
-    def transition_attribute_regexp
-      #      db_schema.map { |sch| sch[0] }.join('|')
-      # @columns is from Sequel Model
-      %r{\A/(#{@columns.join('|')})(.*)\z}
-    end
+        super(childklass)
+        @parent = parent
 
-    # pkid can be a single value for single-pk models,  or an array.
-    # type checking/convertion is done in check_odata_key_type
-    def find_by_odata_key(pkid)
-      # amazingly this works as expected from an Entity.get_related(...) anonymous class
-      # without need to redefine primary_key_lookup (returns nil for valid but unrelated keys)
-      primary_key_lookup(pkid)
-    end
+        set_relation_info(@parent, childattrib)
 
-    # super-minimal type check, but better as nothing
-    def check_odata_val_type(val, type)
-      case type
-      when :integer
-        val =~ ONLY_INTEGER_RGX ? [true, Integer(val)] : [false, val]
-      when :string
-        [true, val]
-      else
-        [true, val] # todo...
-      end
-    rescue StandardError
-      [false, val]
-    end
+        @child_method = parent.method(childattrib.to_sym)
+        @child_dataset_method = parent.method("#{childattrib}_dataset".to_sym)
 
-    # methods related to transitions to next state (cf. walker)
-    module Transitions
-      def transition_end(_match_result)
-        [nil, :end]
+        @cx = navigated_dataset
       end
 
-      def transition_count(_match_result)
-        [self, :end_with_count]
+      def odata_post(req)
+        @modelk.odata_create_entity_and_relation(req,
+                                                 @navattr_reflection,
+                                                 @nav_parent)
       end
 
-      def transition_id(match_result)
-        if (id = match_result[1])
-
-          ck, casted_id = check_odata_key(id)
-
-          if ck
-            if (y = find_by_odata_key(casted_id))
-              [y, :run]
-            else
-              [nil, :error, ErrorNotFound]
-            end
-          else
-            [nil, :error, BadRequestError]
-          end
-        else
-          [nil, :error, ServerTransitionError]
-        end
+      def initialize_dataset(dtset = nil)
+        @cx = dtset || navigated_dataset
+        @uparms = UrlParameters4Coll.new(@cx, @params)
       end
+      # redefinitions of the main methods for a navigated collection
+      # (eg. all Books of Author[2]  is Author[2].Books.all )
 
-      def allowed_transitions
-        @allowed_transitions
+      def all
+        @child_method.call
       end
 
-      def entity_allowed_transitions
-        @entity_allowed_transitions
+      def count
+        @child_method.call.count
       end
 
-      def build_allowed_transitions
-        @allowed_transitions = [Safrano::TransitionEnd,
-                                Safrano::TransitionCount,
-                                Safrano::Transition.new(entity_id_url_regexp,
-                                                        trans: 'transition_id')].freeze
+      def dataset
+        @child_dataset_method.call
       end
 
-      def build_entity_allowed_transitions
-        @entity_allowed_transitions = [
-          Safrano::TransitionEnd,
-          Safrano::TransitionCount,
-          Safrano::TransitionLinks,
-          Safrano::TransitionValue,
-          Safrano::Transition.new(transition_attribute_regexp, trans: 'transition_attribute')
-        ]
-        if (ncurgx = @nav_collection_url_regexp)
-          @entity_allowed_transitions <<
-            Safrano::Transition.new(%r{\A/(#{ncurgx})(.*)\z}, trans: 'transition_nav_collection')
-        end
-        if (neurgx = @nav_entity_url_regexp)
-          @entity_allowed_transitions <<
-            Safrano::Transition.new(%r{\A/(#{neurgx})(.*)\z}, trans: 'transition_nav_entity')
-        end
-        @entity_allowed_transitions.freeze
-        @entity_allowed_transitions
+      def navigated_dataset
+        @child_dataset_method.call
       end
-    end
-    include Transitions
-  end
 
-  # special handling for composite key
-  module EntityClassMultiPK
-    include EntityClassBase
-    # input  fx='aas',fy_w='0001'
-    # output true, ['aas', '0001'] ... or false when typ-error
-    def check_odata_key(mid)
-      # @iuk_rgx is (needs to be) built on start with
-      # collklass.prepare_pk
-      md = @iuk_rgx.match(mid).to_a
-      md.shift # remove first element which is the whole match
-      mdc = []
-      error = false
-      primary_key.each_with_index do |pk, i|
-        ck, casted = check_odata_val_type(md[i], db_schema[pk][:type])
-        if ck
-          mdc << casted
-        else
-          error = true
-          break
-        end
+      def each
+        y = @child_method.call
+        y.each { |enty| yield enty }
       end
-      if error
-        [false, md]
-      else
-        [true, mdc]
-      end
-    end
-  end
-
-  # special handling for single key
-  module EntityClassSinglePK
-    include EntityClassBase
 
-    def check_odata_key(id)
-      check_odata_val_type(id, db_schema[primary_key][:type])
-    end
-  end
-
-  # normal handling for non-media entity
-  module EntityClassNonMedia
-    # POST for non-media entity collection -->
-    # 1. Create and add entity from payload
-    # 2. Create relationship if needed
-    def odata_create_entity_and_relation(req, assoc, parent)
-      # TODO: this is for v2 only...
-      req.with_parsed_data do |data|
-        data.delete('__metadata')
-        # validate payload column names
-        if (invalid = invalid_hash_data?(data))
-          ::OData::Request::ON_CGST_ERROR.call(req)
-          return [422, EMPTY_HASH, ['Invalid attribute name: ', invalid.to_s]]
-        end
-
-        if req.accept?(APPJSON)
-          new_entity = new_from_hson_h(data)
-          if parent
-            odata_create_save_entity_and_rel(req, new_entity, assoc, parent)
-          else
-            # in-changeset requests get their own transaction
-            new_entity.save(transaction: !req.in_changeset)
-          end
-          req.register_content_id_ref(new_entity)
-          new_entity.copy_request_infos(req)
-
-          [201, CT_JSON, new_entity.to_odata_post_json(service: req.service)]
-        else # TODO: other formats
-          415
-        end
+      def to_a
+        y = @child_method.call
+        y.to_a
       end
     end
   end