parse-stack-next 5.2.0 → 5.3.0

data/lib/parse/model/associations/belongs_to.rb

@@ -119,6 +119,23 @@ module Parse
 
         # These items are added as attributes with the special data type of :pointer
         def belongs_to(key, opts = {})
+          # An explicitly-passed `as:` that names a scalar data type
+          # (`:string`, `:integer`, `:boolean`, …) is almost always a mistake —
+          # you cannot point at a scalar — and most often means a `property`
+          # was written with `as:` out of habit. Reject it at declaration time.
+          # This is the only association footgun decidable without all models
+          # loaded: an unresolved *class* name may simply be a forward
+          # reference (the target is required later), so that check is deferred
+          # to {Parse.validate_associations!}.
+          explicit_as = opts.key?(:as) ? opts[:as] : nil
+          if explicit_as && Parse::Properties::TYPES.include?(explicit_as.to_s.to_sym)
+            scalar = explicit_as.to_s.to_sym
+            raise ArgumentError,
+                  "#{self}##{key}: `as: #{explicit_as.inspect}` names the reserved data type " \
+                  ":#{scalar}, not a Parse class. For a scalar column write " \
+                  "`property #{key.inspect}, #{scalar.inspect}`; if you really mean a Parse class " \
+                  "named #{scalar.to_s.camelize.inspect}, pass `class_name: #{scalar.to_s.camelize.inspect}` instead."
+          end
           opts = { as: key, field: key.to_s.camelize(:lower), required: false }.merge(opts)
           # `opts[:class_name]` is the explicit target Parse class name; it takes
           # precedence over the legacy `as: :symbol` shorthand (where the
@@ -134,6 +151,22 @@ module Parse
           set_attribute_method = :"#{key}_set_attribute!"
 
           if self.fields[key].present? && Parse::Properties::BASE_FIELD_MAP[key].nil?
+            existing_type = self.fields[key]
+            # A structural redeclaration that CHANGES the type to a pointer
+            # (e.g. a field first declared `property :owner, :string` and then
+            # `property :owner, as: :user` / `belongs_to :owner`) is almost
+            # always a bug — and, because `property … as:` now delegates here,
+            # it is the same silent-String failure mode this whole feature
+            # exists to fix. Honor the same `strict_property_redefinition`
+            # contract that `property` enforces so the conflict is not
+            # downgraded to a warning. A same-type reopen (existing :pointer)
+            # still just warns, matching the prior behavior.
+            if existing_type != :pointer && Parse.strict_property_redefinition
+              raise ArgumentError,
+                    "#{self}##{key} is already defined as :#{existing_type}; refusing to " \
+                    "redeclare it as a :pointer association (target #{klassName}). Set " \
+                    "Parse.strict_property_redefinition = false to fall back to warn-and-ignore."
+            end
             warn "Belongs relation #{self}##{key} already defined with type #{klassName}"
             return false
           end
@@ -151,6 +184,20 @@ module Parse
           # Mapping between local attribute name and the remote column name
           self.field_map.merge!(key => parse_field)
 
+          # Agent metadata: a belongs_to pointer can carry a semantic description
+          # (and per-value enum descriptions) just like a `property` can. This
+          # also lets `property :x, as: :user, _description: "..."` round-trip its
+          # metadata through the delegation in Parse::Properties#property.
+          if opts[:_description].present?
+            self.property_descriptions[key] = opts[:_description].to_s.freeze
+          end
+          if opts[:_enum].is_a?(Hash) && opts[:_enum].any?
+            normalized = opts[:_enum].each_with_object({}) do |(value, desc), h|
+              h[value.to_s] = desc.to_s.freeze
+            end
+            self.property_enum_descriptions[key] = normalized.freeze
+          end
+
           # used for dirty tracking
           define_attribute_methods key
 

data/lib/parse/model/classes/user.rb

@@ -835,6 +835,26 @@ module Parse
       @session
     end
 
