odata_duty 0.30.0

data/lib/odata_duty/enum_type.rb

@@ -0,0 +1,71 @@
+module OdataDuty
+  class EnumMember
+    attr_reader :name
+
+    def initialize(name)
+      @name = name.to_str
+    end
+  end
+
+  class EnumType
+    def self.members
+      @members ||= []
+    end
+
+    def self.member(name)
+      members << EnumMember.new(name)
+    end
+
+    class Metadata
+      attr_reader :enum_type
+
+      def initialize(enum_type)
+        @enum_type = enum_type
+      end
+
+      def members
+        enum_type.members
+      end
+
+      def scalar?
+        true
+      end
+
+      def name
+        enum_type.to_s.split('::').last.sub(/EnumType\z/, '').sub(/Enum\z/, '')
+      end
+
+      def metadata_type
+        :enum
+      end
+
+      def property_type
+        name
+      end
+    end
+
+    def self.__metadata
+      Metadata.new(self)
+    end
+
+    attr_reader :object
+
+    def initialize(object, _context)
+      @object = object
+    end
+
+    def self.to_value(*)
+      new(*).__to_value
+    end
+
+    def __to_value
+      return object if __member_names.include?(object)
+
+      raise InvalidValue, "#{object} is not a valid member of #{__member_names}"
+    end
+
+    def __member_names
+      @__member_names ||= self.class.members.map(&:name)
+    end
+  end
+end

data/lib/odata_duty/errors.rb

@@ -0,0 +1,52 @@
+module OdataDuty
+  class Error < StandardError; end
+
+  class PropertyAlreadyDefinedError < ArgumentError; end
+  class InvalidNCNamesError < ArgumentError; end
+  class InitArgsMismatchError < ArgumentError; end
+
+  class RequestError < Error
+    attr_reader :code, :target
+
+    def initialize(message = 'Request Error', code: nil, target: nil)
+      super(message)
+      @code = code
+      @target = target
+    end
+
+    def status
+      :internal_server_error
+    end
+  end
+
+  class ServerError < RequestError; end
+
+  class NoImplementationError < ServerError
+    def status
+      :not_implemented
+    end
+  end
+
+  class NotYetSupportedError < NoImplementationError; end
+  class InvalidValue < ServerError; end
+
+  class ClientError < RequestError
+    def status
+      :bad_request
+    end
+  end
+
+  class ResourceNotFoundError < ClientError
+    def status
+      :not_found
+    end
+  end
+
+  class UnknownPropertyError < ClientError; end
+  class UnknownCollectionError < ClientError; end
+  class InvalidFilterValue < ClientError; end
+  class InvalidPropertyReferenceValue < ClientError; end
+  class InvalidType < ClientError; end
+  class NoSuchPropertyError < ClientError; end
+  class InvalidQueryOptionError < ClientError; end
+end

data/lib/odata_duty/executor.rb

