parse-stack-next 4.5.0

data/lib/parse/model/shortnames.rb

@@ -0,0 +1,8 @@
+require_relative "object"
+
+# Simple include to use short verion of core class names
+::Installation = Parse::Installation unless defined?(::Installation)
+::Role = Parse::Role unless defined?(::Role)
+::Product = Parse::Product unless defined?(::Product)
+::Session = Parse::Session unless defined?(::Session)
+::User = Parse::User unless defined?(::User)

data/lib/parse/model/time_zone.rb

@@ -0,0 +1,141 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/values/time_zone"
+require_relative "model"
+
+module Parse
+  # This class a wrapper around ActiveSupport::TimeZone when using Parse columns that
+  # store IANA time zone identifiers (ex. Installation collection). Parse does not have a
+  # native time zone data type, but this class is provided to manage and perform timezone-like
+  # operation on those properties which you have marked as type _:timezone_.
+  #
+  # When declaring a property of type :timezone, you may also define a default just like
+  # any other property. In addition, the framework will automatically add a validation
+  # to make sure that your property is either nil or one of the valid IANA time zone identifiers.
+  #
+  # Each instance of {Parse::TimeZone} has a {Parse::TimeZone#zone} attribute that provides access to
+  # the underlying {http://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html ActiveSupport::TimeZone}
+  # instance, which you can use to perform time zone operations.
+  # @example
+  #  class Event < Parse::Object
+  #    # an event occurs in a time zone.
+  #    property :time_zone, :timezone, default: 'America/Los_Angeles'
+  #  end
+  #
+  #  event = Event.new
+  #  event.time_zone.name # => 'America/Los_Angeles'
+  #  event.time_zone.valid? # => true
+  #
+  #  event.time_zone.zone # => ActiveSupport::TimeZone
+  #  event.time_zone.formatted_offset # => "-08:00"
+  #
+  #  event.time_zone = 'Europe/Paris'
+  #  event.time_zone.formatted_offset # => +01:00"
+  #
+  #  event.time_zone = 'Galaxy/Andromeda'
+  #  event.time_zone.valid? # => false
+  # @version 1.7.1
+  class TimeZone
+    # The mapping of TimeZones
+    MAPPING = ActiveSupport::TimeZone::MAPPING
+
+    # Create methods based on the allowable public methods on ActiveSupport::TimeZone.
+    # Basically sets up sending forwarding calls to the `zone` object for a Parse::TimeZone object.
+    (ActiveSupport::TimeZone.public_instance_methods(false) - [:to_s, :name, :as_json]).each do |meth|
+      Parse::TimeZone.class_eval do
+        define_method meth do |*args|
+          zone.send meth, *args
+        end
+      end
+    end
+
+    # Creates a new instance given the IANA identifier (ex. America/Los_Angeles)
+    # @overload new(iana)
+    #  @param iana [String] the IANA identifier (ex. America/Los_Angeles)
+    #  @return [Parse::TimeZone]
+    # @overload new(timezone)
+    #  You can instantiate a new instance with either a {Parse::TimeZone} or an {http://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html ActiveSupport::TimeZone}
+    #  object.
+    #  @param timezone [Parse::TimeZone|ActiveSupport::TimeZone] an instance of either timezone class.
+    #  @return [Parse::TimeZone]
+    def initialize(iana)
+      if iana.is_a?(String)
+        @name = iana
+        @zone = nil
+      elsif iana.is_a?(::Parse::TimeZone)
+        @zone = iana.zone
+        @name = nil
+      elsif iana.is_a?(::ActiveSupport::TimeZone)
+        @zone = iana
+        @name = nil
+      end
+    end
+
+    # @!attribute [rw] name
+    # @raise ArgumentError if value is not a string type.
+    # @return [String] the IANA identifier for this time zone.
+    def name
+      @zone.present? ? zone.name : @name
+    end
+
+    def name=(iana)
+      unless iana.nil? || iana.is_a?(String)
+        raise ArgumentError, "Parse::TimeZone#name should be an IANA time zone identifier."
+      end
+      @name = iana
+      @zone = nil
+    end
+
+    # @!attribute [rw] zone
+    # Returns an instance of {http://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html ActiveSupport::TimeZone}
+    # based on the IANA identifier. The setter may allow usign an IANA string identifier,
+    # a {Parse::TimeZone} or an
+    # {http://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html ActiveSupport::TimeZone}
+    # object.
+    # @see #name
+    # @raise ArgumentError
+    # @return [ActiveSupport::TimeZone]
+    def zone
+      # lazy load the TimeZone object only when the user requests it, otherwise
+      # just keep the name of the string around. Makes encoding/decoding faster.
+      if @zone.nil? && @name.present?
+        @zone = ::ActiveSupport::TimeZone.new(@name)
+        @name = nil # clear out the cache
+      end
+      @zone
+    end
+
+    def zone=(timezone)
+      if timezone.is_a?(::ActiveSupport::TimeZone)
+        @zone = timezone
+        @name = nil
+      elsif timezone.is_a?(Parse::TimeZone)
+        @name = timezone.name
+        @zone = nil
+      elsif timezone.nil? || timezone.is_a?(String)
+        @name = timezone
+        @zone = nil
+      else
+        raise ArgumentError, "Invalid value passed to Parse::TimeZone#zone."
+      end
+    end
+
+    # (see #to_s)
+    def as_json(*args)
+      name
+    end
+
+    # @return [String] the IANA identifier for this timezone or nil.
+    def to_s
+      name
+    end
+
+    # Returns true or false whether the time zone exists in the {http://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html ActiveSupport::TimeZone} mapping.
+    # @return [Bool] true if it contains a valid time zone
+    def valid?
+      ActiveSupport::TimeZone[to_s].present?
+    end
+  end
+end

