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

data/lib/mollie/sdk_hooks/global_usage.rb

@@ -0,0 +1,54 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mollie
+  module SDKHooks
+    # Maps global fields to the operation IDs that accept them in the request body.
+    GLOBAL_USAGE = T.let(
+      {
+        profile_id: %w[
+          create-payment
+          release-authorization
+          create-session
+          request-apple-pay-payment-session
+          create-payment-link
+          create-customer-payment
+          create-subscription
+          create-sales-invoice
+        ].freeze,
+        testmode: %w[
+          create-webhook
+          update-webhook
+          delete-webhook
+          test-webhook
+          create-connect-balance-transfer
+          create-payment
+          update-payment
+          cancel-payment
+          release-authorization
+          create-session
+          create-refund
+          create-payment-link
+          update-payment-link
+          delete-payment-link
+          create-customer
+          update-customer
+          delete-customer
+          create-customer-payment
+          create-mandate
+          revoke-mandate
+          create-subscription
+          update-subscription
+          cancel-subscription
+          create-sales-invoice
+          update-sales-invoice
+          delete-sales-invoice
+          create-transfer
+          verify-payee
+        ].freeze,
+        custom_user_agent: [].freeze
+      }.freeze,
+      T::Hash[Symbol, T::Array[String]]
+    )
+  end
+end

data/lib/mollie/sdk_hooks/hooks.rb

@@ -0,0 +1,99 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require_relative "./types"
+require_relative "./registration"
+
+module Mollie
+  module SDKHooks
+    class Hooks
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        @sdk_init_hooks = T.let([], T::Array[AbstractSDKHook])
+        @before_request_hooks = T.let([], T::Array[AbstractSDKHook])
+        @after_success_hooks = T.let([], T::Array[AbstractSDKHook])
+        @after_error_hooks = T.let([], T::Array[AbstractSDKHook])
+        Registration.init_hooks(self)
+      end
+
+      sig { params(hook: AbstractSDKHook).void }
+      def register_sdk_init_hook(hook)
+        @sdk_init_hooks << hook
+      end
+
+      sig { params(hook: AbstractSDKHook).void }
+      def register_before_request_hook(hook)
+        @before_request_hooks << hook
+      end
+
+      sig { params(hook: AbstractSDKHook).void }
+      def register_after_success_hook(hook)
+        @after_success_hooks << hook
+      end
+
+      sig { params(hook: AbstractSDKHook).void }
+      def register_after_error_hook(hook)
+        @after_error_hooks << hook
+      end
+
+      sig { params(config: SDKConfiguration).returns(SDKConfiguration) }
+      def sdk_init(config:)
+        @sdk_init_hooks.each do |hook|
+          config = hook.sdk_init(config: config)
+        end
+
+        return config
+      end
+
+      sig do
+        params(
+          hook_ctx: BeforeRequestHookContext,
+          request: Faraday::Request
+        )
+          .returns(Faraday::Request)
+      end
+      def before_request(hook_ctx:, request:)
+        @before_request_hooks.each do |hook|
+          request = hook.before_request(hook_ctx: hook_ctx, request: request)
+        end
+
+        request
+      end
+
+      sig do
+        params(
+          hook_ctx: AfterSuccessHookContext,
+          response: Faraday::Response
+        )
+          .returns(Faraday::Response)
+      end
+      def after_success(hook_ctx:, response:)
+        @after_success_hooks.each do |hook|
+          response = hook.after_success(hook_ctx: hook_ctx, response: response)
+        end
+
+        response
+      end
+
+      sig do
+        params(
+          error: T.nilable(::StandardError),
+          hook_ctx: AfterErrorHookContext,
+          response: T.nilable(Faraday::Response)
+        )
+          .returns(T.nilable(Faraday::Response))
+      end
+      def after_error(error:, hook_ctx:, response:)
+        @after_error_hooks.each do |hook|
+          response = hook.after_error(error: error, hook_ctx: hook_ctx, response: response)
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/mollie/sdk_hooks/mollie_auth_utils.rb

