odata_duty 0.30.0

data/lib/odata_duty/set_resolver.rb

@@ -0,0 +1,51 @@
+module OdataDuty
+  class SetResolver
+    attr_reader :context
+
+    def initialize(context:, init_args:)
+      @context = context
+      return unless respond_to?(:od_after_init)
+
+      begin
+        call_od_after_init(init_args)
+      rescue InitArgsMismatchError => e
+        e.backtrace.insert(1, entity_set._defined_at_)
+        raise
+      rescue StandardError => e
+        e.backtrace.insert(2, entity_set._defined_at_)
+        raise
+      end
+    end
+
+    def od_next_link_skiptoken(token = nil)
+      @od_next_link_skiptoken = token.to_s if token
+      @od_next_link_skiptoken
+    end
+
+    private
+
+    def call_od_after_init(init_args)
+      case init_args
+      when nil then od_after_init
+      when Hash then od_after_init(**init_args)
+      when Array then od_after_init(*init_args)
+      else od_after_init(init_args)
+      end
+    rescue ArgumentError => e
+      handle_init_args_error(e)
+    end
+
+    def handle_init_args_error(arg_error)
+      raise unless arg_error.backtrace.first.include?("od_after_init'")
+
+      err = InitArgsMismatchError.new(arg_error)
+      err.set_backtrace(arg_error.backtrace)
+
+      raise err
+    end
+
+    def entity_set
+      context.endpoint.entity_set
+    end
+  end
+end

data/lib/odata_duty.rb

