odata_duty 0.30.0

data/lib/odata_duty/property/collection_prop.rb

@@ -0,0 +1,25 @@
+require_relative 'single_prop'
+
+module OdataDuty
+  module Property
+    class CollectionProp < SingleProp
+      def convert(value, context)
+        value.map { |v| super(v, context) }
+      rescue NoMethodError
+        raise InvalidValue, "#{value} is not an collection"
+      end
+
+      def to_oas2_type
+        if scalar?
+          raw_type.to_oas2(is_collection: true)
+        else
+          { 'type' => 'array', 'items' => { '$ref' => "#/definitions/#{raw_type.name}" } }
+        end
+      end
+
+      def collection?
+        true
+      end
+    end
+  end
+end

data/lib/odata_duty/property/single_prop.rb

@@ -0,0 +1,131 @@
+module OdataDuty
+  module Property
+    CORE_ANNOTATION_TERMS = { computed: 'Org.OData.Core.V1.Computed',
+                              immutable: 'Org.OData.Core.V1.Immutable' }.freeze
+
+    class SingleProp
+      attr_reader :name, :nullable, :calling_method, :line__defined__at, :raw_type, :type,
+                  :set_type, :method_name, :mutability
+
+      def initialize(name, type, line__defined__at:, nullable:, method:, mutability:)
+        @line__defined__at = line__defined__at
+        @name = name.to_sym
+        @calling_method = method if method.respond_to?(:call)
+        method = nil if method.respond_to?(:call)
+        @method_name = (method || name).to_sym
+        @nullable = nullable ? true : false
+        @mutability = mutability
+        load_type_instance_vars(type)
+      end
+
+      def computed?
+        mutability == :computed
+      end
+
+      def immutable?
+        mutability == :immutable
+      end
+
+      def non_insertable?
+        mutability == :non_insertable
+      end
+
+      def core_annotation_term
+        CORE_ANNOTATION_TERMS[mutability]
+      end
+
+      def settable_on_create?
+        !computed? && !non_insertable?
+      end
+
+      def settable_on_update?
+        !computed? && !immutable?
+      end
+
+      def calling_method?
+        !calling_method.nil?
+      end
+
+      def nullable?
+        nullable
+      end
+
+      def boolean?
+        raw_type == EdmBool
+      end
+
+      def string?
+        raw_type == EdmString
+      end
+
+      def int?
+        raw_type == EdmInt64
+      end
+
+      def date?
+        raw_type == EdmDate
+      end
+
+      def datetime?
+        raw_type == EdmDateTimeOffset
+      end
+
+      def enum?
+        raw_type.respond_to?(:members)
+      end
+
+      def enum_members
+        raw_type.members
+      end
+
+      def scalar?
+        raw_type.scalar?
+      end
+
+      def to_value(value, context)
+        convert(value, context)
+      rescue InvalidValue => e
+        raise InvalidValue, "#{name} : #{e}"
+      end
+
+      def convert(value, context)
+        return if value.nil?
+
+        @set_type.to_value(value, context)
+      end
+
+      def filter_convert(value, context)
+        convert(value, context)
+      rescue OdataDuty::InvalidValue
+        raise InvalidFilterValue, "Invalid value #{value} for #{name}"
+      end
+
+      def to_oas2
+        to_oas2_type.dup.tap do |oas2|
+          oas2.merge!('readOnly' => true) if computed?
+          oas2.merge!('x-nullable' => true) if nullable
+        end
+      end
+
+      def to_oas2_type
+        return raw_type.to_oas2(is_collection: false) if scalar? && !enum?
+
+        { '$ref' => "#/definitions/#{raw_type.name}" }
+      end
+
+      # nil (falsy) rather than false: callers only consume truthiness
+      def collection?; end
+
+      private
+
+      def load_type_instance_vars(type)
+        type = Array(type).first
+        @set_type = TYPES_MAPPING[type] || type
+        raise "Invalid type #{type.inspect} for #{name}" unless @set_type
+
+        @raw_type = @set_type.respond_to?(:__metadata) ? @set_type.__metadata : @set_type
+        @type = @raw_type.respond_to?(:property_type) ? @raw_type.property_type : @raw_type.name
+      end
+    end
+  end
+end