@@ -0,0 +1,277 @@
+require_relative 'context_wrapper'
+require_relative 'parslet_search_expression'
+
+module OdataDuty
+  class Executor # rubocop:disable Metrics/ClassLength
+    def self.execute(**)
+      new(**).execute
+    end
+
+    def self.create(**)
+      new(**).create
+    end
+
+    def self.update(**)
+      new(**).update
+    end
+
+    def self.delete(**)
+      new(**).delete
+    end
+
+    attr_reader :schema, :url, :context, :query_options
+
+    def initialize(schema:, url:, context:, query_options:)
+      @schema = schema
+      @url = url
+      @context = context
+      @query_options = query_options
+    end
+
+    def points = schema.endpoints
+
+    def execute
+      set_builder = prepare_builder(endpoint, wrapped_context, query_options)
+      select = query_options['$select']
+      props = selected(endpoint.entity_type, select) if select
+      apply_select(set_builder, props)
+
+      if url.include?('(')
+        individual(set_builder, endpoint, wrapped_context, props)
+      elsif url.include?('/$count')
+        apply_search(set_builder, query_options['$search'])
+        set_builder.count
+      else
+        collection(set_builder, endpoint, wrapped_context, query_options, props)
+      end
+    end
+
+    def create
+      unless endpoint.supports_create?
+        raise NoImplementationError, "create not implemented for #{endpoint.url}"
+      end
+
+      Oj.dump(endpoint
+          .create(context: wrapped_context)
+          .merge(
+            '@odata.context': wrapped_context.od_full_url('$metadata',
+                                                          anchor: "#{endpoint.name}/$entity")
+          ),
+              mode: :compat)
+    end
+
+    def update
+      unless endpoint.supports_update?
+        raise NoImplementationError, "update not implemented for #{endpoint.url}"
+      end
+
+      entity_id = extract_value_from_brackets(url)
+      Oj.dump(endpoint
+          .update(entity_id, context: wrapped_context)
+          .merge(
+            '@odata.context': wrapped_context.od_full_url('$metadata',
+                                                          anchor: "#{endpoint.name}/$entity")
+          ),
+              mode: :compat)
+    end
+
+    def delete
+      unless endpoint.supports_delete?
+        raise NoImplementationError, "delete not implemented for #{endpoint.url}"
+      end
+
+      entity_id = extract_value_from_brackets(url)
+      endpoint.delete(entity_id, context: wrapped_context)
+      Oj.dump({ '@odata.context': wrapped_context.od_full_url('$metadata') }, mode: :compat)
+    end
+
+    def prepare_builder(endpoint, context, query_options)
+      endpoint.new_entity_set(context: context).tap do |set_builder|
+        filter = query_options['$filter']
+        apply_filter(endpoint, set_builder, filter) if query_options.key?('$filter')
+      end
+    end
+
+    private
+
+    def wrapped_context
+      @wrapped_context ||= ContextWrapper.new(context, base_url: schema.base_url,
+                                                       endpoint: endpoint,
+                                                       query_options: query_options)
+    end
+
+    def endpoint
+      @endpoint ||= points
+                    .find { |e| url.split('/$count').first.split('(').first == e.url }
+                    .tap do |result|
+        raise UnknownPropertyError, "No endpoint #{url} found in #{urls}" unless result
+      end
+    end
+
+    def urls = points.map(&:url)
+
+    def apply_filter(endpoint, set_builder, filter_string)
+      filters = Filter.parse(filter_string)
+      if Filter.or?(filter_string)
+        apply_or_filter(endpoint, set_builder, filters)
+      else
+        filters.each { |filter| apply_and_filter(endpoint, set_builder, filter) }
+      end
+    end
+
+    def apply_and_filter(endpoint, set_builder, filter)
+      value = filter_value(endpoint, set_builder, filter)
+      _filter(filter, set_builder, value)
+    end
+
+    def apply_or_filter(endpoint, set_builder, filters)
+      unless set_builder.respond_to?(:od_filter_or)
+        raise NoImplementationError, 'OR filtering not supported'
+      end
+
+      predicates = filters.map do |filter|
+        FilterPredicate.new(property_name: filter.property_name, operation: filter.operation,
+                            value: filter_value(endpoint, set_builder, filter))
+      end
+      set_builder.od_filter_or(predicates)
+    end
+
+    def filter_value(endpoint, set_builder, filter)
+      property = endpoint.entity_type.properties.find { |p| p.name == filter.property_name }
+      assert_filter_valid_for_property(filter, property)
+      property.filter_convert(filter.value, set_builder.context)
+    end
+
+    def assert_filter_valid_for_property(filter, property)
+      raise UnknownPropertyError, "No such property #{filter.property_name}" unless property
+
+      return unless property.collection?
+
+      raise InvalidQueryOptionError,
+            "Cannot apply '#{filter.operation}' to a collection property '#{property.name}'."
+    end
+
+    def _filter(filter, set_builder, value)
+      specific_method = :"od_filter_#{filter.property_name}_#{filter.operation}"
+      generic_method = :"od_filter_#{filter.operation}"
+      if set_builder.respond_to?(specific_method)
+        set_builder.public_send(specific_method, value)
+      elsif set_builder.respond_to?(generic_method)
+        set_builder.public_send(generic_method, filter.property_name, value)
+      else
+        raise NoImplementationError, "#{filter.property_name} #{filter.operation} not supported"
+      end
+    end
+
+    def extract_value_from_brackets(url)
+      match_data = url.match(/.*\(([^)]+)\)/)
+      return nil unless match_data
+
+      value = match_data[1]
+
+      value.gsub(/\A"|"\z/, '').gsub(/\A'|'\z/, '')
+    end
+
+    def selected(entity_type, select_query)
+      valid_selected(select_query.split(',').map(&:strip)).map do |p|
+        entity_type.properties.find { |a| a.name.to_s == p }.tap do |prop|
+          raise UnknownPropertyError, "The property '#{p}' does not exist" unless prop
+        end
+      end
+    rescue UnknownPropertyError, InvalidQueryOptionError => e
+      e.backtrace.unshift entity_type._defined_at_
+      raise
+    end
+
+    def valid_selected(selected)
+      selected.each do |p|
+        unless Property.valid_name?(p)
+          raise InvalidQueryOptionError, "The property '#{p}' is not valid"
+        end
+      end
+    end
+
+    def apply_remaining(query_options, set_builder)
+      query_options.except('$count', '$filter', '$select')
+                   .select { |k, _| k.start_with?('$') }.each do |k, v|
+        __send__("apply_#{k[1..]}", set_builder, v)
+      end
+    end
+
+    def apply_select(set_builder, props)
+      return unless set_builder.respond_to?(:od_select)
+
+      selected = (props || endpoint.entity_type.properties).map(&:name)
+      selected += endpoint.entity_type.property_refs.map(&:name)
+      set_builder.od_select(selected.uniq)
+    end
+
+    def apply_top(set_builder, top)
+      if !set_builder.respond_to?(:od_top) && top
+        raise NoImplementationError, "$top not implemented for #{set_builder.class}"
+      end
+
+      set_builder.od_top(top) if top
+    end
+
+    def apply_skip(set_builder, skip)
+      if !set_builder.respond_to?(:od_skip) && skip
+        raise NoImplementationError, "$skip not implemented for #{set_builder.class}"
+      end
+
+      set_builder.od_skip(skip) if skip
+    end
+
+    def apply_skiptoken(set_builder, skiptoken)
+      if !set_builder.respond_to?(:od_skiptoken) && skiptoken
+        raise NoImplementationError, "$skiptoken not implemented for #{set_builder.class}"
+      end
+
+      set_builder.od_skiptoken(skiptoken) if skiptoken
+    end
+
+    def apply_search(set_builder, search_string)
+      if !set_builder.respond_to?(:od_search) && search_string
+        raise NoImplementationError, "$search not implemented for #{set_builder.class}"
+      end
+
+      return unless search_string
+
+      search_expression = SearchExpression.parse(search_string)
+      set_builder.od_search(search_expression)
+    end
+
+    def add_next_link(data, set_builder, query_options, context)
+      return unless set_builder.od_next_link_skiptoken
+
+      next_query_options = query_options.merge(:$skiptoken => set_builder.od_next_link_skiptoken)
+      data[:'@odata.nextLink'] = context.od_full_url(url, **next_query_options)
+    end
+
+    require 'oj'
+
+    def collection(set_builder, endpoint, context, query_options, props)
+      count = set_builder.count if query_options['$count'] == 'true'
+      apply_remaining(query_options, set_builder)
+      data = { '@odata.context' => context.od_full_url('$metadata', anchor: endpoint.name),
+               'value' => endpoint.collection(set_builder, context: context, selected: props) }
+      data['@odata.count'] = count if count
+      add_next_link(data, set_builder, query_options, context)
+      Oj.dump(data, mode: :compat)
+    end
+
+    def individual(set_builder, endpoint, context, props)
+      entity_id = extract_value_from_brackets(url)
+      apply_remaining(query_options, set_builder)
+
+      Oj.dump(
+        endpoint
+          .individual(set_builder, entity_id, context: context, selected: props)
+          .merge(
+            '@odata.context': context.od_full_url('$metadata', anchor: "#{endpoint.name}/$entity")
+          ),
+        mode: :compat
+      )
+    end
+  end
+end