@@ -0,0 +1,28 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mollie
+  module SDKHooks
+    module MollieAuthUtils
+      extend T::Sig
+
+      # Organization-level credentials (advanced access tokens, OAuth tokens) are prefixed
+      # with "access_". Global fields like profile_id/testmode may only be injected into
+      # request bodies when such a credential is configured.
+      sig { params(security: T.untyped).returns(T::Boolean) }
+      def self.client_can_have_global_fields?(security)
+        return false if security.nil?
+
+        token = security.api_key || security.advanced_access_token || security.o_auth
+        return false if token.nil?
+
+        token.start_with?("access_")
+      end
+
+      sig { params(profile_id: T.nilable(::String), testmode: T.nilable(T::Boolean)).returns(T::Boolean) }
+      def self.client_has_global_fields?(profile_id, testmode)
+        testmode == true || !profile_id.nil?
+      end
+    end
+  end
+end

data/lib/mollie/sdk_hooks/mollie_hooks.rb

@@ -0,0 +1,118 @@
+# typed: true
+# frozen_string_literal: true
+
+require "securerandom"
+require "json"
+require "uri"
+
+require_relative "./types"
+require_relative "./global_usage"
+require_relative "./mollie_auth_utils"
+
+module Mollie
+  module SDKHooks
+    class MollieHooks < AbstractSDKHook
+      extend T::Sig
+
+      GLOBAL_FIELD_WIRE_NAMES = T.let(
+        { profile_id: "profileId", testmode: "testmode" }.freeze,
+        T::Hash[Symbol, String]
+      )
+
+      sig do
+        override
+          .params(
+            hook_ctx: BeforeRequestHookContext,
+            request: Faraday::Request
+          )
+          .returns(Faraday::Request)
+      end
+      def before_request(hook_ctx:, request:)
+        validate_path_parameters(request)
+        handle_idempotency_key(request)
+        customize_user_agent(request, hook_ctx)
+
+        security = hook_ctx.security_source&.call
+        inject_global_fields(request, hook_ctx) if MollieAuthUtils.client_can_have_global_fields?(security)
+
+        request
+      end
+
+      private
+
+      sig { params(request: Faraday::Request).void }
+      def validate_path_parameters(request)
+        path = T.must(URI.parse(request.path.to_s).path)
+        segments = path.split("/", -1)
+
+        segments.each_with_index do |segment, index|
+          next if index.zero? && segment.empty?
+
+          next unless segment.nil? || segment.strip.empty?
+
+          Kernel.raise StandardError,
+                       "Invalid request: empty path parameter detected in [#{request.http_method.to_s.upcase}] '#{path}'"
+        end
+      end
+
+      sig { params(request: Faraday::Request).void }
+      def handle_idempotency_key(request)
+        existing = request.headers["Idempotency-Key"]
+        return if existing && !existing.to_s.empty?
+
+        request.headers["Idempotency-Key"] = SecureRandom.uuid
+      end
+
+      sig { params(request: Faraday::Request, hook_ctx: BeforeRequestHookContext).void }
+      def customize_user_agent(request, hook_ctx)
+        config = hook_ctx.config
+        custom_user_agent = config.globals.dig(:parameters, :header, :custom_user_agent)
+        package_name = config.user_agent.to_s.split(" ").last
+
+        mollie_user_agent = "Speakeasy/#{config.gen_version} Ruby/#{RUBY_VERSION} #{package_name}/#{config.sdk_version}"
+        mollie_user_agent = "#{mollie_user_agent} #{custom_user_agent}" if custom_user_agent && !custom_user_agent.to_s.empty?
+
+        request.headers["User-Agent"] = mollie_user_agent
+      end
+
+      sig { params(request: Faraday::Request, hook_ctx: BeforeRequestHookContext).void }
+      def inject_global_fields(request, hook_ctx)
+        operation_id = hook_ctx.operation_id
+        config = hook_ctx.config
+
+        field_values = {
+          profile_id: config.globals.dig(:parameters, :queryParam, :profile_id),
+          testmode: config.globals.dig(:parameters, :queryParam, :testmode)
+        }
+
+        fields_to_inject = {}
+        GLOBAL_USAGE.each do |field, operations|
+          next unless operations.include?(operation_id)
+
+          value = field_values[field]
+          next if value.nil?
+
+          fields_to_inject[GLOBAL_FIELD_WIRE_NAMES.fetch(field, field.to_s)] = value
+        end
+
+        return if fields_to_inject.empty?
+
+        body = request.body
+        return if body.nil? || body.to_s.empty?
+
+        begin
+          parsed_body = JSON.parse(T.cast(body, String))
+        rescue JSON::ParserError
+          return
+        end
+        return unless parsed_body.is_a?(Hash)
+
+        fields_to_inject.each do |key, value|
+          parsed_body[key] = value unless parsed_body.key?(key)
+        end
+
+        request.body = JSON.generate(parsed_body)
+      end
+    end
+  end
+end

