odata_duty 0.30.0

data/lib/generators/odata_duty/install/install_generator.rb

@@ -0,0 +1,60 @@
+module OdataDuty
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      class_option :module, type: :string, default: nil, desc: 'Module namespace'
+
+      def create_controller
+        template 'controller.rb.tt',
+                 File.join('app/controllers', controller_path, 'api_controller.rb')
+      end
+
+      def create_schema
+        template 'schema.rb.tt', File.join('app/schemas', controller_path, 'schema.rb')
+      end
+
+      def add_routes
+        route route_contents
+      end
+
+      private
+
+      def controller_path
+        options[:module]&.underscore || ''
+      end
+
+      def module_name
+        options[:module]&.camelize
+      end
+
+      def controller_class
+        [module_name, 'ApiController'].compact.join('::')
+      end
+
+      def schema_class
+        [module_name, 'Schema'].compact.join('::')
+      end
+
+      def route_controller
+        parts = []
+        parts << controller_path unless controller_path.empty?
+        parts << 'api'
+        parts.join('/')
+      end
+
+      def route_contents
+        <<~RUBY
+          scope '/api' do
+            root '#{route_controller}#index'
+            get '$metadata' => '#{route_controller}#metadata'
+            get '$oas2' => '#{route_controller}#oas2'
+            get '*url' => '#{route_controller}#show'
+            post '*url' => '#{route_controller}#create'
+            delete '*url' => '#{route_controller}#destroy'
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/generators/odata_duty/install/templates/controller.rb.tt

@@ -0,0 +1,43 @@
+class <%= controller_class %> < ApplicationController
+  def index
+    render json: OdataDuty::EdmxSchema.index_hash(schema_metadata_url)
+  end
+
+  def metadata
+    render xml: OdataDuty::EdmxSchema.metadata_xml(schema)
+  end
+
+  def oas2
+    # Power Automate's "Import from URL" is a browser-side cross-origin fetch; without this CORS
+    # header it fails with a misleading "couldn't download" error even though the server 200s.
+    response.set_header('Access-Control-Allow-Origin', '*')
+    render json: OdataDuty::OAS2.build_json(schema)
+  end
+
+  def show
+    render json: schema.execute(params[:url], context: self, query_options: query_options)
+  end
+
+  def create
+    render json: schema.create(params[:url], context: self, query_options: query_options)
+  end
+
+  def destroy
+    schema.delete(params[:url], context: self, query_options: query_options)
+    head :no_content
+  end
+
+  private
+
+  def query_options
+    params.to_unsafe_hash.except('url', 'action', 'controller', 'format')
+  end
+
+  def schema
+    <%= schema_class %>.build(request)
+  end
+
+  def schema_metadata_url
+    url_for(action: :metadata, only_path: false)
+  end
+end

data/lib/generators/odata_duty/install/templates/schema.rb.tt

@@ -0,0 +1,16 @@
+<% if module_name %>module <%= module_name %>
+<% end %>class Schema
+  def self.build(request)
+    OdataDuty::SchemaBuilder.build(namespace: "<%= module_name || 'MySpace' %>",
+                                   host: request.host_with_port,
+                                   scheme: request.scheme,
+                                   base_path: '/api') do |s|
+      s.title = 'My Dynamic API'
+      s.version = '0.0.1'
+      # Add entity types and sets here
+    end
+  end
+end
+<% if module_name %>
+end
+<% end %>

data/lib/metadata.xml.erb

