familia 2.0.0.pre16 → 2.0.0.pre18

data/lib/familia/features/relationships/indexing/unique_index_generators.rb

@@ -33,9 +33,12 @@ module Familia
         #   - Employee.rebuild_email_index
         #
         # Generates on Employee (self):
-        #   - employee.add_to_class_email_index
+        #   - employee.add_to_class_email_index (called automatically on save)
         #   - employee.remove_from_class_email_index
         #   - employee.update_in_class_email_index(old_email)
+        #
+        # Note: Class-level indexes auto-populate on save(). Instance-scoped indexes
+        # (with within:) remain manual as they require parent context.
         module UniqueIndexGenerators
           module_function
 
@@ -101,35 +104,42 @@ module Familia
 
             # Generate instance query method (e.g., company.find_by_badge_number)
             actual_target_class.class_eval do
-              define_method("find_by_#{field}") do |field_value|
+              define_method(:"find_by_#{field}") do |provided_value|
                 # Use declared field accessor instead of manual instantiation
                 index_hash = send(index_name)
 
-                # Get the identifier from the hash
-                object_id = index_hash[field_value.to_s]
-                return nil unless object_id
+                # Get the identifier from the hash using .get method.
+                # We use .get instead of [] because it's part of the standard interface
+                # common across all DataType classes (List, UnsortedSet, SortedSet, HashKey).
+                # While unique indexes always use HashKey, using .get maintains consistency
+                # with the broader DataType API patterns used throughout Familia.
+                record_id = index_hash.get(provided_value)
+                return nil unless record_id
 
-                indexed_class.new(object_id)
+                indexed_class.find_by_identifier(record_id)
               end
 
               # Generate bulk query method (e.g., company.find_all_by_badge_number)
-              define_method("find_all_by_#{field}") do |field_values|
-                return [] if field_values.empty?
+              define_method(:"find_all_by_#{field}") do |provided_ids|
+                provided_ids = Array(provided_ids)
+                return [] if provided_ids.empty?
 
                 # Use declared field accessor instead of manual instantiation
                 index_hash = send(index_name)
 
                 # Get all identifiers from the hash
-                object_ids = index_hash.values_at(*field_values.map(&:to_s))
+                record_ids = index_hash.values_at(*provided_ids.map(&:to_s))
                 # Filter out nil values and instantiate objects
-                object_ids.compact.map { |object_id| indexed_class.new(object_id) }
+                record_ids.compact.map { |record_id|
+                  indexed_class.find_by_identifier(record_id)
+                }
               end
 
               # Accessor method already created by ensure_index_field above
               # No need to manually define it here
 
               # Generate method to rebuild the unique index for this parent instance
-              define_method("rebuild_#{index_name}") do
+              define_method(:"rebuild_#{index_name}") do
                 # Use declared field accessor instead of manual instantiation
                 index_hash = send(index_name)
 
@@ -156,7 +166,7 @@ module Familia
           def generate_mutation_methods_self(indexed_class, field, target_class, index_name)
             target_class_config = target_class.config_name
             indexed_class.class_eval do
-              method_name = "add_to_#{target_class_config}_#{index_name}"
+              method_name = :"add_to_#{target_class_config}_#{index_name}"
               Familia.ld("[UniqueIndexGenerators] #{name} method #{method_name}")
 
               define_method(method_name) do |target_instance|
@@ -172,7 +182,7 @@ module Familia
                 index_hash[field_value.to_s] = identifier
               end
 
-              method_name = "remove_from_#{target_class_config}_#{index_name}"
+              method_name = :"remove_from_#{target_class_config}_#{index_name}"
               Familia.ld("[UniqueIndexGenerators] #{name} method #{method_name}")
 
               define_method(method_name) do |target_instance|
@@ -188,7 +198,7 @@ module Familia
                 index_hash.remove(field_value.to_s)
               end
 
-              method_name = "update_in_#{target_class_config}_#{index_name}"
+              method_name = :"update_in_#{target_class_config}_#{index_name}"
               Familia.ld("[UniqueIndexGenerators] #{name} method #{method_name}")
 
               define_method(method_name) do |target_instance, old_field_value = nil|
@@ -218,30 +228,39 @@ module Familia
           # - Employee.email_index
           # - Employee.rebuild_email_index
           def generate_query_methods_class(field, index_name, indexed_class)