data/lib/odata_duty/filter.rb

@@ -0,0 +1,76 @@
+module OdataDuty
+  class Filter
+    def self.parse(str)
+      validate(str)
+      separator = or?(str) ? ' or ' : ' and '
+      split_outside_quotes(str, separator).map { |s| new(s) }
+    end
+
+    def self.or?(str)
+      mask_quoted(str).include?(' or ')
+    end
+
+    def self.validate(str)
+      masked = mask_quoted(str)
+      if masked.include?(' and ') && masked.include?(' or ')
+        raise NotYetSupportedError, 'mixed AND/OR not supported'
+      end
+
+      %w[add sub mul div mod].each do |operator|
+        if masked.include?(" #{operator} ")
+          raise NotYetSupportedError,
+                'filtering with arithmetic operators not supported'
+        end
+      end
+      return unless masked.include?('(')
+
+      raise NotYetSupportedError,
+            'filtering does not support functions or Grouping Operators'
+    end
+
+    # Replace the contents of single-quoted literals with spaces so substring
+    # checks never match separators inside a value. Doubled quotes ('') escape.
+    def self.mask_quoted(str)
+      in_quote = false
+      str.each_char.map do |char|
+        if char == "'"
+          in_quote = !in_quote
+          char
+        else
+          in_quote ? ' ' : char
+        end
+      end.join
+    end
+
+    def self.split_outside_quotes(str, separator)
+      remaining = str.dup
+      mask_quoted(str).split(separator).map do |masked_segment|
+        segment = remaining.slice!(0, masked_segment.length)
+        remaining.slice!(0, separator.length)
+        segment
+      end
+    end
+
+    private_class_method :mask_quoted, :split_outside_quotes
+
+    def initialize(filter_string)
+      @property_name, @operation, @value = filter_string.split(nil, 3)
+    end
+
+    def value
+      @value.delete_prefix("'").delete_suffix("'")
+    end
+
+    def operation
+      @operation.to_sym
+    end
+
+    def property_name
+      if @property_name.include?('/')
+        raise NotYetSupportedError, 'nested property filtering not supported yet'
+      end
+
+      @property_name.to_sym
+    end
+  end
+end

