parse-stack-next 4.5.0

data/lib/parse/api/aggregate.rb

@@ -0,0 +1,79 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext"
+require_relative "./objects"
+
+module Parse
+  module API
+    # REST API methods for fetching CRUD operations on Parse objects.
+    module Aggregate
+      # The class prefix for fetching objects.
+      # @!visibility private
+      PATH_PREFIX = "aggregate/"
+
+      # @!visibility private
+      PREFIX_MAP = Parse::API::Objects::PREFIX_MAP
+
+      # @!visibility private
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Class methods to be applied to {Parse::Client}
+      module ClassMethods
+        # Get the aggregate API path for this class.
+        #
+        # +className+ is validated to prevent path-smuggling — aggregate
+        # endpoints are master-key-only on Parse Server, so any traversal
+        # here pivots a master-key request to a different endpoint.
+        #
+        # @param className [String] the name of the Parse collection.
+        # @return [String] the API uri path
+        # @raise [ArgumentError] if className violates the identifier pattern.
+        def aggregate_uri_path(className)
+          if className.is_a?(Parse::Pointer)
+            className = className.parse_class
+          end
+          className = Parse::API::PathSegment.identifier!(className, kind: "className")
+          "#{PATH_PREFIX}#{className}"
+        end
+      end
+
+      # Get the API path for this class.
+      # @param className [String] the name of the Parse collection.
+      # @return [String] the API uri path
+      def aggregate_uri_path(className)
+        self.class.aggregate_uri_path(className)
+      end
+
+      # Aggregate a set of matching objects for a query.
+      # @param className [String] the name of the Parse collection.
+      # @param query [Hash] The set of query constraints.
+      # @param opts [Hash] additional options to pass to the {Parse::Client} request.
+      # @param headers [Hash] additional HTTP headers to send with the request.
+      # @return [Parse::Response]
+      # @see Parse::Query
+      def aggregate_objects(className, query = {}, headers: {}, **opts)
+        response = request :get, aggregate_uri_path(className), query: query, headers: headers, opts: opts
+        response.parse_class = className if response.present?
+        response
+      end
+
+      # Execute a MongoDB-style aggregation pipeline on a Parse collection.
+      # @param className [String] the name of the Parse collection.
+      # @param pipeline [Array] the MongoDB aggregation pipeline stages.
+      # @param opts [Hash] additional options to pass to the {Parse::Client} request.
+      # @param headers [Hash] additional HTTP headers to send with the request.
+      # @return [Parse::Response]
+      # @see Parse::Query
+      def aggregate_pipeline(className, pipeline = [], headers: {}, **opts)
+        query = { pipeline: pipeline.to_json }
+        response = request :get, aggregate_uri_path(className), query: query, headers: headers, opts: opts
+        response.parse_class = className if response.present?
+        response
+      end
+    end #Aggregate
+  end #API
+end

data/lib/parse/api/all.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Note: Do not require "../client" here - this file is loaded from client.rb
+# and adding that require would create a circular dependency.
+require_relative "path_segment"
+require_relative "analytics"
+require_relative "aggregate"
+require_relative "batch"
+require_relative "config"
+require_relative "files"
+require_relative "cloud_functions"
+require_relative "hooks"
+require_relative "objects"
+require_relative "push"
+require_relative "schema"
+require_relative "server"
+require_relative "sessions"
+require_relative "users"
+
+module Parse
+  # The module containing most of the REST API requests supported by Parse Server.
+  # Defines all the Parse REST API endpoints.
+  module API
+  end
+end

data/lib/parse/api/analytics.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Parse
+  module API
+    # Defines the Analytics interface for the Parse REST API
+    module Analytics
+
+      # Send analytics data.
+      # @param event_name [String] the name of the event.
+      # @param metrics [Hash] the metrics to attach to event.
+      # @see http://docs.parseplatform.org/rest/guide/#analytics Parse Analytics
+      def send_analytics(event_name, metrics = {})
+        request :post, "events/#{event_name}", body: metrics
+      end
+    end
+  end
+end

