safrano 0.4.0 → 0.4.5

data/lib/safrano/{odata_rack_builder.rb → rack_builder.rb}

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'rack'
 require 'rack/cors'
 
 module Rack
-  module OData
+  module Safrano
     # just a Wrapper to ensure (force?) that mandatory middlewares are acutally
     # used
     class Builder < ::Rack::Builder
@@ -10,9 +12,23 @@ module Rack
         super(default_app) {}
         use ::Rack::Cors
         instance_eval(&block) if block_given?
-        use ::Rack::Lint
         use ::Rack::ContentLength
       end
     end
   end
 end
+
+# deprecated
+# REMOVE 0.6
+module Rack
+  module OData
+    class Builder < ::Rack::Safrano::Builder
+      def initialize(default_app = nil, &block)
+        ::Safrano::Deprecation.deprecate('Rack::OData::Builder',
+                                         'Use Rack::Safrano::Builder instead')
+
+        super
+      end
+    end
+  end
+end

data/lib/safrano/request.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require 'rack'
 require 'rfc2047'
 
-module OData
+module Safrano
   # monkey patch deactivate Rack/multipart because it does not work on simple
   # OData $batch requests when the content-length
   # is not passed
   class Request < Rack::Request
     HEADER_PARAM = /\s*[\w.]+=(?:[\w.]+|"(?:[^"\\]|\\.)*")?\s*/.freeze
