safrano 0.4.2 → 0.5.0

data/lib/safrano/rack_app.rb

@@ -1,72 +1,47 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'rack'
-require_relative '../odata/walker.rb'
-require_relative 'request.rb'
-require_relative 'response.rb'
+require_relative '../odata/walker'
+require_relative 'request'
+require_relative 'response'
 
-module OData
+module Safrano
   # handle GET PUT etc
   module MethodHandlers
     def odata_options
-      # cf. stackoverflow.com/questions/22924678/sinatra-delete-response-headers
-
-      x = if @walker.status == :end
-            headers.delete('Content-Type')
-            @response.headers.delete('Content-Type')
-            [200, EMPTY_HASH, '']
-          else
-            odata_error
-          end
-      @response.headers['Content-Type'] = ''
-      x
-    end
-
-    def odata_error
-      return @walker.error.odata_get(@request) unless @walker.error.nil?
-
-      # this is too critical; raise a real Exception
-      raise 'Walker construction failed with a unknown Error '
+      @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
-      if @walker.status == :end
-        @walker.end_context.odata_delete(@request)
-      else
-        odata_error
-      end
+      @walker.finalize.tap_error { |err| return err.odata_get(@request) }
+             .if_valid { |context| context.odata_delete(@request) }
     end
 
     def odata_put
-      if @walker.status == :end
-        @walker.end_context.odata_put(@request)
-      else
-        odata_error
-      end
+      @walker.finalize.tap_error { |err| return err.odata_get(@request) }
+             .if_valid { |context| context.odata_put(@request) }
     end
 
     def odata_patch
-      if @walker.status == :end
-        @walker.end_context.odata_patch(@request)
-      else
-        odata_error
-      end
+      @walker.finalize.tap_error { |err| return err.odata_get(@request) }
+             .if_valid { |context| context.odata_patch(@request) }
     end
 
     def odata_get
-      if @walker.status == :end
-        @walker.end_context.odata_get(@request)
-      else
-        odata_error
-      end
+      @walker.finalize.tap_error { |err| return err.odata_get(@request) }
+             .if_valid { |context| context.odata_get(@request) }
     end
 
     def odata_post
-      if @walker.status == :end
-        @walker.end_context.odata_post(@request)
-      else
-        odata_error
-      end
+      @walker.finalize.tap_error { |err| return err.odata_get(@request) }
+             .if_valid { |context| context.odata_post(@request) }
     end
 
     def odata_head
@@ -77,22 +52,21 @@ module OData
   # the main Rack server app. Source: the Rack docu/examples and partly
   # inspired from Sinatra
   class ServerApp
-    METHODS_REGEXP = Regexp.new('HEAD|OPTIONS|GET|POST|PATCH|MERGE|PUT|DELETE')
+    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
-      headers 'Cache-Control' => 'no-cache'
-      headers 'Expires' => '-1'
-      headers 'Pragma' => 'no-cache'
 
+    def before
       @request.service_base = self.class.get_service_base
 
-      neg_error = @request.negotiate_service_version
-
-      raise RuntimeError if neg_error
-
-      return false unless @request.service
-
-      headers 'DataServiceVersion' => @request.service.data_service_version
+      @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
@@ -117,6 +91,11 @@ module OData
       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?']]
@@ -130,13 +109,23 @@ module OData
     end
 
     def call(env)
-      @request = OData::Request.new(env)
-      @response = OData::Response.new
+      # for thread safety
+      dup._call(env)
+    end
 
-      before
+    def _call(env)
+      begin
+        @request = Safrano::Request.new(env)
+        @response = Safrano::Response.new
 
-      dispatch
+        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
 
@@ -165,10 +154,22 @@ module OData
     end
 
     def self.publish_service(&block)
-      sbase = OData::ServiceBase.new
+      sbase = Safrano::ServiceBase.new
       sbase.instance_eval(&block) if block_given?
       sbase.finalize_publishing
       set_servicebase(sbase)
     end
   end
 end
+
+# deprecated
+# REMOVE 0.6
+module OData
+  class ServerApp < Safrano::ServerApp
+    def self.publish_service(&block)
+      ::Safrano::Deprecation.deprecate('OData::ServerApp',
+                                       'Use Safrano::ServerApp instead')
+      super
+    end
+  end
+end

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
@@ -164,44 +162,97 @@ module OData
       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
+            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
+
+    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
-            OData::MAX_DATASERVICE_VERSION
+            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
 