-            indexed_class.define_singleton_method("find_by_#{field}") do |field_value|
+            indexed_class.define_singleton_method(:"find_by_#{field}") do |provided_id|
               index_hash = send(index_name) # Access the class-level hashkey DataType
-              object_id = index_hash[field_value.to_s]
 
-              return nil unless object_id
+              # Get the identifier from the hash using .get method.
+              # We use .get instead of [] because it's part of the standard interface
+              # common across all DataType classes (List, UnsortedSet, SortedSet, HashKey).
+              # While unique indexes always use HashKey, using .get maintains consistency
+              # with the broader DataType API patterns used throughout Familia.
+              record_id = index_hash.get(provided_id)
+
+              return nil unless record_id
 
-              new(object_id)
+              indexed_class.find_by_identifier(record_id)
             end
 
             # Generate class-level bulk query method
-            indexed_class.define_singleton_method("find_all_by_#{field}") do |field_values|
-              return [] if field_values.empty?
+            indexed_class.define_singleton_method(:"find_all_by_#{field}") do |provided_ids|
+              provided_ids = Array(provided_ids)
+              return [] if provided_ids.empty?
 
               index_hash = send(index_name) # Access the class-level hashkey DataType
-              object_ids = index_hash.values_at(*field_values.map(&:to_s))
+              record_ids = index_hash.values_at(*provided_ids.map(&:to_s))
               # Filter out nil values and instantiate objects
-              object_ids.compact.map { |object_id| new(object_id) }
+              record_ids.compact.map { |record_id|
+                indexed_class.find_by_identifier(record_id)
+              }
             end
 
             # The index accessor method is already created by the class_hashkey declaration
             # No need to manually create it - Horreum handles this automatically
 
             # Generate method to rebuild the class-level index
-            indexed_class.define_singleton_method("rebuild_#{index_name}") do
+            indexed_class.define_singleton_method(:"rebuild_#{index_name}") do
               index_hash = send(index_name) # Access the class-level hashkey DataType
 
               # Clear existing index using DataType method
@@ -260,7 +279,7 @@ module Familia
           # - employee.update_in_class_email_index(old_email)
           def generate_mutation_methods_class(field, index_name, indexed_class)
             indexed_class.class_eval do
-              define_method("add_to_class_#{index_name}") do
+              define_method(:"add_to_class_#{index_name}") do
                 index_hash = self.class.send(index_name)  # Access the class-level hashkey DataType
                 field_value = send(field)
 
@@ -269,7 +288,7 @@ module Familia
                 index_hash[field_value.to_s] = identifier
               end
 
-              define_method("remove_from_class_#{index_name}") do
+              define_method(:"remove_from_class_#{index_name}") do
                 index_hash = self.class.send(index_name)  # Access the class-level hashkey DataType
                 field_value = send(field)
 
@@ -278,7 +297,7 @@ module Familia
                 index_hash.remove(field_value.to_s)
               end
 
-              define_method("update_in_class_#{index_name}") do |old_field_value = nil|
+              define_method(:"update_in_class_#{index_name}") do |old_field_value = nil|
                 new_field_value = send(field)
 
                 # Use class-level transaction for atomicity with DataType abstraction

data/lib/familia/features/relationships/indexing.rb

@@ -18,7 +18,7 @@ module Familia
       #   end
       #
       #   user = User.new(user_id: 'u1', email: 'alice@example.com')
-      #   user.add_to_class_email_lookup
+      #   user.save  # Automatically populates email_lookup index
       #   User.find_by_email('alice@example.com')  # → user
       #
       # @example Instance-scoped unique index (within parent, 1:1 via HashKey)
@@ -58,6 +58,12 @@ module Familia
       # - Instance unique: "company:c1:badge_index" → HashKey
       # - Instance multi: "company:c1:dept_index:engineering" → UnsortedSet
       #
+      # Auto-Indexing:
+      # Class-level unique_index declarations automatically populate on save():
+      #   user = User.new(email: 'test@example.com')
+      #   user.save  # Auto-indexes email → user_id
+      # Instance-scoped indexes (with within:) remain manual (require parent context).
+      #
       # Design Philosophy:
       # Indexing is for finding objects by attribute, not ordering them.
       # Use multi_index with UnsortedSet (no temporal scores), then sort in Ruby:

data/lib/familia/features/relationships/participation/participant_methods.rb

@@ -23,8 +23,10 @@ module Familia
         # ├── add_to_customer_domains(customer, score)    # Add myself to customer's domains
         # ├── remove_from_customer_domains(customer)      # Remove myself from customer's domains
         # ├── score_in_customer_domains(customer)         # Get my score (sorted_set only)
