rom 5.4.1 → 6.0.0.alpha1

data/lib/rom/components/dsl/relation.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+module ROM
+  module Components
+    module DSL
+      # Setup DSL-specific relation extensions
+      #
+      # @private
+      class Relation < Core
+        key :relations
+
+        # @api private
+        def call
+          super(constant: constant, config: constant.config.component)
+        end
+
+        # @api private
+        memoize def constant
+          build_class do |dsl|
+            config.component.adapter = dsl.adapter if dsl.adapter
+
+            class_exec(&dsl.block) if dsl.block
+
+            if (schema_dataset = components.schemas.first&.config&.dataset)
+              config.component.dataset = schema_dataset
+            end
+          end
+        end
+
+        # @api private
+        memoize def class_name
+          class_name_inferrer[
+            config.id,
+            type: :relation,
+            inflector: inflector,
+            class_namespace: provider.class_namespace
+          ]
+        end
+
+        # @api private
+        def class_parent
+          ROM::Relation[adapter]
+        end
+      end
+    end
+  end
+end

data/lib/rom/components/dsl/schema.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "rom/schema"
+require "rom/attribute"
+
+require_relative "core"
+
+module ROM
+  module Components
+    module DSL
+      # @private
+      class Schema < Core
+        key :schemas
+
+        option :attributes, default: -> { EMPTY_HASH.dup }
+
+        # Defines a relation attribute with its type and options.
+        #
+        # When only options are given, type is left as nil. It makes
+        # sense when it is used alongside a schema inferrer, which will
+        # populate the type.
+        #
+        # @see Components::DSL#schema
+        #
+        # @api public
+        def attribute(name, type_or_options, options = EMPTY_HASH)
+          if attributes.key?(name)
+            raise(AttributeAlreadyDefinedError, "Attribute #{name.inspect} already defined")
+          end
+
+          build_attribute_info(name, type_or_options, options).tap do |attr_info|
+            attributes[name] = attr_info
+          end
+        end
+
+        # Specify which key(s) should be the primary key
+        #
+        # @api public
+        def primary_key(*names)
+          names.each do |name|
+            attributes[name][:type] = attributes[name][:type].meta(primary_key: true)
+          end
+          self
+        end
+
+        # @api private
+        def call
+          # Evaluate block only if it's not a schema defined by Relation.view DSL
+          instance_eval(&block) if block && !config.view
+
+          enabled_plugins.each_value do |plugin|
+            plugin.apply unless plugin.applied?
+          end
+
+          configure
+
+          components.add(key, config: config, block: config.view ? block : nil)
+        end
+
+        # @api private
+        # rubocop:disable Metrics/AbcSize
+        def configure
+          config.update(attributes: attributes.values)
+
+          # TODO: make this simpler
+          config.update(
+            relation: relation_id,
+            inferrer: config.inferrer.with(enabled: config.infer)
+          )
+
+          if !view? && relation?
+            config.join!({namespace: relation_id}, :right) if config.id != relation_id
+
+            provider.config.component.update(dataset: config.dataset) if config.dataset
+            provider.config.component.update(id: config.as) if config.as
+          end
+
+          provider.config.schema.infer = config.infer
+
+          super
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        # Builds a representation of the information needed to create an
+        # attribute. It returns a hash with `:type` and `:options` keys.
+        #
+        # @return [Hash]
+        #
+        # @see [Schema.build_attribute_info]
+        #
+        # @api private
+        def build_attribute_info(name, type_or_options, options = EMPTY_HASH)
+          type, options = if type_or_options.is_a?(::Hash)
+                            [nil, type_or_options]
+                          else
+                            [build_type(type_or_options, options), options]
+                          end
+          ROM::Schema.build_attribute_info(type, **options, name: name)
+        end
+
+        # Builds a type instance from base type and meta options
+        #
+        # @return [Dry::Types::Type] Type instance
+        #
+        # @api private
+        def build_type(type, options = EMPTY_HASH)
+          meta = ROM::Attribute::META_OPTIONS
+            .map { |opt| [opt, options[opt]] if options.key?(opt) }
+            .compact
+            .to_h
+
+          # TODO: this should be probably moved to rom/compat
+          source = ROM::Relation::Name[relation_id, config.dataset]
+
+          base =
+            if options[:read]
+              type.meta(source: source, read: options[:read])
+            elsif type.optional? && type.meta[:read]
+              type.meta(source: source, read: type.meta[:read].optional)
+            else
+              type.meta(source: source)
+            end
+
+          if meta.empty?
+            base
+          else
+            base.meta(meta)
+          end
+        end
+
+        # @api private
+        def relation_id
+          relation? ? provider.config.component.id : config.id
+        end
+
+        # @api private
+        def relation?
+          provider.config.component.type == :relation
+        end
+
+        # @api private
+        def view?
+          config.view.equal?(true)
+        end
+      end
+    end
+  end
+end