+    # A non-master {Parse::Client} bound to this user's session token, for
+    # acting on the server *as this user* with full ACL / CLP / +protectedFields+
+    # enforcement and no master-key fallback. It mirrors the connection settings
+    # of +base+ (the configured client by default) but carries no master key and
+    # binds {#session_token}, so even raw REST calls through it are authorized as
+    # the user with no per-call ceremony. The web-counterpart of
+    # {Parse::Webhooks::Payload#user_client}; the typical client-side entry point
+    # is right after a login:
+    #
+    #   client = Parse::User.login(username, password).session_client
+    #   Parse::Query.new("Post", client: client).results   # scoped to the user
+    #
+    # @param base [Parse::Client] the client whose connection settings to mirror.
+    # @return [Parse::Client, nil] +nil+ when the user has no session token
+    #   (e.g. fetched/saved under the master key rather than logged in).
+    def session_client(base = self.client)
+      return nil if @session_token.nil? || @session_token.to_s.strip.empty?
+      base.become(@session_token)
+    end
+
     # @!visibility private
     # Keys that must never flow through +Parse::User.create+ from a
     # mass-assigned hash. +authData+ on the user-signup endpoint causes

data/lib/parse/model/core/actions.rb

@@ -1196,16 +1196,14 @@ module Parse
         success
       end
 
-      # Runs all the registered `before_save` related callbacks.
+      # Back-compat alias for {Parse::Object#run_before_save_callbacks}. The
+      # canonical name spells out exactly what runs (the before_save callbacks,
+      # before phase only) and is symmetric with run_after_save_callbacks /
+      # run_before_create_callbacks / run_after_create_callbacks. Retained so
+      # existing callers of `prepare_save!` keep working.
+      # @return [Boolean] false if a before_save callback halted the chain, else true.
       def prepare_save!
-        # With terminator configured, run_callbacks will return false if any callback returns false
-        # We track if the block executes to know if callbacks were halted
-        callback_success = false
-        run_callbacks(:save) do
-          callback_success = true
-          true
-        end
-        callback_success
+        run_before_save_callbacks
       end
 
       # @return [Hash] a hash of the list of changes made to this instance.

data/lib/parse/model/core/pluralized_aliases.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Parse
+  # Global `const_missing` hook that lazily resolves the plural form of a
+  # {Parse::Object} subclass constant to that class. Referencing `Posts`
+  # when a class `Post` exists installs `Posts` as an alias for `Post` on
+  # the referencing module and returns it, so query entry points like
+  # `Posts.where(...).count` work without any per-model boilerplate.
+  #
+  # The hook is prepended onto `Module` so it applies to constant lookups
+  # in any namespace (top-level and nested). It is tightly guarded: every
+  # path that is not a plural-of-a-Parse-class falls through to `super`,
+  # preserving normal `NameError` and autoloader (Zeitwerk/classic)
+  # behavior. The whole feature is gated on {Parse.pluralized_aliases?} so
+  # opting out (`Parse.pluralized_aliases = false`) makes this a near-zero
+  # cost pass-through.
+  #
+  # @see Parse.pluralized_aliases
+  # @see Parse.__pluralized_alias_for
+  module PluralizedAliases
+    def const_missing(name)
+      klass = Parse.__pluralized_alias_for(self, name) if defined?(Parse)
+      return klass unless klass.nil?
+      super
+    end
+  end
+end
+
+Module.prepend(Parse::PluralizedAliases)

data/lib/parse/model/core/properties.rb

@@ -197,6 +197,33 @@ module Parse
           # data_type = :timezone if key == :time_zone || key == :timezone
         end
 
+        # A property that names a pointer target — via `as:`/`class_name:` or an
+        # explicit :pointer data type — is really a belongs_to association, not a
+        # scalar column. Delegate so `property :rejected_by, as: :user` behaves
+        # identically to `belongs_to :rejected_by, as: :user` instead of silently
+        # storing a String (the `as:` option was previously dropped, leaving the
+        # field as the default :string type). Reusing belongs_to keeps the
+        # className-trust guard and autofetch/dirty-tracking in one place rather
+        # than duplicating pointer handling here. `opts` is still raw user input
+        # at this point (the defaults merge happens further down), so only an
+        # explicitly-passed :field is forwarded and belongs_to defaults the rest.
+        if opts.key?(:as) || opts.key?(:class_name) || data_type == :pointer
+          forwarded = %i[as class_name field required _description _enum]
+          bt_opts = {}
+          forwarded.each { |o| bt_opts[o] = opts[o] if opts.key?(o) }
+          # belongs_to has no scalar-property machinery (defaults, symbolize,
+          # enum validation, alias toggles, scope generation). Surface — rather
+          # than silently drop — any such option so a `default:`/`symbolize:` on
+          # a pointer property isn't quietly ignored.
+          dropped = opts.keys.map(&:to_sym) - forwarded
+          unless dropped.empty?
+            warn "[#{self}] property #{key.inspect} resolves to a pointer association; " \
+                 "ignoring unsupported option(s) #{dropped.map(&:inspect).join(', ')} " \
+                 "(not available on belongs_to)."
+          end
+          return belongs_to(key, bt_opts)
+        end
+
         data_type = :timezone if data_type == :string && (key == :time_zone || key == :timezone)
 
         # allow :bool for :boolean