-        # ├── update_score_in_customer_domains(customer)  # Update my score (sorted_set only)
         # └── position_in_customer_domains(customer)      # Get my position (list only)
+        #
+        # Note: To update scores, use the DataType API directly:
+        #   customer.domains.add(domain.identifier, new_score, xx: true)
 
         module Builder
           extend CollectionOperations
@@ -126,7 +128,9 @@ module Familia
 
           # Build score-related methods for sorted sets
           # Creates: domain.score_in_customer_domains(customer)
-          #          domain.update_score_in_customer_domains(customer, new_score)
+          #
+          # Note: Score updates use DataType API directly:
+          #   customer.domains.add(domain.identifier, new_score, xx: true)
           def self.build_score_methods(participant_class, target_name, collection_name)
             # Get score method
             score_method = "score_in_#{target_name}_#{collection_name}"

data/lib/familia/features/safe_dump.rb

@@ -1,9 +1,8 @@
 # lib/familia/features/safe_dump.rb
 
 #
-#   Class instance variables are used here for feature configuration
-#   (e.g., @dump_method, @load_method). These are set once and not mutated
-#   at runtime, so thread safety is not a concern for this feature.
+# Class instance variables are used here for configuration. These are set
+# once at loadtime and not mutated, so thread safety is not an issue here.
 #
 module Familia
   module Features

data/lib/familia/features/transient_fields.rb

@@ -1,6 +1,7 @@
 # lib/familia/features/transient_fields.rb
 
 require_relative 'transient_fields/redacted_string'
+require_relative 'transient_fields/transient_field_type'
 
 module Familia
   module Features
@@ -104,7 +105,7 @@ module Familia
     # (HashiCorp Vault, AWS Secrets Manager) or languages with secure memory handling.
     #
     module TransientFields
-      Familia::Base.add_feature self, :transient_fields, depends_on: nil
+      Familia::Base.add_feature self, :transient_fields, depends_on: nil, field_group: :transient_fields
 
       def self.included(base)
         Familia.trace :LOADED, self, base if Familia.debug?
@@ -143,8 +144,12 @@ module Familia
           @transient_fields ||= []
           @transient_fields << name unless @transient_fields.include?(name)
 
+          # Add to field_groups if the group exists
+          if field_groups&.key?(:transient_fields)
+            field_groups[:transient_fields] << name
+          end
+
           # Use the field type system for proper integration
-          require_relative 'transient_fields/transient_field_type'
           field_type = TransientFieldType.new(name, as: as, **kwargs.merge(fast_method: false))
           register_field_type(field_type)
         end

data/lib/familia/features.rb

@@ -4,7 +4,7 @@
 require_relative 'features/autoloader'
 
 module Familia
-  FeatureDefinition = Data.define(:name, :depends_on)
+  FeatureDefinition = Data.define(:name, :depends_on, :field_group)
 
   # Familia::Features
   #
@@ -147,6 +147,11 @@ module Familia
       calling_location = caller_locations(1, 1)&.first
       options[:calling_location] = calling_location&.path
 
+      # Initialize field group if feature declares one
+      if feature_def&.field_group && respond_to?(:field_group)
+        field_group(feature_def.field_group)
+      end
+
       # Add feature options if the class supports them (Horreum classes)
       add_feature_options(feature_name, **options) if respond_to?(:add_feature_options)
 

data/lib/familia/field_type.rb

@@ -117,25 +117,7 @@ module Familia
         klass.define_method :"#{method_name}=" do |value|
           instance_variable_set(:"@#{field_name}", value)
 
-          # If this field is the identifier and object_identifier feature is loaded,
-          # update objid_lookup mapping when identifier is set after objid generation
-          if respond_to?(:objid) &&
-             self.class.respond_to?(:identifier_field) &&
-             self.class.identifier_field == field_name &&
-             self.class.respond_to?(:objid_lookup)
-            current_objid = instance_variable_get(:@objid)
-            self.class.objid_lookup[current_objid] = value if current_objid && value
-          end
 
-          # If this field is the identifier and external_identifier feature is loaded,
-          # update extid_lookup mapping when identifier is set after extid generation
-          if respond_to?(:extid) &&
-             self.class.respond_to?(:identifier_field) &&
-             self.class.identifier_field == field_name &&
-             self.class.respond_to?(:extid_lookup)
-            current_extid = instance_variable_get(:@extid)
-            self.class.extid_lookup[current_extid] = value if current_extid && value
-          end
         end
       end
     end