data/lib/rom/components/dsl/view.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+module ROM
+  module Components
+    module DSL
+      # @api private
+      class View < Core
+        key :views
+
+        # @api private
+        attr_reader :schema_block
+
+        # @api private
+        attr_reader :relation_block
+
+        # @see Components::DSL#view
+        #
+        # @api public
+        def schema(&block)
+          @schema_block = block
+          self
+        end
+
+        # @see Components::DSL#view
+        #
+        # @api public
+        def relation(&block)
+          @relation_block = block
+          self
+        end
+
+        # @api private
+        def call
+          # Nest view under relation ns
+          config.join!({namespace: relation_id}, :right)
+
+          if args.empty? && block.arity.positive?
+            raise ArgumentError, "schema attribute names must be provided as the second argument"
+          end
+
+          # Capture schema and relation blocks if there are no args
+          # otherwise assume args is a list of attributes to project
+          if args.empty? && block
+            instance_eval(&block)
+          else
+            schema { schema.project(*args.first) }
+          end
+
+          provider.schema(
+            id: config.id,
+            namespace: relation_id,
+            relation: relation_id,
+            view: true,
+            &schema_block
+          )
+
+          components.add(
+            key,
+            config: config,
+            relation_id: relation_id,
+            # Default to the block because we assume the schema was set based on args
+            relation_block: relation_block || block
+          )
+        end
+
+        private
+
+        # @api private
+        def args
+          config.args
+        end
+
+        # @api private
+        def relation_id
+          provider.config.component.id
+        end
+      end
+    end
+  end
+end