-    HEADER_VAL_RAW = '(?:\w+|\*)\/(?:\w+(?:\.|\-|\+)?|\*)*'.freeze
+    HEADER_VAL_RAW = '(?:\w+|\*)\/(?:\w+(?:\.|\-|\+)?|\*)*'
     HEADER_VAL_WITH_PAR = /(?:#{HEADER_VAL_RAW})\s*(?:;#{HEADER_PARAM})*/.freeze
     ON_CGST_ERROR = (proc { |r| raise(Sequel::Rollback) if r.in_changeset })
 
@@ -15,6 +17,7 @@ module OData
     class AcceptEntry
       attr_accessor :params
       attr_reader :entry
+
       def initialize(entry)
         params = entry.scan(HEADER_PARAM).map! do |s|
           key, value = s.strip.split('=', 2)
@@ -94,7 +97,9 @@ module OData
     end
 
     def create_odata_walker
-      @env['safrano.walker'] = @walker = Walker.new(@service, path_info, @content_id_references)
+      @env['safrano.walker'] = @walker = Walker.new(@service,
+                                                    path_info,
+                                                    @content_id_references)
     end
 
     def accept
@@ -108,13 +113,6 @@ module OData
       end
     end
 
-    def uribase
-      return @uribase if @uribase
-
-      @uribase =
-        "#{env['rack.url_scheme']}://#{env['HTTP_HOST']}#{service.xpath_prefix}"
-    end
-
     def accept?(type)
       preferred_type(type).to_s.include?(type)
     end
@@ -134,14 +132,14 @@ module OData
 
     def with_media_data
       if (filename = @env['HTTP_SLUG'])
-        
-        yield @env['rack.input'], 
+
+        yield @env['rack.input'],
                content_type.split(';').first,
                Rfc2047.decode(filename)
 
       else
         ON_CGST_ERROR.call(self)
-        return [400, {}, ['File upload error: Missing SLUG']]
+        [400, EMPTY_HASH, ['File upload error: Missing SLUG']]
       end
     end
 
@@ -152,56 +150,109 @@ module OData
           data = JSON.parse(body.read)
         rescue JSON::ParserError => e
           ON_CGST_ERROR.call(self)
-          return [400, {}, ['JSON Parser Error while parsing payload : ',
-                            e.message]]
+          return [400, EMPTY_HASH, ['JSON Parser Error while parsing payload : ',
+                                    e.message]]
         end
 
         yield data
 
       else # TODO: other formats
 
-        [415, {}, []]
+        [415, EMPTY_HASH, EMPTY_ARRAY]
       end
     end
 
-    def negotiate_service_version
-      maxv = if (rqv = env['HTTP_MAXDATASERVICEVERSION'])
-               OData::ServiceBase.parse_data_service_version(rqv)
-             else
-               OData::MAX_DATASERVICE_VERSION
-             end
-      return OData::BadRequestError if maxv.nil?
-      # client request an too old version --> 501
-      return OData::NotImplementedError if maxv < OData::MIN_DATASERVICE_VERSION
-
-      minv = if (rqv = env['HTTP_MINDATASERVICEVERSION'])
-               OData::ServiceBase.parse_data_service_version(rqv)
-             else
-               OData::MIN_DATASERVICE_VERSION
-             end
-      return OData::BadRequestError if minv.nil?
-      # client request an too new version --> 501
-      return OData::NotImplementedError if minv > OData::MAX_DATASERVICE_VERSION
-      return OData::BadRequestError if minv > maxv
-
-      v = if (rqv = env['HTTP_DATASERVICEVERSION'])
-            OData::ServiceBase.parse_data_service_version(rqv)
+    # input is the       DataServiceVersion request header string, eg.
+    # '2.0;blabla' ---> Version -> 2
+    DATASERVICEVERSION_RGX = /\A([1234])(?:\.0);*\w*\z/.freeze
+
+    MAX_DTSV_PARSE_ERROR = Safrano::BadRequestError.new(
+      'MaxDataServiceVersion could not be parsed'
+    ).freeze
+    def get_maxversion
+      if (rqv = env['HTTP_MAXDATASERVICEVERSION'])
+        if (m = DATASERVICEVERSION_RGX.match(rqv))
+          # client request an too old version --> 501
+          if (maxv = m[1]) < Safrano::MIN_DATASERVICE_VERSION
+            Safrano::VersionNotImplementedError
           else
-            OData::MAX_DATASERVICE_VERSION
+            Contract.valid(maxv)
           end
+        else
+          MAX_DTSV_PARSE_ERROR
+        end
+      else
+        # not provided in request header --> take ours
+        Safrano::CV_MAX_DATASERVICE_VERSION
+      end
+    end
 
-      return OData::BadRequestError if v.nil?
-      return OData::NotImplementedError if v > OData::MAX_DATASERVICE_VERSION
-      return OData::NotImplementedError if v < OData::MIN_DATASERVICE_VERSION
-
-      @service = nil
-      @service = case maxv
-                 when '1'
-                   @service_base.v1
-                 when '2', '3', '4'
-                   @service_base.v2
-                 end
-      nil
+    DTSV_PARSE_ERROR = Safrano::BadRequestError.new(
+      'DataServiceVersion could not be parsed'
+    ).freeze
+    def get_version
+      if (rqv = env['HTTP_DATASERVICEVERSION'])
+        if (m = DATASERVICEVERSION_RGX.match(rqv))
+          # client request an too new version --> 501
+          if ((v = m[1]) > Safrano::MAX_DATASERVICE_VERSION) ||
+             (v < Safrano::MIN_DATASERVICE_VERSION)
+            Safrano::VersionNotImplementedError
+          else
+            Contract.valid(v)
+          end
+        else
+          DTSV_PARSE_ERROR
+        end
+      else
+        # not provided in request header --> take our maxv
+        Safrano::CV_MAX_DATASERVICE_VERSION
+      end
+    end
+
+    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))
+          # client request an too new version --> 501
+          if (minv = m[1]) > Safrano::MAX_DATASERVICE_VERSION
+            Safrano::VersionNotImplementedError
+          else
+            Contract.valid(minv)
+          end
+        else
+          MIN_DTSV_PARSE_ERROR
+        end
+      else
+        # not provided in request header --> take ours
+        Safrano::CV_MIN_DATASERVICE_VERSION
+      end
+    end
+
+    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|
+          return MAX_LT_MIN_DTSV_ERROR if minv > maxv
+
+          get_version.if_valid do |v|
+            @service = nil
+            @service = case maxv
+                       when '1'
+                         @service_base.v1
+                       when '2', '3', '4'
+                         @service_base.v2
+                       else
+                         return Safrano::VersionNotImplementedError
+                       end
+
+            Contract::OK
+          end # valid get_version
+        end # valid get_minversion
+      end # valid get_maxversion
     end
   end
 end

data/lib/safrano/response.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'rack'
 
 # monkey patch deactivate Rack/multipart because it does not work on simple
 # OData $batch requests when the content-length is not passed
-module OData
+module Safrano
   # borrowed fro Sinatra
   # The response object. See Rack::Response and Rack::Response::Helpers for
   # more info:
@@ -12,7 +14,7 @@ module OData
     DROP_BODY_RESPONSES = [204, 205, 304].freeze
     def initialize(*)
       super
-      headers['Content-Type'] ||= 'text/html'
+      headers[CONTENT_TYPE] ||= APPJSON_UTF8
     end
 
     def body=(value)
@@ -34,7 +36,7 @@ module OData
 
       if drop_body?
         close
-        result = []
+        result = EMPTY_ARRAY
       end
 
       if calculate_content_length?

data/lib/safrano/sequel_join_by_paths.rb