data/lib/odata_duty/property.rb

@@ -0,0 +1,49 @@
+require 'odata_duty/edms'
+require 'odata_duty/property/single_prop'
+require 'odata_duty/property/collection_prop'
+
+module OdataDuty
+  module Property
+    MUTABILITIES = %i[read_write immutable non_insertable computed].freeze
+    MUTABILITIES_LIST = MUTABILITIES.map(&:inspect).join(', ').freeze
+
+    def self.new(name, type = String, line__defined__at: nil, nullable: true, method: nil,
+                 computed: :unset, mutability: :unset)
+      unless valid_name?(name)
+        raise InvalidNCNamesError, "\"#{name}\" is not a valid property name"
+      end
+
+      prop_class = type.instance_of?(Array) ? CollectionProp : SingleProp
+      prop_class.new(name, type,
+                     line__defined__at: line__defined__at,
+                     nullable: nullable,
+                     method: method,
+                     mutability: resolve_mutability(name, computed, mutability))
+    end
+
+    def self.resolve_mutability(name, computed, mutability)
+      mutability = computed_to_mutability(name, computed, mutability) unless computed == :unset
+      mutability = :read_write if mutability == :unset
+      return mutability if MUTABILITIES.include?(mutability)
+
+      raise ArgumentError,
+            "#{name}: invalid mutability #{mutability.inspect}, " \
+            "must be one of #{MUTABILITIES_LIST}"
+    end
+
+    def self.computed_to_mutability(name, computed, mutability)
+      unless mutability == :unset
+        raise ArgumentError,
+              "#{name}: pass either `mutability:` or `computed:`, not both \u2014 they control " \
+              'the same axis'
+      end
+      computed ? :computed : :read_write
+    end
+
+    NAME_REGEXP = Regexp.new('\A(?:\p{L}|_)(?:[\p{L}\p{Nd}_])*\z').freeze
+
+    def self.valid_name?(name)
+      name.match?(NAME_REGEXP)
+    end
+  end
+end

data/lib/odata_duty/railtie.rb

@@ -0,0 +1,11 @@
+require 'rails/railtie'
+
+module OdataDuty
+  class Railtie < Rails::Railtie
+    # Auto-load generators
+    generators do
+      require 'generators/odata_duty/install/install_generator'
+      require 'generators/odata_duty/entity_set/entity_set_generator'
+    end
+  end
+end

data/lib/odata_duty/schema_builder/complex_type.rb

@@ -0,0 +1,34 @@
+require_relative 'data_type'
+require_relative '../mapper_builder'
+
+module OdataDuty
+  module SchemaBuilder
+    class ComplexType < DataType
+      attr_reader :properties
+
+      def initialize(**kwargs)
+        super
+        @properties = []
+      end
+
+      def property(name, *args, line__defined__at: caller.first, **kwargs)
+        if properties.any? { |p| p.name == name.to_sym }
+          raise PropertyAlreadyDefinedError, "#{name} is already defined"
+        end
+
+        Property.new(name, *args, line__defined__at: line__defined__at, **kwargs).tap do |property|
+          properties << property
+        end
+      end
+
+      def to_oas2
+        {
+          'type' => 'object',
+          'properties' => properties.to_h do |property|
+                            [property.name.to_s, property.to_oas2]
+                          end
+        }
+      end
+    end
+  end
+end

data/lib/odata_duty/schema_builder/container.rb

@@ -0,0 +1,16 @@
+module OdataDuty
+  module SchemaBuilder
+    class Container
+      attr_reader :name, :_defined_at_
+
+      def initialize(name:)
+        @name = name.clone
+        @_defined_at_ = caller.find { |line| !line.include?('/lib/odata_duty/') }
+
+        return if Property.valid_name?(@name)
+
+        raise InvalidNCNamesError, "\"#{@name}\" is not a valid property name"
+      end
+    end
+  end
+end

data/lib/odata_duty/schema_builder/data_type.rb

