cloudinary-account-provisioning 0.1.0

data/lib/cld_provisioning/sdk_hooks/account_config.rb

@@ -0,0 +1,62 @@
+# typed: true
+# frozen_string_literal: true
+
+require "uri"
+
+module CldProvisioning
+  module SDKHooks
+    # Parses Cloudinary account configuration from CLOUDINARY_ACCOUNT_URL
+    # or individual CLOUDINARY_ACCOUNT_* environment variables.
+    #
+    # URL format: account://<provisioning_api_key>:<provisioning_api_secret>@<account_id>
+    class AccountConfig
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :account_id
+
+      sig { returns(String) }
+      attr_reader :provisioning_api_key
+
+      sig { returns(String) }
+      attr_reader :provisioning_api_secret
+
+      sig { void }
+      def initialize
+        @account_id = T.let("", String)
+        @provisioning_api_key = T.let("", String)
+        @provisioning_api_secret = T.let("", String)
+
+        account_url = ENV["CLOUDINARY_ACCOUNT_URL"]
+        load_from_url(account_url) if account_url && !account_url.empty?
+
+        override_from_env("CLOUDINARY_ACCOUNT_ID") { |v| @account_id = v }
+        override_from_env("CLOUDINARY_PROVISIONING_API_KEY") { |v| @provisioning_api_key = v }
+        override_from_env("CLOUDINARY_PROVISIONING_API_SECRET") { |v| @provisioning_api_secret = v }
+      end
+
+      private
+
+      sig { params(name: String, block: T.proc.params(value: String).void).void }
+      def override_from_env(name, &block)
+        value = ENV[name]
+        block.call(value) if value && !value.empty?
+      end
+
+      sig { params(url: String).void }
+      def load_from_url(url)
+        unless url.start_with?("account://")
+          raise ArgumentError, "Invalid CLOUDINARY_ACCOUNT_URL scheme. Expecting 'account://'"
+        end
+
+        # Replace custom scheme with http:// so URI can parse it
+        parsed = URI.parse(url.sub("account://", "http://"))
+        @account_id = parsed.host || ""
+        @provisioning_api_key = parsed.user ? URI.decode_www_form_component(T.must(parsed.user)) : ""
+        @provisioning_api_secret = parsed.password ? URI.decode_www_form_component(T.must(parsed.password)) : ""
+      rescue URI::InvalidURIError => e
+        raise ArgumentError, "Invalid CLOUDINARY_ACCOUNT_URL: '#{url}' (#{e.message})"
+      end
+    end
+  end
+end

data/lib/cld_provisioning/sdk_hooks/cloudinary_account_hook.rb

@@ -0,0 +1,87 @@
+# typed: true
+# frozen_string_literal: true
+
+require "base64"
+require_relative "types"
+require_relative "account_config"
+
+module CldProvisioning
+  module SDKHooks
+    # Populates account_id from CLOUDINARY_ACCOUNT_URL on init, and
+    # attaches Basic auth (provisioning_api_key:provisioning_api_secret) to every request.
+    #
+    # Credential resolution order:
+    #   1. Explicit security passed to the SDK constructor
+    #   2. CLOUDINARY_ACCOUNT_URL / individual CLOUDINARY_ACCOUNT_* env vars
+    class CloudinaryAccountHook < AbstractSDKHook
+      extend T::Sig
+
+      sig { params(config: AccountConfig).void }
+      def initialize(config:)
+        @config = T.let(config, AccountConfig)
+      end
+
+      sig { override.params(config: SDKConfiguration).returns(SDKConfiguration) }
+      def sdk_init(config:)
+        account_id = config.globals.dig(:parameters, :pathParam, :account_id)
+        if (account_id.nil? || (account_id.is_a?(String) && account_id.empty?)) && !@config.account_id.empty?
+          config.globals[:parameters] ||= {}
+          params = T.must(config.globals[:parameters])
+          params[:pathParam] ||= {}
+          T.must(params[:pathParam])[:account_id] = @config.account_id
+        end
+
+        config
+      end
+
+      sig { override.params(hook_ctx: BeforeRequestHookContext, request: Faraday::Request).returns(Faraday::Request) }
+      def before_request(hook_ctx:, request:)
+        key, secret = resolve_credentials(hook_ctx)
+
+        if key.empty? || secret.empty?
+          raise "Provisioning API key and secret are required"
+        end
+
+        encoded = Base64.strict_encode64("#{key}:#{secret}")
+        request.headers["Authorization"] = "Basic #{encoded}"
+
+        request
+      end
+
+      private
+
+      sig { params(hook_ctx: BeforeRequestHookContext).returns([String, String]) }
+      def resolve_credentials(hook_ctx)
+        key = @config.provisioning_api_key
+        secret = @config.provisioning_api_secret
+
+        security = resolve_security(hook_ctx.security_source)
+        return [key, secret] unless security
+
+        if security.is_a?(Models::Shared::Security)
+          key = security.provisioning_api_key unless security.provisioning_api_key.empty?
+          secret = security.provisioning_api_secret unless security.provisioning_api_secret.empty?
+        elsif security.is_a?(Hash)
+          sym_sec = security.transform_keys(&:to_sym)
+          if sym_sec[:cloudinary_account_auth]
+            auth = sym_sec[:cloudinary_account_auth]
+            auth = auth.transform_keys(&:to_sym) if auth.is_a?(Hash)
+            key = auth[:provisioning_api_key] || key if auth.is_a?(Hash)
+            secret = auth[:provisioning_api_secret] || secret if auth.is_a?(Hash)
+          elsif sym_sec[:provisioning_api_key] || sym_sec[:provisioning_api_secret]
+            key = sym_sec[:provisioning_api_key] || key
+            secret = sym_sec[:provisioning_api_secret] || secret
+          end
+        end
+
+        [key.to_s, secret.to_s]
+      end
+
+      sig { params(source: T.untyped).returns(T.untyped) }
+      def resolve_security(source)
+        return nil if source.nil?
+        source.is_a?(Proc) ? source.call : source
+      end
+    end
+  end
+end