@@ -1,5 +1,5 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require_relative '../sequel/plugins/join_by_paths.rb'
+require_relative '../sequel/plugins/join_by_paths'
 
 Sequel::Model.plugin Sequel::Plugins::JoinByPaths

data/lib/safrano/service.rb

@@ -1,184 +1,118 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'rexml/document'
-require 'odata/relations.rb'
-require 'odata/batch.rb'
-require 'odata/error.rb'
-
-module OData
+require 'odata/relations'
+require 'odata/batch'
+require 'odata/complex_type'
+require 'odata/function_import'
+require 'odata/error'
+require 'odata/filter/sequel'
+require 'set'
+require 'odata/collection'
+
+module Safrano
   # this module has all methods related to expand/defered output preparation
   # and will be included in Service class
   module ExpandHandler
-    PATH_SPLITTER = %r{\A(\w+)\/?(.*)\z}.freeze
-    def get_deferred_odata_h(entity:, attrib:, uribase:)
-      { '__deferred' => { 'uri' => "#{entity.uri(uribase)}/#{attrib}" } }
-    end
-
-    # split expand argument into first and rest part
-    def split_entity_expand_arg(exp_one)
-      if exp_one.include?('/')
-        m = PATH_SPLITTER.match(exp_one)
-        cur_exp = m[1].strip
-        rest_exp = m[2]
-        # TODO: check errorhandling
-        raise OData::ServerError if cur_exp.nil?
+    PATH_SPLITTER = %r{\A(\w+)/?(.*)\z}.freeze
+    DEFERRED = '__deferred'
+    URI = 'uri'
 
-        k = cur_exp.to_sym
-      else
-        k = exp_one.strip.to_sym
-        rest_exp = nil
-      end
-      yield k, rest_exp
+    def get_deferred_odata_h(entity_uri:, attrib:)
+      { DEFERRED => { URI => "#{entity_uri}/#{attrib}" } }
     end
 
     # default v2
     # overriden in ServiceV1
-    def get_coll_odata_h(array:, expand: nil, uribase:, icount: nil)
-      res = array.map do |w|
-        get_entity_odata_h(entity: w,
-                           expand: expand,
-                           uribase: uribase)
-      end
-      if icount
-        { 'results' => res, '__count' => icount }
-      else
-        { 'results' => res }
-      end
-    end
-
-    # for expand 1..n nav attributes
-    # actually same as  v1 get_coll_odata_h
-#    def get_expandcoll_odata_h(array:, expand: nil, uribase:, icount: nil)
-#      array.map do |w|
-#        get_entity_odata_h(entity: w,
-#                           expand: expand,
-#                           uribase: uribase)
-#      end
-#    end
-
-    # handle a single expand
-    def handle_entity_expand_one(entity:, exp_one:, nav_values_h:, nav_coll_h:,
-                                 uribase:)
-
-
-      split_entity_expand_arg(exp_one) do |first, rest_exp|
-         if ( entity.nav_values.has_key?(first) )
-          if (enval = entity.nav_values[first])
-            nav_values_h[first.to_s] = get_entity_odata_h(entity: enval,
-                                                        expand: rest_exp,
-                                                        uribase: uribase)
-          else
-# FK is NULL --> nav_value is nil --> return empty json          
-            nav_values_h[first.to_s] = {}
-          end                                              
-        elsif (encoll = entity.nav_coll[first])
-#           nav attributes that are a collection (x..n)
-           nav_coll_h[first.to_s] = get_coll_odata_h(array: encoll,
-                                                    expand: rest_exp,
-                                                    uribase: uribase)
-#          nav_coll_h[first.to_s] = get_expandcoll_odata_h(array: encoll,
-#                                                    expand: rest_exp,
-#                                                    uribase: uribase)
-
-
-        end
-      end
-    end
-
-    def handle_entity_expand(entity:, expand:, nav_values_h:,
-                             nav_coll_h:, uribase:)
-      expand.strip!
-      explist = expand.split(',')
-      # handle multiple expands
-      explist.each do |exp|
-        handle_entity_expand_one(entity: entity, 
-                                 exp_one: exp,
-                                 nav_values_h: nav_values_h,
-                                 nav_coll_h: nav_coll_h,
-                                 uribase: uribase)
-      end
-    end
-
-    def handle_entity_deferred_attribs(entity:, nav_values_h:,
-                                       nav_coll_h:, uribase:)
-      entity.nav_values.each_key do |ksy|
-        ks = ksy.to_s
-        next if nav_values_h.key?(ks)
-
-        nav_values_h[ks] = get_deferred_odata_h(entity: entity,
-                                                attrib: ks, uribase: uribase)
-      end
-      entity.nav_coll.each_key do |ksy|
-        ks = ksy.to_s
-        next if nav_coll_h.key?(ks)
-
-        nav_coll_h[ks] = get_deferred_odata_h(entity: entity, attrib: ks,
-                                              uribase: uribase)
+    RESULTS_K = 'results'
+    COUNT_K = '__count'
+    def get_coll_odata_h(array:, template:, icount: nil)
+      array.map! do |w|
+        get_entity_odata_h(entity: w, template: template)
       end
