mollie-ruby-sdk 0.0.1.pre.alpha.9

data/lib/mollie/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 Mollie
+  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/mollie/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 Mollie
+  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

data/lib/mollie/utils/utils.rb

@@ -0,0 +1,245 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require "cgi"
+require "date"
+require "base64"
+require "stringio"
+require "sorbet-runtime"
+
+module Mollie
+  module Utils
+    include ::Kernel
+    extend T::Sig
+
+    sig { params(val: ::Object).returns(::String) }
+    def self.val_to_string(val)
+      if val.class.respond_to?(:enums)
+        T.unsafe(val).serialize.to_s
+      elsif val.is_a?(::DateTime)
+        val.strftime("%Y-%m-%dT%H:%M:%S.%NZ").sub(/(\.\d*[1-9])0+Z\z/, "\\1Z").sub(/\.0+Z\z/, "Z")
+      else
+        val.to_s
+
+      end
+    end
+
+    MIME_TYPES = {
+      ".json" => "application/json",
+      ".xml" => "application/xml",
+      ".pdf" => "application/pdf",
+      ".zip" => "application/zip",
+      ".gz" => "application/gzip",
+      ".csv" => "text/csv",
+      ".txt" => "text/plain",
+      ".html" => "text/html",
+      ".htm" => "text/html",
+      ".css" => "text/css",
+      ".js" => "application/javascript",
+      ".png" => "image/png",
+      ".jpg" => "image/jpeg",
+      ".jpeg" => "image/jpeg",
+      ".gif" => "image/gif",
+      ".svg" => "image/svg+xml",
+      ".webp" => "image/webp",
+      ".mp3" => "audio/mpeg",
+      ".mp4" => "video/mp4",
+      ".yaml" => "application/yaml",
+      ".yml" => "application/yaml"
+    }.freeze
+
+    sig { params(filename: ::String).returns(::String) }
+    def self.mime_type_for_filename(filename)
+      ext = ::File.extname(filename).downcase
+      MIME_TYPES.fetch(ext, "application/octet-stream")
+    end
+
+    sig do
+      params(metadata: T::Hash[::Symbol, ::String], field_name: ::String, obj: ::Object)
+        .returns(T::Hash[::Symbol, T::Array[::String]])
+    end
+    def self._get_serialized_params(metadata, field_name, obj)
+      params = {}
+
+      serialization = metadata.fetch(:serialization, "")
+      params[metadata.fetch(:field_name, field_name)] = [obj.to_json] if serialization == "json"
+
+      params
+    end
+
+    sig { params(status: ::Integer).returns(T::Boolean) }
+    def self.error_status?(status)
+      status_major = status / 100
+      return true if status_major == 4
+      return true if status_major == 5
+
+      false
+    end
+
+    sig { params(content_type: ::String, pattern: ::String).returns(T::Boolean) }
+    def self.match_content_type(content_type, pattern)
+      return true if ["*", "*/*"].include?(pattern)
+
+      # Media types are case-insensitive (RFC 9110 section 8.3.1).
+      pattern = pattern.strip.downcase
+      return true if content_type.strip.downcase == pattern
+
+      pieces = content_type.split(";")
+      pieces.each do |piece|
+        return true if pattern == piece.strip.downcase
+      end
+
+      false
+    end
+
+    sig { params(status_code: ::Integer, status_codes: T::Array[::String]).returns(T::Boolean) }
+    def self.match_status_code(status_code, status_codes)
+      return true if status_codes.include?("default")
+      status_code = status_code.to_s
+      status_codes.each do |code|
+        return true if code == status_code
+        return true if code.downcase.end_with?("xx") && status_code[0] == code[0]
+      end
+
+      false
+    end
+
+    sig { params(optional: T::Boolean).returns(T.proc.params(s: ::String).returns(T.nilable(::DateTime))) }
+    def self.datetime_from_iso_format(optional)
+      ::Kernel.lambda do |s|
+        return nil if optional && s.nil?
+
+        return ::DateTime.strptime(s, "%Y-%m-%dT%H:%M:%S.%NZ")
+      end
+    end
+
+    sig { params(optional: T::Boolean).returns(T.proc.params(s: ::String).returns(T.nilable(::Date))) }
+    def self.date_from_iso_format(optional)
+      ::Kernel.lambda do |s|
+        return nil if optional && s.nil?
+
+        return ::Date.iso8601(s)
+      end
+    end
+
+    sig do
+      params(enum_type: T.class_of(T::Enum), optional: T::Boolean)
+        .returns(T.nilable(T.proc.params(s: ::String).returns(T.nilable(T::Enum))))
+    end
+    def self.enum_from_string(enum_type, optional)
+      ::Kernel.lambda do |s|
+        return nil if optional && s.nil?
+
+        return enum_type.deserialize(s)
+      end
+    end
+
+    sig do
+      params(enum_type: ::Module, optional: T::Boolean)
+        .returns(T.proc.params(s: ::String).returns(T.untyped))
+    end
+    def self.open_enum_from_string(enum_type, optional)
+      ::Kernel.lambda do |s|
+        return nil if optional && s.nil?
+
+        return T.unsafe(enum_type).deserialize(s)
+      end
+    end
+
+    sig { params(name: ::String).returns(T.proc.returns(::String)) }
+    def self.field_name(name)
+      T.let(proc { name }, T.proc.returns(::String))
+    end
+
+    sig { params(field: ::Crystalline::MetadataFields::Field, data_class: ::Object).returns(::Object) }
+    def self.parse_field(field, data_class)
+      field_metadata = field.metadata[:metadata_string]
+      return nil if field_metadata.nil?
+
+      field_value = data_class.send(field.name)
+      return nil if field_value.nil?
+
+      field_value
+    end
+
+    sig do
+      params(form: T::Array[T::Array[T.any(::String, T::Array[T.nilable(::String)])]])
+        .returns(T::Hash[::Symbol, ::Object])
+    end
+    def self.encode_form(form)
+      payload = {}
+      form.each do |field_name, field|
+        field = T.must(field)
+        if field.length == 2
+          if field[0].nil?
+            # Handle multiple values for the same field name (arrays)
+            if payload.key?(field_name)
+              # Convert to array if not already
+              unless payload[field_name].is_a?(::Array)
+                payload[field_name] = [payload[field_name]]
+              end
+
+              payload[field_name] << field[1]
+            else
+              payload[field_name] = field[1]
+            end
+          else
+            # Handle file uploads
+            file_part = Faraday::Multipart::FilePart.new(
+              ::StringIO.new(T.must(field[1])),
+              mime_type_for_filename(T.must(field[0])),
+              field[0]
+            )
+
+            # Handle multiple files for the same field name (arrays)
+            if payload.key?(field_name)
+              unless payload[field_name].is_a?(::Array)
+                payload[field_name] = [payload[field_name]]
+              end
+
+              payload[field_name] << file_part
+            else
+              payload[field_name] = file_part
+            end
+          end
+        elsif field.length == 3
+          param_part = Faraday::Multipart::ParamPart.new(field[1], field[2])
+
+          # Handle multiple values for the same field name (arrays)
+          if payload.key?(field_name)
+            unless payload[field_name].is_a?(::Array)
+              payload[field_name] = [payload[field_name]]
+            end
+
+            payload[field_name] << param_part
+          else
+            payload[field_name] = param_part
+          end
+        end
+      end
+
+      payload
+    end
+
+    sig {
+      params(
+        param_name: ::Symbol,
+        value: ::Object,
+        param_type: ::String,
+        gbls: T.nilable(T::Hash[::Symbol, T::Hash[::Symbol, T::Hash[::Symbol, ::Object]]])
+      )
+        .returns(::Object)
+    }
+    def self._populate_from_globals(param_name, value, param_type, gbls)
+      if value.nil? && !gbls.nil?
+        global_value = gbls.dig(:parameters, param_type.to_sym, param_name.to_sym)
+        value = global_value if !global_value.nil?
+      end
+
+      value
+    end
+
+  end
+end