data/lib/familia/horreum/{core/connection.rb → connection.rb}

@@ -149,6 +149,7 @@ module Familia
       # @see MultiResult For details on the return value structure
       # @see #batch_update For similar atomic field updates with MultiResult
       def transaction(&)
+        ensure_relatives_initialized!
         Familia::Connection::TransactionCore.execute_transaction(-> { dbclient }, &)
       end
       alias multi transaction
@@ -243,12 +244,32 @@ module Familia
       # @see MultiResult For details on the return value structure
       # @see Familia.transaction For atomic command execution
       def pipelined(&block)
+        ensure_relatives_initialized!
         Familia::Connection::PipelineCore.execute_pipeline(-> { dbclient }, &block)
       end
       alias pipeline pipelined
 
       private
 
+      # Ensures that related fields have been initialized before entering transactions or pipelines.
+      #
+      # This prevents Redis::Future errors when lazy initialization would occur inside
+      # transaction/pipeline blocks. When commands execute inside transactions, Redis returns
+      # Future objects that don't respond to standard methods, causing cryptic NoMethodError.
+      #
+      # @raise [RuntimeError] if instance has relations but they haven't been initialized
+      # @note Skips check for class methods - they create temporary instances internally
+      # @note Uses singleton class to avoid polluting instance variables
+      def ensure_relatives_initialized!
+        return if is_a?(Class)  # Class methods handle their own instances
+        return unless self.class.respond_to?(:relations?) && self.class.relations?
+        return if singleton_class.instance_variable_defined?(:"@relatives_initialized")
+
+        raise "#{self.class} has related fields but they haven't been initialized. " \
+              "Did you override initialize without calling super? " \
+              "Related fields: #{self.class.related_fields.keys.join(', ')}"
+      end
+
       # Builds the class-level connection chain with handlers in priority order
       def build_connection_chain
         # Cache handlers at class level to avoid creating new instances per model instance

data/lib/familia/horreum/{core/database_commands.rb → database_commands.rb}

@@ -121,7 +121,7 @@ module Familia
       end
 
       def hmset(hsh = {})
-        hsh ||= to_h
+        hsh ||= to_h_for_storage
         Familia.trace :HMSET, nil, hsh if Familia.debug?
         dbclient.hmset dbkey(suffix), hsh
       end

data/lib/familia/horreum/{subclass/definition.rb → definition.rb}

@@ -1,7 +1,8 @@
-# lib/familia/horreum/subclass/definition.rb
+# lib/familia/horreum/definition.rb
 
-require_relative 'related_fields_management'
-require_relative '../shared/settings'
+require_relative 'settings'
+
+require_relative '../field_type'
 
 module Familia
   VALID_STRATEGIES = %i[raise skip ignore warn overwrite].freeze
@@ -28,9 +29,9 @@ module Familia
     @related_fields = nil
     @default_expiration = nil
 
-    # Serialization settings
-    @dump_method = nil
-    @load_method = nil
+    # Field groups
+    @field_groups = nil
+    @current_field_group = nil
 
     # DefinitionMethods - Class-level DSL methods for defining Horreum model structure
     #
@@ -48,6 +49,84 @@ module Familia
       include Familia::Settings
       include Familia::Horreum::RelatedFieldsManagement # Provides DataType field methods
 