+      icount ? { RESULTS_K => array, COUNT_K => icount } : { RESULTS_K => array }
     end
 
     # handle $links ... Note: $expand seems to be ignored when $links
     # are  requested
-    def get_entity_odata_link_h(entity:, uribase:)
-      { uri: entity.uri(uribase) }
-    end
+    def get_entity_odata_link_h(entity:)
+      { uri: entity.uri }
+    end
+
+    EMPTYH = {}.freeze
+    METADATA_K = '__metadata'
+    def get_entity_odata_h(entity:, template:)
+      # start with metadata
+      hres = { METADATA_K => entity.metadata_h }
+
+      template.each do |elmt, arg|
+        case elmt
+        when :all_values
+          hres.merge! entity.casted_values
+
+        when :selected_vals
+          hres.merge! entity.casted_values(arg)
+
+        when :expand_e
+
+          arg.each do |attr, templ|
+            enval = entity.send(attr)
+            hres[attr] = if enval
+                           get_entity_odata_h(entity: enval, template: templ)
+                         else
+                           # FK is NULL --> nav_value is nil --> return empty json
+                           EMPTYH
+                         end
+          end
 
-    def get_entity_odata_h(entity:, expand: nil, uribase:)
-      hres = entity.casted_values
-      hres['__metadata'] = entity.metadata_h(uribase: uribase)
+        when :expand_c
+          arg.each do |attr, templ|
+            next unless  (encoll = entity.send(attr))
 
-      nav_values_h = {}
-      nav_coll_h = {}
+            #  nav attributes that are a collection (x..n)
+            hres[attr] = get_coll_odata_h(array: encoll, template: templ)
+            # else error ?
+          end
 
-      # handle expanded nav attributes
-      unless expand.nil?
-        handle_entity_expand(entity: entity, expand: expand,
-                             nav_values_h: nav_values_h,
-                             nav_coll_h: nav_coll_h,
-                             uribase: uribase)
+        when :deferr
+          euri = entity.uri
+          arg.each do |attr|
+            hres[attr] = get_deferred_odata_h(entity_uri: euri, attrib: attr)
+          end
+        end
       end
-
-      # handle not expanded (deferred) nav attributes
-      handle_entity_deferred_attribs(entity: entity,
-                                     nav_values_h: nav_values_h,
-                                     nav_coll_h: nav_coll_h,
-                                     uribase: uribase)
-      # merge  ...
-      hres.merge!(nav_values_h)
-      hres.merge!(nav_coll_h)
-
       hres
     end
   end
 end
 
-module OData
+module Safrano
   # xml namespace constants needed for the output of XML service and
   # and metadata
   module XMLNS
-    MSFT_ADO = 'http://schemas.microsoft.com/ado'.freeze
-    MSFT_ADO_2009_EDM = "#{MSFT_ADO}/2009/11/edm".freeze
-    MSFT_ADO_2007_EDMX = "#{MSFT_ADO}/2007/06/edmx".freeze
-    MSFT_ADO_2007_META = MSFT_ADO + \
-                         '/2007/08/dataservices/metadata'.freeze
-
-    W3_2005_ATOM = 'http://www.w3.org/2005/Atom'.freeze
-    W3_2007_APP = 'http://www.w3.org/2007/app'.freeze
+    MSFT_ADO = 'http://schemas.microsoft.com/ado'
+    MSFT_ADO_2009_EDM = "#{MSFT_ADO}/2009/11/edm"
+    MSFT_ADO_2007_EDMX = "#{MSFT_ADO}/2007/06/edmx"
+    MSFT_ADO_2007_META = "#{MSFT_ADO}/2007/08/dataservices/metadata"
+
+    W3_2005_ATOM = 'http://www.w3.org/2005/Atom'
+    W3_2007_APP = 'http://www.w3.org/2007/app'
   end
 end
 
 # Link to Model