data/lib/parse/model/core/querying.rb

@@ -120,6 +120,76 @@ module Parse
 
       alias_method :where, :query
 
+      # Define a pluralized constant alias for this class so the plural form
+      # can be used as a query entry point — e.g. `Posts.where(...).count`
+      # for a class `Post`. The alias is the same class object, so every
+      # class method (`where`, `query`, `count`, `find`, `all`, scopes)
+      # works through it and `Posts.parse_class` still returns `"Post"`.
+      #
+      # This is the explicit counterpart to the automatic
+      # {Parse.pluralized_aliases} behavior. Use it when automatic aliasing
+      # is disabled, when the class name ends in `s` (which the automatic
+      # path skips), when you want a custom plural, or for namespaced models
+      # (the alias is defined on the enclosing module, not at top level).
+      #
+      # @example default plural
+      #   class Post < Parse::Object
+      #     pluralized_alias!          # defines ::Posts => Post
+      #   end
+      #
+      # @example custom plural for a name ending in `s`
+      #   class Status < Parse::Object
+      #     pluralized_alias! :Statuses
+      #   end
+      #
+      # @example namespaced model
+      #   module Blog
+      #     class Post < Parse::Object
+      #       pluralized_alias!        # defines Blog::Posts => Blog::Post
+      #     end
+      #   end
+      #
+      # @param constant_name [Symbol, String, nil] the plural constant to
+      #   define; defaults to the ActiveSupport pluralization of the class's
+      #   demodulized name.
+      # @raise [ArgumentError] if the target constant already exists and is
+      #   not this class.
+      # @return [self, nil] self when an alias exists/was created; nil if the
+      #   class is anonymous or the plural matches the singular name.
+      def pluralized_alias!(constant_name = nil)
+        base = name
+        return nil if base.nil?
+        parts = base.split("::")
+        short = parts.last
+        plural = (constant_name && constant_name.to_s) || short.pluralize
+        return nil if plural == short
+        # NOTE: bare `Object` here would lexically resolve to `Parse::Object`
+        # (we are inside module Parse::Core::Querying), so the alias must be
+        # anchored at the true top level with `::Object`.
+        parent = parts.length > 1 ? parts[0..-2].join("::").constantize : ::Object
+        if parent.const_defined?(plural.to_sym, false)
+          existing = parent.const_get(plural.to_sym)
+          return self if existing.equal?(self)
+          # A code reloader (Zeitwerk in development) swaps `self` for a fresh
+          # class object but does not clean up the alias constant we set — it
+          # owns no autoload entry for it. On re-run of the class body the
+          # plural still points at the now-orphaned previous class. Re-point it
+          # to the current class instead of raising on every reload. Only a
+          # genuinely foreign constant (not a Parse model mapping to the same
+          # remote class) is treated as a conflict.
+          stale_reload = existing.is_a?(Class) && existing < Parse::Object &&
+                         existing.parse_class == parse_class
+          unless stale_reload
+            raise ArgumentError,
+                  "Cannot define pluralized alias #{plural} for #{base}: " \
+                  "constant already defined as #{existing}."
+          end
+          parent.send(:remove_const, plural.to_sym)
+        end
+        parent.const_set(plural.to_sym, self)
+        self
+      end
+
       # @param conditions (see Parse::Query#where)
       # @return (see Parse::Query#where)
       # @see Parse::Query#where

data/lib/parse/model/file.rb

@@ -734,10 +734,43 @@ module Parse
       ATTRIBUTES
     end
 