@@ -0,0 +1,311 @@
+require 'odata_duty/errors'
+require 'odata_duty/set_resolver'
+require 'odata_duty/schema_builder'
+require 'odata_duty/edmx_schema'
+require 'odata_duty/executor'
+require 'odata_duty/mcp_server_builder'
+require 'odata_duty/oas2'
+require 'odata_duty/property'
+require 'odata_duty/enum_type'
+require 'odata_duty/complex_type'
+require 'odata_duty/entity_type'
+require 'odata_duty/filter'
+require 'odata_duty/filter_predicate'
+require 'odata_duty/create_complex_type_hash_wrapper'
+# :nocov: Rails is not loaded when this file is required in the test suite
+require 'odata_duty/railtie' if defined?(Rails::Railtie)
+# :nocov:
+
+module OdataDuty
+  class EntitySet
+    def self.entity_type(entity_type = nil)
+      @entity_type = entity_type if entity_type
+      @entity_type
+    end
+
+    def self.name(name = nil)
+      @name = name.to_s if name.is_a?(Symbol)
+      @name = name.to_str if name && !name.is_a?(Symbol)
+      @name
+    end
+
+    def self.url(url = nil)
+      @url = url.to_s if url.is_a?(Symbol)
+      @url = url.to_str if url && !url.is_a?(Symbol)
+      @url
+    end
+
+    class Metadata
+      attr_reader :entity_set
+
+      def initialize(entity_set)
+        @entity_set = entity_set
+      end
+
+      def metadata_types
+        [entity_type].map(&:__metadata).flat_map(&:metadata_types)
+      end
+
+      def name
+        entity_set.name ||
+          entity_set.to_s.split('::').last.sub(/EntitySet\z/, '').sub(/Set\z/, '')
+      end
+
+      def entity_type
+        entity_set.entity_type
+      end
+
+      def entity_type_name
+        entity_type.__metadata.name
+      end
+
+      def kind
+        'EntitySet'
+      end
+
+      def url
+        entity_set.url || name
+      end
+
+      def new_entity_set(context:)
+        entity_set.new(context: context)
+      end
+
+      def collection(set_builder, context:, selected:)
+        begin
+          values = set_builder.collection
+        rescue NoMethodError
+          raise NoImplementationError, "collection not implemented for #{entity_set}"
+        end
+
+        mapper = entity_type.mapper(context, selected: selected)
+
+        values.map { |v| mapper.obj_to_hash(v, context) }
+      end
+
+      def individual(set_builder, id, context:, selected:)
+        begin
+          result = set_builder.individual(converted_id(id))
+        rescue NoMethodError
+          raise NoImplementationError, "individual not implemented for #{entity_set}"
+        end
+
+        raise ResourceNotFoundError, "No such entity #{id}" unless result
+
+        entity_type.mapper(context, selected: selected).obj_to_hash(result, context)
+      end
+
+      def create(context:)
+        wrapper = CreateComplexTypeHashWrapper.new(context.query_options, entity_type,
+                                                   operation: :create, context: context)
+        result = entity_set.new(context: context)
+                           .create(wrapper)
+        mapper = entity_type.mapper(context, selected: nil)
+        mapper.obj_to_hash(result, context)
+      end
+
+      def update(id, context:)
+        wrapper = CreateComplexTypeHashWrapper.new(context.query_options, entity_type,
+                                                   operation: :update, context: context)
+        result = entity_set.new(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, context)
+      end
+
+      def delete(id, context:)
+        result = entity_set.new(context: context).delete(converted_id(id))
+        raise ResourceNotFoundError, "No such entity #{id}" unless result
+      end
+
+      def supports_search?
+        # Check if the entity set class supports search by looking for the od_search method
+        entity_set.method_defined?(:od_search)
+      end
+
+      def supports_filter_or?
+        entity_set.method_defined?(:od_filter_or)
+      end
+
+      def supports_collection?
+        # Check if the entity set class supports read by looking for the collection method
+        entity_set.method_defined?(:collection)
+      end
+
+      def supports_individual?
+        # Check if the entity set class supports read-by-id via the individual method
+        entity_set.method_defined?(:individual)
+      end
+
+      def supports_count?
+        # Check if the entity set class supports counting via the count method
+        entity_set.method_defined?(:count)
+      end
+
+      def supports_create?
+        # Check if the entity set class supports create by looking for the create method
+        entity_set.method_defined?(:create)
+      end
+
+      def supports_update?
+        # Check if the entity set class supports update by looking for the update method
+        entity_set.method_defined?(:update)
+      end
+
+      def supports_delete?
+        # Check if the entity set class supports delete by looking for the delete method
+        entity_set.method_defined?(:delete)
+      end
+
+      def non_insertable_property_names
+        @non_insertable_property_names ||=
+          entity_type.properties.select(&:non_insertable?).map(&:name)
+      end
+
+      private
+
+      def converted_id(id)
+        entity_type.property_refs.first.convert(id, nil)
+      rescue OdataDuty::InvalidValue => e
+        raise InvalidPropertyReferenceValue, "Invalid individual id : #{e}"
+      end
+    end
+
+    def self.__metadata
+      Metadata.new(self)
+    end
+
+    attr_reader :context
+
+    def initialize(context:)
+      @context = context
+      od_after_init
+    end
+
+    def od_after_init; end
+
+    def od_next_link_skiptoken(token = nil)
+      @od_next_link_skiptoken = token.to_s if token
+      @od_next_link_skiptoken
+    end
+  end
+
+  class Schema
+    def self.namespace(name = nil)
+      @namespace = name if name
+      @namespace
+    end
+
+    def self.version(name = nil)
+      @version = name if name
+      @version
+    end
+
+    def self.title(name = nil)
+      @title = name if name
+      @title
+    end
+
+    def self.entity_sets(entity_sets = nil)
+      @entity_sets = entity_sets.uniq if entity_sets
+      @entity_sets
+    end
+
+    def self.base_url(url = nil)
+      @base_url = url if url
+      @base_url
+    end
+
+    class Metadata
+      attr_reader :schema
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def version = schema.version
+      def title = schema.title
+
+      def namespace
+        schema.namespace
+      end
+
+      def entity_sets
+        schema.entity_sets.map(&:__metadata)
+      end
+
+      def metadata_types
+        @metadata_types ||= entity_sets.flat_map(&:metadata_types).uniq.map(&:__metadata)
+      end
+
+      def entity_types
+        metadata_types.select { |mt| mt.metadata_type == :entity }
+      end
+
+      def complex_types
+        metadata_types.select { |mt| mt.metadata_type == :complex }
+      end
+
+      def enum_types
+        metadata_types.select { |mt| mt.metadata_type == :enum }
+      end
+
+      def endpoints
+        entity_sets
+      end
+
+      def check_names
+        names = Set.new
+        (enum_types + complex_types + entity_types).each do |et|
+          raise "Duplicate #{et.name} type" if names.include?(et.name)
+
+          names << et.name
+        end
+      end
+    end
+
+    def self.__metadata
+      Metadata.new(self)
+    end
+
+    def self.metadata_xml
+      metadata = __metadata
+      metadata.check_names
+
+      ERB.new(File.read("#{__dir__}/metadata.xml.erb")).result(binding)
+    end
+
+    def self.index_hash(metadata_url)
+      {
+        '@odata.context': metadata_url,
+        value: endpoints.map do |e|
+          { name: e.name, kind: e.kind, url: e.url }
+        end
+      }
+    end
+
+    def self.endpoints
+      __metadata.endpoints
+    end
+
+    def self.execute(url, context:, query_options: {})
+      Executor.execute(url: url, context: context, query_options: query_options, schema: self)
+    end
+
+    def self.create(url, context:, query_options: nil)
+      Executor.create(url: url, context: context, query_options: query_options, schema: self)
+    end
+
+    def self.update(url, context:, query_options: nil)
+      Executor.update(url: url, context: context, query_options: query_options, schema: self)
+    end
+
+    def self.delete(url, context:, query_options: nil)
+      Executor.delete(url: url, context: context, query_options: query_options, schema: self)
+    end
+
+    def self.to_mcp_server
+      McpServerBuilder.build(self)
+    end
+  end
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: odata_duty
+version: !ruby/object:Gem::Version
+  version: 0.30.0
+platform: ruby
+authors:
+- Grant Petersen-Speelman
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mcp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.20.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.20.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: uri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description: A unified DSL for exposing structured data and operations across analytics
+  tools (PowerBI), no-code platforms (PowerAutomate), and AI agents (via MCP).
+email:
+- grant@nexl.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/generators/odata_duty/entity_set/entity_set_generator.rb
+- lib/generators/odata_duty/entity_set/templates/entity_set.rb.erb
+- lib/generators/odata_duty/entity_set/templates/entity_set_spec.rb.erb
+- lib/generators/odata_duty/entity_set/templates/entity_type.rb.erb
+- lib/generators/odata_duty/entity_set/templates/entity_type_spec.rb.erb
+- lib/generators/odata_duty/entity_set/templates/odata_active_record_concern.rb.erb
+- lib/generators/odata_duty/entity_set/templates/resolver.rb.erb
+- lib/generators/odata_duty/entity_set/templates/resolver_spec.rb.erb
+- lib/generators/odata_duty/install/install_generator.rb
+- lib/generators/odata_duty/install/templates/controller.rb.tt
+- lib/generators/odata_duty/install/templates/schema.rb.tt
+- lib/metadata.xml.erb
+- lib/odata_duty.rb
+- lib/odata_duty/complex_type.rb
+- lib/odata_duty/context_wrapper.rb
+- lib/odata_duty/create_complex_type_hash_wrapper.rb
+- lib/odata_duty/dynamic_object_wrapper.rb.erb
+- lib/odata_duty/edms.rb
+- lib/odata_duty/edmx_schema.rb
+- lib/odata_duty/entity_type.rb
+- lib/odata_duty/enum_type.rb
+- lib/odata_duty/errors.rb
+- lib/odata_duty/executor.rb
+- lib/odata_duty/filter.rb
+- lib/odata_duty/filter_predicate.rb
+- lib/odata_duty/mapper_builder.rb
+- lib/odata_duty/mcp_input_schemas.rb
+- lib/odata_duty/mcp_server_builder.rb
+- lib/odata_duty/oas2.rb
+- lib/odata_duty/oas2/collection_get_path.rb
+- lib/odata_duty/oas2/collection_post_path.rb
+- lib/odata_duty/oas2/individual_delete_path.rb
+- lib/odata_duty/oas2/individual_get_path.rb
+- lib/odata_duty/oas2/individual_patch_path.rb
+- lib/odata_duty/parslet_search_expression.rb
+- lib/odata_duty/property.rb
+- lib/odata_duty/property/collection_prop.rb
+- lib/odata_duty/property/single_prop.rb
+- lib/odata_duty/railtie.rb
+- lib/odata_duty/schema_builder.rb
+- lib/odata_duty/schema_builder/complex_type.rb
+- lib/odata_duty/schema_builder/container.rb
+- lib/odata_duty/schema_builder/data_type.rb
+- lib/odata_duty/schema_builder/endpoint.rb
+- lib/odata_duty/schema_builder/entity_set.rb
+- lib/odata_duty/schema_builder/entity_type.rb
+- lib/odata_duty/schema_builder/enum_type.rb
+- lib/odata_duty/set_resolver.rb
+homepage:
+licenses: []
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: A unified, intent-driven interface layer that serves automation, AI, and
+  developer platforms with minimal duplication.
+test_files: []