data/lib/mollie/utils/webhooks/signature_validator.rb

@@ -0,0 +1,115 @@
+# typed: true
+# frozen_string_literal: true
+
+require "openssl"
+
+module Mollie
+  module Utils
+    module Webhooks
+      class InvalidSignatureException < StandardError; end
+
+      class SignatureValidator
+        extend T::Sig
+
+        SIGNATURE_HEADER = "X-Mollie-Signature"
+        SIGNATURE_PREFIX = "sha256="
+
+        sig { params(signing_secrets: T.any(::String, T::Array[::String])).void }
+        def initialize(signing_secrets)
+          @signing_secrets = T.let(
+            signing_secrets.is_a?(Array) ? signing_secrets.dup : [signing_secrets],
+            T::Array[::String]
+          )
+        end
+
+        sig do
+          params(
+            payload: ::String,
+            signing_secrets: T.any(::String, T::Array[::String]),
+            signatures: T.nilable(T.any(::String, T::Array[T.nilable(::String)]))
+          )
+            .returns(T::Boolean)
+        end
+        def self.validate(payload, signing_secrets, signatures = nil)
+          new(signing_secrets).validate_payload(payload, signatures)
+        end
+
+        sig do
+          params(
+            payload: ::String,
+            signatures: T.nilable(T.any(::String, T::Array[T.nilable(::String)]))
+          )
+            .returns(T::Boolean)
+        end
+        def validate_payload(payload, signatures = nil)
+          signature_list = normalize_signatures(signatures)
+          return false if signature_list.empty?
+
+          validate_signatures(payload, signature_list)
+        end
+
+        sig { params(payload: ::String, secret: ::String).returns(::String) }
+        def self.create_signature(payload, secret)
+          OpenSSL::HMAC.hexdigest("SHA256", secret, payload)
+        end
+
+        private
+
+        sig do
+          params(signatures: T.nilable(T.any(::String, T::Array[T.nilable(::String)])))
+            .returns(T::Array[::String])
+        end
+        def normalize_signatures(signatures)
+          case signatures
+          when ::String
+            signatures.empty? ? [] : [signatures]
+          when Array
+            signatures.compact.reject(&:empty?)
+          else
+            []
+          end
+        end
+
+        sig { params(payload: ::String, signatures: T::Array[::String]).returns(T::Boolean) }
+        def validate_signatures(payload, signatures)
+          signatures.each do |signature|
+            extracted_signature = extract_signature(signature)
+
+            return true if valid_signature?(extracted_signature, payload)
+          end
+
+          Kernel.raise InvalidSignatureException, "Invalid webhook signature"
+        end
+
+        sig { params(signature_header: ::String).returns(::String) }
+        def extract_signature(signature_header)
+          if signature_header.start_with?(SIGNATURE_PREFIX)
+            T.must(signature_header[SIGNATURE_PREFIX.length..])
+          else
+            signature_header
+          end
+        end
+
+        sig { params(provided_signature: ::String, payload: ::String).returns(T::Boolean) }
+        def valid_signature?(provided_signature, payload)
+          @signing_secrets.any? do |secret|
+            expected_signature = self.class.create_signature(payload, secret)
+            constant_time_equals(expected_signature, provided_signature)
+          end
+        end
+
+        sig { params(left: ::String, right: ::String).returns(T::Boolean) }
+        def constant_time_equals(left, right)
+          max_length = [left.length, right.length].max
+          mismatch = left.length ^ right.length
+
+          (0...max_length).each do |index|
+            mismatch |= (left.getbyte(index) || 0) ^ (right.getbyte(index) || 0)
+          end
+
+          mismatch.zero?
+        end
+      end
+    end
+  end
+end