data/lib/mollie/sdk_hooks/registration.rb

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+#
+# This file is only ever generated once on the first generation and then is free to be modified.
+# Any hooks you wish to add should be registered in the init_hooks method.
+#
+# Hooks are registered per SDK instance, and are valid for the lifetime of the SDK instance.
+#
+
+require_relative "./types"
+require_relative "./mollie_hooks"
+
+module Mollie
+  module SDKHooks
+    class Registration
+      extend T::Sig
+
+      sig do
+        params(
+          hooks: Hooks
+        )
+          .void
+      end
+      def self.init_hooks(hooks)
+        mollie_hooks = MollieHooks.new
+
+        hooks.register_before_request_hook mollie_hooks
+      end
+    end
+  end
+end

data/lib/mollie/sdk_hooks/types.rb

@@ -0,0 +1,180 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require_relative "../sdkconfiguration"
+
+module Mollie
+  module SDKHooks
+    class HookContext
+      extend T::Sig
+
+      sig { returns(SDKConfiguration) }
+      attr_accessor :config
+
+      sig { returns(::String) }
+      attr_accessor :base_url
+
+      sig { returns(T.nilable(T::Array[::String])) }
+      attr_accessor :oauth2_scopes
+
+      sig { returns(::String) }
+      attr_accessor :operation_id
+
+      sig { returns(T.nilable(T.proc.returns(T.untyped))) }
+      attr_accessor :security_source
+
+      sig do
+        params(
+          config: SDKConfiguration,
+          base_url: ::String,
+          oauth2_scopes: T.nilable(T::Array[::String]),
+          operation_id: ::String,
+          security_source: T.nilable(T.proc.returns(T.untyped))
+        )
+          .void
+      end
+      def initialize(config:, base_url:, oauth2_scopes:, operation_id:, security_source:)
+        @config = T.let(config, SDKConfiguration)
+        @base_url = T.let(base_url, ::String)
+        @oauth2_scopes = T.let(oauth2_scopes, T.nilable(T::Array[::String]))
+        @operation_id = T.let(operation_id, ::String)
+        @security_source = T.let(security_source, T.nilable(T.proc.returns(T.untyped)))
+      end
+    end
+
+    class BeforeRequestHookContext < HookContext
+      extend T::Sig
+
+      sig do
+        params(
+          hook_ctx: HookContext
+        )
+          .void
+      end
+      def initialize(hook_ctx:)
+        super(
+          config: hook_ctx.config,
+          base_url: hook_ctx.base_url,
+          operation_id: hook_ctx.operation_id,
+          oauth2_scopes: hook_ctx.oauth2_scopes,
+          security_source: hook_ctx.security_source
+        )
+      end
+    end
+
+    class AfterSuccessHookContext < HookContext
+      extend T::Sig
+
+      sig do
+        params(
+          hook_ctx: HookContext
+        )
+          .void
+      end
+      def initialize(hook_ctx:)
+        super(
+          config: hook_ctx.config,
+          base_url: hook_ctx.base_url,
+          operation_id: hook_ctx.operation_id,
+          oauth2_scopes: hook_ctx.oauth2_scopes,
+          security_source: hook_ctx.security_source
+        )
+      end
+    end
+
+    class AfterErrorHookContext < HookContext
+      extend T::Sig
+
+      sig do
+        params(
+          hook_ctx: HookContext
+        )
+          .void
+      end
+      def initialize(hook_ctx:)
+        super(
+          config: hook_ctx.config,
+          base_url: hook_ctx.base_url,
+          operation_id: hook_ctx.operation_id,
+          oauth2_scopes: hook_ctx.oauth2_scopes,
+          security_source: hook_ctx.security_source
+        )
+      end
+    end
+
+    module AbstractSDKInitHook
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      sig { overridable.params(config: SDKConfiguration).returns(SDKConfiguration) }
+      def sdk_init(config:)
+        ::Kernel.raise ::NotImplementedError.new
+      end
+    end
+
+    module AbstractBeforeRequestHook
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      sig do
+        overridable
+          .params(
+            hook_ctx: BeforeRequestHookContext,
+            request: Faraday::Request
+          )
+          .returns(Faraday::Request)
+      end
+      def before_request(hook_ctx:, request:)
+        ::Kernel.raise ::NotImplementedError.new
+      end
+    end
+
+    module AbstractAfterSuccessHook
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      sig do
+        overridable
+          .params(
+            hook_ctx: AfterSuccessHookContext,
+            response: Faraday::Response
+          )
+          .returns(Faraday::Response)
+      end
+      def after_success(hook_ctx:, response:)
+        ::Kernel.raise ::NotImplementedError.new
+      end
+    end
+
+    module AbstractAfterErrorHook
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      sig do
+        overridable
+          .params(
+            error: T.nilable(::StandardError),
+            hook_ctx: AfterErrorHookContext,
+            response: T.nilable(Faraday::Response)
+          )
+          .returns(T.nilable(Faraday::Response))
+      end
+      def after_error(error:, hook_ctx:, response:)
+        ::Kernel.raise ::NotImplementedError.new
+      end
+    end
+
+    class AbstractSDKHook
+      include AbstractSDKInitHook
+      include AbstractBeforeRequestHook
+      include AbstractAfterSuccessHook
+      include AbstractAfterErrorHook
+    end
+  end
+end