+      # Defines a field group to organize related fields.
+      #
+      # Field groups provide a way to categorize and query fields by purpose or feature.
+      # When a block is provided, fields defined within the block are automatically
+      # added to the group. Without a block, an empty group is initialized.
+      #
+      # @param name [Symbol, String] the name of the field group
+      # @yield optional block for defining fields within the group
+      # @return [Array<Symbol>] the array of field names in the group
+      #
+      # @raise [Familia::Problem] if attempting to nest field groups
+      #
+      # @example Manual field grouping
+      #   class User < Familia::Horreum
+      #     field_group :personal_info do
+      #       field :name
+      #       field :email
+      #     end
+      #   end
+      #
+      #   User.personal_info  # => [:name, :email]
+      #
+      # @example Initialize empty group
+      #   class User < Familia::Horreum
+      #     field_group :placeholder
+      #   end
+      #
+      #   User.placeholder  # => []
+      #
+      def field_group(name, &block)
+
+        # Prevent nested field groups
+        if @current_field_group
+          raise Familia::Problem,
+            "Cannot define field group :#{name} while :#{@current_field_group} is being defined. " \
+            "Nested field groups are not supported."
+        end
+
+        # Initialize group
+        field_groups[name.to_sym] ||= []
+
+        if block_given?
+          @current_field_group = name.to_sym
+          begin
+            instance_eval(&block)
+          ensure
+            @current_field_group = nil
+          end
+        else
+          Familia.ld "[field_group] Created field group :#{name} but no block given" if Familia.debug?
+        end
+
+        field_groups[name.to_sym]
+      end
+
+      # Returns the list of all field group names defined for the class.
+      #
+      # @return [Array<Symbol>] array of field group names
+      #
+      # @example
+      #   class User < Familia::Horreum
+      #     field_group :personal_info do
+      #       field :name
+      #     end
+      #     field_group :metadata do
+      #       field :created_at
+      #     end
+      #   end
+      #
+      #   User.field_groups  # => [
+      #     :personal_info => [...],
+      #     :metadata => [..]
+      #   ]
+      #
+      def field_groups
+        @field_groups ||= {}
+      end
+
       # Sets or retrieves the unique identifier field for the class.
       #
       # This method defines or returns the field or method that contains the unique
@@ -90,30 +169,9 @@ module Familia
       #   - :skip - skip definition if method exists
       #   - :warn - warn but proceed (may overwrite)
       #   - :ignore - proceed silently (may overwrite)
-      # @param category [Symbol, nil] field category for special handling:
-      #   - nil - regular field (default)
-      #   - :encrypted - field contains encrypted data
-      #   - :transient - field is not persisted
-      #   - Others, depending on features available
-      #
-      def field(name, as: name, fast_method: :"#{name}!", on_conflict: :raise, category: nil)
-        # Use field type system for consistency
-        require_relative '../../field_type'
-
-        # Create appropriate field type based on category
-        field_type = if category == :transient
-                       require_relative '../../features/transient_fields/transient_field_type'
-                       TransientFieldType.new(name, as: as, fast_method: false, on_conflict: on_conflict)
-                     else
-                       # For regular fields and other categories, create custom field type with category override
-                       custom_field_type = Class.new(FieldType) do
-                         define_method :category do
-                           category || :field
-                         end
-                       end
-                       custom_field_type.new(name, as: as, fast_method: fast_method, on_conflict: on_conflict)
-                     end
-
+      #
+      def field(name, as: name, fast_method: :"#{name}!", on_conflict: :raise)
+        field_type = FieldType.new(name, as: as, fast_method: fast_method, on_conflict: on_conflict)
         register_field_type(field_type)
       end
 
@@ -123,8 +181,8 @@ module Familia
       # @param blk [Proc] a block that returns the suffix (optional).
       # @return [String, Symbol] the current suffix or Familia.default_suffix if none is set.
       #
-      def suffix(a = nil, &blk)
-        @suffix = a || blk if a || !blk.nil?
+      def suffix(val = nil, &blk)
+        @suffix = val || blk if val || !blk.nil?
         @suffix || Familia.default_suffix
       end
 
@@ -137,8 +195,8 @@ module Familia
       # which typically occurs with anonymous classes that haven't had their prefix
       # explicitly set.
       #
-      def prefix(a = nil)
-        @prefix = a if a
+      def prefix(val = nil)
+        @prefix = val if val
         @prefix || begin
           if name.nil?
             raise Problem, 'Cannot generate prefix for anonymous class. ' \
@@ -148,9 +206,9 @@ module Familia
         end
       end
 
-      def logical_database(v = nil)
-        Familia.trace :LOGICAL_DATABASE_DEF, "instvar:#{@logical_database}", v if Familia.debug?
-        @logical_database = v unless v.nil?
+      def logical_database(num = nil)
+        Familia.trace :LOGICAL_DATABASE_DEF, "instvar:#{@logical_database}", num if Familia.debug?
+        @logical_database = num unless num.nil?
         @logical_database || parent&.logical_database
       end
 
@@ -175,14 +233,6 @@ module Familia
         @has_related_fields ||= false
       end
 
-      def dump_method
-        @dump_method || :to_json # Familia.dump_method
-      end
-
-      def load_method
-        @load_method || :from_json # Familia.load_method
-      end
-
       # Storage for field type instances
       def field_types
         @field_types ||= {}