@@ -0,0 +1,18 @@
+module OdataDuty
+  module SchemaBuilder
+    class DataType
+      attr_reader :name, :_defined_at_
+
+      def initialize(name:)
+        @name = name.clone
+        @_defined_at_ = caller.find { |line| !line.include?('/lib/odata_duty/') }
+
+        return if Property.valid_name?(@name)
+
+        raise InvalidNCNamesError, "\"#{@name}\" is not a valid property name"
+      end
+
+      def scalar?; end
+    end
+  end
+end

data/lib/odata_duty/schema_builder/endpoint.rb

@@ -0,0 +1,117 @@
+module OdataDuty
+  module SchemaBuilder
+    class Endpoint
+      attr_reader :entity_set
+
+      def initialize(entity_set)
+        @entity_set = entity_set
+      end
+
+      def name = entity_set.name
+      def url = entity_set.url
+
+      def new_entity_set(context:)
+        entity_set.resolver_class.new(context: context, init_args: entity_set.init_args)
+      end
+
+      def entity_type = entity_set.entity_type
+
+      def collection(set_builder, context:, selected:)
+        unless set_builder.respond_to?(:collection)
+          raise NoImplementationError, "collection not implemented for #{set_builder.class}"
+        end
+
+        values = set_builder.collection
+        mapper = entity_type.mapper(context, selected: selected)
+
+        # builder mapping never reads context; pass nil (accept equivalent mutant)
+        values.map { |v| mapper.obj_to_hash(v, nil) }
+      rescue StandardError => e
+        extend_error(e, set_builder, :collection)
+      end
+
+      def individual(set_builder, id, context:, selected:)
+        unless set_builder.respond_to?(:individual)
+          raise NoImplementationError, "individual not implemented for #{set_builder.class}"
+        end
+
+        result = set_builder.individual(converted_id(id))
+        raise ResourceNotFoundError, "No such entity #{id}" unless result
+
+        entity_type.mapper(context, selected: selected).obj_to_hash(result, nil)
+      rescue StandardError => e
+        extend_error(e, set_builder, :individual)
+      end
+
+      def create(context:)
+        wrapper = CreateComplexTypeHashWrapper.new(context.query_options, entity_type,
+                                                   operation: :create, context: context)
+        result = new_entity_set(context: context).create(wrapper)
+        mapper = entity_type.mapper(context, selected: nil)
+        mapper.obj_to_hash(result, nil)
+      end
+
+      def supports_search?
+        entity_set.supports_search?
+      end
+
+      def supports_collection?
+        entity_set.supports_collection?
+      end
+
+      def supports_individual?
+        entity_set.supports_individual?
+      end
+
+      def supports_count?
+        entity_set.supports_count?
+      end
+
+      def update(id, context:)
+        wrapper = CreateComplexTypeHashWrapper.new(context.query_options, entity_type,
+                                                   operation: :update, context: context)
+        result = new_entity_set(context: context).update(converted_id(id), wrapper)
+        raise ResourceNotFoundError, "No such entity #{id}" unless result
+
+        entity_type.mapper(context, selected: nil).obj_to_hash(result, nil)
+      end
+
+      def delete(id, context:)
+        result = new_entity_set(context: context).delete(converted_id(id))
+        raise ResourceNotFoundError, "No such entity #{id}" unless result
+      end
+
+      def supports_create?
+        entity_set.supports_create?
+      end
+
+      def supports_update?
+        entity_set.supports_update?
+      end
+
+      def supports_delete?
+        entity_set.supports_delete?
+      end
+
+      private
+
+      def extend_error(err, set_builder, method_name)
+        klass = set_builder.class
+        err.backtrace.unshift(entity_set._defined_at_)
+        if set_builder.respond_to?(:od_after_init)
+          err.backtrace.unshift(klass.instance_method(:od_after_init).source_location.join(':'))
+        end
+        if set_builder.respond_to?(method_name)
+          err.backtrace.unshift(klass.instance_method(method_name).source_location.join(':'))
+        end
+        raise
+      end
+
+      def converted_id(id)
+        entity_type.property_refs.first.convert(id, nil)
+      rescue OdataDuty::InvalidValue => e
+        raise InvalidPropertyReferenceValue, "Invalid individual id : #{e}"
+      end
+    end
+  end
+end

data/lib/odata_duty/schema_builder/entity_set.rb