data/lib/odata_duty/filter_predicate.rb

@@ -0,0 +1,12 @@
+module OdataDuty
+  class FilterPredicate
+    attr_reader :property_name, :operation, :value
+
+    def initialize(property_name:, operation:, value:)
+      @property_name = property_name
+      @operation = operation
+      @value = value
+      freeze
+    end
+  end
+end

data/lib/odata_duty/mapper_builder.rb

@@ -0,0 +1,86 @@
+require 'securerandom'
+
+module OdataDuty
+  class MapperBuilder
+    def self.build(complex_type, selected: nil, &)
+      mapper_class = build_class(complex_type, selected: selected)
+      mapper_class.new(complex_type, &)
+    end
+
+    def self.build_class(complex_type, selected:)
+      @dynamic_classes ||= {}
+      @dynamic_classes[complex_type] ||= {}
+      complex_classes = @dynamic_classes.fetch(complex_type)
+      selected_key = selected&.map(&:name)&.sort
+      complex_classes[selected_key] ||= eval_erb_class(complex_type, selected: selected)
+    end
+
+    require 'erb'
+    ERB_TEMPLATE = ERB.new(File.read("#{__dir__}/dynamic_object_wrapper.rb.erb"), trim_mode: '<>')
+    ERB_TEMPLATE.location = ["#{__dir__}/dynamic_object_wrapper.rb.erb", 1]
+    ERB_TEMPLATE.freeze
+
+    def self.eval_erb_class(complex_type, selected:)
+      properties = selected || complex_type.properties
+      class_result = ERB_TEMPLATE.result(binding)
+
+      eval(class_result) # rubocop:disable Security/Eval
+    end
+
+    attr_accessor :obj, :context
+    attr_reader :complex_type, :set_types, :calling_methods
+
+    # generated mappers fetch only the entries they need, so no filtering here
+    def initialize(complex_type, &block)
+      @complex_type = complex_type
+      @set_types = complex_type.properties.to_h { |cp| [cp.name, cp.set_type] }
+      @calling_methods = complex_type.properties.to_h { |cp| [cp.name, cp.calling_method] }
+      @block = block
+    end
+
+    def wrapped_obj
+      @wrapped_obj ||= complex_type.new(obj, context)
+    end
+
+    def obj_to_hash(obj, context)
+      @wrapped_obj = nil
+      self.context = context
+      self.obj = obj
+      base_hash = to_h
+      @block.call(base_hash, obj)
+      base_hash
+    end
+
+    def obj_to_base_hash(obj)
+      return nil if obj.nil?
+
+      @wrapped_obj = nil
+      self.obj = obj
+      to_h
+    end
+
+    VALID_BOOLEAN_VALUES = [true, false, nil].freeze
+
+    def confirm_boolean(name, value)
+      case value
+      when true, false, nil
+        value
+      else
+        raise InvalidValue, "Property #{name} must be a boolean and not #{value}"
+      end
+    end
+
+    def not_nullable(name, value)
+      raise InvalidValue, "Property #{name} cannot be null" if value.nil?
+
+      value
+    end
+
+    def confirm_one_of(name, value, valid_values)
+      return nil if value.nil?
+      return value if valid_values.include?(value)
+
+      raise InvalidValue, "Property #{name} must be one of #{valid_values} and not #{value}"
+    end
+  end
+end

