moderation_api 2.41.0 → 3.1.0

data/lib/moderation_api/utils/query_params.rb

@@ -0,0 +1,167 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require "date"
+require "base64"
+require "sorbet-runtime"
+
+module ModerationApi
+  module Utils
+    extend T::Sig
+
+    sig {
+      params(
+        clazz: Object,
+        query_params: Object,
+        url_override: T.nilable(::String),
+        gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])
+      )
+        .returns(T::Hash[T.any(String, Symbol), T::Array[String]])
+    }
+    def self.get_query_params(clazz, query_params, url_override = nil, gbls = nil)
+      parsed_params = T.let({}, T::Hash[T.any(String, Symbol), T::Array[String]])
+      if !url_override.nil?
+        parsed_url = URI.parse(url_override)
+        URI.decode_www_form(parsed_url.query.to_s).each do |key, value|
+          parsed_params[key] ||= []
+          T.must(parsed_params[key]) << value
+        end
+      end
+
+      params = T.let({}, T::Hash[T.any(String, Symbol), T::Array[String]])
+      T.unsafe(clazz).fields.each do |f|
+        request_metadata = f.metadata[:request]
+        next if !request_metadata.nil?
+
+        metadata = f.metadata[:query_param]
+        next if metadata.nil?
+
+        param_name = f.name
+        value = query_params&.send(param_name.to_sym)
+        value = _populate_from_globals(param_name, value, "queryParam", gbls)
+
+        f_name = metadata[:field_name]
+        serialization = metadata.fetch(:serialization, "")
+        if serialization != ""
+          params = params.merge(
+            _get_serialized_params(
+              metadata,
+              f_name,
+              value
+            )
+          )
+        else
+          style = metadata.fetch(:style, "form")
+          case style
+          when "deepObject"
+            params = params.merge(
+              _get_deep_object_query_params(
+                metadata,
+                f_name,
+                value
+              )
+            )
+          when "form"
+            params = params.merge(
+              _get_delimited_query_params(
+                metadata,
+                f_name,
+                value,
+                ","
+              )
+            )
+          when "pipeDelimited"
+            params = params.merge(
+              _get_delimited_query_params(
+                metadata,
+                f_name,
+                value,
+                "|"
+              )
+            )
+          else
+            raise StandardError, "not yet implemented"
+          end
+        end
+      end
+
+      params.merge(parsed_params)
+    end
+
+    sig do
+      params(metadata: T::Hash[Symbol, String], field_name: String, obj: Object)
+        .returns(T::Hash[T.any(String, Symbol), T::Array[String]])
+    end
+    def self._get_deep_object_query_params(metadata, field_name, obj)
+      params = T.let({}, T::Hash[T.any(String, Symbol), T::Array[String]])
+
+      return params if obj.nil?
+
+      if obj.respond_to?(:fields)
+        T.unsafe(obj).fields.each do |obj_field|
+          obj_param_metadata = obj_field.metadata[:query_param]
+          next if obj_param_metadata.nil?
+
+          val = obj.send(obj_field.name)
+          next if val.nil?
+
+          key = "#{metadata.fetch(:field_name, field_name)}[#{obj_param_metadata.fetch(:field_name, obj_field.name)}]"
+          if val.is_a?(Array)
+            val.each do |v|
+              next if v.nil?
+
+              params[key] = [] if !params.include?(key)
+
+              T.must(params[key]) << val_to_string(v)
+            end
+          else
+            params[key] = [val_to_string(val)]
+          end
+        end
+      elsif obj.is_a?(Hash)
+        obj.each do |key, value|
+          next if value.nil?
+
+          param_key = "#{metadata.fetch(:field_name, field_name)}[#{key}]"
+          if value.is_a?(Array)
+            value.each do |val|
+              next if val.nil?
+
+              params[param_key] = [] if !params.include?(param_key)
+
+              T.must(params[param_key]).append(val_to_string(val))
+            end
+          else
+            params[param_key] = [val_to_string(value)]
+          end
+        end
+      end
+
+      params
+    end
+
+    sig do
+      params(metadata: T::Hash[Symbol, String], field_name: String, obj: Object, delimiter: String)
+        .returns(T::Hash[T.any(String, Symbol), T::Array[String]])
+    end
+    def self._get_delimited_query_params(metadata, field_name, obj, delimiter)
+      get_query_param_field_name = lambda do |obj_field|
+        obj_param_metadata = obj_field.metadata[:query_param]
+
+        return {} if obj_param_metadata.nil?
+
+        return obj_param_metadata.fetch(:field_name, obj_field.name)
+      end
+
+      _populate_form(
+        field_name,
+        T.cast(metadata.fetch(:explode, true), T::Boolean),
+        obj,
+        delimiter,
+        &get_query_param_field_name
+      )
+    end
+  end
+end