data/lib/rom/components/dsl.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require "rom/relation/name"
+
+require "rom/components/dsl/gateway"
+require "rom/components/dsl/dataset"
+require "rom/components/dsl/schema"
+require "rom/components/dsl/relation"
+require "rom/components/dsl/view"
+require "rom/components/dsl/association"
+require "rom/components/dsl/command"
+require "rom/components/dsl/mapper"
+
+module ROM
+  # This extends Configuration class with the DSL methods
+  #
+  # @api public
+  module Components
+    module DSL
+      # Set or get custom dataset block
+      #
+      # This block will be evaluated when a relation is instantiated and registered
+      # in a relation registry.
+      #
+      # @example
+      #   class Users < ROM::Relation[:memory]
+      #     dataset { sort_by(:id) }
+      #   end
+      #
+      # @api public
+      def dataset(id = nil, **options, &block)
+        __dsl__(DSL::Dataset, id: id, **options, &block)
+      end
+
+      # Specify a relation schema
+      #
+      # With a schema defined commands will set up a type-safe input handler automatically
+      #
+      # @example
+      #   class Users < ROM::Relation[:sql]
+      #     schema do
+      #       attribute :id, Types::Serial
+      #       attribute :name, Types::String
+      #     end
+      #   end
+      #
+      #   # access schema from a finalized relation
+      #   users.schema
+      #
+      # @return [Schema]
+      #
+      # @param [Symbol] dataset An optional dataset name
+      # @param [Boolean] infer Whether to do an automatic schema inferring
+      # @param [Boolean, Symbol] view Whether this is a view schema
+      #
+      # @api public
+      def schema(id = nil, **options, &block)
+        __dsl__(DSL::Schema, id: id, dataset: id, **options, &block)
+      end
+
+      # Relation definition DSL
+      #
+      # @example
+      #   setup.relation(:users) do
+      #     def names
+      #       project(:name)
+      #     end
+      #   end
+      #
+      # @api public
+      def relation(id, dataset: id, **options, &block)
+        __dsl__(DSL::Relation, id: id, dataset: dataset, **options, &block)
+      end
+
+      # Define a relation view with a specific schema
+      #
+      # This method should only be used in cases where a given adapter doesn't
+      # support automatic schema projection at run-time.
+      #
+      # @overload view(name, schema, &block)
+      #   @example View with the canonical schema
+      #     class Users < ROM::Relation[:sql]
+      #       view(:listing, schema) do
+      #         order(:name)
+      #       end
+      #     end
+      #
+      #   @example View with a projected schema
+      #     class Users < ROM::Relation[:sql]
+      #       view(:listing, schema.project(:id, :name)) do
+      #         order(:name)
+      #       end
+      #     end
+      #
+      # @overload view(name, &block)
+      #   @example View with the canonical schema and arguments
+      #     class Users < ROM::Relation[:sql]
+      #       view(:by_name) do |name|
+      #         where(name: name)
+      #       end
+      #     end
+      #
+      #   @example View with projected schema and arguments
+      #     class Users < ROM::Relation[:sql]
+      #       view(:by_name) do
+      #         schema { project(:id, :name) }
+      #         relation { |name| where(name: name) }
+      #       end
+      #     end
+      #
+      #   @example View with a schema extended with foreign attributes
+      #     class Users < ROM::Relation[:sql]
+      #       view(:index) do
+      #         schema { append(relations[:tasks][:title]) }
+      #         relation { |name| where(name: name) }
+      #       end
+      #     end
+      #
+      # @return [Symbol] view method name
+      #
+      # @api public
+      def view(id, *args, &block)
+        __dsl__(DSL::View, id: id, args: args, &block)
+        id
+      end
+
+      # Define associations for a relation
+      #
+      # @example
+      #   class Users < ROM::Relation[:sql]
+      #     associations do
+      #       has_many :tasks
+      #       has_many :posts
+      #       has_many :posts, as: :priority_posts, view: :prioritized
+      #       belongs_to :account
+      #     end
+      #   end
+      #
+      #   class Posts < ROM::Relation[:sql]
+      #     associations do
+      #       belongs_to :users, as: :author
+      #     end
+      #
+      #     view(:prioritized) do
+      #       where { priority <= 3 }
+      #     end
+      #   end
+      #
+      # @return [Array<Components::Association>]
+      #
+      # @api public
+      def associations(source: config.component.id, namespace: source, **options, &block)
+        __dsl__(DSL::Association, source: source, namespace: namespace, **options, &block)
+        components.associations
+      end
+
+      # Command definition DSL
+      #
+      # @example
+      #   setup.commands(:users) do
+      #     define(:create) do
+      #       input NewUserParams
+      #       result :one
+      #     end
+      #
+      #     define(:update) do
+      #       input UserParams
+      #       result :many
+      #     end
+      #
+      #     define(:delete) do
+      #       result :many
+      #     end
+      #   end
+      #
+      # @api public
+      def commands(namespace, **options, &block)
+        __dsl__(DSL::Command, namespace: namespace, relation: namespace, **options, &block)
+        components.commands
+      end
+
+      # Mapper definition DSL
+      #
+      # @api public
+      def mappers(namespace = nil, **options, &block)
+        __dsl__(DSL::Mapper, namespace: namespace, relation: namespace, **options, &block)
+        components.mappers
+      end
+
+      # Configures a plugin for a specific adapter to be enabled for all relations
+      #
+      # @example
+      #   setup = ROM::Setup.new(:sql, 'sqlite::memory')
+      #
+      #   setup.plugin(:sql, relations: :instrumentation) do |p|
+      #     p.notifications = MyNotificationsBackend
+      #   end
+      #
+      #   setup.plugin(:sql, relations: :pagination)
+      #
+      # @param [Symbol] adapter The adapter identifier
+      # @param [Hash<Symbol=>Symbol>] spec Component identifier => plugin identifier
+      #
+      # @return [Plugin]
+      #
+      # @api public
+      def plugin(*args, &block)
+        case args.size
+        when 2
+          adapter, spec = args
+          type, name = spec.flatten(1)
+
+          # TODO: plugin types are singularized, so this is not consistent
+          #       with the configuration DSL for plugins that uses plural
+          #       names of the components - this should be unified
+          plugin = ROM
+            .plugins[Inflector.singularize(type)].adapter(adapter).fetch(name)
+            .configure(&block)
+
+          config.component.plugins << plugin
+
+          plugin
+        when 1
+          plugin(self.adapter, *args)
+        else
+          raise ArgumentError, "+plugin+ accepts either 1 or 2 arguments (#{args.size} given)"
+        end
+      end
+
+      # @api public
+      def gateway(id, **options, &block)
+        __dsl__(DSL::Gateway, id: id, **options, &block)
+      end
+
+      private
+
+      # @api private
+      def __dsl__(klass, type: klass.type, **options, &block)
+        type_config = config[type].join(options, :right).inherit!(config.component)
+
+        if klass.nested && block
+          dsl = klass.new(provider: self, config: type_config)
+          dsl.enable_plugins
+          dsl.configure
+          dsl.instance_eval(&block)
+          dsl
+        else
+          dsl = klass.new(provider: self, config: type_config, block: block)
+          dsl.enable_plugins
+          dsl.()
+        end
+      end
+    end
+  end
+end