data/lib/odata_duty/mcp_input_schemas.rb

@@ -0,0 +1,59 @@
+module OdataDuty
+  module McpInputSchemas
+    extend self
+
+    # Property names are used as-is (symbols) for keys/required and the root `type: object` is
+    # omitted; the MCP SDK normalizes the keys and supplies the root type default.
+
+    def count_input_schema(supports_search:)
+      properties = { '$filter' => { 'type' => 'string' } }
+      properties['$search'] = { 'type' => 'string' } if supports_search
+      { 'properties' => properties, 'required' => [] }
+    end
+
+    def list_input_schema(supports_search:)
+      properties = {
+        '$filter' => { 'type' => 'string', 'description' => 'OData $filter expression' },
+        '$select' => { 'type' => 'string',
+                       'description' => 'Comma-separated properties to return' }
+      }
+      if supports_search
+        properties['$search'] = { 'type' => 'string',
+                                  'description' => 'Search expression (AND, OR, NOT)' }
+      end
+      properties['$top'] = { 'type' => 'integer', 'description' => 'Max records to return' }
+      properties['$skip'] = { 'type' => 'integer', 'description' => 'Records to skip' }
+      { 'properties' => properties, 'required' => [] }
+    end
+
+    def create_input_schema(entity_type)
+      writable = entity_type.properties.select(&:settable_on_create?)
+      properties = writable.to_h { |p| [p.name, p.to_oas2] }
+      required = writable.reject(&:nullable).map(&:name)
+      { 'properties' => properties, 'required' => required }
+    end
+
+    def update_input_schema(entity_type)
+      key = entity_type.property_refs.first
+      writable = entity_type.properties.select(&:settable_on_update?)
+      properties = { key.name => key.to_oas2 }
+      writable.each { |p| properties[p.name] = p.to_oas2 }
+      { 'properties' => properties, 'required' => [key.name] }
+    end
+
+    def get_input_schema(entity_type)
+      key = entity_type.property_refs.first
+      properties = {
+        key.name => key.to_oas2,
+        '$select' => { 'type' => 'string',
+                       'description' => 'Comma-separated properties to return' }
+      }
+      { 'properties' => properties, 'required' => [key.name] }
+    end
+
+    def delete_input_schema(entity_type)
+      key = entity_type.property_refs.first
+      { 'properties' => { key.name => key.to_oas2 }, 'required' => [key.name] }
+    end
+  end
+end