-module OData
-  MAX_DATASERVICE_VERSION = '2'.freeze
-  MIN_DATASERVICE_VERSION = '1'.freeze
+module Safrano
+  MAX_DATASERVICE_VERSION = '2'
+  MIN_DATASERVICE_VERSION = '1'
+  CV_MAX_DATASERVICE_VERSION = Contract.valid(MAX_DATASERVICE_VERSION).freeze
+  CV_MIN_DATASERVICE_VERSION = Contract.valid(MIN_DATASERVICE_VERSION).freeze
   include XMLNS
   # Base class for service. Subclass will be for V1, V2 etc...
   class ServiceBase
     include Safrano
     include ExpandHandler
 
-    XML_PREAMBLE = '<?xml version="1.0" encoding="utf-8" standalone="yes"?>' + \
-                   "\r\n".freeze
+    XML_PREAMBLE = %Q(<?xml version="1.0" encoding="utf-8" standalone="yes"?>\r\n)
 
     # This is just a hash of entity Set Names to the corresponding Class
     # Example
@@ -196,10 +130,14 @@ module OData
     attr_accessor :xname
     attr_accessor :xnamespace
     attr_accessor :xpath_prefix
-    #    attr_accessor :xuribase
+    attr_accessor :xserver_url
+    attr_accessor :uribase
     attr_accessor :meta
     attr_accessor :batch_handler
     attr_accessor :relman
+    attr_accessor :complex_types
+    attr_accessor :function_imports
+
     # Instance attributes for specialized Version specific Instances
     attr_accessor :v1
     attr_accessor :v2
@@ -213,36 +151,31 @@ module OData
       #  because of the version subclasses that dont use "super" initialise
       # (todo: why not??)
       @meta = ServiceMeta.new(self)
-      @batch_handler = OData::Batch::DisabledHandler.new
-      @relman = OData::RelationManager.new
+      @batch_handler = Safrano::Batch::DisabledHandler.new
+      @relman = Safrano::RelationManager.new
+      @complex_types = Set.new
+      @function_imports = {}
       @cmap = {}
       instance_eval(&block) if block_given?
     end
 
-    DATASERVICEVERSION_RGX = /\A([1234])(?:\.0);*\w*\z/.freeze
     TRAILING_SLASH = %r{/\z}.freeze
     DEFAULT_PATH_PREFIX = '/'
-
-    # input is the       DataServiceVersion request header string, eg.
-    # '2.0;blabla' ---> Version -> 2
-    def self.parse_data_service_version(inp)
-      m = DATASERVICEVERSION_RGX.match(inp)
-      m[1] if m
-    end
+    DEFAULT_SERVER_URL = 'http://localhost:9494'
 
     def enable_batch
-      @batch_handler = OData::Batch::EnabledHandler.new
+      @batch_handler = Safrano::Batch::EnabledHandler.new
       (@v1.batch_handler = @batch_handler) if @v1
       (@v2.batch_handler = @batch_handler) if @v2
     end
 
     def enable_v1_service
-      @v1 = OData::ServiceV1.new
+      @v1 = Safrano::ServiceV1.new
       copy_attribs_to @v1
     end
 
     def enable_v2_service
-      @v2 = OData::ServiceV2.new
+      @v2 = Safrano::ServiceV2.new
       copy_attribs_to @v2
     end
 
@@ -264,59 +197,91 @@ module OData
       (@v1.xpath_prefix = @xpath_prefix) if @v1
       (@v2.xpath_prefix = @xpath_prefix) if @v2
     end
+
+    def server_url(surl)
+      @xserver_url = surl.sub(TRAILING_SLASH, '')
+      (@v1.xserver_url = @xserver_url) if @v1
+      (@v2.xserver_url = @xserver_url) if @v2
+    end
+
     # end public API
 
+    def set_uribase
+      @uribase = if @xpath_prefix.empty?
+                   @xserver_url
+                 elsif @xpath_prefix[0] == '/'
+                   "#{@xserver_url}#{@xpath_prefix}"
+                 else
+                   "#{@xserver_url}/#{@xpath_prefix}"
+                 end
+      (@v1.uribase = @uribase) if @v1
+      (@v2.uribase = @uribase) if @v2
+    end
+
     def copy_attribs_to(other)
       other.cmap = @cmap
       other.collections = @collections
+      other.allowed_transitions = @allowed_transitions
       other.xtitle = @xtitle
       other.xname = @xname
       other.xnamespace = @xnamespace
       other.xpath_prefix = @xpath_prefix
+      other.xserver_url = @xserver_url
+      other.uribase = @uribase
       other.meta = ServiceMeta.new(other) # hum ... #todo: versions as well ?
       other.relman = @relman
       other.batch_handler = @batch_handler
+      other.complex_types = @complex_types
+      other.function_imports = @function_imports
       other
     end
 