-    # @return [Boolean] Two files are equal if they have the same url
+    # The value used to decide whether two {Parse::File}s refer to the same
+    # underlying file -- for equality ({#==}) and, through it, for dirty
+    # tracking (the property setter compares files with `==` to decide whether
+    # a `:file` field changed).
+    #
+    # Today this is the bare canonical {#url}: signed-URL query parameters are
+    # stripped into `@presigned_url` and `force_ssl` coercion is applied, so two
+    # files at the same storage location compare equal regardless of how the URL
+    # was signed or whether it was `http`/`https`. The URL is the best identity
+    # signal currently available -- Parse Server's S3 files adapter does not
+    # surface a content digest (ETag / MD5 / sha256) through `Parse::File`.
+    #
+    # FUTURE DIRECTION: when a files adapter can expose a content hash, this is
+    # the single seam to override so equality keys off file *content* instead of
+    # URL -- e.g. a custom `Parse::File` subclass or adapter shim returning the
+    # S3 ETag / sha256 here. Overriding this one method updates {#==} (and a
+    # future `#eql?`/`#hash` pair, if added) without touching dirty tracking.
+    # No content-hash source exists yet, so the URL is authoritative for now.
+    # @return [String, nil]
+    def content_signature
+      url
+    end
+
+    # @return [Boolean] Two files are equal when their {#content_signature}
+    #   matches. Both sides go through the same reader, so the comparison is
+    #   symmetric and force_ssl-consistent: the previous `@url == u.url` form
+    #   compared one side's raw stored URL against the other's normalized
+    #   reader, so two files at the same location read as unequal whenever
+    #   {Parse::File.force_ssl} coerced one side from `http://` to `https://`
+    #   (and `a == b` disagreed with `b == a`). Because the default signature is
+    #   the bare canonical URL (signed-URL query parameters stripped into
+    #   `@presigned_url`), a freshly re-signed URL for the same object is equal
+    #   while a different underlying location is not. See {#content_signature}
+    #   for the content-hash override seam.
     def ==(u)
       return false unless u.is_a?(self.class)
-      @url == u.url
+      content_signature == u.content_signature
     end
 
     # Allows mass assignment from a Parse JSON hash.

data/lib/parse/model/object.rb

@@ -1645,6 +1645,25 @@ module Parse
       run_callbacks_from_list(self.class._destroy_callbacks, :after)
     end
 
+    # Run before_save callbacks for this object (BEFORE phase only). Used by the
+    # beforeSave webhook. Honors :if/:unless conditions and the callback
+    # terminator: returns false if a callback halts the chain. The after_*
+    # callbacks are NOT run here -- they belong to the afterSave webhook.
+    # @return [Boolean] false if a before_save callback halted the chain, else true.
+    def run_before_save_callbacks
+      run_before_phase_callbacks(:save)
+    end
+
+    # Run before_create callbacks for this object (BEFORE phase only). Parse
+    # Server exposes no separate beforeCreate trigger, so the beforeSave webhook
+    # runs these for new objects right after before_save -- matching ActiveModel
+    # order, where before_save wraps before_create. Honors :if/:unless and the
+    # terminator.
+    # @return [Boolean] false if a before_create callback halted the chain, else true.
+    def run_before_create_callbacks
+      run_before_phase_callbacks(:create)
+    end
+
     # Returns a hash of all the changes that have been made to the object. By default
     # changes to the Parse::Properties::BASE_KEYS are ignored unless you pass true as
     # an argument.
@@ -2054,6 +2073,28 @@ module Parse
       end
       true
     end
+
+    # Runs ONLY the before-phase callbacks of an ActiveModel callback chain
+    # (`:save` or `:create`), fully honoring `:if`/`:unless` conditions and the
+    # model's terminator, WITHOUT running the after-phase callbacks. ActiveModel
+    # `run_callbacks(kind) { block }` runs before -> block -> after; we throw out
+    # of the block so the after callbacks never run, while the before callbacks
+    # get complete condition/terminator handling. If a before callback halts the
+    # chain (returns false), the block never executes, so `completed` stays false
+    # and we report the halt. Used by the webhook before-phase so it does not
+    # double-fire after_* (those belong to the afterSave webhook).
+    # @return [Boolean] false if the chain was halted by a before callback.
+    def run_before_phase_callbacks(kind)
+      tag = :"__parse_before_phase_#{kind}"
+      completed = false
+      catch(tag) do
+        run_callbacks(kind) do
+          completed = true
+          throw tag
+        end
+      end
+      completed
+    end
   end
 end
 

data/lib/parse/stack/version.rb

@@ -6,6 +6,6 @@ module Parse
   # The Parse Server SDK for Ruby
   module Stack
     # The current version.
-    VERSION = "5.2.0"
+    VERSION = "5.3.0"
   end
 end

data/lib/parse/stack.rb

@@ -548,6 +548,21 @@ module Parse
   #   PARSE_STRICT_POINTER_SHAPES=true
   @strict_pointer_shapes = ENV["PARSE_STRICT_POINTER_SHAPES"] == "true"
 