data/lib/moderation_api/utils/request_bodies.rb

@@ -0,0 +1,79 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require "cgi"
+require "date"
+require "base64"
+require "sorbet-runtime"
+
+module ModerationApi
+  module Utils
+    extend T::Sig
+
+    SERIALIZATION_METHOD_TO_CONTENT_TYPE = {
+      'json': "application/json",
+      'form': "application/x-www-form-urlencoded",
+      'multipart': "multipart/form-data",
+      'raw': "application/octet-stream",
+      'string': "text/plain"
+    }.freeze
+
+    sig do
+      params(
+        request: Object,
+        nullable: T::Boolean,
+        optional: T::Boolean,
+        request_field_name: Symbol,
+        serialization_method: Symbol
+      )
+        .returns([String, Object, T.nilable(T::Array[T::Array[T.any(T::Array[T.nilable(String)], String)]])])
+    end
+    def self.serialize_request_body(request, nullable, optional, request_field_name, serialization_method)
+      return ["", nil, nil] if request.nil? && !nullable && optional
+
+      if !request.respond_to?(:fields) || !request.respond_to?(request_field_name)
+        return serialize_content_type(SERIALIZATION_METHOD_TO_CONTENT_TYPE[serialization_method], request)
+      end
+
+      request_metadata = T.let(nil, T.nilable(T::Array[T::Array[T.any(T::Array[T.nilable(String)], String)]]))
+      T.unsafe(request).fields.each do |f|
+        if f.name == request_field_name
+          request_metadata = f.metadata[:request]
+          break
+        end
+      end
+
+      if request_metadata.nil?
+        # Field name collision: model has a field matching request_field_name but without :request metadata.
+        # Serialize the entire object as the request body.
+        return serialize_content_type(SERIALIZATION_METHOD_TO_CONTENT_TYPE[serialization_method], request)
+      end
+
+      request_val = request.send(request_field_name)
+      return ["", nil, nil] if request_val.nil?
+
+      serialize_content_type(
+        request_metadata.fetch(:media_type, "application/octet-stream"),
+        request_val
+      )
+    end
+
+    sig do
+      params(media_type: String, request: Object)
+        .returns([String, Object, T.nilable(T::Array[T::Array[T.any(T::Array[T.nilable(String)], String)]])])
+    end
+    def self.serialize_content_type(media_type, request)
+      if media_type.match("^(application|text)\\/([^+]+\\+)*json.*")
+        return media_type, ::Crystalline.to_json(request), nil
+      end
+
+      return serialize_multipart_form(media_type, request) if media_type.match("^multipart\\/.*")
+      return media_type, serialize_form_data(request), nil if media_type.match("^application\\/x-www-form-urlencoded.*")
+      return media_type, request, nil if request.is_a?(String) || request.is_a?(Array)
+
+      raise StandardError, "invalid request body type #{request.class} for mediaType #{media_type}"
+    end
+  end
+end

data/lib/moderation_api/utils/retries.rb