@@ -0,0 +1,67 @@
+require 'delegate'
+require_relative 'container'
+
+module OdataDuty
+  module SchemaBuilder
+    class EntitySet < Container
+      attr_reader :entity_type, :url, :resolver, :init_args
+
+      def initialize(entity_type:, resolver:, name: nil, url: nil, init_args: nil)
+        @resolver = resolver.clone
+        name = name&.to_s || @resolver.split('::').last.sub(/Resolver\z/, '')
+        super(name: name)
+        @url = (url&.to_s || @name).clone
+        @entity_type = entity_type
+        @init_args = init_args
+      end
+
+      def entity_type_name = entity_type.name
+
+      def resolver_class = Module.const_get(resolver)
+
+      def supports_search?
+        # Check if the resolver class supports search by looking for the od_search method
+        resolver_class.method_defined?(:od_search)
+      end
+
+      def supports_filter_or?
+        resolver_class.method_defined?(:od_filter_or)
+      end
+
+      def supports_collection?
+        # Check if the resolver class supports read by looking for the collection method
+        resolver_class.method_defined?(:collection)
+      end
+
+      def supports_individual?
+        # Check if the resolver class supports read-by-id via the individual method
+        resolver_class.method_defined?(:individual)
+      end
+
+      def supports_count?
+        # Check if the resolver class supports counting via the count method
+        resolver_class.method_defined?(:count)
+      end
+
+      def supports_create?
+        # Check if the resolver class supports create by looking for the create method
+        resolver_class.method_defined?(:create)
+      end
+
+      def supports_update?
+        # Check if the resolver class supports update by looking for the update method
+        resolver_class.method_defined?(:update)
+      end
+
+      def supports_delete?
+        # Check if the resolver class supports delete by looking for the delete method
+        resolver_class.method_defined?(:delete)
+      end
+
+      def non_insertable_property_names
+        @non_insertable_property_names ||=
+          entity_type.properties.select(&:non_insertable?).map(&:name)
+      end
+    end
+  end
+end

data/lib/odata_duty/schema_builder/entity_type.rb

@@ -0,0 +1,49 @@
+require_relative 'complex_type'
+
+module OdataDuty
+  module SchemaBuilder
+    class EntityType < ComplexType
+      attr_reader :property_refs
+
+      def initialize(**kwargs)
+        super
+        @property_refs = []
+      end
+
+      def property_ref(*args, **kwargs)
+        kwargs[:mutability] = :computed unless kwargs.key?(:mutability) || kwargs.key?(:computed)
+        property(*args, nullable: false, **kwargs).tap do |property|
+          raise 'Multiple Property Reference not yet supported' if property_refs.size.positive?
+
+          property_refs << property
+        end
+      end
+
+      def mapper(context, selected:)
+        context.current['odata_url_base'] ||= context.od_full_url(context.endpoint.url)
+        if integer_property_ref?
+          int_mapper(context, selected: selected)
+        else
+          string_mapper(context, selected: selected)
+        end
+      end
+
+      def int_mapper(context, selected:)
+        MapperBuilder.build(self, selected: selected) do |result, obj|
+          result['@odata.id'] = "#{context.current.fetch('odata_url_base')}(#{obj.id})"
+        end
+      end
+
+      def string_mapper(context, selected:)
+        MapperBuilder.build(self, selected: selected) do |result, obj|
+          result['@odata.id'] = "#{context.current.fetch('odata_url_base')}('#{obj.id}')"
+        end
+      end
+
+      def integer_property_ref?
+        @property_ref_raw_type ||= property_refs.first.raw_type
+        @property_ref_raw_type == EdmInt64
+      end
+    end
+  end
+end

data/lib/odata_duty/schema_builder/enum_type.rb

@@ -0,0 +1,32 @@
+require_relative 'data_type'
+
+module OdataDuty
+  module SchemaBuilder
+    class EnumType < DataType
+      attr_reader :members
+
+      def initialize(**kwargs)
+        super
+        @members = []
+      end
+
+      def member(*)
+        @members << EnumMember.new(*)
+      end
+
+      def scalar?
+        true
+      end
+
+      def to_value(val, _context)
+        return val if members.map(&:name).include?(val)
+
+        raise InvalidValue, "#{val} is not a valid member of #{members}"
+      end
+
+      def to_oas2
+        { 'type' => 'string', 'enum' => members.map(&:name) }
+      end
+    end
+  end
+end