data/lib/parse/api/batch.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext"
+
+module Parse
+  module API
+    # Defines the Batch interface for the Parse REST API
+    # @see Parse::BatchOperation
+    # @see Array.destroy
+    # @see Array.save
+    module Batch
+      # @note You cannot use batch_requests with {Parse::User} instances that need to
+      #  be created.
+      # @overload batch_request(requests)
+      #  Perform a set of {Parse::Request} instances as a batch operation.
+      #  @param requests [Array<Parse::Request>] the set of requests to batch.
+      # @overload batch_request(operation)
+      #  Submit a batch operation.
+      #  @param operation [Parse::BatchOperation] the batch operation.
+      # @return [Array<Parse::Response>] if successful, a set of responses for each operation in the batch.
+      # @return [Parse::Response] if an error occurred, the error response.
+      def batch_request(batch_operations)
+        unless batch_operations.is_a?(Parse::BatchOperation)
+          batch_operations = Parse::BatchOperation.new batch_operations
+        end
+        response = request(:post, "batch", body: batch_operations.as_json)
+        response.success? && response.batch? ? response.batch_responses : response
+      end
+    end
+  end
+end

data/lib/parse/api/cloud_functions.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Parse
+  module API
+    # Defines the CloudCode interface for the Parse REST API
+    module CloudFunctions
+
+      # Call a cloud function.
+      # @param name [String] the name of the cloud function.
+      # @param body [Hash] the parameters to forward to the function.
+      # @param opts [Hash] additional options for the request.
+      # @option opts [String] :session_token The session token for authenticated requests.
+      # @option opts [String] :master_key Whether to use the master key for this request.
+      # @return [Parse::Response]
+      def call_function(name, body = {}, opts: {})
+        safe = Parse::API::PathSegment.identifier!(name, kind: "function name")
+        request :post, "functions/#{safe}", body: body, opts: opts
+      end
+
+      # Trigger a job.
+      # @param name [String] the name of the job to trigger.
+      # @param body [Hash] the parameters to forward to the job.
+      # @param opts [Hash] additional options for the request.
+      # @option opts [String] :session_token The session token for authenticated requests.
+      # @option opts [String] :master_key Whether to use the master key for this request.
+      # @return [Parse::Response]
+      def trigger_job(name, body = {}, opts: {})
+        safe = Parse::API::PathSegment.identifier!(name, kind: "job name")
+        request :post, "jobs/#{safe}", body: body, opts: opts
+      end
+
+      # Call a cloud function with a specific session token.
+      # This is a convenience method that ensures the session token is properly passed.
+      # @param name [String] the name of the cloud function.
+      # @param body [Hash] the parameters to forward to the function.
+      # @param session_token [String] the session token for authenticated requests.
+      # @return [Parse::Response]
+      def call_function_with_session(name, body = {}, session_token)
+        opts = {}
+        opts[:session_token] = session_token if session_token.present?
+        call_function(name, body, opts: opts)
+      end
+
+      # Trigger a job with a specific session token.
+      # This is a convenience method that ensures the session token is properly passed.
+      # @param name [String] the name of the job to trigger.
+      # @param body [Hash] the parameters to forward to the job.
+      # @param session_token [String] the session token for authenticated requests.
+      # @return [Parse::Response]
+      def trigger_job_with_session(name, body = {}, session_token)
+        opts = {}
+        opts[:session_token] = session_token if session_token.present?
+        trigger_job(name, body, opts: opts)
+      end
+    end
+  end
+end

data/lib/parse/api/config.rb

