safrano 0.5.1 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b38827d37fa3bfed54a30aa61c04b5da27470071c5e3167fb5a08aa5c48a69af
-  data.tar.gz: 3754e63822b6c504b42bc698df360295ab92bcf96a2ed8fdef4af7f2ed5c8d85
+  metadata.gz: fb412667db93e26340fc21440c89572fbff42fe52ae36807614f0fd11aac808c
+  data.tar.gz: 90883acded679aa860346e49242b1149933ccdb474e3e39eb6a893da5958dde7
 SHA512:
-  metadata.gz: 0c6a3949c741f120955b4582ddad95aa3fefe80f613030970c174b4fe000129e4d2f67dcb43deae5608a2a287a489a4c94d6ba0df5a613c5557b22b8ca4f625b
-  data.tar.gz: 7e5070fa657435fbc3a2932344392e58fa7105863bb045ad5a0aac7227a1e7ce5e4f54628915c81156da2f315eb359409c786243c47697877237ac08294a7872
+  metadata.gz: f66a01241685f18493d0519cb009674f0764e260ccc79b048ebc7346b5d4c64bd78deeb9983a0b4893e4fcfc2d1361f7024ca212bcbdc8071191417e793d9427
+  data.tar.gz: 85e2cdd6c5c65e52f882fe2e8386cdf772c239ecdf27d979d473170f51bb1c0a37d8919cb8fc7422bb04eadf50baa8adb1ad4e712ea3952d3e2c0f7d9923bd48

data/lib/core_ext/Numeric/convert.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# require 'bigdecimal/util'
+
+module Safrano
+  module CoreIncl
+    module Numeric
+      module Convert
+        def toDecimalString
+          BigDecimal(to_s).to_s('F')
+        end
+
+        def toDecimalPrecisionString(precision)
+          p = Integer(precision)
+          BigDecimal(self, p).to_s('F')
+        end
+
+        def toDecimalPrecisionScaleString(precision, scale)
+          p = Integer(precision)
+          sprintf("%#{p + 2}.#{scale}f", self).strip
+        end
+      end
+    end
+  end
+end

data/lib/core_ext/numeric.rb

@@ -0,0 +1,3 @@
+require_relative 'Numeric/convert'
+
+Numeric.include Safrano::CoreIncl::Numeric::Convert

data/lib/odata/collection.rb

@@ -60,7 +60,10 @@ module Safrano
       end
 
       def initialize_dataset(dtset = nil)
-        @cx = dtset || @modelk
+        @cx = @cx || dtset || @modelk
+      end
+
+      def initialize_uparms
         @uparms = UrlParameters4Coll.new(@cx, @params)
       end
 
@@ -131,9 +134,9 @@ module Safrano
 
       # on model class level we return the collection
       def odata_get(req)
-        @params = req.params
+        @params = @params || req.params
         initialize_dataset
