activecypher 0.3.0 → 0.6.0

data/lib/active_cypher/fixtures.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module ActiveCypher
+  module Fixtures
+    # Something went wrong with your test fixtures.
+    # Maybe they're on vacation. Maybe they're just imaginary.
+    class FixtureError < StandardError; end
+
+    # You asked for a fixture that doesn't exist.
+    # It's playing hide and seek. Mostly hide.
+    class FixtureNotFoundError < StandardError; end
+
+    # Load a graph fixture profile.
+    # @param profile [Symbol, String, nil] the profile name (default: :default)
+    # @return [void]
+    def self.load(profile: nil)
+      # 1. Resolve file
+      profile_name = (profile || :default).to_s
+      fixtures_dir = File.expand_path('test/fixtures/graph', Dir.pwd)
+      file = File.join(fixtures_dir, "#{profile_name}.rb")
+      raise FixtureNotFoundError, "Fixture profile not found: #{profile_name} (#{file})" unless File.exist?(file)
+
+      # 2. Reset registry
+      Registry.reset!
+
+      # 3. Parse the profile file (to discover which models are referenced)
+      parser = Parser.new(file)
+      dsl_context = parser.parse
+
+      # 4. Validate relationships upfront (cross-DB)
+      validate_relationships(dsl_context.relationships)
+
+      # 5. Gather unique connections for all model classes referenced in this profile
+      model_classes = dsl_context.nodes.map { |node| node[:model_class] }.uniq
+      connections = model_classes.map do |klass|
+        klass.connection
+      rescue StandardError
+        nil
+      end.compact.uniq
+
+      # 6. Wipe all nodes in each relevant connection
+      connections.each do |conn|
+        conn.execute_cypher('MATCH (n) DETACH DELETE n')
+      rescue StandardError => e
+        warn "[ActiveCypher::Fixtures.load] Failed to clear connection #{conn.inspect}: #{e.class}: #{e.message}"
+      end
+
+      # 7. Evaluate nodes and relationships (batched if large)
+      if dsl_context.nodes.size > 100 || dsl_context.relationships.size > 200
+        NodeBuilder.bulk_build(dsl_context.nodes)
+        # Create all nodes first, then validate relationships again with populated Registry
+        validate_relationships(dsl_context.relationships)
+        RelBuilder.bulk_build(dsl_context.relationships)
+      else
+        dsl_context.nodes.each do |node|
+          NodeBuilder.build(node[:ref], node[:model_class], node[:props])
+        end
+        rel_builder = RelBuilder.new
+        dsl_context.relationships.each do |rel|
+          rel_builder.build(rel[:ref], rel[:from_ref], rel[:type], rel[:to_ref], rel[:props])
+        end
+      end
+
+      # 8. Return registry for convenience
+      Registry
+    end
+
+    # Clear all nodes in all known connections.
+    # @return [void]
+    def self.clear_all
+      # Find all concrete (non-abstract) model classes inheriting from ActiveCypher::Base
+      model_classes = []
+      ObjectSpace.each_object(Class) do |klass|
+        next unless klass < ActiveCypher::Base
+        next if klass.respond_to?(:abstract_class?) && klass.abstract_class?
+
+        model_classes << klass
+      end
+
+      # Gather unique connections from all model classes
+      connections = model_classes.map do |klass|
+        klass.connection
+      rescue StandardError
+        nil
+      end.compact.uniq
+
+      # Wipe all nodes in each connection
+      connections.each do |conn|
+        conn.execute_cypher('MATCH (n) DETACH DELETE n')
+      rescue StandardError => e
+        warn "[ActiveCypher::Fixtures.clear_all] Failed to clear connection #{conn.inspect}: #{e.class}: #{e.message}"
+      end
+      true
+    end
+
+    # Validates relationships for cross-DB issues
+    # @param relationships [Array<Hash>] array of relationship definitions
+    # @raise [FixtureError] if cross-DB relationship is found
+    def self.validate_relationships(relationships)
+      model_connections = {}
+
+      # First build a mapping of model class => connection details
+      ObjectSpace.each_object(Class) do |klass|
+        next unless klass < ActiveCypher::Base
+        next if klass.respond_to?(:abstract_class?) && klass.abstract_class?
+
+        begin
+          conn = klass.connection
+          # Store connection details for comparison
+          model_connections[klass] = {
+            adapter: conn.class.name,
+            config: conn.instance_variable_get(:@config),
+            object_id: conn.object_id
+          }
+        rescue StandardError
+          # Skip if can't get connection
+        end
+      end
+
+      relationships.each do |rel|
+        from_ref = rel[:from_ref]
+        to_ref = rel[:to_ref]
+
+        # Get node classes from DSL context
+        # In real data, nodes have already been created by this point
+        from_node = Registry.get(from_ref)
+        to_node = Registry.get(to_ref)
+
+        # Skip if we can't find both nodes yet (will be caught later)
+        next unless from_node && to_node
+
+        from_class = from_node.class
+        to_class = to_node.class
+
+        # Look up connection details for each class
+        from_conn_details = model_connections[from_class]
+        to_conn_details = model_connections[to_class]
+
+        # If either class isn't in our mapping, refresh it
+        unless from_conn_details
+          conn = from_class.connection
+          from_conn_details = {
+            adapter: conn.class.name,
+            config: conn.instance_variable_get(:@config),
+            object_id: conn.object_id
+          }
+          model_connections[from_class] = from_conn_details
+        end
+
+        unless to_conn_details
+          conn = to_class.connection
+          to_conn_details = {
+            adapter: conn.class.name,
+            config: conn.instance_variable_get(:@config),
+            object_id: conn.object_id
+          }
+          model_connections[to_class] = to_conn_details
+        end
+
+        # Compare connection details
+        next unless from_conn_details[:object_id] != to_conn_details[:object_id] ||
+                    from_conn_details[:adapter] != to_conn_details[:adapter] ||
+                    from_conn_details[:config][:database] != to_conn_details[:config][:database]
+
+        raise FixtureError, 'Cross-database relationship? Sorry, your data has commitment issues. ' \
+                            "Nodes #{from_ref} (#{from_class}) and #{to_ref} (#{to_class}) use different databases."
+      end
+    end
+
+    # Fetch a node by logical ref.
+    # @param ref [Symbol, String]
+    # @return [Object]
+    def self.[](ref)
+      Registry[ref]
+    end
+  end
+end