@@ -0,0 +1,125 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Parse
+  module API
+    # Defines the Config interface for the Parse REST API
+    module Config
+
+      # @!attribute config
+      #  @return [Hash] the cached config hash for the client.
+      attr_writer :config
+
+      # @!attribute master_key_only
+      #  @return [Hash] the cached masterKeyOnly flag map for the client.
+      attr_writer :master_key_only
+
+      # @!visibility private
+      CONFIG_PATH = "config"
+
+      # @return [Hash] force fetch the application configuration hash.
+      def config!
+        @config = nil
+        @master_key_only = nil
+        self.config
+      end
+
+      # Return the configuration hash for the configured application for this client.
+      # This method caches the configuration after the first time it is fetched.
+      # The accompanying `masterKeyOnly` map (if returned by the server) is cached
+      # alongside it and exposed via {#master_key_only}.
+      # @return [Hash] force fetch the application configuration hash.
+      def config
+        if @config.nil?
+          response = request :get, CONFIG_PATH
+          unless response.error?
+            result = response.result || {}
+            @config = result["params"] || {}
+            @master_key_only = result["masterKeyOnly"] || {}
+          end
+        end
+        @config
+      end
+
+      # Return every config entry zipped with its masterKeyOnly trait.
+      #
+      # Pass `master: true` to include keys whose `masterKeyOnly` flag is `true`;
+      # the default `master: false` filters those entries out, matching what a
+      # non-master-key client would actually observe. Each entry has the shape
+      # `{ value: ..., master_key_only: Boolean }`. This is a client-side
+      # filter on the already-cached config — it does NOT re-request the
+      # config. When the connection is not authenticated with the master key,
+      # Parse Server has already stripped master-key-only entries before the
+      # response reaches the cache, so `master: true` has nothing extra to
+      # surface in that case.
+      #
+      # @param master [Boolean] when true, include master-key-only entries.
+      # @return [Hash{String=>Hash}] map of config key to `{value:, master_key_only:}`.
+      def config_entries(master: false)
+        config if @config.nil?
+        return {} if @config.nil?
+        flags = @master_key_only || {}
+        @config.each_with_object({}) do |(key, value), out|
+          is_master_only = flags[key] == true
+          next if is_master_only && !master
+          out[key] = { value: value, master_key_only: is_master_only }
+        end
+      end
+
+      # Return the masterKeyOnly flag map for the application configuration.
+      # Keys map to `true` when the corresponding config param is only readable
+      # by master-key clients. Lazily triggers a config fetch on first access.
+      # @return [Hash{String=>Boolean}] the cached masterKeyOnly map, or an
+      #   empty hash if the server did not return one (e.g. non-master-key reads).
+      def master_key_only
+        config if @master_key_only.nil?
+        @master_key_only || {}
+      end
+
+      # Update the application configuration.
+      #
+      # Pass `master_key_only:` to additionally mark (or unmark) which keys are
+      # only readable by master-key clients. Parse Server merges this map into
+      # the existing flags; unspecified keys keep their current flag. Note that
+      # Parse Server rejects masterKeyOnly entries for keys that do not exist
+      # in `params` (either in this PUT body or already stored).
+      #
+      # @param params [Hash] the hash of key value pairs.
+      # @param master_key_only [Hash{String=>Boolean}, nil] optional flag map
+      #   to merge into the server-side masterKeyOnly settings.
+      # @return [Boolean] true if the configuration was successfully updated.
+      def update_config(params, master_key_only: nil)
+        body = { params: params }
+        unless master_key_only.nil?
+          body[:masterKeyOnly] = master_key_only
+          # Parse Server (9.x) rejects PUT /parse/config when masterKeyOnly
+          # references a key that is not present in the request's params
+          # payload, EVEN IF the key already exists in stored config. The
+          # SDK absorbs that constraint by backfilling any flag-only keys
+          # from the cached @config so flag-only updates round-trip cleanly.
+          # Without this, `update_config({}, master_key_only: {foo: false})`
+          # would always fail with a server-side 400 even after foo was
+          # previously persisted.
+          if @config.is_a?(Hash)
+            master_key_only.each_key do |k|
+              ks = k.to_s
+              next if body[:params].key?(ks) || body[:params].key?(k)
+              cached = @config[ks]
+              body[:params][ks] = cached unless cached.nil?
+            end
+          end
+        end
+        response = request :put, CONFIG_PATH, body: body
+        return false if response.error?
+        result = response.result["result"]
+        if result
+          @config.merge!(params) if @config.present?
+          if master_key_only.is_a?(Hash) && @master_key_only.is_a?(Hash)
+            @master_key_only.merge!(master_key_only.transform_keys(&:to_s))
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/parse/api/files.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext"
+
+module Parse
+  module API
+    # Defines the Parse Files interface for the Parse REST API
+    module Files
+      # @!visibility private
+      FILES_PATH = "files"
+
+      # Upload and create a Parse file.
+      # @param fileName [String] the basename of the file.
+      # @param data [Hash] the data related to this file.
+      # @param content_type [String] the mime-type of the file.
+      # @return [Parse::Response]
+      def create_file(fileName, data = {}, content_type = nil)
+        safe = Parse::API::PathSegment.file!(fileName, kind: "file name")
+        headers = {}
+        headers.merge!({ Parse::Protocol::CONTENT_TYPE => content_type.to_s }) if content_type.present?
+        response = request :post, "#{FILES_PATH}/#{safe}", body: data, headers: headers
+        response.parse_class = Parse::Model::TYPE_FILE
+        response
+      end
+    end
+  end
+end