+  # Configuration for automatic pluralized class-name aliases. When enabled
+  # (the default), referencing the plural form of a {Parse::Object} subclass
+  # constant resolves to that class, so `Posts.where(...)` works for a class
+  # `Post`. The alias is created lazily on first reference via `const_missing`
+  # and points at the same class object, so every class method
+  # (`where`, `query`, `count`, `find`, `all`, scopes) works for free and
+  # `Posts.parse_class` still returns `"Post"`. Classes whose name already
+  # ends in `s` are skipped. Set to false to opt out globally.
+  # @example Opt out globally
+  #   Parse.pluralized_aliases = false
+  # @example ENV opt-out
+  #   PARSE_PLURALIZED_ALIASES=false
+  # @see Parse::Core::Querying#pluralized_alias!
+  @pluralized_aliases = ENV["PARSE_PLURALIZED_ALIASES"] != "false"
+
   # Tuning bundle for the synchronize-create lock. Per-call kwargs override.
   # Keys: :ttl (seconds, default 3, max 30), :wait (seconds, default 2.0,
   # max 30), :on_degraded (:warn, :warn_throttled, :raise, :proceed).
@@ -630,7 +645,8 @@ module Parse
                   :rewrite_lookups, :strict_property_redefinition,
                   :synchronize_create_default, :synchronize_create_options, :synchronize_create_secret,
                   :synchronize_create_store, :synchronize_classes,
-                  :strict_pointer_shapes, :suppress_server_version_warning
+                  :strict_pointer_shapes, :suppress_server_version_warning,
+                  :pluralized_aliases
 
     # Check whether the Parse Server version deprecation warning is
     # silenced. Returns true if either the in-process accessor or the
@@ -714,6 +730,140 @@ module Parse
       @strict_pointer_shapes == true
     end
 
