linked_rails 0.0.1

data/lib/linked_rails/helpers/ontola_actions_helper.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Helpers
+    module OntolaActionsHelper
+      def add_exec_action_header(headers, action)
+        headers['Exec-Action'] ||= ''
+        headers['Exec-Action'] += "#{action}\n"
+      end
+
+      def ontola_copy_action(value)
+        Vocab.libro["actions/copyToClipboard?#{{value: value}.to_param}"]
+      end
+
+      def ontola_dialog_action(resource, opener: nil)
+        Vocab.libro["actions/dialog/alert?#{{resource: resource, opener: opener}.compact.to_param}"]
+      end
+
+      def ontola_dialog_close_action
+        Vocab.libro['actions/dialog/close']
+      end
+
+      def ontola_redirect_action(location, reload: nil)
+        Vocab.libro["actions/redirect?#{{location: location, reload: reload}.compact.to_param}"]
+      end
+
+      def ontola_snackbar_action(text)
+        Vocab.libro["actions/snackbar?#{{text: text}.to_param}"]
+      end
+    end
+  end
+end

data/lib/linked_rails/helpers/resource_helper.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Helpers
+    module ResourceHelper
+      def current_resource
+        return @current_resource if instance_variable_defined?(:@current_resource)
+
+        @current_resource ||= resolve_current_resource
+      end
+
+      def new_resource
+        @new_resource ||=
+          if requested_resource.try(:singular_resource?)
+            requested_resource
+          elsif parent_resource
+            new_resource_from_parent
+          else
+            build_new_resource
+          end
+      end
+
+      def params_for_parent
+        params.dup
+      end
+
+      def parent_from_params
+        @parent_from_params ||= LinkedRails.iri_mapper.parent_from_params(params, user_context)
+      end
+
+      def parent_from_params!
+        parent_from_params || raise(ActiveRecord::RecordNotFound)
+      end
+
+      def parent_resource
+        @parent_resource ||= requested_resource_parent || parent_from_params
+      end
+
+      def parent_resource!
+        parent_resource || raise(ActiveRecord::RecordNotFound)
+      end
+
+      def requested_resource_parent
+        requested_resource&.parent
+      end
+
+      private
+
+      def build_new_resource
+        controller_class.build_new(user_context: user_context)
+      end
+
+      def new_resource_from_parent
+        parent_resource.build_child(
+          controller_class,
+          user_context: user_context
+        )
+      end
+
+      def resolve_current_resource
+        case action_name
+        when 'create', 'new'
+          new_resource
+        else
+          requested_resource
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/iri_mapper.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class IRIMapper
+    class << self
+      EMPTY_IRI_OPTS = {params: {}}.freeze
+
+      # Converts an IRI into a hash containing the action, class, iri and the params of the iri
+      # @return [Hash]
+      # @example Valid resource IRI
+      #   opts_from_iri('https://example.com/resource/1?foo=bar')
+      #   => {
+      #     action: 'show',
+      #     class: Resource,
+      #     params: {
+      #       id: '1',
+      #       foo: 'bar'
+      #     }
+      #   }
+      # @example Valid collection IRI
+      #   opts_from_iri('https://example.com/resources?foo=bar')
+      #   => {
+      #     action: 'index',
+      #     class: Resource,
+      #     params: {
+      #       foo: 'bar'
+      #     }
+      #   }
+      # @example Invalid IRI
+      #   opts_from_iri('https://example.com/invalid/1')
+      #   => {
+      #     params: {}
+      #   }
+      def opts_from_iri(iri, method: 'GET')
+        query = Rack::Utils.parse_nested_query(URI(iri.to_s).query)
+        params = Rails.application.routes.recognize_path(iri.to_s, method: method)
+
+        route_params_to_opts(params.merge(query))
+      rescue ActionController::RoutingError
+        EMPTY_IRI_OPTS.dup
+      end
+
+      def index_resource_from_iri(iri, user_context)
+        ensure_absolute_iri!(iri)
+
+        opts = opts_from_iri(iri)
+        index_resource_from_opts(opts, user_context)
+      end
+
+      def index_resource_from_iri!(iri, user_context)
+        index_resource_from_iri(iri, user_context) || raise(ActiveRecord::RecordNotFound)
+      end
+
+      def index_resource_from_opts(opts, user_context)
+        opts[:class]&.requested_index_resource(opts[:params], user_context) if opts[:action] == 'index'
+      end
+
+      def parent_from_params(params, user_context)
+        return unless params.key?(:parent_iri)
+
+        parent_iri = "/#{params[:parent_iri]}"
+        opts = LinkedRails.iri_mapper.opts_from_iri(parent_iri)
+        opts[:params] = params.except(:parent_iri, :singular_route).merge(opts[:params])
+
+        LinkedRails.iri_mapper.resource_from_opts(opts, user_context)
+      end
+
+      def resource_from_iri(iri, user_context)
+        ensure_absolute_iri!(iri)
+
+        opts = opts_from_iri(iri)
+        resource_from_opts(opts, user_context)
+      end
+
+      def resource_from_iri!(iri, user_context)
+        resource_from_iri(iri, user_context) || raise(ActiveRecord::RecordNotFound)
+      end
+
+      def resource_from_opts(opts, user_context)
+        opts[:class]&.requested_resource(opts, user_context)
+      end
+
+      def route_params_to_opts(params)
+        controller_class = class_for_controller(params[:controller])
+
+        return EMPTY_IRI_OPTS.dup if controller_class.blank?
+
+        {
+          action: params[:action],
+          class: controller_class,
+          params: params.except(:action, :controller)
+        }.with_indifferent_access
+      end
+
+      def single_resource_from_iri(iri, user_context)
+        ensure_absolute_iri!(iri)
+
+        opts = opts_from_iri(iri)
+        single_resource_from_opts(opts, user_context)
+      end
+
+      def single_resource_from_iri!(iri, user_context)
+        single_resource_from_iri(iri, user_context) || raise(ActiveRecord::RecordNotFound)
+      end
+
+      def single_resource_from_opts(opts, user_context)
+        opts[:class]&.requested_single_resource(opts[:params], user_context) unless opts[:params] == 'index'
+      end
+
+      private
+
+      def class_for_controller(controller)
+        return if controller.blank?
+
+        "::#{controller.camelize}Controller"
+          .safe_constantize
+          .try(:controller_class)
+      end
+
+      def ensure_absolute_iri!(iri)
+        raise("An absolute url is expected. #{iri} is given.") if iri.blank? || URI(iri).relative?
+      end
+    end
+  end
+end