+    # this is a central place. We extend Sequel models with OData functionality
+    # The included/extended modules depends on the properties(eg, pks, field types) of the model
+    # we differentiate
+    #  * 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)
       # check that the provided klass is a Sequel Model
-      unless modelklass.is_a? Sequel::Model::ClassMethods
-        raise OData::API::ModelNameError, modelklass
-      end
 
-      if modelklass.ancestors.include? OData::Entity
+      raise(Safrano::API::ModelNameError, modelklass) unless modelklass.is_a? Sequel::Model::ClassMethods
+
+      if modelklass.ancestors.include? Safrano::Entity
         # modules were already added previously;
         # cleanup state to avoid having data from previous calls
         # mostly usefull for testing (eg API)
         modelklass.reset
-      else # first API call... (normal non-testing case)
-        if modelklass.primary_key.is_a?(Array)
-          modelklass.extend OData::EntityClassMultiPK
-          modelklass.include OData::EntityMultiPK
-        else
-          modelklass.extend OData::EntityClassSinglePK
-          modelklass.include OData::EntitySinglePK
-        end
+      elsif modelklass.primary_key.is_a?(Array) # first API call... (normal non-testing case)
+        modelklass.extend Safrano::EntityClassMultiPK
+        modelklass.include Safrano::EntityMultiPK
+      else
+        modelklass.extend Safrano::EntityClassSinglePK
+        modelklass.include Safrano::EntitySinglePK
       end
+
       # Media/Non-media
       if is_media
-        modelklass.extend OData::EntityClassMedia
+        modelklass.extend Safrano::EntityClassMedia
         # set default media handler . Can be overridden later with the
         #  "use HandlerKlass, options" API
 
         modelklass.set_default_media_handler
         modelklass.api_check_media_fields
-        modelklass.include OData::MediaEntity
+        modelklass.include Safrano::MediaEntity
       else
-        modelklass.extend OData::EntityClassNonMedia
-        modelklass.include OData::NonMediaEntity
+        modelklass.extend Safrano::EntityClassNonMedia
+        modelklass.include Safrano::NonMediaEntity
       end
 
       modelklass.prepare_pk
       modelklass.prepare_fields
       esname = (entity_set_name || modelklass).to_s.freeze
-      modelklass.instance_eval { @entity_set_name = esname }
+      serv_namespace = @xnamespace
+      modelklass.instance_eval do
+        @entity_set_name = esname
+        @namespace = serv_namespace
+      end
       @cmap[esname] = modelklass
       set_collections_sorted(@cmap.values)
     end
@@ -337,6 +302,23 @@ module OData
       modelklass.deferred_iblock = block if block_given?
     end
 
+    def publish_complex_type(ctklass)
+      # check that the provided klass is a Safrano ComplexType
+
+      raise(Safrano::API::ComplexTypeNameError, ctklass) unless ctklass.superclass == Safrano::ComplexType
+
+      serv_namespace = @xnamespace
+      ctklass.instance_eval { @namespace = serv_namespace }
+
+      @complex_types.add ctklass
+    end
+
+    def function_import(name)
+      funcimp = Safrano::FunctionImport(name)
+      @function_imports[name] = funcimp
+      funcimp
+    end
+
     def cmap=(imap)
       @cmap = imap
       set_collections_sorted(@cmap.values)
@@ -347,9 +329,7 @@ module OData
     # example: CrewMember must be matched before Crew otherwise we get error
     def set_collections_sorted(coll_data)
       @collections = coll_data
-      if @collections
-        @collections.sort_by! { |klass| klass.entity_set_name.size }.reverse!
-      end
+      @collections.sort_by! { |klass| klass.entity_set_name.size }.reverse! if @collections
       @collections
     end
 
@@ -370,10 +350,32 @@ module OData
       # set default path prefix if path_prefix was not called
       path_prefix(DEFAULT_PATH_PREFIX) unless @xpath_prefix
 
+      # set default server url if server_url was not called
+      server_url(DEFAULT_SERVER_URL) unless @xserver_url
+
+      set_uribase
+
       @collections.each(&:finalize_publishing)
