sequent 7.1.1 → 8.0.0

data/lib/sequent/core/aggregate_root.rb

@@ -12,8 +12,7 @@ module Sequent
       module ClassMethods
         ##
         # Enable snapshots for this aggregate. The aggregate instance
-        # must define the *load_from_snapshot* and *save_to_snapshot*
-        # methods.
+        # must define the *take_snapshot* methods.
         #
         def enable_snapshots(default_threshold: 20)
           @snapshot_default_threshold = default_threshold
@@ -41,7 +40,8 @@ module Sequent
       include SnapshotConfiguration
       extend ActiveSupport::DescendantsTracker
 
-      attr_reader :id, :uncommitted_events, :sequence_number, :event_stream
+      attr_reader :id, :uncommitted_events, :sequence_number
+      attr_accessor :latest_snapshot_sequence_number
 
       def self.load_from_history(stream, events)
         first, *rest = events
@@ -49,6 +49,7 @@ module Sequent
           # rubocop:disable Security/MarshalLoad
           aggregate_root = Marshal.load(Base64.decode64(first.data))
           # rubocop:enable Security/MarshalLoad
+          aggregate_root.latest_snapshot_sequence_number = first.sequence_number
           rest.each { |x| aggregate_root.apply_event(x) }
         else
           aggregate_root = allocate # allocate without calling new
@@ -61,9 +62,6 @@ module Sequent
         @id = id
         @uncommitted_events = []
         @sequence_number = 1
-        @event_stream = EventStream.new aggregate_type: self.class.name,
-                                        aggregate_id: id,
-                                        snapshot_threshold: self.class.snapshot_default_threshold
       end
 
       def load_from_history(stream, events)
@@ -100,13 +98,38 @@ module Sequent
         "#{self.class.name}: #{@id}"
       end
 
+      def event_stream
+        EventStream.new(
+          aggregate_type: self.class.name,
+          aggregate_id: id,
+          events_partition_key: events_partition_key,
+          snapshot_outdated_at: snapshot_outdated? ? Time.now : nil,
+        )
+      end
+
+      # Provide the partitioning key for storing events. This value
+      # must be a string and will be used by PostgreSQL to store the
+      # events in the right partition.
+      #
+      # The value may change over the lifetime of the aggregate, old
+      # events will be moved to the correct partition after a
+      # change. This can be an expensive database operation.
+      def events_partition_key
+        nil
+      end
+
       def clear_events
         @uncommitted_events = []
       end
 
-      def take_snapshot!
-        snapshot = build_event SnapshotEvent, data: Base64.encode64(Marshal.dump(self))
-        @uncommitted_events << snapshot
+      def snapshot_outdated?
+        snapshot_threshold = self.class.snapshot_default_threshold
+        events_since_latest_snapshot = @sequence_number - (latest_snapshot_sequence_number || 1)
+        snapshot_threshold.present? && events_since_latest_snapshot >= snapshot_threshold
+      end
+
+      def take_snapshot
+        build_event SnapshotEvent, data: Base64.encode64(Marshal.dump(self))
       end
 
       def apply_event(event)

data/lib/sequent/core/aggregate_snapshotter.rb

@@ -24,23 +24,25 @@ module Sequent
           @last_aggregate_id,
           command.limit,
         )
-        aggregate_ids.each do |aggregate_id|
-          take_snapshot!(aggregate_id)
-        end
+        snapshots = aggregate_ids.filter_map { |aggregate_id| take_snapshot(aggregate_id) }
+        Sequent.configuration.event_store.store_snapshots(snapshots)
+
         @last_aggregate_id = aggregate_ids.last
         throw :done if @last_aggregate_id.nil?
       end
 
       on TakeSnapshot do |command|
-        take_snapshot!(command.aggregate_id)
+        snapshot = take_snapshot(command.aggregate_id)
+        Sequent.configuration.event_store.store_snapshots([snapshot]) if snapshot
       end
 
-      def take_snapshot!(aggregate_id)
+      def take_snapshot(aggregate_id)
         aggregate = repository.load_aggregate(aggregate_id)
         Sequent.logger.info "Taking snapshot for aggregate #{aggregate}"
-        aggregate.take_snapshot!
+        aggregate.take_snapshot
       rescue StandardError => e
         Sequent.logger.error("Failed to take snapshot for aggregate #{aggregate_id}: #{e}, #{e.inspect}")
