safrano 0.5.4 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89b3584ee45b115a0a463faea56586c06271c36ea080c4f73b64fb4a4a641802
-  data.tar.gz: 977386e3bff89f18c6b596f1f4244623e85b2960ab9cb9eed6ebf7c9c1c0498f
+  metadata.gz: fb412667db93e26340fc21440c89572fbff42fe52ae36807614f0fd11aac808c
+  data.tar.gz: 90883acded679aa860346e49242b1149933ccdb474e3e39eb6a893da5958dde7
 SHA512:
-  metadata.gz: e45fb7cd3af3aa3b0d918229f84760b9c779a01a55d5f46f593e93dd2f18dbefe5e3713141cf3d72523b3e2069b426130760531c991549993f861c26c9b8a2f0
-  data.tar.gz: 943e0cb99f039eb41c69204dd348347965b188a0e334d13c075ffe06188b01a44e8bc757b86509de24ca843b9253f131ed3c30bbbc4eaaa2d176cc6b5e71249d
+  metadata.gz: f66a01241685f18493d0519cb009674f0764e260ccc79b048ebc7346b5d4c64bd78deeb9983a0b4893e4fcfc2d1361f7024ca212bcbdc8071191417e793d9427
+  data.tar.gz: 85e2cdd6c5c65e52f882fe2e8386cdf772c239ecdf27d979d473170f51bb1c0a37d8919cb8fc7422bb04eadf50baa8adb1ad4e712ea3952d3e2c0f7d9923bd48

data/lib/core_ext/Numeric/convert.rb

@@ -10,10 +10,14 @@ module Safrano
           BigDecimal(to_s).to_s('F')
         end
 
-        def toDecimalPrecisionString(precision, scale = nil)
+        def toDecimalPrecisionString(precision)
           p = Integer(precision)
+          BigDecimal(self, p).to_s('F')
+        end
 
-          scale.nil? ? BigDecimal(self, p).to_s('F') : sprintf("%#{p + 2}.#{scale}f", self).strip
+        def toDecimalPrecisionScaleString(precision, scale)
+          p = Integer(precision)
+          sprintf("%#{p + 2}.#{scale}f", self).strip
         end
       end
     end

data/lib/odata/edm/primitive_types.rb

@@ -37,86 +37,87 @@ module Safrano
 
   # 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(props)
+  def self.add_edm_types(metadata, props)
     # try num/dec with db_type:
-    props[: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
-                             props[:edm_precision] = prec
-                             "Edm.Decimal(#{prec})"
-                           else
-                             # we have precision and scale
-                             props[:edm_scale] = scale
-                             props[:edm_precision] = prec
-                             "Edm.Decimal(#{prec},#{scale})"
-                           end
-                         elsif prec
-                           # we have precision only
-                           props[:edm_precision] = prec
-                           "Edm.Decimal(#{prec})"
-                         else
-                           'Edm.Decimal'
-                         end
-    end
-    return if props[:edm_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:
-    props[: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
-                           props[:edm_precision] = prec
-                           'Edm.Double'
-                         end
-    end
-    return if props[:edm_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
-    props[: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 props[:edm_type]
-
-    props[: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
+    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/model_ext.rb

@@ -35,6 +35,12 @@ module Safrano
     attr_reader :odata_upk_parts
     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
@@ -75,6 +81,7 @@ module Safrano
       @uparms = nil
       @params = nil
       @cx = nil
+      @cols_metadata = {}
     end
 
     def build_uri(uribase)
@@ -177,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[:edm_type] }
+                  'Type' => metadata[:edm_type] }
         attrs['Nullable'] = 'false' if prop[:allow_null] == false
         enty.add_element('Property', attrs)
       end
@@ -350,47 +358,79 @@ module Safrano
       end
     end
 
-    def finalize_publishing
-      build_type_name
-
-      # build default output template structure
-      build_default_template
-
-      # add edm_types into schema
-      db_schema.each do |_col, props|
-        Safrano.add_edm_types(props)
-      end
-
+    def build_casted_cols(service)
       # cols needed catsting before final json output
       @casted_cols = {}
       db_schema.each { |col, props|
-        if (props[:edm_precision] && (props[:edm_type] =~ /\AEdm.Decimal\(/i))
-          # we save the precision and scale in the lambda (binding!)
-          @casted_cols[col] = ->(x) {
-            # not sure if these copies are really needed, but feels better that way
-            x&.toDecimalPrecisionString(props[:edm_precision], props[:edm_scale])
-          }
+        # 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 props[:edm_type] == 'Edm.Decimal'
+        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 props[:edm_type] == 'Edm.Binary'
+        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
+
+      # 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/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'
@@ -138,6 +139,7 @@ module Safrano
     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
@@ -158,6 +160,7 @@ module Safrano
       @function_imports = {}
       @function_import_keys = []
       @cmap = {}
+      @type_mappings = {}
       instance_eval(&block) if block_given?
     end
 
@@ -242,6 +245,7 @@ module Safrano
       other.complex_types = @complex_types
       other.function_imports = @function_imports
       other.function_import_keys = @function_import_keys
+      other.type_mappings = @type_mappings
       other
     end
 
@@ -330,6 +334,11 @@ module Safrano
       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)
@@ -370,10 +379,10 @@ 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)
 
         # Output create (POST) as single entity (Standard) or as array (non-standard buggy)

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.4'
+  VERSION = '0.5.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: safrano
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.5
 platform: ruby
 authors:
 - oz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-17 00:00:00.000000000 Z
+date: 2021-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -166,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