data/lib/rom/components/gateway.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "rom/open_struct"
+require_relative "core"
+
+module ROM
+  module Components
+    # @api public
+    class Gateway < Core
+      # @api public
+      def build
+        gateway = adapter.is_a?(ROM::Gateway) ? adapter : setup
+
+        # TODO: once Gateway is unified with the rest of component types, this
+        #       won't be needed as it'll happen automatically when inheriting
+        #       config settings
+        gateway_config.plugins.concat(gateway.class.config.component.plugins)
+
+        gateway.instance_variable_set("@config", gateway_config)
+        gateway.use_logger(config.logger) if config.logger
+
+        gateway
+      end
+
+      # @api private
+      def adapter
+        config.adapter
+      end
+
+      private
+
+      # @api private
+      def setup
+        if config.args.empty?
+          ROM::Gateway.setup(adapter, **config)
+        else
+          ROM::Gateway.setup(adapter, *config.args)
+        end
+      end
+
+      # @api private
+      def gateway_config
+        hash = config.to_h
+        keys = hash.keys - %i[type namespace opts]
+
+        ROM::OpenStruct.new(**keys.zip(hash.values_at(*keys)).to_h, **config.opts)
+      end
+    end
+  end
+end

data/lib/rom/components/mapper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "core"
+
+module ROM
+  module Components
+    # @api public
+    class Mapper < Core
+      # @!attribute [r] constant
+      #   @return [Class] Component's target class
+      option :constant, type: Types.Interface(:new), optional: true
+
+      # @!attribute [r] object
+      #   @return [Class] Pre-initialized object that should be used instead of the constant
+      #   @api public
+      option :object, optional: true
+
+      # @api public
+      def build
+        object || constant.build
+      end
+
+      # @api public
+      def relation
+        config.relation
+      end
+    end
+  end
+end