+        nil
       end
     end
   end

data/lib/sequent/core/command_record.rb

@@ -7,7 +7,7 @@ module Sequent
   module Core
     module SerializesCommand
       def command
-        args = Sequent::Core::Oj.strict_load(command_json)
+        args = serialize_json? ? Sequent::Core::Oj.strict_load(command_json) : command_json
         Class.const_get(command_type).deserialize_from_json(args)
       end
 
@@ -16,7 +16,7 @@ module Sequent
         self.aggregate_id = command.aggregate_id if command.respond_to? :aggregate_id
         self.user_id = command.user_id if command.respond_to? :user_id
         self.command_type = command.class.name
-        self.command_json = Sequent::Core::Oj.dump(command.attributes)
+        self.command_json = serialize_json? ? Sequent::Core::Oj.dump(command.attributes) : command.attributes
 
         # optional attributes (here for historic reasons)
         # this should be moved to a configurable CommandSerializer
@@ -30,6 +30,13 @@ module Sequent
 
       private
 
+      def serialize_json?
+        return true unless self.class.respond_to? :columns_hash
+
+        json_column_type = self.class.columns_hash['command_json'].sql_type_metadata.type
+        %i[json jsonb].exclude? json_column_type
+      end
+
       def serialize_attribute?(command, attribute)
         [self, command].all? { |obj| obj.respond_to?(attribute) }
       end
@@ -39,32 +46,34 @@ module Sequent
     class CommandRecord < Sequent::ApplicationRecord
       include SerializesCommand
 
+      self.primary_key = :id
       self.table_name = 'command_records'
 
-      has_many :event_records
+      has_many :child_events,
+               inverse_of: :parent_command,
+               class_name: :EventRecord,
+               foreign_key: :command_record_id
 
       validates_presence_of :command_type, :command_json
 
-      def parent
-        EventRecord
-          .where(aggregate_id: event_aggregate_id, sequence_number: event_sequence_number)
-          .where('event_type != ?', Sequent::Core::SnapshotEvent.name)
-          .first
-      end
+      # A `belongs_to` association fails in weird ways with ActiveRecord 7.1, probably due to the use of composite
+      # primary keys so use an explicit query here and cache the result.
+      def parent_event
+        return nil unless event_aggregate_id && event_sequence_number
 
-      def children
-        event_records
+        @parent_event ||= EventRecord.find_by(aggregate_id: event_aggregate_id, sequence_number: event_sequence_number)
       end
 
-      def origin
-        parent.present? ? find_origin(parent) : self
+      def origin_command
+        parent_event&.parent_command&.origin_command || self
       end
 
-      def find_origin(record)
-        return find_origin(record.parent) if record.parent.present?
-
-        record
-      end
+      # @deprecated
+      alias parent parent_event
+      # @deprecated
+      alias children child_events
+      # @deprecated
+      alias origin origin_command
     end
   end
 end

data/lib/sequent/core/command_service.rb

@@ -67,7 +67,7 @@ module Sequent
       def process_command(command)
         fail ArgumentError, 'command is required' if command.nil?
 
-        Sequent.logger.debug("[CommandService] Processing command #{command.class}")
+        Sequent.logger.debug("[CommandService] Processing command #{command.class}") if Sequent.logger.debug?
 
         filters.each { |filter| filter.execute(command) }
 
@@ -118,7 +118,7 @@ module Sequent
       def initialize(command)
         @command = command
         msg = @command.respond_to?(:aggregate_id) ? " #{@command.aggregate_id}" : ''
-        super "Invalid command #{@command.class}#{msg}, errors: #{@command.validation_errors}"
+        super("Invalid command #{@command.class}#{msg}, errors: #{@command.validation_errors}")
       end
 
       def errors(prefix = nil)

data/lib/sequent/core/event_publisher.rb

@@ -51,7 +51,7 @@ module Sequent
       def process_event(event)
         fail ArgumentError, 'event is required' if event.nil?
 
-        Sequent.logger.debug("[EventPublisher] Publishing event #{event.class}")
+        Sequent.logger.debug("[EventPublisher] Publishing event #{event.class}") if Sequent.logger.debug?
 
         configuration.event_handlers.each do |handler|
           handler.handle_message event

data/lib/sequent/core/event_record.rb