@@ -0,0 +1,139 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require "faraday/retry"
+require "time"
+require "sorbet-runtime"
+
+module ModerationApi
+  module Utils
+    class BackoffStrategy
+      extend T::Sig
+
+      sig { returns(T.nilable(::Float)) }
+      attr_accessor :exponent
+
+      sig { returns(T.nilable(::Integer)) }
+      attr_accessor :initial_interval
+
+      sig { returns(T.nilable(::Integer)) }
+      attr_accessor :max_elapsed_time
+
+      sig { returns(T.nilable(::Integer)) }
+      attr_accessor :max_interval
+
+      sig do
+        params(
+          exponent: T.nilable(::Float),
+          initial_interval: T.nilable(::Integer),
+          max_elapsed_time: T.nilable(::Integer),
+          max_interval: T.nilable(::Integer)
+        )
+          .void
+      end
+      def initialize(exponent: nil, initial_interval: nil, max_elapsed_time: nil, max_interval: nil)
+        @exponent = T.let(exponent, T.nilable(::Float))
+        @initial_interval = T.let(initial_interval, T.nilable(::Integer))
+        @max_elapsed_time = T.let(max_elapsed_time, T.nilable(::Integer))
+        @max_interval = T.let(max_interval, T.nilable(::Integer))
+      end
+    end
+
+    class RetryConfig
+      extend T::Sig
+
+      sig { returns(T.nilable(BackoffStrategy)) }
+      attr_accessor :backoff
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :retry_connection_errors
+
+      sig { returns(T.nilable(::String)) }
+      attr_accessor :strategy
+
+      sig do
+        params(
+          backoff: T.nilable(BackoffStrategy),
+          retry_connection_errors: T.nilable(T::Boolean),
+          strategy: T.nilable(::String)
+        )
+          .void
+      end
+      def initialize(backoff: nil, retry_connection_errors: nil, strategy: nil)
+        @backoff = T.let(backoff, T.nilable(BackoffStrategy))
+        @retry_connection_errors = T.let(retry_connection_errors, T.nilable(T::Boolean))
+        @strategy = T.let(strategy, T.nilable(::String))
+      end
+
+      sig { params(initial_time: ::Time).returns(::Hash) }
+      def to_faraday_retry_options(initial_time:)
+        retry_options = {
+          # must overwrite default max of 2 retries and it must be positive
+          max: 1_000_000_000,
+          # ensure all HTTP methods are retried, especially via retry_if
+          methods: []
+        }
+
+        if @retry_connection_errors
+          retry_options[:exceptions] = Faraday::Retry::Middleware::DEFAULT_EXCEPTIONS + [Faraday::ConnectionFailed]
+        end
+
+        if @strategy == "backoff" && @backoff
+          retry_options[:backoff_factor] = @backoff.exponent unless @backoff.exponent.nil?
+          retry_options[:interval] = (@backoff.initial_interval.to_f / 1000) unless @backoff.initial_interval.nil?
+          retry_options[:max_interval] = (@backoff.max_interval.to_f / 1000) unless @backoff.max_interval.nil?
+
+          unless @backoff.max_elapsed_time.nil?
+            stop_time = initial_time + (@backoff.max_elapsed_time.to_f / 1000)
+            retry_options[:retry_if] = -> (_env, _exc) { Time.now < stop_time }
+          end
+
+        end
+
+        retry_options
+      end
+    end
+
+    class RetryMiddleware < Faraday::Retry::Middleware
+      extend T::Sig
+
+      sig { params(retries: T.untyped, env: T.untyped).returns(T.untyped) }
+      def calculate_sleep_amount(retries, env)
+        retry_after = [calculate_retry_after(env), calculate_rate_limit_reset(env)].compact.max
+        retry_interval = calculate_retry_interval(retries)
+        return retry_interval if retry_after.nil?
+
+        # unlike the stock middleware, cap server delays at max_interval rather
+        # than abandoning the retry
+        [[retry_after, @options.max_interval].min, retry_interval].max
+      end
+
+      private
+
+      sig { params(env: T.untyped).returns(T.untyped) }
+      def calculate_retry_after(env)
+        response_headers = env[:response_headers]
+        return unless response_headers
+
+        ms_value = response_headers["retry-after-ms"]
+        return ms_value.to_f / 1000 if ms_value&.match?(/\A\s*\d+\s*\z/)
+
+        value = response_headers["retry-after"]
+        return if value.nil? || value.strip.empty?
+        return value.to_f if value.match?(/\A\s*\d+\s*\z/)
+
+        begin
+          Time.httpdate(value) - Time.now
+        rescue ArgumentError
+          begin
+            Time.iso8601(value) - Time.now
+          rescue ArgumentError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moderation_api/utils/security.rb