+    # Whether automatic pluralized class-name aliases are enabled. Defaults
+    # to true; opt out with `Parse.pluralized_aliases = false` or
+    # `PARSE_PLURALIZED_ALIASES=false`. See {Parse.pluralized_aliases}.
+    # @return [Boolean]
+    def pluralized_aliases?
+      @pluralized_aliases != false
+    end
+
+    # @!visibility private
+    # Resolve a (possibly plural) missing constant to its singular
+    # {Parse::Object} subclass and install the alias on the referencing
+    # module. Returns the class when an alias was created, otherwise nil so
+    # the caller (`const_missing`) can fall through to `super` and preserve
+    # normal `NameError` / autoloading behavior.
+    #
+    # Guards (fail-through to nil unless ALL hold):
+    #   - the feature is enabled,
+    #   - {Parse::Object} is loaded,
+    #   - the name singularizes to a *different* string (i.e. looks plural),
+    #   - the singular form does NOT already end in `s` (per design: classes
+    #     whose name ends in `s` are not auto-aliased),
+    #   - the singular constant is defined (searching ancestors so a
+    #     top-level model is visible from a nested reference) and is a
+    #     `Parse::Object` subclass,
+    #   - the plural is not already defined on the referencing module.
+    #
+    # @param mod [Module] the module/class on which `const_missing` fired.
+    # @param name [Symbol] the missing constant name.
+    # @return [Class, nil]
+    def __pluralized_alias_for(mod, name)
+      return nil unless pluralized_aliases?
+      return nil unless defined?(Parse::Object)
+      str = name.to_s
+      singular = str.singularize
+      return nil if singular == str
+      return nil if singular.end_with?("s")
+      sym = singular.to_sym
+      return nil unless mod.const_defined?(sym, true)
+      klass = mod.const_get(sym)
+      return nil unless klass.is_a?(Class) && klass < Parse::Object
+      return nil if mod.const_defined?(name, false)
+      mod.const_set(name, klass)
+      klass
+    rescue NameError, LoadError
+      # const_get/const_defined? can raise on malformed names or autoload
+      # failures; never let alias resolution mask the original lookup.
+      nil
+    end
+
+    # Verify that every association target across the loaded {Parse::Object}
+    # subclasses resolves to a known Parse class. Covers `belongs_to` and
+    # `property … as:` pointer targets (via each class's `references`),
+    # `has_many … through: :relation` targets (via `relations`), and the
+    # query- and array-backed `has_many` targets (via `has_many_associations`)
+    # — the bucket where an `as:` typo otherwise stays latent until the
+    # association is first traversed at call time.
+    #
+    # This is the deferred companion to the definition-time scalar guard in
+    # {Parse::Associations::BelongsTo::ClassMethods#belongs_to}: at declaration
+    # time a forward reference (a target class that is required later) is legal
+    # and indistinguishable from a typo, so the cross-class resolution check is
+    # run here — after all models are loaded. Intended to run once at boot, in
+    # CI, or from a rake task ("during the upgrade").
+    #
+    # A target resolves when it is a Parse system class (`_User`, `_Role`,
+    # `_Installation`, `_Session`, …) or a registered {Parse::Object} subclass
+    # (via {Parse::Model.find_class}). Note this checks against *loaded Ruby
+    # models*: if you intentionally point at a server-side class that has no
+    # Ruby model, define a stub model for it or exclude it via `classes:`.
+    #
+    # @param classes [Array<Class>, nil] optional subset of Parse::Object
+    #   subclasses to check; defaults to every loaded subclass.
+    # @raise [ArgumentError] if any target is unresolved, listing each
+    #   offending `Class#field -> 'Target'`.
+    # @return [true] when every association target resolves.
+    def validate_associations!(classes: nil)
+      models = classes || Parse::Object.descendants
+      problems = []
+      models.each do |klass|
+        next unless klass.respond_to?(:parse_class)
+        if klass.respond_to?(:references)
+          klass.references.each do |field, target|
+            next if _association_target_resolvable?(target)
+            # `references` is keyed by the remote (camelCase) column; report the
+            # declared Ruby accessor so the operator can find the offending line.
+            accessor = (klass.respond_to?(:field_map) && klass.field_map.key(field)) || field
+            problems << "#{klass}##{accessor} -> #{target.inspect} (no such Parse class)"
+          end
+        end
+        if klass.respond_to?(:relations)
+          klass.relations.each do |field, target|
+            next if _association_target_resolvable?(target)
+            problems << "#{klass}##{field} (relation) -> #{target.inspect} (no such Parse class)"
+          end
+        end
+        if klass.respond_to?(:has_many_associations)
+          klass.has_many_associations.each do |accessor, meta|
+            # `:relation`-storage has_many is mirrored into `relations` and is
+            # already reported above; only the `:query` and `:array` storage
+            # targets (which live nowhere else) need checking here. This is the
+            # branch where a `has_many … as:` typo hides, since a query-backed
+            # has_many resolves its target lazily at call time.
+            next if meta[:storage] == :relation
+            target = meta[:target_class]
+            next if target.nil? || _association_target_resolvable?(target)
+            problems << "#{klass}##{accessor} (has_many #{meta[:storage]}) -> " \
+                        "#{target.inspect} (no such Parse class)"
+          end
+        end
+      end
+      unless problems.empty?
+        raise ArgumentError,
+              "Unresolved Parse association targets:\n  " + problems.join("\n  ") +
+              "\nRequire/define the target class, or fix the `as:`/`class_name:` name."
+      end
+      true
+    end
+
+    # @!visibility private
+    # Whether an association target class name resolves to a known Parse
+    # class. Parse system classes resolve against {Parse::Model::SYSTEM_CLASS_MAP}
+    # — both the canonical `_`-prefixed value (`_User`) and the bare-name key
+    # (`User`) — even when their Ruby class is not loaded; everything else must
+    # resolve via {Parse::Model.find_class}. A leading underscore is NOT a
+    # blanket pass: a typo'd system name such as `_Usr` is neither in the map
+    # nor a registered model, so it is still surfaced as unresolved.
+    def _association_target_resolvable?(target)
+      name = target.to_s
+      return false if name.empty?
+      return true if Parse::Model::SYSTEM_CLASS_MAP.key?(name) ||
+                     Parse::Model::SYSTEM_CLASS_MAP.value?(name)
+      !Parse::Model.find_class(name).nil?
+    end
+
     # Check if MCP server feature is enabled
     # Requires PARSE_MCP_ENABLED=true in environment AND Parse.mcp_server_enabled = true
     # @return [Boolean]
@@ -851,4 +1001,9 @@ end
 # the setter on load.
 Parse._attach_slow_query_subscriber! if Parse.slow_query_threshold_ms
 
+# Install the lazy pluralized class-name alias hook (Posts -> Post). Loaded
+# last so Parse::Object and the Parse.__pluralized_alias_for helper are
+# already defined. Gated at runtime on Parse.pluralized_aliases?.
+require_relative "model/core/pluralized_aliases"
+
 require_relative "stack/railtie" if defined?(::Rails)