-
+        initialize_uparms
         @uparms.check_all.if_valid { |_ret|
           odata_get_apply_params.if_valid { |_ret|
             odata_get_output(req)
@@ -170,8 +173,7 @@ module Safrano
       end
 
       def initialize_dataset(dtset = nil)
-        @cx = dtset || navigated_dataset
-        @uparms = UrlParameters4Coll.new(@cx, @params)
+        @cx = @cx || dtset || navigated_dataset
       end
       # redefinitions of the main methods for a navigated collection
       # (eg. all Books of Author[2]  is Author[2].Books.all )

data/lib/odata/complex_type.rb

@@ -2,6 +2,7 @@
 
 module Safrano
   module FunctionImport
+    EMPTY_HASH = {}.freeze
     class ResultDefinition
       D = 'd'
       DJ_OPEN = '{"d":'
@@ -12,75 +13,166 @@ module Safrano
       RESULTSK = 'results'
       COLLECTION = 'Collection'
 
-      def initialize(klassmod)
-        @klassmod = klassmod
+      def allowed_transitions
+        [Safrano::TransitionEnd]
       end
 
-      def to_odata_json(result, _req)
-        "#{DJ_OPEN}#{result.odata_h.to_json}#{DJ_CLOSE}"
+      def transition_end(_match_result)
+        Safrano::Transition::RESULT_END
       end
 
-      def type_metadata
+      # we will have this on class and instance level for making things simpler first
+      def self.klassmod
+        @klassmod
+      end
+
+      # return a subclass of ResultAsComplexType
+      def self.asComplexType(klassmod)
+        Class.new(ResultAsComplexType) do
+          @klassmod = klassmod
+        end
+      end
+
+      # return a subclass of ResultAsComplexType
+      def self.asComplexTypeColl(klassmod)
+        Class.new(ResultAsComplexTypeColl) do
+          @klassmod = klassmod
+        end
+      end
+
+      def self.asPrimitiveType(klassmod)
+        Class.new(ResultAsPrimitiveType) do
+          @klassmod = klassmod
+        end
+      end
+
+      def self.asPrimitiveTypeColl(klassmod)
+        Class.new(ResultAsPrimitiveTypeColl) do
+          @klassmod = klassmod
+        end
+      end
+
+      def self.asEntity(klassmod)
+        Class.new(ResultAsEntity) do
+          @klassmod = klassmod
+        end
+      end
+
+      def self.asEntityColl(klassmod)
+        Class.new(ResultAsEntityColl) do
+          @klassmod = klassmod
+        end
+      end
+
+      def initialize(value)
+        @value = value
+      end
+
+      def odata_get(req)
+        [200, EMPTY_HASH, [to_odata_json(req)]]
+      end
+
+      def self.type_metadata
         @klassmod.type_name
       end
+
+      def type_metadata
+        self.class.type_metadata
+      end
+
+      # needed for ComplexType result
+      def to_odata_json(_req)
+        "#{DJ_OPEN}#{@value.odata_h.to_json}#{DJ_CLOSE}"
+      end
+
+      # wrapper
+      # for OData Entity and Collections, return them directly
+      # for others, ie ComplexType, Prims etc, return the ResultDefinition-subclass wrapped result
+      def self.do_execute_func_result(result, _req, apply_query_params = false)
+        self.new(result)
+      end
     end
+
     class ResultAsComplexType < ResultDefinition
+      def self.type_metadata
+        @klassmod.type_name
+      end
     end
+
     class ResultAsComplexTypeColl < ResultDefinition
-      def type_metadata
+      def self.type_metadata
         "Collection(#{@klassmod.type_name})"
       end
 
-      def to_odata_json(coll, req)
-#        "#{DJ_OPEN}#{{ RESULTSK => coll.map { |c| c.odata_h } }.to_json}#{DJ_CLOSE}"
-        template = @klassmod.output_template
+      def to_odata_json(req)
+        #        "#{DJ_OPEN}#{{ RESULTSK => coll.map { |c| c.odata_h } }.to_json}#{DJ_CLOSE}"
+        template = self.class.klassmod.output_template
         # TODO: Error handling if database contains binary BLOB data that cant be
         # interpreted as UTF-8 then JSON will fail here
 
-        innerh = req.service.get_coll_odata_h(array: coll,
+        innerh = req.service.get_coll_odata_h(array: @value,
                                               template: template)
-                                              
+
         innerj = innerh.to_json
 
         "#{DJ_OPEN}#{innerj}#{DJ_CLOSE}"
       end
     end
+
     class ResultAsEntity < ResultDefinition
-      def to_odata_json(result_entity, req)
-        result_entity.instance_exec do
-          copy_request_infos(req)
-          to_odata_json(request: req)
-        end
+      def self.type_metadata
+        @klassmod.type_name
+      end
+
+      # wrapper
+      # for OData Entity  return them directly
+      def self.do_execute_func_result(result, _req, apply_query_params = false)
+        # note: Sequel entities instances seem to be thread safe, so we can
+        # safely add request-dependant data (eg. req.params) there
+        apply_query_params ? result : result.inactive_query_params
       end
     end
+
     class ResultAsEntityColl < ResultDefinition
-      def type_metadata
+      def self.type_metadata
         "Collection(#{@klassmod.type_name})"
       end
 
-      def to_odata_json(result_dataset, req)
+      # wrapper
+      # for OData Entity Collection return them directly
+      def self.do_execute_func_result(result, req, apply_query_params = false)
         coll = Safrano::OData::Collection.new(@klassmod)
+        # instance_exec has other instance variables; @values would be nil in the block below
+        # need to pass a local copy
+        dtset = result
         coll.instance_exec do
-          @params = req.params
-          initialize_dataset(result_dataset)
+          @params = apply_query_params ? req.params : EMPTY_HASH
+          initialize_dataset(dtset)
+          initialize_uparms
         end
-        coll.to_odata_json(request: req)
+        coll
       end
     end
+
     class ResultAsPrimitiveType < ResultDefinition
-      def to_odata_json(result, _req)
+      def self.type_metadata
+        @klassmod.type_name
+      end
+
+      def to_odata_json(_req)
         { D => { METAK => { TYPEK => type_metadata },
-                 VALUEK => @klassmod.odata_value(result) } }.to_json
+                 VALUEK => self.class.klassmod.odata_value(@value) } }.to_json
       end
     end
+
     class ResultAsPrimitiveTypeColl < ResultDefinition
-      def type_metadata
+      def self.type_metadata
         "Collection(#{@klassmod.type_name})"
       end
 
-      def to_odata_json(result, _req)
-        { D => { METAK => { TYPEK => type_metadata },
-                 RESULTSK => @klassmod.odata_collection(result) } }.to_json
+      def to_odata_json(_req)
+        { D => { METAK => { TYPEK => self.class.type_metadata },
+                 RESULTSK => self.class.klassmod.odata_collection(@value) } }.to_json
       end
     end
   end
@@ -90,8 +182,9 @@ module Safrano
   # with added OData functionality
   class ComplexType
     attr_reader :values
+
     EMPTYH = {}.freeze
-    
+
     @namespace = nil
     def self.namespace
       @namespace
@@ -100,28 +193,28 @@ module Safrano
     def self.props
       @props
     end
-    
+
     def type_name
       self.class.type_name
     end
-    
+
     def metadata_h
       {   type: type_name }
     end
-    
+
     def casted_values
       # MVP... TODO: handle time mappings like in Entity models
       values
     end
-    
+
     # needed for nested json output
     # this is a simpler version of model_ext#output_template
     def self.default_template
       template = {}
       expand_e = {}
-      
+
       template[:all_values] = EMPTYH
-      @props.each { |prop, kl| 
+      @props.each { |prop, kl|
         if kl.respond_to? :default_template
           expand_e[prop] = kl.default_template
         end
@@ -129,10 +222,11 @@ module Safrano
       template[:expand_e] = expand_e
       template
     end
-    
+
     def self.output_template
       default_template
     end
+
     def self.type_name
       @namespace ? "#{@namespace}.#{self.to_s}" : self.to_s
     end
@@ -157,11 +251,11 @@ module Safrano
     end
 
     def self.return_as_collection_descriptor
-      FunctionImport::ResultAsComplexTypeColl.new(self)
+      FunctionImport::ResultDefinition.asComplexTypeColl(self)
     end
 
     def self.return_as_instance_descriptor
-      FunctionImport::ResultAsComplexType.new(self)
+      FunctionImport::ResultDefinition.asComplexType(self)
     end
 
     # add metadata xml to the passed REXML schema object

data/lib/odata/edm/primitive_types.rb

@@ -15,30 +15,109 @@ module Safrano
   # Classes specifying generic types that Sequel will convert to
   # database-specific types.
   DB_TYPE_STRING_RGX = /\ACHAR\s*\(\d+\)\z/.freeze
-
+  DB_TYPE_NUMDEC_RGX = /\A(NUMERIC|DECIMAL)\s*(\(\s*((\d+)\s*(,\s*(\d+))?)\s*\))?\s*\z/i.freeze
+  # thank you rubular
+  # Test String: DECIMAL (55,2 )
+  # Match groups
+  # 1	DECIMAL
+  # 2	(55,2 )
+  # 3	55,2
+  # 4	55
+  # 5	,2
+  # 6	2
+
+  DB_TYPE_FLOATP_RGX = /\A\s*(FLOAT)\s*(\(\s*(\d+)\s*\))?\s*\z/i.freeze
+
+  # Note: "char" (quoted!) is postgresql's byte type
+  DB_TYPE_INTLIKE_RGX = /\A\s*(smallserial|smallint|integer|int2|int4|int8|int|mediumint|bigint|serial|bigserial|tinyint)\s*/i.freeze
   # used in $metadata
   # cf. Sequel Database column_schema_default_to_ruby_value
   #                     schema_column_type
   # https://www.odata.org/documentation/odata-version-2-0/overview/
-  def self.default_edm_type(ruby_type:)
-    case ruby_type
-    when :integer
-      'Edm.Int32'
-    when :string
-      'Edm.String'
-    when :date, :datetime,
-      'Edm.DateTime'
-    when :time
-      'Edm.Time'
-    when :boolean
-      'Edm.Boolean'
-    when :float
-      'Edm.Double'
-    when :decimal
-      'Edm.Decimal'
-    when :blob
-      'Edm.Binary'
-    end
+
+  # type mappings are hard, especially between "Standards" like SQL and OData V2 (might be a bit better in V4 ?)
+  # this is all best effort/try to make it work  logic
+  def self.add_edm_types(metadata, props)
+    # try num/dec with db_type:
+    metadata[:edm_type] = if (md = DB_TYPE_NUMDEC_RGX.match(props[:db_type]))
+                            prec = md[4]
+                            scale = md[6]
+                            if (scale && prec)
+                              if (scale == '0') # dont force default scale to 0 like SQL standard
+                                metadata[:edm_precision] = prec
+                                "Edm.Decimal(#{prec})"
+                              else
+                                # we have precision and scale
+                                metadata[:edm_scale] = scale
+                                metadata[:edm_precision] = prec
+                                "Edm.Decimal(#{prec},#{scale})"
+                              end
+                            elsif prec
+                              # we have precision only
+                              metadata[:edm_precision] = prec
+                              "Edm.Decimal(#{prec})"
+                            else
+                              'Edm.Decimal'
+                            end
+                          end
+    return if metadata[:edm_type]
+
+    # try float(prec) with db_type:
+    metadata[:edm_type] = if (md = DB_TYPE_FLOATP_RGX.match(props[:db_type]))
+                            # FLOAT( 22) match groups
+                            # 1	FLOAT
+                            # 2	(22 )
+                            # 3	22
+
+                            if (prec = md[3])
+                              # we have precision only
+                              metadata[:edm_precision] = prec
+                              'Edm.Double'
+                            end
+                          end
+    return if metadata[:edm_type]
+
+    # try int-like with db_type:
+    # smallint|int|integer|bigint|serial|bigserial
+    metadata[:edm_type] = if (md = DB_TYPE_INTLIKE_RGX.match(props[:db_type]))
+
+                            if (itype = md[1])
+                              case itype.downcase
+                              when 'smallint', 'int2', 'smallserial'
+                                'Edm.Int16'
+                              when 'int', 'integer', 'serial', 'mediumint', 'int4'
+                                'Edm.Int32'
+                              when 'bigint', 'bigserial', 'int8'
+                                'Edm.Int64'
+                              when 'tinyint'
+                                'Edm.Byte'
+                              end
+                            end
+                          end
+    return if metadata[:edm_type]
+
+    # try with Sequel(ruby) type
+    metadata[:edm_type] = case props[:type]
+                          when :integer
+                            'Edm.Int32'
+                          when :string
+                            'Edm.String'
+                          when :date
+                            'Edm.DateTime'
+                          when :datetime
+                            'Edm.DateTime'
+                          when :time
+                            'Edm.Time'
+                          when :boolean
+                            'Edm.Boolean'
+                          when :float
+                            'Edm.Double'
+                          when :decimal
+                            'Edm.Decimal'
+                          when :blob
+                            'Edm.Binary'
+                          else
+                          end
   end
 
   # use Edm twice so that we can do include Safrano::Edm and then

data/lib/odata/entity.rb

@@ -125,7 +125,7 @@ module Safrano
     end
 
     def copy_request_infos(req)
-      @params = req.params
+      @params = @inactive_query_params ? EMPTY_HASH : req.params
       @do_links = req.walker.do_links
       @uparms = UrlParameters4Single.new(self, @params)
     end
@@ -152,6 +152,11 @@ module Safrano
              .tap_error { |e| return e.odata_get(req) }
     end
 
+    def inactive_query_params
+      @inactive_query_params = true
+      self # chaining
+    end
+
     DELETE_REL_AND_ENTY = lambda do |entity, assoc, parent|
       Safrano.remove_nav_relation(assoc, parent)
       entity.destroy(transaction: false)
@@ -306,36 +311,6 @@ module Safrano
     end
   end
 
-  module MappingBeforeOutput
-    # needed for proper datetime output
-    def casted_values(cols = nil)
-      vals = case cols
-             when nil
-               # we need to dup the model values as we need to change it before passing to_json,
-               # but we dont want to interfere with Sequel's owned data
-               # (eg because then in worst case it could happen that we write back changed values to DB)
-               values_for_odata.dup
-             else
-               selected_values_for_odata(cols)
-             end
-      self.class.time_cols.each { |tc| vals[tc] = vals[tc]&.iso8601 if vals.key?(tc) }
-      vals
-    end
-  end
-  module NoMappingBeforeOutput
-    # current model does not have eg. Time fields--> no special mapping, just to_json is fine
-    # --> we can use directly the model.values (values_for_odata) withoud dup'ing it as we dont
-    # need to change it, just output as is
-    def casted_values(cols = nil)
-      case cols
-      when nil
-        values_for_odata
-      else
-        selected_values_for_odata(cols)
-      end
-    end
-  end
-
   module MediaEntity
     # media entity metadata for json h
     def metadata_h

data/lib/odata/function_import.rb

@@ -21,7 +21,7 @@ module Safrano
       end
 
       def allowed_transitions
-        [Safrano::TransitionEnd]
+        [Safrano::TransitionExecuteFunc]
       end
 
       def input(**parmtypes)
@@ -43,6 +43,12 @@ module Safrano
         self
       end
 
+      def auto_query_parameters
+        @auto_query_params = true
+        self # chaining
+      end
+      alias auto_query_params auto_query_parameters
+
       def return(klassmod, &proc)
         raise('Please provide a code block') unless block_given?
 
@@ -51,7 +57,7 @@ module Safrano
                      else
                        # if it's neither a ComplexType nor a Model-Entity
                        # --> assume it is a Primitive
-                       ResultAsPrimitiveType.new(klassmod)
+                       ResultDefinition.asPrimitiveType(klassmod)
                      end
         @proc = proc
         self
@@ -65,7 +71,8 @@ module Safrano
                      else
                        # if it's neither a ComplexType nor a Modle-Entity
                        # --> assume it is a Primitive
-                       ResultAsPrimitiveTypeColl.new(klassmod)
+                       #                       ResultAsPrimitiveTypeColl.new(klassmod)
+                       ResultDefinition.asPrimitiveTypeColl(klassmod)
                      end
         @proc = proc
         self
@@ -136,32 +143,23 @@ module Safrano
         funky
       end
 
-      def with_validated_get(req)
+      def with_transition_validated(req)
         #        initialize_params
+        @params = req.params
         return yield unless (@error = check_url_func_params)
 
-        @error.odata_get(req) if @error
-      end
-
-      def to_odata_json(req)
-        result = @proc.call(**@funcparams)
-        @returning.to_odata_json(result, req)
+        [nil, :error, @error] if @error
       end
 
-      def odata_get_output(req)
-        [200, EMPTY_HASH, [to_odata_json(req)]]
-      end
-
-      def odata_get(req)
-        @params = req.params
-
-        with_validated_get(req) do
-          odata_get_output(req)
+      def do_execute_func(req)
+        with_transition_validated(req) do
+          result = @proc.call(**@funcparams)
+          [@returning.do_execute_func_result(result, req, @auto_query_params), :run]
         end
       end
 
-      def transition_end(_match_result)
-        Transition::RESULT_END
+      def transition_execute_func(_match_result)
+        [self, :run_with_execute_func]
       end
     end
   end

data/lib/odata/model_ext.rb

@@ -5,7 +5,9 @@
 # Thus Below we have called that "EntityClass". It's meant as "Collection"
 
 require 'json'
+require 'base64'
 require 'rexml/document'
+require 'bigdecimal'
 require_relative '../safrano/core'
 require_relative 'error'
 require_relative 'collection_filter'
@@ -31,8 +33,14 @@ module Safrano
     attr_reader :default_template
     attr_reader :uri
     attr_reader :odata_upk_parts
-    attr_reader :time_cols
+    attr_reader :casted_cols
     attr_reader :namespace
+    # store cols metata here in the model (sub)-class. Initially we stored this infos (eg. edm_types etc)
+    # directly into sequels db_schema hash. But this hash is on the upper Sequel::Model(table) class
+    # and is shared by all subclasses.
+    # By storing it separately here we are less dependant from Sequel, and have less issues with
+    # testing with multiples models class derived from same Sequel::Model(table)
+    attr_reader :cols_metadata
 
     # initialising block of code to be executed at end of
     # ServerApp.publish_service after all model classes have been registered
@@ -73,7 +81,7 @@ module Safrano
       @uparms = nil
       @params = nil
       @cx = nil
-      @@time_cols = nil
+      @cols_metadata = {}
     end
 
     def build_uri(uribase)
@@ -81,11 +89,11 @@ module Safrano
     end
 
     def return_as_collection_descriptor
-      Safrano::FunctionImport::ResultAsEntityColl.new(self)
+      Safrano::FunctionImport::ResultDefinition.asEntityColl(self)
     end
 
     def return_as_instance_descriptor
-      Safrano::FunctionImport::ResultAsEntity.new(self)
+      Safrano::FunctionImport::ResultDefinition.asEntity(self)
     end
 
     def execute_deferred_iblock
@@ -94,10 +102,10 @@ module Safrano
 
     # Factory json-> Model Object instance
     def new_from_hson_h(hash)
-      #enty = new
-      #enty.set_fields(hash, data_fields, missing: :skip)
+      # enty = new
+      # enty.set_fields(hash, data_fields, missing: :skip)
       enty = create(hash)
-      #enty.set(hash)
+      # enty.set(hash)
       enty
     end
 
@@ -176,13 +184,14 @@ module Safrano
              end
       # with their properties
       db_schema.each do |pnam, prop|
+        metadata = @cols_metadata[pnam]
         if prop[:primary_key] == true
           enty.add_element('Key').add_element('PropertyRef',
                                               'Name' => pnam.to_s)
         end
         attrs = { 'Name' => pnam.to_s,
                   #                  'Type' => Safrano.get_edm_type(db_type: prop[:db_type]) }
-                  'Type' => prop[:odata_edm_type] }
+                  'Type' => metadata[:edm_type] }
         attrs['Nullable'] = 'false' if prop[:allow_null] == false
         enty.add_element('Property', attrs)
       end
@@ -349,20 +358,79 @@ module Safrano
       end
     end
 
-    def finalize_publishing
+    def build_casted_cols(service)
+      # cols needed catsting before final json output
+      @casted_cols = {}
+      db_schema.each { |col, props|
+        # first check if we have user-defined type mapping
+        usermap = nil
+        dbtyp = props[:db_type]
+        metadata = @cols_metadata[col]
+        if (service.type_mappings.values.find { |map| usermap = map.match(dbtyp) })
+
+          metadata[:edm_type] = usermap.edm_type
+
+          @casted_cols[col] = usermap.castfunc
+          next # this will override our rules below !
+        end
+
+        if (metadata[:edm_precision] && (metadata[:edm_type] =~ /\AEdm.Decimal\(/i))
+          # we save the precision and/or scale in the lambda (binding!)
+
+          @casted_cols[col] = if metadata[:edm_scale]
+                                ->(x) {
+                                  # not sure if these copies are really needed, but feels better that way
+                                  # output  decimal with precision and scale
+                                  x&.toDecimalPrecisionScaleString(metadata[:edm_precision], metadata[:edm_scale])
+                                }
+                              else
+                                ->(x) {
+                                  # not sure if these copies are really needed, but feels better that way
+                                  # output  decimal with precision only
+                                  x&.toDecimalPrecisionString(metadata[:edm_precision])
+                                }
+                              end
+
+          next
+        end
+        if metadata[:edm_type] == 'Edm.Decimal'
+          @casted_cols[col] = ->(x) { x&.toDecimalString }
+          next
+        end
+        # Odata V2 Spec:
+        # Edm.Binary	Base64 encoded value of an EDM.Binary value represented as a JSON string
+        # See for example https://services.odata.org/V2/Northwind/Northwind.svc/Categories(1)?$format=json
+        if metadata[:edm_type] == 'Edm.Binary'
+          @casted_cols[col] = ->(x) { Base64.encode64(x) unless x.nil? } # Base64
+          next
+        end
+        # TODO check this more in details
+        # NOTE: here we use :type which is the sequel defined ruby-type
+        if props[:type] == :datetime
+          @casted_cols[col] = ->(x) { x&.iso8601 }
+
+        end
+      }
+    end
+
+    def finalize_publishing(service)
       build_type_name
 
       # build default output template structure
       build_default_template
 
-      # Time columns
-      @time_cols = db_schema.select { |_c, v| v[:type] == :datetime }.map { |c, _v| c }
-
-      # add edm_types into schema
-      db_schema.each do |_col, props|
-        props[:odata_edm_type] = Safrano.default_edm_type(ruby_type: props[:type])
+      # add edm_types into metadata store
+      @cols_metadata = {}
+      db_schema.each do |col, props|
+        metadata = @cols_metadata.key?(col) ? @cols_metadata[col] : (@cols_metadata[col] = {})
+        Safrano.add_edm_types(metadata, props)
       end
 
+      build_casted_cols(service)
+      # unless @casted_cols.empty?
+      # require 'pry'
+      # binding.pry
+      # end
       # and finally build the path lists and allowed tr's
       build_attribute_path_list
       build_expand_path_list

data/lib/odata/transition.rb

@@ -6,7 +6,7 @@ require_relative 'error'
 module Safrano
   # represents a state transition when navigating/parsing the url path
   # from left to right
-  class Transition < Regexp
+  class Transition
     attr_accessor :trans
     attr_accessor :match_result
     attr_accessor :rgx
@@ -53,7 +53,31 @@ module Safrano
     end
   end
 
+  # Transition that does not move/change the input
+  class InplaceTransition < Transition
+    def initialize(trans:)
+      @trans = trans
+    end
+
+    def do_match(str)
+      @str = str
+    end
+
+    def path_remain
+      @str
+    end
+
+    def path_done
+      EMPTYSTR
+    end
+
+    def do_transition(ctx)
+      ctx.method(@trans).call(@str)
+    end
+  end
+
   TransitionEnd = Transition.new('\A(\/?)\z', trans: 'transition_end')
+  TransitionExecuteFunc = InplaceTransition.new(trans: 'transition_execute_func')
   TransitionMetadata = Transition.new('\A(\/\$metadata)(.*)',
                                       trans: 'transition_metadata')
   TransitionBatch = Transition.new('\A(\/\$batch)(.*)',

data/lib/odata/walker.rb

@@ -30,17 +30,23 @@ module Safrano
     # are $links requested ?
     attr_reader :do_links
 
+    attr_reader :request
+
     NIL_SERVICE_FATAL = 'Walker is called with a nil service'
     EMPTYSTR = ''
     SLASH = '/'
 
-    def initialize(service, path, content_id_refs = nil)
+    def initialize(service, path, request, content_id_refs = nil)
       raise NIL_SERVICE_FATAL unless service
 
       path = URI.decode_www_form_component(path)
       @context = service
       @content_id_refs = content_id_refs
 
+      # needed because for function import we need access to the url parameters (req.params)
+      # who contains the functions params
+      @request = request
+
       @contexts = [@context]
 
       @path_start = @path_remain = if service
@@ -109,6 +115,16 @@ module Safrano
       end
     end
 
+    # execute function import with request parameters
+    # input: @context containt the function to exectute,
+    #        @request.params should normally contain the params
+    # result: validate the params for the given function, execute the function and
+    #          return it's result back into @context,
+    #          and finaly set status :end   (or error if anyting went wrong )
+    def do_run_with_execute_func
+      @context, @status, @error = @context.do_execute_func(@request)
+    end
+
     # little hacks... depending on returned state, set some attributes
     def state_mappings
       case @status
@@ -137,6 +153,8 @@ module Safrano
         # entity reference here and place it in @context
       when :run_with_content_id
         do_run_with_content_id
+      when :run_with_execute_func
+        do_run_with_execute_func
       end
 
       @contexts << @context

data/lib/safrano/request.rb

@@ -99,6 +99,7 @@ module Safrano
     def create_odata_walker
       @env['safrano.walker'] = @walker = Walker.new(@service,
                                                     path_info,
+                                                    self,
                                                     @content_id_references)
     end
 

data/lib/safrano/service.rb

@@ -5,6 +5,7 @@ require 'odata/relations'
 require 'odata/batch'
 require 'odata/complex_type'
 require 'odata/function_import'
+require 'safrano/type_mapping'
 require 'odata/error'
 require 'odata/filter/sequel'
 require 'set'
@@ -137,6 +138,8 @@ module Safrano
     attr_accessor :relman
     attr_accessor :complex_types
     attr_accessor :function_imports
+    attr_accessor :function_import_keys
+    attr_accessor :type_mappings
 
     # Instance attributes for specialized Version specific Instances
     attr_accessor :v1
@@ -155,7 +158,9 @@ module Safrano
       @relman = Safrano::RelationManager.new
       @complex_types = Set.new
       @function_imports = {}
+      @function_import_keys = []
       @cmap = {}
+      @type_mappings = {}
       instance_eval(&block) if block_given?
     end
 
@@ -239,6 +244,8 @@ module Safrano
       other.batch_handler = @batch_handler
       other.complex_types = @complex_types
       other.function_imports = @function_imports
+      other.function_import_keys = @function_import_keys
+      other.type_mappings = @type_mappings
       other
     end
 
@@ -322,9 +329,16 @@ module Safrano
     def function_import(name)
       funcimp = Safrano::FunctionImport(name)
       @function_imports[name] = funcimp
+      @function_import_keys << name
+      set_funcimports_sorted
       funcimp
     end
 
+    def with_db_type(*dbtypnams, &proc)
+      m = TypeMapping.builder(*dbtypnams, &proc)
+      @type_mappings[m.db_types_rgx] = m
+    end
+
     def cmap=(imap)
       @cmap = imap
       set_collections_sorted(@cmap.values)
@@ -339,6 +353,10 @@ module Safrano
       @collections
     end
 
+    # need to be sorted by size too
+    def set_funcimports_sorted
+      @function_import_keys.sort_by! { |k| k.size }.reverse!
+    end
     # to be called at end of publishing block to ensure we get the right names
     # and additionally build the list of valid attribute path's used
     # for validation of $orderby or $filter params
@@ -361,15 +379,30 @@ module Safrano
 
       set_uribase
 
-      @collections.each(&:finalize_publishing)
-
       # finalize the uri's and include NoMappingBeforeOutput or MappingBeforeOutput as needed
       @collections.each do |klass|
+        klass.finalize_publishing(self)
+
         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)
+
+        # define the most optimal casted_values method for the given model(klass)
+        if (klass.casted_cols.empty?)
+          klass.send(:define_method, :casted_values) do |cols = nil|
+            cols ? selected_values_for_odata(cols) : values_for_odata
+          end
+        else
+          klass.send(:define_method, :casted_values) do |cols = nil|
+            # we need to dup the model values as we need to change it before passing to_json,
+            # but we dont want to interfere with Sequel's owned data
+            # (eg because then in worst case it could happen that we write back changed values to DB)
+            vals = cols ? selected_values_for_odata(cols) : values_for_odata.dup
+            self.class.casted_cols.each { |cc, lambda| vals[cc] = lambda.call(vals[cc]) if vals.key?(cc) }
+            vals
+          end
+        end
       end
 
       # build allowed transitions (requires that @collections are filled and sorted for having a
@@ -401,7 +434,7 @@ module Safrano
     end
 
     def base_url_func_regexp
-      @function_imports.keys.join('|')
+      @function_import_keys.join('|')
     end
 
     def service
@@ -495,7 +528,9 @@ module Safrano
       doc.add_element('edmx:Edmx', 'Version' => '1.0')
       doc.root.add_namespace('xmlns:edmx', XMLNS::MSFT_ADO_2007_EDMX)
       serv = doc.root.add_element('edmx:DataServices',
-                                  'm:DataServiceVersion' => '1.0')
+                                  # TODO: export the real version (result from version negotions)
+                                  # but currently we support only v1 and v2, and most users will use v2
+                                  'm:DataServiceVersion' => '2.0')
       # 'm:DataServiceVersion' => "#{self.dataServiceVersion}" )
       # DataServiceVersion: This attribute MUST be in the data service
       # metadata namespace

data/lib/safrano/type_mapping.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# Note: Safrano has hardcoded mapping rules for most of types.
+# But
+#   it might not be 100% complete
+#   it might not always do what is expected
+# The type mapping functionality here  allows Safrano users to design type mapping themselves
+# and fill or fix the two above issues
+module Safrano
+  # Base class
+  class TypeMapping
+    attr_reader :castfunc
+    attr_reader :db_types_rgx
+    attr_reader :edm_type
+
+    # wrapper to handle API
+    class Builder
+      attr_reader :xedm_type
+      attr_reader :castfunc
+      attr_reader :db_types_rgx
+      attr_reader :bui1
+      attr_reader :bui2
+
+      def initialize(*dbtyps)
+        @db_types_rgx = dbtyps.join('|')
+        @rgx = /\A\s*(?:#{@db_types_rgx})\s*\z/i
+      end
+
+      def edm_type(input)
+        @xedm_type = input
+      end
+
+      def with_one_param(lambda = nil, &proc)
+        proc1 = block_given? ? proc : lambda
+        @bui1 = Builder1Par.new(@db_types_rgx, proc1)
+      end
+
+      def with_two_params(lambda = nil, &proc)
+        proc2 = block_given? ? proc : lambda
+        @bui2 = Builder2Par.new(@db_types_rgx, proc2)
+      end
+
+      def json_value(lambda = nil, &proc)
+        @castfunc = block_given? ? proc : lambda
+      end
+
+      def match(curtyp)
+        if (@bui2 && (m = @bui2.match(curtyp)))
+          m
+        elsif (@bui1 && (m = @bui1.match(curtyp)))
+          m
+        elsif  @rgx.match(curtyp)
+          type_mapping
+        end
+      end
+
+      def type_mapping
+        # TODO perf; return always same object when called multiple times
+        FixedTypeMapping.new(self)
+      end
+    end # Builder
+
+    def self.builder(*dbtypnams, &proc)
+      builder = Builder.new(*dbtypnams)
+      builder.instance_eval(&proc)
+      builder
+    end
+
+    class Builder1Par < Builder
+      def initialize(db_ty_rgx, proc)
+        @db_types_rgx = db_ty_rgx
+        @proc = proc
+        @rgx = /\A\s*(?:#{@db_types_rgx})\s*\(\s*(\d+)\s*\)\z/i
+      end
+
+      def match(curtyp)
+        (@md = @rgx.match(curtyp)) ? type_mapping : nil
+      end
+
+      def json_value(lambda = nil, &proc)
+        @castfunc = block_given? ? proc : lambda
+      end
+
+      # this is a bit advanced/obscure programming
+      # the intance_exec here is required to produce correct results
+      # ie. it produces concrete instances of edm_type and json_val lambda
+      # for the later, it is kind of currying but with the *implicit* parameters
+      # from the calling context eg par1
+
+      # probably this is not best-practice programing as we
+      # have a mutating object (the builder) that
+      # produces different lambdas after each type_mapping(mutation) calls
+      def type_mapping
+        p1val = @md[1]
+        instance_exec p1val, &@proc
+
+        TypeMapping1Par.new(self)
+      end
+    end
+    class Builder2Par < Builder
+      def initialize(db_ty_rgx, proc)
+        @db_types_rgx = db_ty_rgx
+        @proc = proc
+        @rgx = /\A\s*(?:#{@db_types_rgx})\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)\s*\z/i
+      end
+
+      def match(curtyp)
+        (@md = @rgx.match(curtyp)) ? type_mapping : nil
+      end
+
+      # this is a bit advanced/obscure programming
+      # the intance_exec here is required to produce correct results
+      # ie. it produces concrete instances of edm_type and json_val lambda
+      # for the later, it is kind of currying but with the *implicit* parameters
+      # from the calling context eg par1 and par2
+
+      # probably this is not best-practice programing as we
+      # have a mutating object (the builder) that
+      # produces different lambdas after each type_mapping(mutation) calls
+      def type_mapping
+        p1val = @md[1]
+        p2val = @md[2]
+        instance_exec p1val, p2val, &@proc
+        TypeMapping2Par.new(self)
+      end
+    end
+  end
+
+  # Fixed type (ie. without variable parts)
+  class FixedTypeMapping < TypeMapping
+    def initialize(builder)
+      @edm_type = builder.xedm_type
+      @castfunc = builder.castfunc
+    end
+  end
+
+  class TypeMapping1Par < TypeMapping
+    def initialize(builder)
+      @edm_type = builder.xedm_type
+      @castfunc = builder.castfunc
+    end
+  end
+  class TypeMapping2Par < TypeMapping
+    def initialize(builder)
+      @edm_type = builder.xedm_type
+      @castfunc = builder.castfunc
+    end
+  end
+end

data/lib/safrano/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: safrano
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.5
 platform: ruby
 authors:
 - oz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-27 00:00:00.000000000 Z
+date: 2021-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -117,12 +117,14 @@ files:
 - lib/core_ext/Dir/iter.rb
 - lib/core_ext/Hash/transform.rb
 - lib/core_ext/Integer/edm.rb
+- lib/core_ext/Numeric/convert.rb
 - lib/core_ext/REXML/Document/output.rb
 - lib/core_ext/String/convert.rb
 - lib/core_ext/String/edm.rb
 - lib/core_ext/dir.rb
 - lib/core_ext/hash.rb
 - lib/core_ext/integer.rb
+- lib/core_ext/numeric.rb
 - lib/core_ext/rexml.rb
 - lib/core_ext/string.rb
 - lib/odata/attribute.rb
@@ -164,6 +166,7 @@ files:
 - lib/safrano/response.rb
 - lib/safrano/sequel_join_by_paths.rb
 - lib/safrano/service.rb
+- lib/safrano/type_mapping.rb
 - lib/safrano/version.rb
 - lib/sequel/plugins/join_by_paths.rb
 homepage: https://gitlab.com/dm0da/safrano