@@ -0,0 +1,116 @@
+<?xml version="1.0" encoding="utf-8"?>
+<edmx:Edmx Version="4.0" xmlns:edmx="http://docs.oasis-open.org/odata/ns/edmx" edmx:schemaLocation="https://docs.oasis-open.org/odata/odata-csdl-xml/v4.01/os/schemas/edm.xsd https://docs.oasis-open.org/odata/odata-csdl-xml/v4.01/os/schemas/edmx.xsd">
+    <edmx:Reference Uri="https://docs.oasis-open.org/odata/odata-vocabularies/v4.0/vocabularies/Org.OData.Capabilities.V1.xml">
+        <edmx:Include Namespace="Org.OData.Capabilities.V1" Alias="Capabilities" />
+    </edmx:Reference>
+    <edmx:Reference Uri="https://docs.oasis-open.org/odata/odata-vocabularies/v4.0/vocabularies/Org.OData.Core.V1.xml">
+        <edmx:Include Namespace="Org.OData.Core.V1" Alias="Core" />
+    </edmx:Reference>
+    <edmx:DataServices>
+        <Schema Namespace="<%= metadata.namespace %>" xmlns="http://docs.oasis-open.org/odata/ns/edm">
+             <% if metadata.version %><Annotation Term="<%= metadata.namespace %>.Version" String="<%= metadata.version %>" /><% end %>
+             <% if metadata.title %><Annotation Term="<%= metadata.namespace %>.Title" String="<%= metadata.title %>" /><% end %>
+
+             <% metadata.enum_types.each do |enum_type| %>
+                <EnumType Name="<%= enum_type.name %>">
+                    <% enum_type.members.each do |member| %>
+                        <Member Name="<%= member.name %>" />
+                    <% end %>
+                </EnumType>
+            <% end %>
+            <% metadata.complex_types.each do |complex_type| %>
+                <ComplexType Name="<%= complex_type.name %>">
+                    <% complex_type.properties.each do |property| %>
+                        <% if property.core_annotation_term %>
+                            <Property Name="<%= property.name %>" Nullable="<%= property.nullable %>" Type="<%= property.collection? ? "Collection(" : "" %><%= property.type.include?(".") ? "" : "#{metadata.namespace}." %><%= property.type %><%= property.collection? ? ")" : "" %>">
+                                <Annotation Term="<%= property.core_annotation_term %>" Bool="true" />
+                            </Property>
+                        <% else %>
+                            <Property Name="<%= property.name %>" Nullable="<%= property.nullable %>" Type="<%= property.collection? ? "Collection(" : "" %><%= property.type.include?(".") ? "" : "#{metadata.namespace}." %><%= property.type %><%= property.collection? ? ")" : "" %>" />
+                        <% end %>
+                    <% end %>
+                </ComplexType>
+            <% end %>
+            <% metadata.entity_types.each do |entity_type| %>
+                <EntityType Name="<%= entity_type.name %>">
+                    <Key>
+                        <% entity_type.property_refs.each do |property| %>
+                            <PropertyRef Name="<%= property.name %>" />
+                        <% end %>
+                    </Key>
+                    <% entity_type.properties.each do |property| %>
+                        <% if property.core_annotation_term %>
+                            <Property Name="<%= property.name %>" Nullable="<%= property.nullable %>" Type="<%= property.collection? ? "Collection(" : "" %><%= property.type.include?(".") ? "" : "#{metadata.namespace}." %><%= property.type %><%= property.collection? ? ")" : "" %>">
+                                <Annotation Term="<%= property.core_annotation_term %>" Bool="true" />
+                            </Property>
+                        <% else %>
+                            <Property Name="<%= property.name %>" Nullable="<%= property.nullable %>" Type="<%= property.collection? ? "Collection(" : "" %><%= property.type.include?(".") ? "" : "#{metadata.namespace}." %><%= property.type %><%= property.collection? ? ")" : "" %>" />
+                        <% end %>
+                    <% end %>
+                </EntityType>
+            <% end %>
+            <EntityContainer Name="Container">
+                <% metadata.entity_sets.each do |entity_set| %>
+                    <EntitySet Name="<%= entity_set.name %>" EntityType="<%= metadata.namespace %>.<%= entity_set.entity_type_name %>">
+                        <% if entity_set.supports_search? %>
+                            <Annotation Term="Capabilities.SearchRestrictions">
+                                <Record>
+                                    <PropertyValue Property="Searchable" Bool="true" />
+                                    <PropertyValue Property="UnsupportedExpressions" EnumMember="Capabilities.SearchExpressions/group" />
+                                </Record>
+                            </Annotation>
+                        <% end %>
+                        <% if entity_set.supports_filter_or? %>
+                            <Annotation Term="Capabilities.FilterRestrictions">
+                                <Record>
+                                    <PropertyValue Property="Filterable" Bool="true" />
+                                    <PropertyValue Property="FilterExpressionRestrictions">
+                                        <Collection>
+                                            <Record>
+                                                <PropertyValue Property="Property" PropertyPath="*" />
+                                                <PropertyValue Property="AllowedExpressions" EnumMember="Capabilities.FilterExpressionType/SingleValue" />
+                                            </Record>
+                                        </Collection>
+                                    </PropertyValue>
+                                </Record>
+                            </Annotation>
+                        <% end %>
+                        <% non_insertable = entity_set.non_insertable_property_names %>
+                        <% if !entity_set.supports_create? || non_insertable.any? %>
+                            <Annotation Term="Capabilities.InsertRestrictions">
+                                <Record>
+                                    <% if !entity_set.supports_create? %>
+                                        <PropertyValue Property="Insertable" Bool="false" />
+                                    <% end %>
+                                    <% if non_insertable.any? %>
+                                        <PropertyValue Property="NonInsertableProperties">
+                                            <Collection>
+                                                <% non_insertable.each do |property_name| %>
+                                                    <PropertyPath><%= property_name %></PropertyPath>
+                                                <% end %>
+                                            </Collection>
+                                        </PropertyValue>
+                                    <% end %>
+                                </Record>
+                            </Annotation>
+                        <% end %>
+                        <% if !entity_set.supports_update? %>
+                            <Annotation Term="Capabilities.UpdateRestrictions">
+                                <Record>
+                                    <PropertyValue Property="Updatable" Bool="false" />
+                                </Record>
+                            </Annotation>
+                        <% end %>
+                        <% if !entity_set.supports_delete? %>
+                            <Annotation Term="Capabilities.DeleteRestrictions">
+                                <Record>
+                                    <PropertyValue Property="Deletable" Bool="false" />
+                                </Record>
+                            </Annotation>
+                        <% end %>
+                    </EntitySet>
+                <% end %>
+            </EntityContainer>
+        </Schema>
+    </edmx:DataServices>
+</edmx:Edmx>

data/lib/odata_duty/complex_type.rb

@@ -0,0 +1,70 @@
+require_relative 'mapper_builder'
+
+module OdataDuty
+  class ComplexType
+    def self.properties
+      @properties ||= []
+    end
+
+    def self.property(name, *args, **kwargs)
+      if properties.any? { |p| p.name == name.to_sym }
+        raise PropertyAlreadyDefinedError, "#{name} is already defined"
+      end
+
+      Property.new(name, *args, **kwargs).tap do |property|
+        properties << property
+      end
+    end
+
+    class Metadata
+      attr_reader :complex_type
+
+      def initialize(complex_type)
+        @complex_type = complex_type
+      end
+
+      def properties
+        complex_type.properties
+      end
+
+      def name
+        complex_type.to_s.split('::').last.sub(/ComplexType\z/, '').sub(/Complex\z/, '')
+      end
+
+      def property_type
+        name
+      end
+
+      def metadata_type
+        :complex
+      end
+
+      # callers uniq the result, so duplicates from repeated property types are fine
+      def metadata_types(visited = [])
+        return [] if visited.include?(complex_type)
+
+        visited << complex_type
+        raw_types = properties.map(&:raw_type)
+        nested = raw_types.grep(Metadata).flat_map { |m| m.metadata_types(visited) }
+        [complex_type] +
+          nested +
+          raw_types.grep(EnumType::Metadata).map(&:enum_type)
+      end
+
+      # nil (falsy) rather than false: callers only consume truthiness
+      def scalar?; end
+    end
+
+    def self.__metadata
+      Metadata.new(self)
+    end
+
+    attr_reader :object
+    attr_reader :od_context
+
+    def initialize(object, context)
+      @object = object
+      @od_context = context
+    end
+  end
+end

data/lib/odata_duty/context_wrapper.rb

@@ -0,0 +1,26 @@
+require 'delegate'
+require 'uri'
+
+module OdataDuty
+  class ContextWrapper < SimpleDelegator
+    attr_reader :caller_context, :base_url, :endpoint, :query_options
+
+    def initialize(caller_context, base_url:, endpoint:, query_options:)
+      super(caller_context)
+      @base_url = base_url.chomp('/')
+      @endpoint = endpoint
+      @query_options = query_options.to_h
+    end
+
+    def od_full_url(path, anchor: nil, **query_params)
+      URI.parse([base_url, path].join('/')).tap do |uri|
+        uri.query = URI.encode_www_form(query_params) if query_params.any?
+        uri.fragment = anchor
+      end.to_str
+    end
+
+    def current
+      @current ||= {}
+    end
+  end
+end

data/lib/odata_duty/create_complex_type_hash_wrapper.rb

@@ -0,0 +1,49 @@
+module OdataDuty
+  class CreateComplexTypeHashWrapper
+    SETTABLE_BY_OPERATION = { create: :settable_on_create?, update: :settable_on_update? }.freeze
+
+    def initialize(hash, complex_type, operation:, context:)
+      @hash = hash
+      @complex_type = complex_type
+      @operation = operation
+      @context = context
+    end
+
+    def method_missing(method_name, *args)
+      matching_prop = @complex_type.properties.find { |p| p.name == method_name }
+      unless matching_prop && args.empty?
+        raise NoSuchPropertyError, "No such property '#{method_name}'"
+      end
+
+      __load(matching_prop, method_name, @hash[method_name.to_s])
+    end
+
+    def respond_to_missing?(method_name, _include_private)
+      @complex_type.properties.any? { |p| p.name == method_name }
+    end
+
+    private
+
+    def __load(matching_prop, method_name, value)
+      return nil unless settable?(matching_prop)
+      return nil if value.nil?
+      return matching_prop.to_value(value, @context) if matching_prop.scalar?
+
+      if matching_prop.collection?
+        value.map { |v| __wrap(v, matching_prop.raw_type) }
+      else
+        __wrap(value, matching_prop.raw_type)
+      end
+    rescue InvalidValue => e
+      raise InvalidType, "The value provided for '#{method_name}' is of wrong type: #{e}"
+    end
+
+    def settable?(prop)
+      prop.public_send(SETTABLE_BY_OPERATION.fetch(@operation))
+    end
+
+    def __wrap(value, raw_type)
+      CreateComplexTypeHashWrapper.new(value, raw_type, operation: @operation, context: @context)
+    end
+  end
+end

data/lib/odata_duty/dynamic_object_wrapper.rb.erb

@@ -0,0 +1,79 @@
+Class.new(MapperBuilder) do
+  def to_h
+  <% properties.each do |property| %>
+    <% if property.calling_method? %>
+    <%= property.name %>_value = calling_methods.fetch(:<%= property.method_name %>).call(obj)
+    <% elsif complex_type.respond_to?(:instance_methods) && complex_type.instance_methods.include?(property.method_name) %>
+    <%= property.name %>_value = wrapped_obj.<%= property.method_name %>
+    <% else %>
+    <%= property.name %>_value = obj.<%= property.method_name %>
+    <% end %>
+
+  <% if property.collection? %>
+    <% if property.scalar? %>
+      begin 
+      <% if property.boolean? %>
+        <%= property.name %>_value&.map{ |rw| confirm_boolean("<%= property.name %>", rw) }
+      <% elsif property.string? %>
+        <%= property.name %>_value = <%= property.name %>_value&.map{ |v| v&.to_str }
+      <% elsif property.int? %>
+        <%= property.name %>_value = <%= property.name %>_value&.map{ |v| v&.to_int }
+      <% elsif property.date? %>
+        <%= property.name %>_value = <%= property.name %>_value&.map{ |v| v&.to_date&.iso8601 }
+      <% elsif property.datetime? %>
+        <%= property.name %>_value = <%= property.name %>_value&.map{ |v| v&.to_datetime&.iso8601 }
+      <% else %>
+        raise('<%= property.type %> Coming soon')
+      <% end %>
+      rescue NoMethodError => no__err
+        err = InvalidValue.new(no__err.message)
+        err.set_backtrace(no__err.backtrace.clone)
+        err.backtrace.unshift "<%= property.line__defined__at %>"
+        raise err
+      end
+    <% else %>
+      <%= property.name %>_value = <%= property.name %>_value&.map{ |rw| <%= property.name %>_mapper.obj_to_base_hash(rw) }
+    <% end %>
+  <% else %>
+    <% if property.scalar? %> 
+      begin
+      <% if property.boolean? %>
+        <%= property.name %>_value = confirm_boolean("<%= property.name %>", <%= property.name %>_value)
+      <% elsif property.string? %>
+        <%= property.name %>_value = <%= property.name %>_value&.to_str
+      <% elsif property.int? %>
+        <%= property.name %>_value = <%= property.name %>_value&.to_int
+      <% elsif property.date? %>
+        <%= property.name %>_value = <%= property.name %>_value&.to_date&.iso8601
+      <% elsif property.datetime? %>
+        <%= property.name %>_value = <%= property.name %>_value&.to_datetime&.iso8601
+      <% elsif property.enum? %>
+        <%= property.name %>_value = confirm_one_of("<%= property.name %>", <%= property.name %>_value, %w[<%= property.enum_members.map(&:name).join(' ') %>])
+      <% else %>
+        raise('<%= property.type %> Coming soon')
+      <% end %>
+      rescue NoMethodError => no__err
+        err = InvalidValue.new(no__err.message)
+        err.set_backtrace(no__err.backtrace.clone)
+        err.backtrace.unshift "<%= property.line__defined__at %>"
+        raise err
+      end
+    <% else %>
+      <%= property.name %>_value = <%= property.name %>_mapper.obj_to_base_hash(<%= property.name %>_value)
+    <% end %>
+  <% end %>
+  <% end %>
+    {
+    <% properties.each do |property| %>
+      '<%= property.name %>' => <% unless property.nullable? %>not_nullable("<%= property.name %>",<% end %><%= property.name %>_value<% unless property.nullable? %>)<% end %>,
+    <% end %>
+    }
+  end
+
+<% properties.reject(&:scalar?).each do |property| %>
+  # lazy so self/mutually-referencing types recurse per row of data, not per type
+  def <%= property.name %>_mapper
+    @<%= property.name %>_mapper ||= MapperBuilder.build(set_types.fetch(:<%= property.name %>))
+  end
+<% end %>
+end

data/lib/odata_duty/edms.rb

@@ -0,0 +1,122 @@
+require 'date'
+
+module OdataDuty
+  class EdmBase
+    def self.scalar?
+      true
+    end
+  end
+
+  class EdmInt64 < EdmBase
+    def self.property_type
+      'Edm.Int64'
+    end
+
+    OAS_TYPE = { 'type' => 'integer', 'format' => 'int64' }.freeze
+
+    def self.to_oas2(is_collection:)
+      return { 'type' => 'array', 'items' => OAS_TYPE } if is_collection
+
+      OAS_TYPE
+    end
+
+    def self.to_value(object, _context)
+      Integer(object)
+    rescue StandardError => e
+      raise InvalidValue, e
+    end
+  end
+
+  class EdmString < EdmBase
+    def self.property_type
+      'Edm.String'
+    end
+
+    OAS_TYPE = { 'type' => 'string' }.freeze
+
+    def self.to_oas2(is_collection:)
+      return { 'type' => 'array', 'items' => OAS_TYPE } if is_collection
+
+      OAS_TYPE
+    end
+
+    def self.to_value(object, _context)
+      object.to_str
+    rescue StandardError => e
+      raise InvalidValue, e
+    end
+  end
+
+  class EdmDate < EdmBase
+    def self.property_type
+      'Edm.Date'
+    end
+
+    OAS_TYPE = { 'type' => 'string', 'format' => 'date' }.freeze
+
+    def self.to_oas2(is_collection:)
+      return { 'type' => 'array', 'items' => OAS_TYPE } if is_collection
+
+      OAS_TYPE
+    end
+
+    def self.to_value(object, _context)
+      object.to_date.iso8601
+    rescue StandardError => e
+      raise InvalidValue, e
+    end
+  end
+
+  class EdmDateTimeOffset < EdmBase
+    def self.property_type
+      'Edm.DateTimeOffset'
+    end
+
+    OAS_TYPE = { 'type' => 'string', 'format' => 'date-time' }.freeze
+
+    def self.to_oas2(is_collection:)
+      return { 'type' => 'array', 'items' => OAS_TYPE } if is_collection
+
+      OAS_TYPE
+    end
+
+    def self.to_value(object, _context)
+      object.to_datetime.iso8601
+    rescue StandardError => e
+      raise InvalidValue, e
+    end
+  end
+
+  class EdmBool < EdmBase
+    def self.property_type
+      'Edm.Boolean'
+    end
+
+    OAS_TYPE = { 'type' => 'boolean' }.freeze
+
+    def self.to_oas2(is_collection:)
+      return { 'type' => 'array', 'items' => OAS_TYPE } if is_collection
+
+      OAS_TYPE
+    end
+
+    VALID_VALUES = [true, false, nil].freeze
+
+    def self.to_value(object, _context)
+      return true if object == 'true'
+      return false if object == 'false'
+      return object if VALID_VALUES.include?(object)
+
+      object.to_boolean
+    rescue NoMethodError
+      raise InvalidValue, "#{object} not boolean value"
+    end
+  end
+
+  TYPES_MAPPING = { Integer => EdmInt64,
+                    String => EdmString,
+                    Date => EdmDate,
+                    DateTime => EdmDateTimeOffset,
+                    Time => EdmDateTimeOffset,
+                    TrueClass => EdmBool }.freeze
+end

data/lib/odata_duty/edmx_schema.rb

@@ -0,0 +1,19 @@
+require 'erb'
+
+module OdataDuty
+  module EdmxSchema
+    def self.index_hash(schema)
+      {
+        '@odata.context': [schema.base_url.chomp('/'), '$metadata'].join('/'),
+        value: schema.endpoints.map do |e|
+          { name: e.name, kind: 'EntitySet', url: e.url }
+        end
+      }
+    end
+
+    def self.metadata_xml(metadata)
+      b = binding
+      ERB.new(File.read("#{__dir__}/../metadata.xml.erb")).result(b)
+    end
+  end
+end

data/lib/odata_duty/entity_type.rb

@@ -0,0 +1,72 @@
+require_relative 'mapper_builder'
+
+module OdataDuty
+  class EntityType < ComplexType
+    def self.property_refs
+      @property_refs ||= []
+    end
+
+    def self.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
+
+    class Metadata < ComplexType::Metadata
+      attr_reader :entity_type
+
+      def initialize(entity_type)
+        @entity_type = entity_type
+        super
+      end
+
+      def name
+        entity_type.to_s.split('::').last.sub(/EntityType\z/, '').sub(/Entity\z/, '')
+      end
+
+      def metadata_type
+        :entity
+      end
+
+      def property_refs
+        entity_type.property_refs
+      end
+    end
+
+    def self.__metadata
+      Metadata.new(self)
+    end
+
+    def od_endpoint
+      od_context.endpoint
+    end
+
+    def self.mapper(context, selected:)
+      context.current['odata_url_base'] ||= context.od_full_url(context.endpoint.url)
+      if property_refs.first.raw_type == EdmInt64
+        int_mapper(context, selected: selected)
+      else
+        string_mapper(context, selected: selected)
+      end
+    end
+
+    def self.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 self.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 self._defined_at_
+      const_source_location(to_s).join(':')
+    end
+  end
+end