-      
-      #finalize the media handlers
-      @collections.each{|klass| }
+
+      # finalize the uri's and include NoMappingBeforeOutput or MappingBeforeOutput as needed
+      @collections.each do |klass|
+        klass.build_uri(@uribase)
+        klass.include(klass.time_cols.empty? ? Safrano::NoMappingBeforeOutput : Safrano::MappingBeforeOutput)
+      end
+
+      # build allowed transitions (requires that @collections are filled and sorted for having a
+      # correct base_url_regexp)
+      build_allowed_transitions
+
+      # mixin adapter specific modules where needed
+      case Sequel::Model.db.adapter_scheme
+      when :postgres
+        Safrano::Filter::FuncTree.include Safrano::Filter::FuncTreePostgres
+      when :sqlite
+        Safrano::Filter::FuncTree.include Safrano::Filter::FuncTreeSqlite
+      else
+        Safrano::Filter::FuncTree.include Safrano::Filter::FuncTreeDefault
+      end
     end
 
     def execute_deferred_iblocks
@@ -389,19 +391,24 @@ module OData
       @collections.map(&:entity_set_name).join('|')
     end
 
+    def base_url_func_regexp
+      @function_imports.keys.join('|')
+    end
+
     def service
       hres = {}
       hres['d'] = { 'EntitySets' => @collections.map(&:type_name) }
       hres
     end
 
-    def service_xml(req)
+    def service_xml(_req)
       doc = REXML::Document.new
       # separator required ? ?
-      root = doc.add_element('service', 'xml:base' => req.uribase)
+      root = doc.add_element('service', 'xml:base' => @uribase)
 
       root.add_namespace('xmlns:atom', XMLNS::W3_2005_ATOM)
       root.add_namespace('xmlns:app', XMLNS::W3_2007_APP)
+
       # this generates the main xmlns attribute
       root.add_namespace(XMLNS::W3_2007_APP)
       wp = root.add_element 'workspace'
@@ -412,7 +419,7 @@ module OData
       @collections.each do |klass|
         col = wp.add_element('collection', 'href' => klass.entity_set_name)
         ct = col.add_element('atom:title')
-        ct.text = klass.type_name
+        ct.text = klass.entity_set_name
       end
 
       XML_PREAMBLE + doc.to_pretty_xml
@@ -421,10 +428,18 @@ module OData
     def add_metadata_xml_entity_type(schema)
       @collections.each do |klass|
         enty = klass.add_metadata_rexml(schema)
-        klass.add_metadata_navs_rexml(enty, @relman, @xnamespace)
+        klass.add_metadata_navs_rexml(enty, @relman)
       end
     end
 
+    def add_metadata_xml_complex_types(schema)
+      @complex_types.each { |ctklass| ctklass.add_metadata_rexml(schema)   }
+    end
+
+    def add_metadata_xml_function_imports(ec)
+      @function_imports.each_value { |func| func.add_metadata_rexml(ec)    }
+    end
+
     def add_metadata_xml_associations(schema)
       @relman.each_rel do |rel|
         rel.with_metadata_info(@xnamespace) do |name, bdinfo|
@@ -447,7 +462,7 @@ module OData
         # 3.a Entity set's
         ec.add_element('EntitySet',
                        'Name' => klass.entity_set_name,
-                       'EntityType' => "#{@xnamespace}.#{klass.type_name}")
+                       'EntityType' => klass.type_name)
       end
       # 3.b Association set's
       @relman.each_rel do |rel|
@@ -461,6 +476,9 @@ module OData
           assoc.add_element('End', assoend)
         end
       end
+
+      # 4 function imports
+      add_metadata_xml_function_imports(ec)
     end
 
     def metadata_xml(_req)
@@ -494,9 +512,12 @@ module OData
       schema = serv.add_element('Schema',
                                 'Namespace' => @xnamespace,
                                 'xmlns' => XMLNS::MSFT_ADO_2009_EDM)
-      # 1. all EntityType
+      # 1. a. all EntityType
       add_metadata_xml_entity_type(schema)
 
+      # 1. b. all ComplexType
+      add_metadata_xml_complex_types(schema)
+
       # 2. Associations
       add_metadata_xml_associations(schema)
 
@@ -508,20 +529,45 @@ module OData
 
     # methods related to transitions to next state (cf. walker)
     module Transitions