data/lib/mollie/sdkconfiguration.rb

@@ -0,0 +1,113 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/multipart"
+require "faraday/retry"
+require "sorbet-runtime"
+
+require_relative "sdk_hooks/hooks"
+require_relative "utils/retries"
+
+module Mollie
+  extend T::Sig
+
+  SERVERS = T.let(
+    [
+      "https://api.mollie.com"
+    ].freeze,
+    T::Array[::String]
+  )
+  # Contains the list of servers available to the SDK
+
+  class SDKConfiguration
+    extend T::Sig
+
+    sig { returns(T.nilable(Faraday::Connection)) }
+    attr_accessor :client
+
+    sig { returns(::Mollie::SDKHooks::Hooks) }
+    attr_accessor :hooks
+
+    sig { returns(T.nilable(::Mollie::Utils::RetryConfig)) }
+    attr_accessor :retry_config
+
+    sig { returns(T.nilable(::Float)) }
+    attr_accessor :timeout
+
+    sig { returns(T.nilable(T.proc.returns(T.nilable(Models::Components::Security)))) }
+    attr_accessor :security_source
+
+    sig { returns(T.nilable(::String)) }
+    attr_accessor :server_url
+
+    sig { returns(T.nilable(::Integer)) }
+    attr_accessor :server_idx
+
+    sig { returns(T::Hash[::Symbol, T::Hash[::Symbol, T::Hash[::Symbol, ::Object]]]) }
+    attr_accessor :globals
+
+    sig { returns(::String) }
+    attr_accessor :language
+
+    sig { returns(::String) }
+    attr_accessor :openapi_doc_version
+
+    sig { returns(::String) }
+    attr_accessor :sdk_version
+
+    sig { returns(::String) }
+    attr_accessor :gen_version
+
+    sig { returns(::String) }
+    attr_accessor :user_agent
+
+    sig do
+      params(
+        client: T.nilable(Faraday::Connection),
+        hooks: ::Mollie::SDKHooks::Hooks,
+        retry_config: T.nilable(::Mollie::Utils::RetryConfig),
+        timeout_ms: T.nilable(::Integer),
+        security: T.nilable(Models::Components::Security),
+        security_source: T.nilable(T.proc.returns(Models::Components::Security)),
+        server_url: T.nilable(::String),
+        server_idx: T.nilable(::Integer),
+        globals: T.nilable(T::Hash[::Symbol, T::Hash[::Symbol, T::Hash[::Symbol, ::Object]]])
+      )
+        .void
+    end
+    def initialize(client, hooks, retry_config, timeout_ms, security, security_source, server_url, server_idx, globals)
+      @client = client
+      @hooks = hooks
+      @retry_config = retry_config
+      @server_url = server_url
+      @timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      @server_idx = server_idx.nil? ? 0 : server_idx
+      if @server_idx.negative? || @server_idx >= SERVERS.length
+        raise ::StandardError, "Invalid server index #{server_idx}"
+      end
+
+      if !security_source.nil?
+        @security_source = security_source
+      elsif !security.nil?
+        @security_source = -> { security }
+      end
+
+      @globals = globals.nil? ? {} : globals
+      @language = "ruby"
+      @openapi_doc_version = "1.0.0"
+      @sdk_version = "0.0.1-alpha.9"
+      @gen_version = "2.961.1"
+      @user_agent = "speakeasy-sdk/ruby 0.0.1-alpha.9 2.961.1 1.0.0 mollie-ruby-sdk"
+    end
+
+    sig { returns([::String, T::Hash[::Symbol, ::String]]) }
+    def get_server_details
+      return [@server_url.delete_suffix("/"), {}] if !@server_url.nil?
+      @server_idx = T.must(@server_idx)
+      [T.must(SERVERS[@server_idx]), {}]
+    end
+  end
+end