@@ -0,0 +1,158 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require "cgi"
+require "date"
+require "base64"
+require "sorbet-runtime"
+
+module ModerationApi
+  module Utils
+    extend T::Sig
+
+    sig { params(req: Faraday::Request, security: Object, allowed_fields: T.nilable(T::Array[Symbol])).void }
+    def self.configure_request_security(req, security, allowed_fields = nil)
+      return if security.nil?
+
+      sec_fields = if allowed_fields.nil?
+        T.unsafe(security).fields
+      else
+        allowed_fields.filter_map { |name| T.unsafe(security).fields.find { |f| f.name == name } }
+      end
+
+      sec_fields.each do |sec_field|
+        value = security.send(sec_field.name)
+        next if value.nil?
+
+        metadata = sec_field.metadata[:security]
+        next if metadata.nil?
+
+        if metadata[:option]
+          _parse_security_option(req, value)
+          break unless metadata[:composite]
+        end
+
+        next unless metadata[:scheme]
+
+        # Special case for basic auth which could be a flattened struct
+        if metadata[:sub_type] == "basic" && !value.respond_to?(:fields)
+          _parse_security_scheme(req, metadata, security)
+        else
+          _parse_security_scheme(req, metadata, value)
+        end
+
+        break unless metadata[:composite]
+      end
+    end
+
+    sig { params(req: Faraday::Request, option: Object).void }
+    def self._parse_security_option(req, option)
+      # Check if this option uses basic auth (needs the whole object, not individual fields)
+      first_field = T.unsafe(option).fields.first
+      if first_field
+        first_meta = first_field.metadata[:security]
+        if first_meta && first_meta[:type] == "http" && first_meta[:sub_type] == "basic"
+          _parse_security_scheme(req, first_meta, option)
+          return
+        end
+      end
+
+      T.unsafe(option).fields.each do |opt_field|
+        metadata = opt_field.metadata[:security]
+        next if metadata.nil? || !metadata.include?(:scheme)
+
+        _parse_security_scheme(req, metadata, option.send(opt_field.name))
+      end
+    end
+
+    sig { params(req: Faraday::Request, scheme_metadata: T::Hash[Symbol, String], scheme: Object).void }
+    def self._parse_security_scheme(req, scheme_metadata, scheme)
+      scheme_type = scheme_metadata[:type]
+      sub_type = scheme_metadata[:sub_type]
+
+      if scheme.respond_to?(:fields)
+        if scheme_type == "http" && sub_type == "basic"
+          _parse_basic_auth_scheme(req, scheme)
+          return
+        end
+
+        T.unsafe(scheme).fields.each do |field|
+          metadata = field.metadata[:security]
+          next if metadata.nil? || metadata[:field_name].nil?
+
+          value = scheme.send(field.name)
+          _parse_security_scheme_value(req, scheme_metadata, metadata, T.cast(value, String))
+        end
+      else
+        _parse_security_scheme_value(req, scheme_metadata, scheme_metadata, T.cast(scheme, String))
+      end
+    end
+
+    sig do
+      params(
+        req: Faraday::Request,
+        scheme_metadata: T::Hash[Symbol, String],
+        security_metadata: T::Hash[Symbol, String],
+        value: String
+      )
+        .void
+    end
+    def self._parse_security_scheme_value(req, scheme_metadata, security_metadata, value)
+      scheme_type = scheme_metadata[:type]
+      sub_type = scheme_metadata[:sub_type]
+
+      header_name = security_metadata[:field_name]
+
+      case scheme_type
+      when "apiKey"
+        case sub_type
+        when "header"
+          req.headers[header_name] = value
+        when "query"
+          req.params[header_name] = value
+        when "cookie"
+          req.headers["Cookie"][header_name] = value
+        else
+          raise StandardError, "not supported"
+        end
+
+      when "openIdConnect"
+        req.headers[header_name] = value.downcase.start_with?("bearer ") ? value : "Bearer #{value}"
+      when "oauth2"
+        req.headers[header_name] = value.downcase.start_with?("bearer ") ? value : "Bearer #{value}"
+      when "http"
+        if sub_type == "bearer"
+          req.headers[header_name] = value.downcase.start_with?("bearer ") ? value : "Bearer #{value}"
+        elsif sub_type != "custom"
+          raise StandardError, "not supported"
+        end
+      else
+        raise StandardError, "not supported"
+      end
+    end
+
+    sig { params(req: Faraday::Request, scheme: Object).void }
+    def self._parse_basic_auth_scheme(req, scheme)
+      username = T.let("", String)
+      password = T.let("", String)
+
+      T.unsafe(scheme).fields.each do |scheme_field|
+        metadata = scheme_field.metadata[:security]
+        next if metadata.nil? || !metadata.include?(:field_name)
+
+        field_name = metadata[:field_name]
+        value = scheme.send(scheme_field.name)
+
+        username = T.let(value, String) if field_name == "username"
+        password = T.let(value, String) if field_name == "password"
+      end
+
+      data = "#{username}:#{password}".encode
+      # Use strict_encode, because encode adds newlines after 60 chars
+      # https://docs.ruby-lang.org/en/3.0/Base64.html#method-i-encode64
+      req.headers["Authorization"] = "Basic #{Base64.strict_encode64(data)}"
+    end
+  end
+end