data/lib/parse/api/hooks.rb

@@ -0,0 +1,117 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Parse
+  module API
+    # Defines the Parse webhooks interface for the Parse REST API
+    module Hooks
+      # @!visibility private
+      HOOKS_PREFIX = "hooks/"
+      # The allowed set of Parse triggers.
+      TRIGGER_NAMES = [:afterCreate, :afterDelete, :afterFind, :afterSave, :beforeDelete, :beforeFind, :beforeSave].freeze
+      # @!visibility private
+      TRIGGER_NAMES_LOCAL = [:after_create, :after_delete, :after_find, :after_save, :before_delete, :before_find, :before_save].freeze
+      # @!visibility private
+      def _verify_trigger(triggerName)
+        triggerName = triggerName.to_s.camelize(:lower).to_sym
+        raise ArgumentError, "Invalid trigger name #{triggerName}" unless TRIGGER_NAMES.include?(triggerName)
+        triggerName
+      end
+
+      # Fetch all defined cloud code functions.
+      # @return [Parse::Response]
+      def functions
+        opts = { cache: false }
+        request :get, "#{HOOKS_PREFIX}functions", opts: opts
+      end
+
+      # Fetch information about a specific registered cloud function.
+      # @param functionName [String] the name of the cloud code function.
+      # @return [Parse::Response]
+      def fetch_function(functionName)
+        safe = Parse::API::PathSegment.identifier!(functionName, kind: "function name")
+        request :get, "#{HOOKS_PREFIX}functions/#{safe}"
+      end
+
+      # Register a cloud code webhook function pointing to a endpoint url.
+      # @param functionName [String] the name of the cloud code function.
+      # @param url [String] the url endpoint for this cloud code function.
+      # @return [Parse::Response]
+      def create_function(functionName, url)
+        request :post, "#{HOOKS_PREFIX}functions", body: { functionName: functionName, url: url }
+      end
+
+      # Updated the endpoint url for a registered cloud code webhook function.
+      # @param functionName [String] the name of the cloud code function.
+      # @param url [String] the new url endpoint for this cloud code function.
+      # @return [Parse::Response]
+      def update_function(functionName, url)
+        # If you add _method => "PUT" to the JSON body,
+        # and send it as a POST request and parse will accept it as a PUT.
+        safe = Parse::API::PathSegment.identifier!(functionName, kind: "function name")
+        request :put, "#{HOOKS_PREFIX}functions/#{safe}", body: { url: url }
+      end
+
+      # Remove a registered cloud code webhook function.
+      # @param functionName [String] the name of the cloud code function.
+      # @return [Parse::Response]
+      def delete_function(functionName)
+        safe = Parse::API::PathSegment.identifier!(functionName, kind: "function name")
+        request :put, "#{HOOKS_PREFIX}functions/#{safe}", body: { __op: "Delete" }
+      end
+
+      # Get the set of registered triggers.
+      # @return [Parse::Response]
+      def triggers
+        opts = { cache: false }
+        request :get, "#{HOOKS_PREFIX}triggers", opts: opts
+      end
+
+      # Fetch information about a registered webhook trigger.
+      # @param triggerName [String] the name of the trigger. (ex. beforeSave, afterSave)
+      # @param className [String] the name of the Parse collection for the trigger.
+      # @return [Parse::Response]
+      # @see TRIGGER_NAMES
+      def fetch_trigger(triggerName, className)
+        triggerName = _verify_trigger(triggerName)
+        safe_class = Parse::API::PathSegment.identifier!(className, kind: "class name")
+        request :get, "#{HOOKS_PREFIX}triggers/#{safe_class}/#{triggerName}"
+      end
+
+      # Register a new cloud code webhook trigger with an endpoint url.
+      # @param triggerName [String] the name of the trigger. (ex. beforeSave, afterSave)
+      # @param className [String] the name of the Parse collection for the trigger.
+      # @param url [String] the url endpoint for this webhook trigger.
+      # @return [Parse::Response]
+      # @see Parse::API::Hooks::TRIGGER_NAMES
+      def create_trigger(triggerName, className, url)
+        triggerName = _verify_trigger(triggerName)
+        body = { className: className, triggerName: triggerName, url: url }
+        request :post, "#{HOOKS_PREFIX}triggers", body: body
+      end
+
+      # Updated the registered endpoint for this cloud code webhook trigger.
+      # @param triggerName [String] the name of the trigger. (ex. beforeSave, afterSave)
+      # @param className [String] the name of the Parse collection for the trigger.
+      # @param url [String] the new url endpoint for this webhook trigger.
+      # @return [Parse::Response]
+      # @see Parse::API::Hooks::TRIGGER_NAMES
+      def update_trigger(triggerName, className, url)
+        triggerName = _verify_trigger(triggerName)
+        safe_class = Parse::API::PathSegment.identifier!(className, kind: "class name")
+        request :put, "#{HOOKS_PREFIX}triggers/#{safe_class}/#{triggerName}", body: { url: url }
+      end
+
+      # Remove a registered cloud code webhook trigger.
+      # @param triggerName [String] the name of the trigger. (ex. beforeSave, afterSave)
+      # @param className [String] the name of the Parse collection for the trigger.
+      # @return [Parse::Response]
+      # @see Parse::API::Hooks::TRIGGER_NAMES
+      def delete_trigger(triggerName, className)
+        triggerName = _verify_trigger(triggerName)
+        safe_class = Parse::API::PathSegment.identifier!(className, kind: "class name")
+        request :put, "#{HOOKS_PREFIX}triggers/#{safe_class}/#{triggerName}", body: { __op: "Delete" }
+      end
+    end
+  end
+end