data/lib/mollie/sdkconfiguration.rbi

@@ -0,0 +1,89 @@
+# typed: true
+
+class Mollie::SDKConfiguration
+  extend ::Crystalline::MetadataFields::ClassMethods
+
+  def client
+  end
+
+  def client=(client)
+  end
+
+  def gen_version
+  end
+
+  def gen_version=(gen_version)
+  end
+
+  def globals
+  end
+
+  def globals=(globals)
+  end
+
+  def hooks
+  end
+
+  def hooks=(hooks)
+  end
+
+  def language
+  end
+
+  def language=(language)
+  end
+
+  def openapi_doc_version
+  end
+
+  def openapi_doc_version=(openapi_doc_version)
+  end
+
+  def retry_config
+  end
+
+  def retry_config=(retry_config)
+  end
+
+  def sdk_version
+  end
+
+  def sdk_version=(sdk_version)
+  end
+
+  def security_source
+  end
+
+  def security_source=(security_source)
+  end
+
+  def server_idx
+  end
+
+  def server_idx=(server_idx)
+  end
+
+  def server_params
+  end
+
+  def server_params=(server_params)
+  end
+
+  def server_url
+  end
+
+  def server_url=(server_url)
+  end
+
+  def timeout
+  end
+
+  def timeout=(timeout)
+  end
+
+  def user_agent
+  end
+
+  def user_agent=(user_agent)
+  end
+end