data/lib/cld_provisioning/sdk_hooks/hooks.rb

@@ -0,0 +1,100 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+# @generated-id: 6e5371ea4ac4
+
+# typed: true
+# frozen_string_literal: true
+
+require_relative "./types"
+require_relative "./registration"
+
+module CldProvisioning
+  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/cld_provisioning/sdk_hooks/registration.rb

@@ -0,0 +1,37 @@
+# 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 "./account_config"
+require_relative "./cloudinary_account_hook"
+require_relative "./user_agent_hook"
+
+module CldProvisioning
+  module SDKHooks
+    class Registration
+      extend T::Sig
+
+      sig do
+        params(
+          hooks: Hooks
+        )
+          .void
+      end
+      def self.init_hooks(hooks)
+        config = AccountConfig.new
+        account_hook = CloudinaryAccountHook.new(config: config)
+
+        hooks.register_sdk_init_hook(account_hook)
+        hooks.register_before_request_hook(account_hook)
+        hooks.register_sdk_init_hook(UserAgentHook.new)
+      end
+    end
+  end
+end

data/lib/cld_provisioning/sdk_hooks/types.rb

@@ -0,0 +1,181 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+# @generated-id: 8763a28f50e9
+
+# typed: true
+# frozen_string_literal: true
+
+require_relative "../sdkconfiguration"
+
+module CldProvisioning
+  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/cld_provisioning/sdk_hooks/user_agent_hook.rb

@@ -0,0 +1,35 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "types"
+
+module CldProvisioning
+  module SDKHooks
+    # Replaces the default Speakeasy user-agent with a Cloudinary-branded one.
+    #
+    # Format: Cloudinary/AccountProvisioning Ruby/<sdkVersion> Gen/<genVersion> Schema/<schemaVersion> (<system info>)
+    class UserAgentHook < AbstractSDKHook
+      extend T::Sig
+
+      sig { override.params(config: SDKConfiguration).returns(SDKConfiguration) }
+      def sdk_init(config:)
+        original = config.user_agent
+        return config unless original.start_with?("speakeasy-sdk/")
+
+        parts = original.split(" ", 5)
+        return config if parts.length < 5
+
+        sdk_version = parts[1]
+        gen_version = parts[2]
+        schema_version = parts[3]
+
+        ruby_version = RUBY_VERSION
+        platform = RUBY_PLATFORM
+
+        config.user_agent = "Cloudinary/AccountProvisioning Ruby/#{sdk_version} Gen/#{gen_version} Schema/#{schema_version} (Ruby #{ruby_version}; #{platform})"
+
+        config
+      end
+    end
+  end
+end

data/lib/cld_provisioning/sdkconfiguration.rb

@@ -0,0 +1,133 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+# @generated-id: dd52a8954d2e
+
+# 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 CldProvisioning
+  extend T::Sig
+
+  SERVERS = T.let(
+    [
+      # 1 - Regional API endpoints for optimal performance.
+      "https://{region}.cloudinary.com",
+      # 1 - Custom domains for enterprise deployments.
+      "https://{host}"
+    ].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(::CldProvisioning::SDKHooks::Hooks) }
+    attr_accessor :hooks
+
+    sig { returns(T.nilable(::CldProvisioning::Utils::RetryConfig)) }
+    attr_accessor :retry_config
+
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    sig { returns(T.nilable(T.proc.returns(T.nilable(Models::Shared::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::Array[T::Hash[Symbol, String]]) }
+    attr_accessor :server_params
+
+    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: ::CldProvisioning::SDKHooks::Hooks,
+        retry_config: T.nilable(::CldProvisioning::Utils::RetryConfig),
+        timeout_ms: T.nilable(Integer),
+        security: T.nilable(Models::Shared::Security),
+        security_source: T.nilable(T.proc.returns(Models::Shared::Security)),
+        server_url: T.nilable(String),
+        server_idx: T.nilable(Integer),
+        server_params: T::Array[T::Hash[Symbol, String]],
+        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,
+      server_params,
+      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
+
+      @server_params = server_params
+      if !security_source.nil?
+        @security_source = security_source
+      elsif !security.nil?
+        @security_source = -> { security }
+      end
+
+      @globals = globals.nil? ? {} : globals
+      @language = "ruby"
+      @openapi_doc_version = "0.2.1"
+      @sdk_version = "0.1.0"
+      @gen_version = "2.881.17"
+      @user_agent = "speakeasy-sdk/ruby 0.1.0 2.881.17 0.2.1 cloudinary-account-provisioning"
+    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]), T.must(@server_params[@server_idx])]
+    end
+  end
+end