data/lib/linked_rails/middleware/linked_data_params.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Middleware
+    class LinkedDataParams # rubocop:disable Metrics/ClassLength
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        req = Rack::Request.new(env)
+        params_from_query(req)
+        params_from_graph(req)
+
+        @app.call(env)
+      end
+
+      private
+
+      def add_param(hash, key, value) # rubocop:disable Metrics/MethodLength
+        case hash[key]
+        when nil
+          hash[key] = value
+        when Hash
+          hash[key].merge!(value)
+        when Array
+          hash[key].append(value)
+        else
+          hash[key] = [hash[key], value]
+        end
+        hash
+      end
+
+      def associated_class_from_params(reflection, graph, subject)
+        return reflection.klass unless reflection.polymorphic?
+
+        query = graph.query(subject: subject, predicate: Vocab.rdfv[:type])
+        if query.empty?
+          raise("No type given for '#{subject}' referenced by polymorphic association '#{reflection.name}'")
+        end
+
+        iri_to_class(query.first.object)
+      end
+
+      def blob_attribute(base_params, value)
+        base_params["<#{value}>"] if value.starts_with?(Vocab.ll['blobs/'])
+      end
+
+      def convert_query_params(request, target_class)
+        keys = target_class.predicate_mapping.keys.map(&:to_s)
+        class_key = target_class.to_s.underscore
+        data = request.params[class_key] || {}
+        request.params.slice(*keys.map(&:to_s)).each do |key, value|
+          add_param_from_query(data, target_class, key, value)
+        end
+        request.update_param(class_key, data) if data.present?
+      end
+
+      def add_param_from_query(data, target_class, key, value)
+        data[target_class.predicate_mapping[RDF::URI(key)].key] = value
+      end
+
+      def enum_attribute(klass, key, value)
+        opts = RDF::Serializers.serializer_for(klass).try(:enum_options, key)
+        return if opts.blank?
+
+        opts.detect { |_k, options| options.iri == value }&.first&.to_s
+      end
+
+      def graph_from_request(request)
+        request_graph = request.delete_param("<#{Vocab.ll[:graph].value}>")
+        return if request_graph.blank?
+
+        RDF::Graph.load(
+          request_graph[:tempfile].path,
+          content_type: request_graph[:type],
+          canonicalize: true,
+          intern: false
+        )
+      end
+
+      def iri_to_class(iri)
+        iri.to_s.split(LinkedRails.app_vocab.to_s).pop&.classify&.safe_constantize ||
+          ApplicationRecord.descendants.detect { |klass| klass.iri == iri }
+      end
+
+      def logger
+        Rails.logger
+      end
+
+      def nested_attributes(base_params, graph, subject, klass, association, collection) # rubocop:disable Metrics/ParameterLists
+        nested_resources =
+          if graph.query([subject, Vocab.rdfv[:first], nil]).present?
+            nested_attributes_from_list(base_params, graph, subject, klass)
+          else
+            parsed = parse_nested_resource(base_params, graph, subject, klass)
+            collection ? {rand(1_000_000_000).to_s => parsed} : parsed
+          end
+        ["#{association}_attributes", nested_resources]
+      end
+
+      def nested_attributes_from_list(base_params, graph, subject, klass)
+        Hash[
+          RDF::List.new(subject: subject, graph: graph)
+            .map { |nested| [rand(1_000_000_000).to_s, parse_nested_resource(base_params, graph, nested, klass)] }
+        ]
+      end
+
+      # Converts a serialized graph from a multipart request body to a nested
+      # attributes hash.
+      #
+      # The graph sent to the server should be sent under the `ll:graph` form name.
+      # The entrypoint for the graph is the `ll:targetResource` subject, which is
+      # assumed to be the resource intended to be targeted by the request (i.e. the
+      # resource to be created, updated, or deleted).
+      #
+      # @return [Hash] A hash of attributes, empty if no statements were given.
+      def params_from_graph(request)
+        graph = graph_from_request(request)
+
+        return unless graph
+
+        request.update_param(:body_graph, graph)
+        target_class = target_class_from_path(request)
+        return if target_class.blank?
+
+        update_actor_param(request, graph)
+        update_target_params(request, graph, target_class)
+      end
+
+      def params_from_query(request)
+        target_class = target_class_from_path(request) if request.params.present?
+        return unless target_class.try(:predicate_mapping)
+
+        convert_query_params(request, target_class)
+      end
+
+      def parse_nested_resource(base_params, graph, subject, klass)
+        resource = parse_resource(base_params, graph, subject, klass)
+        resource[:id] ||= LinkedRails.iri_mapper.opts_from_iri(subject)[:params][:id] if subject.iri?
+        resource
+      end
+
+      # Recursively parses a resource from graph
+      def parse_resource(base_params, graph, subject, klass)
+        graph
+          .query([subject])
+          .map { |statement| parse_statement(base_params, graph, statement, klass) }
+          .compact
+          .reduce({}) { |h, (k, v)| add_param(h, k, v) }
+      end
+
+      def parse_statement(base_params, graph, statement, klass)
+        field = serializer_field(klass, statement.predicate)
+        if field.is_a?(FastJsonapi::Attribute)
+          parsed_attribute(base_params, klass, field.key, statement.object.value)
+        elsif field.is_a?(FastJsonapi::Relationship)
+          parsed_association(base_params, graph, statement.object, klass, field.association || field.key)
+        end
+      end
+
+      def parsed_association(base_params, graph, object, klass, association)
+        reflection = klass.reflect_on_association(association) || raise("#{association} not found for #{klass}")
+
+        if graph.has_subject?(object)
+          association_klass = associated_class_from_params(reflection, graph, object)
+          nested_attributes(base_params, graph, object, association_klass, association, reflection.collection?)
+        elsif object.iri?
+          attributes_from_iri(object, association, reflection)
+        end
+      end
+
+      def attributes_from_iri(object, association, reflection)
+        if reflection.options[:through]
+          key = reflection.has_one? ? "#{association}_id" : "#{association.to_s.singularize}_ids"
+        elsif reflection.belongs_to?
+          key = reflection.foreign_key
+        end
+        return unless key
+
+        resource = LinkedRails.iri_mapper.resource_from_iri(object, nil)
+        value = resource&.send(reflection.association_primary_key)
+
+        [key, value] if value
+      end
+
+      def parsed_attribute(base_params, klass, key, value)
+        [key, blob_attribute(base_params, value) || enum_attribute(klass, key, value) || value]
+      end
+
+      def serializer_field(klass, predicate)
+        field = klass.try(:predicate_mapping).try(:[], predicate)
+        logger.info("#{predicate} not found for #{klass || 'nil'}") if field.blank?
+        field
+      end
+
+      def target_class_from_path(request) # rubocop:disable Metrics/AbcSize
+        opts = LinkedRails.iri_mapper.opts_from_iri(
+          request.base_url + request.env['REQUEST_URI'],
+          method: request.request_method
+        )
+
+        logger.info("No class found for #{request.base_url + request.env['REQUEST_URI']}") unless opts[:class]
+
+        opts[:class]
+      end
+
+      def update_actor_param(request, graph)
+        actor = graph.query([Vocab.ll[:targetResource], Vocab.schema.creator]).first
+        return if actor.blank?
+
+        request.update_param(:actor_iri, actor.object)
+        graph.delete(actor)
+      end
+
+      def update_target_params(request, graph, target_class)
+        key = target_class.to_s.demodulize.underscore
+        from_body = parse_resource(request.params, graph, Vocab.ll[:targetResource], target_class)
+
+        request.update_param(key, from_body.merge(request.params[key] || {}))
+      end
+    end
+  end
+end