@@ -46,7 +46,7 @@ module Sequent
 
     module SerializesEvent
       def event
-        payload = Sequent::Core::Oj.strict_load(event_json)
+        payload = serialize_json? ? Sequent::Core::Oj.strict_load(event_json) : event_json
         Class.const_get(event_type).deserialize_from_json(payload)
       end
 
@@ -56,7 +56,7 @@ module Sequent
         self.organization_id = event.organization_id if event.respond_to?(:organization_id)
         self.event_type = event.class.name
         self.created_at = event.created_at
-        self.event_json = self.class.serialize_to_json(event)
+        self.event_json = serialize_json? ? self.class.serialize_to_json(event) : event.attributes
 
         Sequent.configuration.event_record_hooks_class.after_serialization(self, event)
       end
@@ -65,42 +65,62 @@ module Sequent
         def serialize_to_json(event)
           Sequent::Core::Oj.dump(event)
         end
+
+        def serialize_json?
+          return true unless respond_to? :columns_hash
+
+          json_column_type = columns_hash['event_json'].sql_type_metadata.type
+          %i[json jsonb].exclude? json_column_type
+        end
       end
 
       def self.included(host_class)
         host_class.extend(ClassMethods)
       end
+
+      def serialize_json?
+        self.class.serialize_json?
+      end
     end
 
     class EventRecord < Sequent::ApplicationRecord
       include SerializesEvent
 
+      self.primary_key = %i[aggregate_id sequence_number]
       self.table_name = 'event_records'
       self.ignored_columns = %w[xact_id]
 
-      belongs_to :stream_record
-      belongs_to :command_record
+      belongs_to :stream_record, foreign_key: :aggregate_id, primary_key: :aggregate_id
 
-      validates_presence_of :aggregate_id, :sequence_number, :event_type, :event_json, :stream_record, :command_record
-      validates_numericality_of :sequence_number, only_integer: true, greater_than: 0
+      belongs_to :parent_command, class_name: :CommandRecord, foreign_key: :command_record_id
 
-      def parent
-        command_record
+      if Gem.loaded_specs['activerecord'].version < Gem::Version.create('7.2')
+        has_many :child_commands,
+                 class_name: :CommandRecord,
+                 primary_key: %i[aggregate_id sequence_number],
+                 query_constraints: %i[event_aggregate_id event_sequence_number]
+      else
+        has_many :child_commands,
+                 class_name: :CommandRecord,
+                 primary_key: %i[aggregate_id sequence_number],
+                 foreign_key: %i[event_aggregate_id event_sequence_number]
       end
 
-      def children
-        CommandRecord.where(event_aggregate_id: aggregate_id, event_sequence_number: sequence_number)
-      end
+      validates_presence_of :aggregate_id, :sequence_number, :event_type, :event_json, :stream_record, :parent_command
+      validates_numericality_of :sequence_number, only_integer: true, greater_than: 0
 
-      def origin
-        parent.present? ? find_origin(parent) : self
+      def self.find_by_event(event)
+        find_by(aggregate_id: event.aggregate_id, sequence_number: event.sequence_number)
       end
 
-      def find_origin(record)
-        return find_origin(record.parent) if record.parent.present?
-
-        record
+      def origin_command
+        parent_command&.origin_command
       end
+
+      # @deprecated
+      alias parent parent_command
+      alias children child_commands
+      alias origin origin_command
     end
   end
 end

data/lib/sequent/core/event_store.rb

@@ -2,11 +2,16 @@
 
 require 'forwardable'
 require_relative 'event_record'
+require_relative 'helpers/pgsql_helpers'
 require_relative 'sequent_oj'
+require_relative 'snapshot_record'
+require_relative 'snapshot_store'
 
 module Sequent
   module Core
     class EventStore
+      include Helpers::PgsqlHelpers
+      include SnapshotStore
       include ActiveRecord::ConnectionAdapters::Quoting
       extend Forwardable
 
@@ -26,15 +31,6 @@ module Sequent
         end
       end
 
-      ##
-      # Disables event type caching (ie. for in development).
-      #
-      class NoEventTypesCache
-        def fetch_or_store(event_type)
-          yield(event_type)
-        end
-      end
-
       ##
       # Stores the events in the EventStore and publishes the events
       # to the registered event_handlers.
@@ -56,7 +52,7 @@ module Sequent
       end
 
       ##