data/lib/parse/model/validations/uniqueness_validator.rb

@@ -0,0 +1,97 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "active_model"
+
+module Parse
+  module Validations
+    # A custom validator that checks if a field value is unique in the Parse collection.
+    #
+    # This validator queries Parse Server to check if another record exists with the
+    # same value for the specified field. It properly handles:
+    # - New records (no id yet)
+    # - Existing records (excludes self from the check)
+    # - Case-insensitive matching (optional)
+    # - Scoped uniqueness (unique within a subset of records)
+    #
+    # @example Basic uniqueness
+    #   class User < Parse::Object
+    #     property :email, :string
+    #     validates :email, uniqueness: true
+    #   end
+    #
+    # @example Case-insensitive uniqueness
+    #   class User < Parse::Object
+    #     property :username, :string
+    #     validates :username, uniqueness: { case_sensitive: false }
+    #   end
+    #
+    # @example Scoped uniqueness (unique within an organization)
+    #   class Employee < Parse::Object
+    #     property :employee_id, :string
+    #     belongs_to :organization
+    #     validates :employee_id, uniqueness: { scope: :organization }
+    #   end
+    #
+    # @example With custom message
+    #   class User < Parse::Object
+    #     property :email, :string
+    #     validates :email, uniqueness: { message: "is already registered" }
+    #   end
+    #
+    class UniquenessValidator < ActiveModel::EachValidator
+      # @param record [Parse::Object] the object being validated
+      # @param attribute [Symbol] the attribute name being validated
+      # @param value [Object] the current value of the attribute
+      def validate_each(record, attribute, value)
+        return if value.blank? && options[:allow_blank]
+        return if value.nil? && options[:allow_nil]
+
+        # Build the query to check for existing records
+        klass = record.class
+
+        # Get the Parse field name for this attribute (available for debugging)
+        _parse_field = klass.field_map[attribute] || attribute.to_s.columnize
+
+        # Build query conditions
+        conditions = {}
+
+        if options[:case_sensitive] == false && value.is_a?(String)
+          # Case-insensitive search using regex
+          conditions[attribute.to_sym] = /\A#{Regexp.escape(value)}\z/i
+        else
+          conditions[attribute.to_sym] = value
+        end
+
+        # Add scope conditions if specified
+        if options[:scope]
+          scope_fields = Array(options[:scope])
+          scope_fields.each do |scope_field|
+            scope_value = record.send(scope_field)
+            conditions[scope_field.to_sym] = scope_value
+          end
+        end
+
+        # Build and execute the query
+        query = klass.query(conditions)
+
+        # Exclude the current record if it's not new
+        unless record.new?
+          query.where(:id.not => record.id)
+        end
+
+        # Check if any matching records exist
+        query.limit(1)
+        existing = query.first
+
+        if existing.present?
+          error_message = options[:message] || "has already been taken"
+          record.errors.add(attribute, error_message)
+        end
+      end
+    end
+  end
+end
+
+# Register the validator with ActiveModel so it can be used with validates helper
+ActiveModel::Validations::UniquenessValidator = Parse::Validations::UniquenessValidator