data/lib/moderation_api/utils/url.rb

@@ -0,0 +1,124 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require "faraday/retry"
+require "sorbet-runtime"
+
+module ModerationApi
+  module Utils
+    sig {
+      params(
+        clazz: Object,
+        server_url: String,
+        path: String,
+        path_params: Object,
+        gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])
+      )
+        .returns(String)
+    }
+    def self.generate_url(clazz, server_url, path, path_params, gbls = nil)
+      T.unsafe(clazz).fields.each do |f|
+        param_metadata = f.metadata[:path_param]
+        next if param_metadata.nil?
+
+        if param_metadata.fetch(:style, "simple") == "simple"
+          param = path_params.send(f.name) if !path_params.nil?
+          param = _populate_from_globals(f.name, param, "pathParam", gbls)
+        end
+
+        f_name = param_metadata.fetch(:field_name, f.name)
+        serialization = param_metadata.fetch(:serialization, "")
+        if serialization != ""
+          serialized_params = _get_serialized_params(param_metadata, f_name, param)
+          serialized_params.each do |k, v|
+            path = path.gsub("{#{k}}", v.join(", "))
+          end
+        else
+          if param.is_a?(Array)
+            pp_vals = []
+            param.each do |pp_val|
+              pp_vals.append(pp_val.to_s)
+            end
+
+            path = path.gsub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(","))
+          elsif param.is_a?(Hash)
+            pp_vals = []
+            param.each do |pp_key, pp_val|
+              value = val_to_string(pp_val)
+
+              if param_metadata.fetch(:explode, false)
+                pp_vals.append("#{pp_key}=#{value}")
+              else
+                pp_vals.append("#{pp_key},#{value}")
+              end
+            end
+
+            path = path.gsub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(","))
+          elsif param.class.include?(::Crystalline::MetadataFields)
+            pp_vals = []
+            attrs = T
+              .unsafe(param)
+              .fields
+              .filter { |field| field.name && param.respond_to?(field.name.to_sym) }
+              .map(&:name)
+            attrs.each do |attr|
+              field = T.unsafe(param).field(attr)
+
+              param_value_metadata = field.metadata[:path_param]
+
+              next if param_value_metadata.nil?
+
+              parm_name = param_value_metadata.fetch(:field_name, f.name)
+
+              param_field_val = param.send(attr)
+
+              if param_field_val.class.respond_to?(:enums)
+                param_field_val = param_field_val.serialize
+              elsif param_field_val.is_a?(DateTime)
+                param_field_val = param_field_val.strftime("%Y-%m-%dT%H:%M:%S.%NZ")
+              end
+
+              if !field.nil? && ::Crystalline::Utils.nilable?(field.type) && param_field_val.nil?
+                next
+              elsif param_metadata.fetch(:explode, false)
+                pp_vals.append("#{parm_name}=#{param_field_val}")
+              else
+                pp_vals.append("#{parm_name},#{param_field_val}")
+              end
+            end
+
+            path = path.gsub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(","))
+          else
+            path = path.gsub("{#{param_metadata.fetch(:field_name, f.name)}}", _encode_path_param(val_to_string(param)))
+          end
+        end
+      end
+
+      server_url.delete_suffix("/") + path
+    end
+
+    # Percent-encode characters that are invalid in URI path segments
+    sig { params(value: String).returns(String) }
+    def self._encode_path_param(value)
+      value.gsub(/[<>{}\[\]|\\^`\s?#%]/) { |c| format("%%%02X", c.ord) }
+    end
+
+    sig { params(url_with_params: String, params: T::Hash[Symbol, T.any(String, T::Enum)]).returns(String) }
+    def self.template_url(url_with_params, params)
+      params.each do |key, value|
+        if value.class.respond_to?(:enums)
+          val_str = T.cast(value, T::Enum).serialize
+        else
+          val_str = value
+        end
+
+        url_with_params = url_with_params.gsub("{#{key}}", val_str)
+      end
+
+      url_with_params
+    end
+
+  end
+end