-      # Returns all events for the AggregateRoot ordered by sequence_number, disregarding snapshot events.
+      # Returns all events for the AggregateRoot ordered by sequence_number, disregarding snapshots.
       #
       # This streaming is done in batches to prevent loading many events in memory all at once. A usecase for ignoring
       # the snapshots is when events of a nested AggregateRoot need to be loaded up until a certain moment in time.
@@ -68,16 +64,20 @@ module Sequent
         stream = find_event_stream(aggregate_id)
         fail ArgumentError, 'no stream found for this aggregate' if stream.blank?
 
-        q = Sequent
-          .configuration
-          .event_record_class
-          .where(aggregate_id: aggregate_id)
-          .where.not(event_type: Sequent.configuration.snapshot_event_class.name)
-          .order(:sequence_number)
-        q = q.where('created_at < ?', load_until) if load_until.present?
         has_events = false
 
-        q.select('event_type, event_json').each_row do |event_hash|
+        # PostgreSQLCursor::Cursor does not support bind parameters, so bind parameters manually instead.
+        sql = ActiveRecord::Base.sanitize_sql_array(
+          [
+            'SELECT * FROM load_events(:aggregate_ids, FALSE, :load_until)',
+            {
+              aggregate_ids: [aggregate_id].to_json,
+              load_until: load_until,
+            },
+          ],
+        )
+
+        PostgreSQLCursor::Cursor.new(sql, {connection: connection}).each_row do |event_hash|
           has_events = true
           event = deserialize_event(event_hash)
           block.call([stream, event])
@@ -85,6 +85,11 @@ module Sequent
         fail ArgumentError, 'no events for this aggregate' unless has_events
       end
 
+      def load_event(aggregate_id, sequence_number)
+        event_hash = query_function(connection, 'load_event', [aggregate_id, sequence_number]).first
+        deserialize_event(event_hash) if event_hash
+      end
+
       ##
       # Returns all events for the aggregate ordered by sequence_number, loading them from the latest snapshot
       # event onwards, if a snapshot is present
@@ -96,40 +101,21 @@ module Sequent
       def load_events_for_aggregates(aggregate_ids)
         return [] if aggregate_ids.none?
 
-        streams = Sequent.configuration.stream_record_class.where(aggregate_id: aggregate_ids)
-
-        query = aggregate_ids.uniq.map { |aggregate_id| aggregate_query(aggregate_id) }.join(' UNION ALL ')
-        events = Sequent.configuration.event_record_class.connection.select_all(query).map do |event_hash|
-          deserialize_event(event_hash)
-        end
-
-        events
-          .group_by(&:aggregate_id)
-          .map do |aggregate_id, es|
+        query_events(aggregate_ids)
+          .group_by { |row| row['aggregate_id'] }
+          .values
+          .map do |rows|
             [
-              streams.find do |stream_record|
-                stream_record.aggregate_id == aggregate_id
-              end.event_stream,
-              es,
+              EventStream.new(
+                aggregate_type: rows.first['aggregate_type'],
+                aggregate_id: rows.first['aggregate_id'],
+                events_partition_key: rows.first['events_partition_key'],
+              ),
+              rows.map { |row| deserialize_event(row) },
             ]
           end
       end
 