@@ -221,6 +271,12 @@ module Familia
         # Complete the registration after installation. If we do this beforehand
         # we can run into issues where it looks like it's already installed.
         field_types[field_type.name] = field_type
+
+        # Add to current field group if one is active
+        if @current_field_group
+          @field_groups[@current_field_group] << field_type.name
+        end
+
         # Freeze the field_type to ensure immutability (maintains Data class heritage)
         field_type.freeze
       end
@@ -303,16 +359,6 @@ module Familia
         @feature_options[feature_name.to_sym]
       end
 
-      # Create and register a transient field type
-      #
-      # @param name [Symbol] The field name
-      #
-      def transient_field(name, **)
-        require_relative '../../features/transient_fields/transient_field_type'
-        field_type = TransientFieldType.new(name, **, fast_method: false)
-        register_field_type(field_type)
-      end
-
       private
 
       # Hook to detect silent overwrites and handle conflicts
@@ -429,7 +475,7 @@ module Familia
 
               # Convert the provided value to a format suitable for Database storage.
               prepared = serialize_value(val)
-              Familia.ld "[.define_fast_writer_method] #{fast_method_name} val: #{val.class} prepared: #{prepared.class}"
+              Familia.ld "[define_fast_writer_method] #{fast_method_name} val: #{val.class} prepared: #{prepared.class}"
 
               # Use the existing accessor method to set the attribute value.
               send :"#{method_name}=", val

data/lib/familia/horreum/{subclass/management.rb → management.rb}

@@ -1,6 +1,4 @@
-# lib/familia/horreum/subclass/management.rb
-
-require_relative 'related_fields_management'
+# lib/familia/horreum/management.rb
 
 module Familia
   class Horreum
@@ -127,15 +125,15 @@ module Familia
       #   User.find_by_key("user:123")  # Returns a User instance if it exists,
       #   nil otherwise
       #
-      def find_by_key(objkey)
+      def find_by_dbkey(objkey)
         raise ArgumentError, 'Empty key' if objkey.to_s.empty?
 
         # We use a lower-level method here b/c we're working with the
         # full key and not just the identifier.
         does_exist = dbclient.exists(objkey).positive?
 
-        Familia.ld "[.find_by_key] #{self} from key #{objkey} (exists: #{does_exist})"
-        Familia.trace :FROM_KEY, nil, objkey if Familia.debug?
+        Familia.ld "[find_by_key] #{self} from key #{objkey} (exists: #{does_exist})"
+        Familia.trace :FIND_BY_DBKEY_KEY, nil, objkey
 
         # This is the reason for calling exists first. We want to definitively
         # and without any ambiguity know if the object exists in the database. If it
@@ -145,11 +143,16 @@ module Familia
         return unless does_exist
 
         obj = dbclient.hgetall(objkey) # horreum objects are persisted as database hashes
-        Familia.trace :FROM_KEY2, nil, "#{objkey}: #{obj.inspect}" if Familia.debug?
-
-        new(**obj)
+        Familia.trace :FIND_BY_DBKEY_INSPECT, nil, "#{objkey}: #{obj.inspect}"
+
+        # Create instance and deserialize fields using existing helper method
+        # This avoids duplicating deserialization logic and keeps field-by-field processing
+        instance = allocate
+        instance.send(:initialize_relatives)
+        instance.send(:initialize_with_keyword_args_deserialize_value, **obj)
+        instance
       end
-      alias from_dbkey find_by_key # deprecated
+      alias find_by_key find_by_dbkey
 
       # Retrieves and instantiates an object from Database using its identifier.
       #
@@ -170,19 +173,19 @@ module Familia
       # @example
       #   User.find_by_id(123)  # Equivalent to User.find_by_key("user:123:object")
       #
-      def find_by_id(identifier, suffix = nil)
+      def find_by_identifier(identifier, suffix = nil)
         suffix ||= self.suffix
         return nil if identifier.to_s.empty?
 
         objkey = dbkey(identifier, suffix)
 
-        Familia.ld "[.find_by_id] #{self} from key #{objkey})"
+        Familia.ld "[find_by_id] #{self} from key #{objkey})"
         Familia.trace :FIND_BY_ID, nil, objkey if Familia.debug?
-        find_by_key objkey
+        find_by_dbkey objkey
       end
+      alias find_by_id find_by_identifier
       alias find find_by_id
-      alias load find_by_id # deprecated
-      alias from_identifier find_by_id # deprecated
+      alias load find_by_id
 
       # Checks if an object with the given identifier exists in the database.
       #