data/lib/odata_duty/schema_builder.rb

@@ -0,0 +1,130 @@
+require_relative 'schema_builder/enum_type'
+require_relative 'schema_builder/complex_type'
+require_relative 'schema_builder/entity_type'
+require_relative 'schema_builder/entity_set'
+require_relative 'schema_builder/endpoint'
+
+module OdataDuty
+  module SchemaBuilder
+    def self.build(**kwargs, &block)
+      Schema.new(**kwargs).tap { |s| block.call(s) }
+    end
+
+    class Schema
+      attr_reader :namespace, :host, :scheme, :base_path, :base_url, :types
+      attr_accessor :version, :title
+
+      def initialize(namespace:, host: 'localhost', scheme: 'https', base_path: '')
+        @namespace = namespace.to_str.clone.freeze
+        @host = host.to_str.clone.freeze
+        @scheme = scheme.to_str.clone.freeze
+        @base_path = base_path.to_str.clone.freeze
+        @base_url = [scheme, '://', host, base_path].join.freeze
+        @types = {}
+        @containers = {}
+      end
+
+      def inspect
+        "#<#{self.class} @namespace=#{@namespace} @base_path=#{@base_path} \
+ containers=#{@containers.keys} types=#{@types.keys}>"
+      end
+
+      def add_complex_type(**kwargs, &block)
+        ComplexType.new(**kwargs).tap do |complex_type|
+          add_type complex_type
+          block.call(complex_type)
+        end
+      end
+
+      def add_enum_type(**kwargs, &block)
+        EnumType.new(**kwargs).tap do |enum_type|
+          add_type enum_type
+          block.call(enum_type)
+        end
+      end
+
+      def add_entity_type(**kwargs, &block)
+        EntityType.new(**kwargs).tap do |entity_type|
+          add_type entity_type
+          block.call(entity_type)
+        end
+      end
+
+      def add_entity_set(**kwargs)
+        EntitySet.new(**kwargs).tap { |entity_set| add_container(entity_set) }
+      end
+
+      def endpoints
+        entity_sets.map { |entity_set| Endpoint.new(entity_set) }
+      end
+
+      def enum_types
+        all_types.grep(EnumType)
+      end
+
+      def complex_types
+        all_types.select { |t| t.instance_of?(ComplexType) }
+      end
+
+      def entity_types
+        all_types.grep(EntityType)
+      end
+
+      def entity_sets = all_containers
+
+      def collection_entity_sets
+        entity_sets.select { |t| t.resolver_class.method_defined?(:collection) }
+      end
+
+      def individual_entity_sets
+        entity_sets.select { |t| t.resolver_class.method_defined?(:individual) }
+      end
+
+      def execute(url, context:, query_options: {})
+        Executor.execute(url: url, context: context, query_options: query_options, schema: self)
+      end
+
+      def create(url, context:, query_options: nil)
+        Executor.create(url: url, context: context, query_options: query_options, schema: self)
+      end
+
+      def update(url, context:, query_options: nil)
+        Executor.update(url: url, context: context, query_options: query_options, schema: self)
+      end
+
+      def delete(url, context:, query_options: nil)
+        Executor.delete(url: url, context: context, query_options: query_options, schema: self)
+      end
+
+      def to_mcp_server
+        McpServerBuilder.build(self)
+      end
+
+      def metadata_xml
+        EdmxSchema.metadata_xml(self)
+      end
+
+      def index_hash
+        EdmxSchema.index_hash(self)
+      end
+
+      private
+
+      def add_type(type)
+        raise "Duplicate #{type.name} type" if @types.key?(type.name)
+
+        @types[type.name] = type
+      end
+
+      def all_types = @types.values.sort_by(&:name)
+
+      def add_container(type)
+        raise "Duplicate #{type.name} Container" if @containers.key?(type.name)
+
+        @containers[type.name] = type
+      end
+
+      def all_containers = @containers.values.sort_by(&:name)
+    end
+  end
+end