-      def aggregate_query(aggregate_id)
-        <<~SQL.chomp
-          (
-          SELECT event_type, event_json
-            FROM #{quote_table_name Sequent.configuration.event_record_class.table_name} AS o
-          WHERE aggregate_id = #{quote(aggregate_id)}
-          AND sequence_number >= COALESCE((SELECT MAX(sequence_number)
-                                           FROM #{quote_table_name Sequent.configuration.event_record_class.table_name} AS i
-                                           WHERE event_type = #{quote Sequent.configuration.snapshot_event_class.name}
-                                             AND i.aggregate_id = #{quote(aggregate_id)}), 0)
-          ORDER BY sequence_number ASC, (CASE event_type WHEN #{quote Sequent.configuration.snapshot_event_class.name} THEN 0 ELSE 1 END) ASC
-          )
-        SQL
-      end
-
       def stream_exists?(aggregate_id)
         Sequent.configuration.stream_record_class.exists?(aggregate_id: aggregate_id)
       end
@@ -137,6 +123,7 @@ module Sequent
       def events_exists?(aggregate_id)
         Sequent.configuration.event_record_class.exists?(aggregate_id: aggregate_id)
       end
+
       ##
       # Replays all events in the event store to the registered event_handlers.
       #
@@ -164,7 +151,7 @@ module Sequent
           event = deserialize_event(record)
           publish_events([event])
           progress += 1
-          ids_replayed << record['id']
+          ids_replayed << record['aggregate_id']
           if progress % block_size == 0
             on_progress[progress, false, ids_replayed]
             ids_replayed.clear
@@ -174,110 +161,105 @@ module Sequent
       end
 
       PRINT_PROGRESS = ->(progress, done, _) do
+        next unless Sequent.logger.debug?
+
         if done
-          Sequent.logger.debug "Done replaying #{progress} events"
+          Sequent.logger.debug("Done replaying #{progress} events")
         else
-          Sequent.logger.debug "Replayed #{progress} events"
+          Sequent.logger.debug("Replayed #{progress} events")
         end
       end
 
-      ##
-      # Returns the ids of aggregates that need a new snapshot.
-      #
-      def aggregates_that_need_snapshots(last_aggregate_id, limit = 10)
-        stream_table = quote_table_name Sequent.configuration.stream_record_class.table_name
-        event_table = quote_table_name Sequent.configuration.event_record_class.table_name
-        query = <<~SQL.chomp
-          SELECT aggregate_id
-            FROM #{stream_table} stream
-           WHERE aggregate_id::varchar > COALESCE(#{quote last_aggregate_id}, '')
-             AND snapshot_threshold IS NOT NULL
-             AND snapshot_threshold <= (
-                   (SELECT MAX(events.sequence_number) FROM #{event_table} events WHERE events.event_type <> #{quote Sequent.configuration.snapshot_event_class.name} AND stream.aggregate_id = events.aggregate_id) -
-                   COALESCE((SELECT MAX(snapshots.sequence_number) FROM #{event_table} snapshots WHERE snapshots.event_type = #{quote Sequent.configuration.snapshot_event_class.name} AND stream.aggregate_id = snapshots.aggregate_id), 0))
-           ORDER BY aggregate_id
-           LIMIT #{quote limit}
-           FOR UPDATE
-        SQL
-        Sequent.configuration.event_record_class.connection.select_all(query).map { |x| x['aggregate_id'] }
-      end
-
       def find_event_stream(aggregate_id)
         record = Sequent.configuration.stream_record_class.where(aggregate_id: aggregate_id).first
         record&.event_stream
       end
 
-      private
+      def permanently_delete_event_stream(aggregate_id)
+        permanently_delete_event_streams([aggregate_id])
+      end
 
-      def quote_table_name(table_name)
-        Sequent.configuration.event_record_class.connection.quote_table_name(table_name)
+      def permanently_delete_event_streams(aggregate_ids)
+        call_procedure(connection, 'permanently_delete_event_streams', [aggregate_ids.to_json])
       end
 
-      def event_types
-        @event_types = if Sequent.configuration.event_store_cache_event_types
-                         ThreadSafe::Cache.new
-                       else
-                         NoEventTypesCache.new
-                       end
+      def permanently_delete_commands_without_events(aggregate_id: nil, organization_id: nil)
+        unless aggregate_id || organization_id
+          fail ArgumentError, 'aggregate_id and/or organization_id must be specified'
+        end
+
+        call_procedure(connection, 'permanently_delete_commands_without_events', [aggregate_id, organization_id])
       end
 
-      def column_names
-        @column_names ||= Sequent
-          .configuration
-          .event_record_class
-          .column_names
-          .reject { |c| c == primary_key_event_records }
+      private
+
+      def connection
+        Sequent.configuration.event_record_class.connection
       end
 
-      def primary_key_event_records
-        @primary_key_event_records ||= Sequent.configuration.event_record_class.primary_key
+      def query_events(aggregate_ids, use_snapshots = true, load_until = nil)
+        query_function(connection, 'load_events', [aggregate_ids.to_json, use_snapshots, load_until])
       end
 
       def deserialize_event(event_hash)
-        event_type = event_hash.fetch('event_type')
-        event_json = Sequent::Core::Oj.strict_load(event_hash.fetch('event_json'))
-        resolve_event_type(event_type).deserialize_from_json(event_json)
+        should_serialize_json = Sequent.configuration.event_record_class.serialize_json?
+        record = Sequent.configuration.event_record_class.new
+        record.event_type = event_hash.fetch('event_type')
+        record.event_json =
+          if should_serialize_json
+            event_hash.fetch('event_json')
+          else
+            # When the column type is JSON or JSONB the event record
+            # class expects the JSON to be deserialized into a hash
+            # already.
+            Sequent::Core::Oj.strict_load(event_hash.fetch('event_json'))
+          end
+        record.event
       rescue StandardError
         raise DeserializeEventError, event_hash
       end
 
-      def resolve_event_type(event_type)
-        event_types.fetch_or_store(event_type) { |k| Class.const_get(k) }
-      end
-
       def publish_events(events)
         Sequent.configuration.event_publisher.publish_events(events)
       end
 
       def store_events(command, streams_with_events = [])
-        command_record = CommandRecord.create!(command: command)
-        event_records = streams_with_events.flat_map do |event_stream, uncommitted_events|
-          unless event_stream.stream_record_id
-            stream_record = Sequent.configuration.stream_record_class.new
-            stream_record.event_stream = event_stream
-            stream_record.save!
-            event_stream.stream_record_id = stream_record.id
-          end
-          uncommitted_events.map do |event|
-            Sequent.configuration.event_record_class.new.tap do |record|
-              record.command_record_id = command_record.id
-              record.stream_record_id = event_stream.stream_record_id
-              record.event = event
-            end
-          end
+        command_record = {
+          created_at: convert_timestamp(command.created_at&.to_time || Time.now),
+          command_type: command.class.name,
+          command_json: command,
+        }
+
+        events = streams_with_events.map do |stream, uncommitted_events|
+          [
+            Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(stream)),
+            uncommitted_events.map do |event|
+              {
+                created_at: convert_timestamp(event.created_at.to_time),
+                event_type: event.class.name,
+                event_json: event,
+              }
+            end,
+          ]
         end
-        connection = Sequent.configuration.event_record_class.connection
-        values = event_records
-          .map { |r| "(#{column_names.map { |c| connection.quote(r[c.to_sym]) }.join(',')})" }
-          .join(',')
-        columns = column_names.map { |c| connection.quote_column_name(c) }.join(',')
-        sql = <<~SQL.chomp
-          insert into #{connection.quote_table_name(Sequent.configuration.event_record_class.table_name)} (#{columns}) values #{values}
-        SQL
-        Sequent.configuration.event_record_class.connection.insert(sql, nil, primary_key_event_records)
+        call_procedure(
+          connection,
+          'store_events',
+          [
+            Sequent::Core::Oj.dump(command_record),
+            Sequent::Core::Oj.dump(events),
+          ],
+        )
       rescue ActiveRecord::RecordNotUnique
         raise OptimisticLockingError
       end
+
+      def convert_timestamp(timestamp)
+        # Since ActiveRecord uses `TIMESTAMP WITHOUT TIME ZONE`
+        # we need to manually convert database timestamps to the
+        # ActiveRecord default time zone on serialization.
+        ActiveRecord.default_timezone == :utc ? timestamp.getutc : timestamp.getlocal
+      end
     end
   end
 end

data/lib/sequent/core/helpers/array_with_type.rb

@@ -13,7 +13,7 @@ module Sequent
         end
 
         def deserialize_from_json(value)
-          value.nil? ? nil : value.map { |item| item_type.deserialize_from_json(item) }
+          value&.map { |item| item_type.deserialize_from_json(item) }
         end
 
         def to_s

data/lib/sequent/core/helpers/association_validator.rb

@@ -35,7 +35,7 @@ module Sequent
             value = record.instance_variable_get("@#{association}")
             if value && incorrect_type?(value, record, association)
               record.errors.add(association, "is not of type #{describe_type(record.class.types[association])}")
-            elsif value&.is_a?(Array)
+            elsif value.is_a?(Array)
               item_type = record.class.types.fetch(association).item_type
               record.errors.add(association, 'is invalid') unless validate_all(value, item_type).all?
             elsif value&.invalid?
@@ -47,7 +47,7 @@ module Sequent
         private
 
         def incorrect_type?(value, record, association)
-          return unless record.class.respond_to?(:types)
+          return false unless record.class.respond_to?(:types)
 
           type = record.class.types[association]
           if type.respond_to?(:candidate?)