data/lib/active_cypher/generators/node_generator.rb

@@ -7,6 +7,11 @@ module ActiveCypher
   module Generators
     class NodeGenerator < Rails::Generators::NamedBase
       source_root File.expand_path('templates', __dir__)
+      class_option :suffix, type: :string,
+                            desc: 'Suffix for the node class (default: Node)',
+                            default: 'Node'
+
+      check_class_collision suffix: 'Node'
 
       argument :attributes, type: :array,
                             default: [], banner: 'name:type name:type'
@@ -16,16 +21,40 @@ module ActiveCypher
                             default: ''
 
       def create_node_file
-        template 'node.rb.erb',
-                 File.join('app/graph', class_path, "#{file_name}.rb")
+        check_runtime_class_collision
+        template 'node.rb.erb', File.join('app/graph', class_path, "#{file_name}.rb")
       end
 
       private
 
+      def check_runtime_class_collision
+        suffix = node_suffix
+        base = name.camelize
+        class_name_with_suffix = base.end_with?(suffix) ? base : "#{base}#{suffix}"
+        return unless class_name_with_suffix.safe_constantize
+
+        raise Thor::Error, "Class collision: #{class_name_with_suffix} is already defined"
+      end
+
+      def node_suffix
+        options[:suffix] || 'Node'
+      end
+
+      def class_name
+        base = super
+        base.end_with?(node_suffix) ? base : "#{base}#{node_suffix}"
+      end
+
+      def file_name
+        base = super
+        suffix = "_#{node_suffix.underscore}"
+        base.end_with?(suffix) ? base : "#{base}#{suffix}"
+      end
+
       # helper for ERB
       def labels_list
         lbls = options[:labels].split(',').map(&:strip).reject(&:blank?)