-      DOLLAR_ID_REGEXP = Regexp.new('\A\/\$').freeze
+      DOLLAR_ID_REGEXP = Regexp.new('\A\/\$')
+      ALLOWED_TRANSITIONS_FIXED = [
+        Safrano::TransitionEnd,
+        Safrano::TransitionMetadata,
+        Safrano::TransitionBatch,
+        Safrano::TransitionContentId
+      ].freeze
+
+      def build_allowed_transitions
+        @allowed_transitions = if @function_imports.empty?
+                                 (ALLOWED_TRANSITIONS_FIXED + [
+                                   Safrano::Transition.new(%r{\A/(#{base_url_regexp})(.*)},
+                                                           trans: 'transition_collection')
+                                 ]).freeze
+                               else
+                                 (ALLOWED_TRANSITIONS_FIXED + [
+                                   Safrano::Transition.new(%r{\A/(#{base_url_regexp})(.*)},
+                                                           trans: 'transition_collection'),
+                                   Safrano::Transition.new(%r{\A/(#{base_url_func_regexp})(.*)},
+                                                           trans: 'transition_service_op')
+                                 ]).freeze
+                               end
+      end
+
       def allowed_transitions
-        @allowed_transitions = [
-          Safrano::TransitionEnd,
-          Safrano::TransitionMetadata,
-          Safrano::TransitionBatch,
-          Safrano::TransitionContentId,
-          Safrano::Transition.new(%r{\A/(#{base_url_regexp})(.*)},
-                                  trans: 'transition_collection')
-        ]
+        @allowed_transitions
+      end
+
+      def thread_safe_collection(collklass)
+        Safrano::OData::Collection.new(collklass)
       end
 
       def transition_collection(match_result)
-        [@cmap[match_result[1]], :run] if match_result[1]
+        [thread_safe_collection(@cmap[match_result[1]]), :run] if match_result[1]
+        #        [@cmap[match_result[1]], :run] if match_result[1]
+      end
+
+      def transition_service_op(match_result)
+        [@function_imports[match_result[1]], :run] if match_result[1]
       end
 
       def transition_batch(_match_result)
@@ -537,7 +583,7 @@ module OData
       end
 
       def transition_end(_match_result)
-        [nil, :end]
+        Safrano::Transition::RESULT_END
       end
     end
 
@@ -545,14 +591,11 @@ module OData
 
     def odata_get(req)
       if req.accept?(APPXML)
-        #  app.headers  'Content-Type' => 'application/xml;charset=utf-8'
-        # Doc: 2.2.3.7.1 Service Document  As per [RFC5023], AtomPub Service
-        # Documents MUST be
-        # identified with the "application/atomsvc+xml" media type (see
-        # [RFC5023] section 8).
-        [200, CT_ATOMXML, [service_xml(req)]]
+        # OData V2 reference service implementations are returning app-xml-u8
+        # so we do
+        [200, CT_APPXML, [service_xml(req)]]
       else
-        # this is returned by http://services.odata.org/V2/OData/OData.svc
+        # this is returned by http://services.odata.org/V2/OData/Safrano.svc
         415
       end
     end
@@ -564,22 +607,22 @@ module OData
       @data_service_version = '1.0'
     end
 
-    def get_coll_odata_links_h(array:, uribase:, icount: nil)
+    def get_coll_odata_links_h(array:, icount: nil)
       array.map do |w|
-        get_entity_odata_link_h(entity: w, uribase: uribase)
+        get_entity_odata_link_h(entity: w)
       end
     end
 
-    def get_coll_odata_h(array:, expand: nil, uribase:, icount: nil)
-      array.map do |w|
+    def get_coll_odata_h(array:, template:, icount: nil)
+      array.map! do |w|
         get_entity_odata_h(entity: w,
-                           expand: expand,
-                           uribase: uribase)
+                           template: template)
       end
+      array
     end
 
     def get_emptycoll_odata_h
-      [{}]
+      EMPTY_HASH_IN_ARY
     end
   end
 
@@ -589,36 +632,37 @@ module OData
       @data_service_version = '2.0'
     end
 
-    def get_coll_odata_links_h(array:, uribase:, icount: nil)
+    def get_coll_odata_links_h(array:, icount: nil)
       res = array.map do |w|
-        get_entity_odata_link_h(entity: w, uribase: uribase)
+        get_entity_odata_link_h(entity: w)
       end
       if icount
-        { 'results' => res, '__count' => icount }
+        { RESULTS_K => res, COUNT_K => icount }
       else
-        { 'results' => res }
+        { RESULTS_K => res }
       end
     end
 
     def get_emptycoll_odata_h
-      { 'results' => [{}] }
+      { RESULTS_K => EMPTY_HASH_IN_ARY }
     end
   end
 
   # a virtual entity for the service metadata
   class ServiceMeta
     attr_accessor :service
+
     def initialize(service)
       @service = service
     end
 
+    ALLOWED_TRANSITIONS_FIXED = [Safrano::TransitionEnd].freeze
     def allowed_transitions
-      @allowed_transitions = [Safrano::Transition.new('',
-                                                      trans: 'transition_end')]
+      ALLOWED_TRANSITIONS_FIXED
     end
 
     def transition_end(_match_result)
-      [nil, :end]
+      Safrano::Transition::RESULT_END
     end
 
     def odata_get(req)