data/lib/parse/api/objects.rb

@@ -0,0 +1,146 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext"
+require_relative "path_segment"
+
+module Parse
+  module API
+    # REST API methods for fetching CRUD operations on Parse objects.
+    module Objects
+      # The class prefix for fetching objects.
+      # @!visibility private
+      CLASS_PATH_PREFIX = "classes/"
+
+      # @!visibility private
+      PREFIX_MAP = { installation: "installations", _installation: "installations",
+                     user: "users", _user: "users",
+                     role: "roles", _role: "roles",
+                     session: "sessions", _session: "sessions" }.freeze
+
+      # @!visibility private
+      # Parse Server objectId format: 1-40 characters of alphanumerics.
+      # The default custom objectId generator in Parse Server uses a
+      # 10-char alphanumeric string; we permit up to 40 to cover apps that
+      # have configured a longer length but still refuse anything outside
+      # this character class.
+      OBJECT_ID_PATTERN = /\A[A-Za-z0-9]{1,40}\z/.freeze
+
+      # @!visibility private
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Class methods to be applied to {Parse::Client}
+      module ClassMethods
+        # Get the API path for this class.
+        #
+        # Both +className+ and +id+ are validated to prevent path-smuggling
+        # attacks where an attacker-controlled string traverses to a
+        # different REST endpoint (e.g. +"../sessions/me"+) with whatever
+        # auth the outer request carries — typically the master key.
+        #
+        # @param className [String] the name of the Parse collection.
+        # @param id [String, nil] optional objectId to add at the end of the path.
+        # @return [String] the API uri path
+        # @raise [ArgumentError] if className or id violates the strict
+        #   identifier / objectId patterns.
+        def uri_path(className, id = nil)
+          if className.is_a?(Parse::Pointer)
+            id = className.id
+            className = className.parse_class
+          end
+          className = Parse::API::PathSegment.identifier!(className, kind: "className")
+          if id
+            id_str = id.to_s
+            unless OBJECT_ID_PATTERN.match?(id_str)
+              raise ArgumentError,
+                    "objectId #{id_str.inspect} contains characters not " \
+                    "allowed in a Parse objectId. Must match " \
+                    "/\\A[A-Za-z0-9]{1,40}\\z/."
+            end
+            id = id_str
+          end
+          uri = "#{CLASS_PATH_PREFIX}#{className}"
+          class_prefix = className.downcase.to_sym
+          if PREFIX_MAP.has_key?(class_prefix)
+            uri = PREFIX_MAP[class_prefix]
+          end
+          id.present? ? "#{uri}/#{id}" : "#{uri}/"
+        end
+      end
+
+      # Get the API path for this class.
+      # @param className [String] the name of the Parse collection.
+      # @param id [String] optional objectId to add at the end of the path.
+      # @return [String] the API uri path
+      def uri_path(className, id = nil)
+        self.class.uri_path(className, id)
+      end
+
+      # Create an object in a collection.
+      # @param className [String] the name of the Parse collection.
+      # @param body [Hash] the body of the request.
+      # @param opts [Hash] additional options to pass to the {Parse::Client} request.
+      # @param headers [Hash] additional HTTP headers to send with the request.
+      # @return [Parse::Response]
+      def create_object(className, body = {}, headers: {}, **opts)
+        response = request :post, uri_path(className), body: body, headers: headers, opts: opts
+        response.parse_class = className if response.present?
+        response
+      end
+
+      # Delete an object in a collection.
+      # @param className [String] the name of the Parse collection.
+      # @param id [String] The objectId of the record in the collection.
+      # @param opts [Hash] additional options to pass to the {Parse::Client} request.
+      # @param headers [Hash] additional HTTP headers to send with the request.
+      # @return [Parse::Response]
+      def delete_object(className, id, headers: {}, **opts)
+        response = request :delete, uri_path(className, id), headers: headers, opts: opts
+        response.parse_class = className if response.present?
+        response
+      end
+
+      # Fetch a specific object from a collection.
+      # @param className [String] the name of the Parse collection.
+      # @param id [String] The objectId of the record in the collection.
+      # @param query [Hash] optional query parameters like keys and include.
+      # @param opts [Hash] additional options to pass to the {Parse::Client} request.
+      # @param headers [Hash] additional HTTP headers to send with the request.
+      # @return [Parse::Response]
+      def fetch_object(className, id, query: nil, headers: {}, **opts)
+        response = request :get, uri_path(className, id), query: query, headers: headers, opts: opts
+        response.parse_class = className if response.present?
+        response
+      end
+
+      # Fetch a set of matching objects for a query.
+      # @param className [String] the name of the Parse collection.
+      # @param query [Hash] The set of query constraints.
+      # @param opts [Hash] additional options to pass to the {Parse::Client} request.
+      # @param headers [Hash] additional HTTP headers to send with the request.
+      # @return [Parse::Response]
+      # @see Parse::Query
+      def find_objects(className, query = {}, headers: {}, **opts)
+        response = request :get, uri_path(className), query: query, headers: headers, opts: opts
+        response.parse_class = className if response.present?
+        response
+      end
+
+      # Update an object in a collection.
+      # @param className [String] the name of the Parse collection.
+      # @param id [String] The objectId of the record in the collection.
+      # @param body [Hash] The key value pairs to update.
+      # @param opts [Hash] additional options to pass to the {Parse::Client} request.
+      # @param headers [Hash] additional HTTP headers to send with the request.
+      # @return [Parse::Response]
+      def update_object(className, id, body = {}, headers: {}, **opts)
+        response = request :put, uri_path(className, id), body: body, headers: headers, opts: opts
+        response.parse_class = className if response.present?
+        response
+      end
+    end #Objects
+  end #API
+end