data/lib/parse/model/validations.rb

@@ -0,0 +1,96 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Load all custom validators for Parse Stack
+require_relative "validations/uniqueness_validator"
+
+module Parse
+  # The Validations module provides custom validators for Parse::Object subclasses.
+  #
+  # Parse Stack builds on ActiveModel::Validations, which means all standard Rails
+  # validations are available:
+  #
+  # - `validates :field, presence: true`
+  # - `validates :field, length: { minimum: 1, maximum: 200 }`
+  # - `validates :field, numericality: { greater_than: 0 }`
+  # - `validates :field, format: { with: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i }`
+  # - `validates :field, inclusion: { in: %w[small medium large] }`
+  # - `validates :field, exclusion: { in: %w[admin root] }`
+  #
+  # In addition, Parse Stack provides:
+  #
+  # - `validates :field, uniqueness: true` - Queries Parse to ensure uniqueness
+  #
+  # @example Full validation example
+  #   class User < Parse::Object
+  #     property :email, :string
+  #     property :username, :string
+  #     property :age, :integer
+  #     property :status, :string
+  #
+  #     # Standard ActiveModel validations
+  #     validates :email, presence: true,
+  #                       format: { with: URI::MailTo::EMAIL_REGEXP }
+  #     validates :username, presence: true,
+  #                          length: { minimum: 3, maximum: 30 }
+  #     validates :age, numericality: { greater_than_or_equal_to: 0 },
+  #                     allow_nil: true
+  #     validates :status, inclusion: { in: %w[active inactive pending] }
+  #
+  #     # Parse-specific uniqueness validation
+  #     validates :email, uniqueness: true
+  #     validates :username, uniqueness: { case_sensitive: false }
+  #
+  #     # Custom validation method
+  #     validate :email_domain_allowed
+  #
+  #     private
+  #
+  #     def email_domain_allowed
+  #       return if email.blank?
+  #       domain = email.split('@').last
+  #       unless %w[company.com partner.org].include?(domain)
+  #         errors.add(:email, "must be from an allowed domain")
+  #       end
+  #     end
+  #   end
+  #
+  # @example Validation callbacks
+  #   class Song < Parse::Object
+  #     property :title, :string
+  #
+  #     validates :title, presence: true
+  #
+  #     before_validation :normalize_title
+  #     after_validation :log_validation_result
+  #
+  #     private
+  #
+  #     def normalize_title
+  #       self.title = title.strip.titleize if title.present?
+  #     end
+  #
+  #     def log_validation_result
+  #       if errors.any?
+  #         puts "Validation failed: #{errors.full_messages.join(', ')}"
+  #       end
+  #     end
+  #   end
+  #
+  # @example Conditional validations
+  #   class Order < Parse::Object
+  #     property :status, :string
+  #     property :shipping_address, :string
+  #     property :tracking_number, :string
+  #
+  #     validates :shipping_address, presence: true, if: :requires_shipping?
+  #     validates :tracking_number, presence: true, if: -> { status == "shipped" }
+  #
+  #     def requires_shipping?
+  #       status.in?(%w[processing shipped delivered])
+  #     end
+  #   end
+  #
+  module Validations
+  end
+end