-        lbls.empty? ? [class_name.gsub(/Node$/, '')] : lbls
+        lbls.empty? ? [class_name.gsub(/#{node_suffix}$/, '')] : lbls
       end
     end
   end

data/lib/active_cypher/generators/relationship_generator.rb

@@ -7,6 +7,9 @@ module ActiveCypher
   module Generators
     class RelationshipGenerator < Rails::Generators::NamedBase
       source_root File.expand_path('templates', __dir__)
+      class_option :suffix, type: :string,
+                            desc: 'Suffix for the relationship class (default: Rel)',
+                            default: 'Rel'
 
       argument :attributes, type: :array,
                             default: [], banner: 'name:type name:type'
@@ -19,12 +22,36 @@ module ActiveCypher
                            desc: 'Cypher relationship type (defaults to class name)'
 
       def create_relationship_file
-        template 'relationship.rb.erb',
-                 File.join('app/graph', class_path, "#{file_name}.rb")
+        check_runtime_class_collision
+        template 'relationship.rb.erb', File.join('app/graph', class_path, "#{file_name}.rb")
       end
 
       private
 
+      def relationship_suffix
+        options[:suffix] || 'Rel'
+      end
+
+      def class_name
+        base = super
+        base.end_with?(relationship_suffix) ? base : "#{base}#{relationship_suffix}"
+      end
+
+      def file_name
+        base = super
+        suffix = "_#{relationship_suffix.underscore}"
+        base.end_with?(suffix) ? base : "#{base}#{suffix}"
+      end
+
+      def check_runtime_class_collision
+        suffix = relationship_suffix
+        base = name.camelize
+        class_name_with_suffix = base.end_with?(suffix) ? base : "#{base}#{suffix}"
+        return unless class_name_with_suffix.safe_constantize.present?
+
+        raise Thor::Error, "Class collision: #{class_name_with_suffix} is already defined"
+      end
+
       def relationship_type
         (options[:type].presence || class_name).upcase
       end

data/lib/active_cypher/generators/templates/application_graph_node.rb

@@ -2,4 +2,5 @@
 
 class ApplicationGraphNode < ActiveCypher::Base
   # Adapter‑specific helpers are injected after connection
+  connects_to writing: :primary
 end

data/lib/active_cypher/generators/templates/node.rb.erb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
+
 class <%= class_name %> < ApplicationGraphNode
-  <% labels_list.each do |lbl| %>
+<% if labels_list.any? -%>
+<% labels_list.each do |lbl| -%>
   label :<%= lbl %>
-    <% end %>
-
-    <% attributes.each do |attr| -%>
-    attribute :<%= attr.name %>, :<%= attr.type || "string" %>
-  <% end -%>
+<% end -%>
+<% end -%>
+<% if attributes.any? -%>
+<% attributes.each do |attr| -%>
+  attribute :<%= attr.name %>, :<%= attr.type || "string" %>
+<% end -%>
+<% end -%>
 end

data/lib/active_cypher/generators/templates/relationship.rb.erb

@@ -2,10 +2,11 @@
 
 class <%= class_name %> < ApplicationGraphRelationship
   from_class :<%= options[:from] %>
-    to_class   :<%= options[:to]   %>
-    type       :<%= relationship_type %>
-
-    <% attributes.each do |attr| -%>
-    attribute :<%= attr.name %>, :<%= attr.type || "string" %>
-  <% end -%>
+  to_class   :<%= options[:to] %>
+  type       :<%= relationship_type %>
+<% if attributes.any? -%>
+<% attributes.each do |attr| -%>
+  attribute :<%= attr.name %>, :<%= attr.type || "string" %>
+<% end -%>
+<% end -%>
 end

data/lib/active_cypher/instrumentation.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'active_support/notifications'
+
+module ActiveCypher
+  # Instrumentation for ActiveCypher operations.
+  # Because every database operation needs a stopwatch and an audience.
+  module Instrumentation
+    # ------------------------------------------------------------------
+    # Core instrumentation method
+    # ------------------------------------------------------------------
+
+    # Instruments an operation and publishes an event with timing information.
+    # @param operation [String, Symbol] The operation name (prefixed with 'active_cypher.')
+    # @param payload [Hash] Additional context for the event
+    # @yield The operation to instrument
+    # @return [Object] The result of the block
+    def instrument(operation, payload = {})
+      # Start timing with monotonic clock for accuracy (because wall time is for amateurs)
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      # Run the actual operation
+      result = yield
+
+      # Calculate duration in milliseconds (because counting seconds is so 1990s)
+      duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1_000).round(2)
+
+      # Add duration to payload
+      payload[:duration_ms] = duration_ms
+
+      # Publish event via ActiveSupport::Notifications
+      event_name = operation.to_s.start_with?('active_cypher.') ? operation.to_s : "active_cypher.#{operation}"
+      ActiveSupport::Notifications.instrument(event_name, payload)
+
+      # Also log if we have logging capabilities
+      log_instrumented_event(operation, payload) if respond_to?(:logger)
+
+      # Return the original result
+      result
+    end
+
+    # ------------------------------------------------------------------
+    # Specialized instrumentation methods
+    # ------------------------------------------------------------------
+
+    # Instruments a database query.
+    # @param cypher [String] The Cypher query
+    # @param params [Hash] Query parameters
+    # @param context [String] Additional context (e.g., "Model.find")
+    # @param metadata [Hash] Additional metadata
+    # @yield The query operation
+    # @return [Object] The result of the block
+    def instrument_query(cypher, params = {}, context: 'Query', metadata: {}, &)
+      truncated_cypher = cypher.to_s.gsub(/\s+/, ' ').strip
+      truncated_cypher = "#{truncated_cypher[0...97]}..." if truncated_cypher.length > 100
+
+      payload = metadata.merge(
+        cypher: truncated_cypher,
+        params: sanitize_params(params),
+        context: context
+      )
+
+      instrument('query', payload, &)
+    end
+
+    # Instruments a connection operation.
+    # @param operation [Symbol] The connection operation (:connect, :disconnect, etc)
+    # @param config [Hash] Connection configuration
+    # @param metadata [Hash] Additional metadata
+    # @yield The connection operation
+    # @return [Object] The result of the block
+    def instrument_connection(operation, config = {}, metadata: {}, &)
+      payload = metadata.merge(
+        config: sanitize_config(config)
+      )
+
+      instrument("connection.#{operation}", payload, &)
+    end
+
+    # Instruments a transaction operation.
+    # @param operation [Symbol] The transaction operation (:begin, :commit, :rollback)
+    # @param transaction_id [String, Integer] Transaction identifier (if available)
+    # @param metadata [Hash] Additional metadata
+    # @yield The transaction operation
+    # @return [Object] The result of the block
+    def instrument_transaction(operation, transaction_id = nil, metadata: {}, &)
+      payload = metadata.dup
+      payload[:transaction_id] = transaction_id if transaction_id
+
+      instrument("transaction.#{operation}", payload, &)
+    end
+
+    # ------------------------------------------------------------------
+    # Sanitization methods
+    # ------------------------------------------------------------------
+
+    # Sanitizes query parameters to remove sensitive values.
+    # @param params [Hash, Object] The parameters to sanitize
+    # @return [Hash, Object] Sanitized parameters
+    def sanitize_params(params)
+      return params unless params.is_a?(Hash)
+
+      params.each_with_object({}) do |(key, value), sanitized|
+        sanitized[key] = if sensitive_key?(key)
+                           '[FILTERED]'
+                         elsif value.is_a?(Hash)
+                           sanitize_params(value)
+                         else
+                           value
+                         end
+      end
+    end
+
+    # Sanitizes connection configuration to remove sensitive values.
+    # @param config [Hash] The configuration to sanitize
+    # @return [Hash] Sanitized configuration
+    def sanitize_config(config)
+      return {} unless config.is_a?(Hash)
+
+      config.each_with_object({}) do |(key, value), result|
+        result[key] = if sensitive_key?(key)
+                        '[FILTERED]'
+                      elsif value.is_a?(Hash)
+                        sanitize_config(value)
+                      else
+                        value
+                      end
+      end
+    end
+
+    # Determines if a key contains sensitive information that should be filtered.
+    # @param key [String, Symbol] The key to check
+    # @return [Boolean] True if the key contains sensitive information
+    def sensitive_key?(key)
+      return true if key.to_s.match?(/\b(password|token|secret|credential|key)\b/i)
+
+      # Check against Rails filter parameters if available
+      if defined?(Rails) && Rails.application
+        Rails.application.config.filter_parameters.any? do |pattern|
+          case pattern
+          when Regexp
+            key.to_s =~ pattern
+          when Symbol, String
+            key.to_s == pattern.to_s
+          else
+            false
+          end
+        end
+      else
+        false
+      end
+    end
+
+    private
+
+    # ------------------------------------------------------------------
+    # Logging integration
+    # ------------------------------------------------------------------
+    # Logs an instrumented event if logging is available.
+    # @param operation [String, Symbol] The operation name
+    # @param payload [Hash] The event payload
+    def log_instrumented_event(operation, payload)
+      return unless respond_to?(:log_debug)
+
+      # Format duration if available
+      duration_text = payload[:duration_ms] ? " (#{payload[:duration_ms]} ms)" : ''
+      operation_name = operation.to_s.sub(/^active_cypher\./, '')
+
+      case operation_name
+      when /query/
+        log_debug("QUERY#{duration_text}: #{payload[:cypher]}")
+        log_debug("PARAMS: #{payload[:params].inspect}") if payload[:params]
+      when /connection/
+        op = operation_name.sub(/^connection\./, '')
+        log_debug("CONNECTION #{op.upcase}#{duration_text}")
+      when /transaction/
+        op = operation_name.sub(/^transaction\./, '')
+        tx_id = payload[:transaction_id] ? " (ID: #{payload[:transaction_id]})" : ''
+        log_debug("TRANSACTION #{op.upcase}#{tx_id}#{duration_text}")
+      else
+        # Generic fallback, for when you just don't know how to categorize your problems
+        log_debug("#{operation_name.upcase}#{duration_text}")
+      end
+    end
+  end
+end

data/lib/active_cypher/model/callbacks.rb

@@ -1,29 +1,21 @@
 # frozen_string_literal: true
 
 module ActiveCypher
-  # <= matches your other concerns
   module Model
-    # @!parse
-    #   # Model::Callbacks provides lifecycle hooks for your models, so you can pretend you have control over what happens and when.
-    #   # Because nothing says "enterprise" like a callback firing at just the wrong moment.
-    #   # Under the hood, it’s all just a little bit of Ruby sorcery, callback witchcraft, and the occasional forbidden incantation from the callback crypt.
+    # @note Now containing even more callback-related Ruby sorcery!
     module Callbacks
       extend ActiveSupport::Concern
 
       EVENTS = %i[
-        initialize find validate create update save destroy
+        initialize find create update save destroy
       ].freeze
 
-      included do
-        include ActiveSupport::Callbacks
-        define_callbacks(*EVENTS)
-      end
+      included do |base|
+        base.define_callbacks(*EVENTS)
 
-      class_methods do
         %i[before after around].each do |kind|
           EVENTS.each do |evt|
-            define_method("#{kind}_#{evt}") do |*filters, &block|
-              # This is where the callback coven gathers to cast their hooks.
+            base.define_singleton_method("#{kind}_#{evt}") do |*filters, &block|
               set_callback(evt, kind, *filters, &block)
             end
           end

data/lib/active_cypher/model/connection_handling.rb

@@ -2,73 +2,58 @@
 
 module ActiveCypher
   module Model
-    # Handles connection logic for models, because every ORM needs a way to feel connected.
-    # @note All real connection magic is just Ruby sorcery, a dash of forbidden Ruby incantations, and a sprinkle of ActiveSupport witchcraft.
+    # Handles connection logic for models, because even graph nodes need to feel emotionally wired.
+    # @note Under the hood: it's just Ruby metaprogramming, config keys, and a dash of ActiveSupport pixie dust.
     module ConnectionHandling
       extend ActiveSupport::Concern
 
       class_methods do
-        # Establishes a connection for the model.
-        # Because every model deserves a shot at disappointment.
-        # @note Under the hood, this is just Ruby sorcery and a little forbidden Ruby wizardry to make your config work.
-        def establish_connection(config)
-          cfg = config.symbolize_keys
-
-          # Handle both URL-based and traditional config
-          if cfg[:url]
-            # Use ConnectionUrlResolver for URL-based config
-            resolver = ActiveCypher::ConnectionUrlResolver.new(cfg[:url])
-            resolved_config = resolver.to_hash
+        # Sets up database connections for different roles (e.g., writing, reading, analytics).
+        #
+        # Supports shorthand (just pass a symbol/string for writing role).
+        # If :reading isn’t provided, it defaults to the same DB as :writing. Because DRY is still cool.
+        #
+        # @param mapping [Hash] A role-to-database mapping. Keys are roles, values are DB keys or specs.
+        #   Example:
+        #     connects_to writing: :primary, reading: :replica
+        # @return [void]
+        def connects_to(mapping)
+          mapping = { writing: mapping } if mapping.is_a?(Symbol) || mapping.is_a?(String)
+          symbolized_mapping = mapping.deep_symbolize_keys
 
-            # Merge any additional config options
-            resolved_config = resolved_config.merge(cfg.except(:url)) if resolved_config
+          raise ArgumentError, 'The :writing role must be defined in connects_to mapping.' unless symbolized_mapping.key?(:writing)
 
-            # Bail if URL couldn't be parsed
-            raise ArgumentError, "Invalid connection URL: #{cfg[:url]}" unless resolved_config
+          # If you're lazy and don't specify :reading, it defaults to :writing. You're welcome.
+          symbolized_mapping[:reading] ||= symbolized_mapping[:writing]
 
-            # Get adapter name from resolved config
-            adapter_name = resolved_config[:adapter]
-          else
-            # Traditional config with explicit adapter
-            adapter_name = cfg[:adapter] or raise ArgumentError, 'Missing :adapter'
-            resolved_config = cfg
-          end
+          symbolized_mapping.each do |role, db_key|
+            # db_key can be a symbol (config name) or a nested hash. We’re not judging.
+            spec_name = db_key.is_a?(Hash) ? db_key.values.first : db_key
 
-          path          = "active_cypher/connection_adapters/#{adapter_name}_adapter"
-          class_name    = "#{adapter_name}_adapter".camelize
+            spec = ActiveCypher::CypherConfig.for(spec_name) # Boom. Pulls your DB config.
+            config_for_adapter = spec.dup
 
-          require path
-          adapter_class = ActiveCypher::ConnectionAdapters.const_get(class_name)
-          self.connection = adapter_class.new(resolved_config)
-          connection.connect
-          connection
-        rescue LoadError => e
-          raise AdapterLoadError, "Could not load ActiveCypher adapter '#{adapter_name}' (#{e.message})"
-        end
-
-        # Sets up multiple connections for different roles, because one pool is never enough.
-        # @param mapping [Hash] Role-to-database mapping
-        # @return [void]
-        # Sets up multiple connections for different roles, because one pool is never enough.
-        # @param mapping [Hash] Role-to-database mapping
-        # @return [void]
-        # @note This is where the Ruby gremlins really start dancing—multiple pools, one registry, and a sprinkle of connection witchcraft.
-        def connects_to(mapping)
-          mapping.deep_symbolize_keys.each do |role, db_key|
-            spec = ActiveCypher::CypherConfig.for(db_key) # ← may raise KeyError
-
-            # If spec contains a URL, use ConnectionFactory
+            # If the spec has a URL, parse it and let it override the boring YAML values.
             if spec[:url]
-              factory = ActiveCypher::ConnectionFactory.new(spec[:url])
-              spec = factory.config.merge(spec.except(:url)) if factory.valid?
+              resolver = ActiveCypher::ConnectionUrlResolver.new(spec[:url])
+              url_config = resolver.to_hash
+              raise ArgumentError, "Invalid connection URL: #{spec[:url]}" unless url_config
+
+              config_for_adapter = url_config.merge(spec.except(*url_config.keys))
             end
 
-            pool = ActiveCypher::ConnectionPool.new(spec)
-            connection_handler.set(role.to_sym, :default, pool)
+            # Create a unique connection pool for this role/config combo.
+            pool = ActiveCypher::ConnectionPool.new(config_for_adapter)
+
+            # Register the pool under this spec name.
+            connection_handler.set(spec_name, pool)
           rescue KeyError => e
             raise ActiveCypher::UnknownConnectionError,
-                  "connects_to #{role}: #{db_key.inspect} – #{e.message}"
+                  "connects_to role `#{role}`: database configuration key `#{spec_name.inspect}` not found in cypher_databases.yml – #{e.message}"
           end
+
+          # Save the mapping for later — introspection, debugging, blaming, etc.
+          self.connects_to_mappings = symbolized_mapping
         end
       end
     end