-      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
+    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)

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,97 +1,83 @@
-require 'rexml/document'
-require 'odata/relations.rb'
-require 'odata/batch.rb'
-require 'odata/error.rb'
+# frozen_string_literal: true
 
-module OData
+require 'rexml/document'
+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_s = cur_exp
-
-      else
-        k_s = exp_one.strip
-        rest_exp = nil
-      end
-      k = k_s.to_sym
-      yield k, k_s, 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:, template:, uribase:, icount: nil)
-      res = array.map do |w|
-        get_entity_odata_h(entity: w,
-                           template: template,
-                           uribase: uribase)
-      end
-      if icount
-        { 'results' => res, '__count' => icount }
-      else
-        { 'results' => res }
+    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) }
+    def get_entity_odata_link_h(entity:)
+      { uri: entity.uri }
     end
 
     EMPTYH = {}.freeze
-    def get_entity_odata_h(entity:, template:, uribase:)
+    METADATA_K = '__metadata'
+    def get_entity_odata_h(entity:, template:)
       # start with metadata
-      hres = { '__metadata' => entity.metadata_h(uribase: uribase) }
+      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,
-                                              uribase: uribase)
+                           get_entity_odata_h(entity: enval, template: templ)
                          else
                            # FK is NULL --> nav_value is nil --> return empty json
                            EMPTYH
                          end
           end
+
         when :expand_c
           arg.each do |attr, templ|
             next unless  (encoll = entity.send(attr))
 
             #  nav attributes that are a collection (x..n)
-            hres[attr] = get_coll_odata_h(array: encoll,
-                                          template: templ,
-                                          uribase: uribase)
+            hres[attr] = get_coll_odata_h(array: encoll, template: templ)
             # else error ?
           end
+
         when :deferr
+          euri = entity.uri
           arg.each do |attr|
-            hres[attr] = get_deferred_odata_h(entity: entity,
-                                              attrib: attr,
-                                              uribase: uribase)
+            hres[attr] = get_deferred_odata_h(entity_uri: euri, attrib: attr)
           end
         end
       end
@@ -100,33 +86,33 @@ module OData
   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
@@ -144,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
@@ -161,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 = '/'.freeze
-
-    # 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_PATH_PREFIX = '/'
+    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
 
@@ -212,56 +197,97 @@ 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
+
+    # keep the bug active for now, but allow to activate the fix,
+    # later we will change the default to be fixed
+    def bugfix_create_response(bool = false)
+      @bugfix_create_response = bool
+    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
 
-      raise(OData::API::ModelNameError, modelklass) unless modelklass.is_a? Sequel::Model::ClassMethods
+      raise(Safrano::API::ModelNameError, modelklass) unless modelklass.is_a? Sequel::Model::ClassMethods
 
-      if modelklass.ancestors.include? OData::Entity
+      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
       elsif modelklass.primary_key.is_a?(Array) # first API call... (normal non-testing case)
-        modelklass.extend OData::EntityClassMultiPK
-        modelklass.include OData::EntityMultiPK
+        modelklass.extend Safrano::EntityClassMultiPK
+        modelklass.include Safrano::EntityMultiPK
       else
-        modelklass.extend OData::EntityClassSinglePK
-        modelklass.include OData::EntitySinglePK
+        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
@@ -282,6 +308,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)
@@ -313,10 +356,35 @@ 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)
+
+        # Output create (POST) as single entity (Standard) or as array (non-standard buggy)
+        klass.include ( @bugfix_create_response ? Safrano::EntityCreateStandardOutput : Safrano::EntityCreateArrayOutput)
+      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
@@ -332,19 +400,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'
@@ -355,7 +428,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
@@ -364,10 +437,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|
@@ -390,7 +471,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|
@@ -404,6 +485,9 @@ module OData
           assoc.add_element('End', assoend)
         end
       end
+
+      # 4 function imports
+      add_metadata_xml_function_imports(ec)
     end
 
     def metadata_xml(_req)
@@ -437,9 +521,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)
 
@@ -451,20 +538,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)
@@ -480,7 +592,7 @@ module OData
       end
 
       def transition_end(_match_result)
-        [nil, :end]
+        Safrano::Transition::RESULT_END
       end
     end
 
@@ -488,14 +600,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
@@ -507,18 +616,18 @@ 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:, template:, 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,
-                           template: template,
-                           uribase: uribase)
+                           template: template)
       end
+      array
     end
 
     def get_emptycoll_odata_h
@@ -532,36 +641,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' => EMPTY_HASH_IN_ARY }
+      { 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)