volcano-sdk 0.5.2

data/lib/volcano/generated_transport_auth.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Authentication operations for the internal generated transport.
+  class GeneratedTransport
+    MALFORMED_USER_PROFILE = 'Expected a complete user profile'
+    private_constant :MALFORMED_USER_PROFILE
+
+    def auth_signup(authorization:, email:, password:, metadata:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::AuthSignupRequest.new(
+          email: email,
+          password: password,
+          user_metadata: metadata
+        )
+        response(*apis.authentication.auth_signup_with_http_info(request))
+      end
+    end
+
+    def auth_signin(authorization:, email:, password:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        data, status, headers = apis.authentication.auth_signin_with_http_info(
+          Generated::AuthSigninRequest.new(email: email, password: password)
+        )
+        response(data, status, headers)
+      end
+    end
+
+    def auth_forgot_password(authorization:, email:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::AuthForgotPasswordRequest.new(email: email)
+        response(
+          *apis.authentication.auth_forgot_password_with_http_info(
+            request, debug_return_type: 'String'
+          )
+        )
+      end
+    end
+
+    def auth_reset_password(authorization:, token:, new_password:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::AuthResetPasswordRequest.new(token:, new_password:)
+        response(
+          *apis.authentication.auth_reset_password_with_http_info(
+            request, debug_return_type: 'String'
+          )
+        )
+      end
+    end
+
+    def auth_get_user(authorization:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        body, status, headers = apis.authentication.auth_get_user_with_http_info(
+          debug_return_type: 'String'
+        )
+        response(JSON.parse(body), status, headers)
+      end
+    rescue JSON::ParserError, TypeError => e
+      raise Error::AuthenticationError, MALFORMED_USER_PROFILE, cause: e
+    end
+
+    def auth_update_user(authorization:, password:, metadata:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        body, status, headers = apis.authentication.auth_update_user_with_http_info(
+          **update_user_options(password:, metadata:)
+        )
+        response(JSON.parse(body), status, headers)
+      end
+    rescue JSON::ParserError, TypeError => e
+      raise Error::AuthenticationError, MALFORMED_USER_PROFILE, cause: e
+    end
+
+    def auth_refresh(authorization:, refresh_token:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::AuthRefreshRequest.new(refresh_token: refresh_token)
+        response(*apis.authentication.auth_refresh_with_http_info(auth_refresh_request: request))
+      end
+    end
+
+    def auth_logout(authorization:, refresh_token:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::AuthRefreshRequest.new(refresh_token: refresh_token)
+        response(*apis.authentication.auth_logout_with_http_info(auth_refresh_request: request))
+      end
+    end
+
+    private
+
+    def update_user_options(password:, metadata:)
+      attributes = {}
+      attributes[:password] = password unless password.nil?
+      attributes[:user_metadata] = metadata unless metadata.nil?
+      {
+        auth_update_user_request: Generated::AuthUpdateUserRequest.new(attributes),
+        debug_body: attributes,
+        debug_return_type: 'String'
+      }
+    end
+  end
+end

data/lib/volcano/generated_transport_confirmation.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Email confirmation operations for the internal generated transport.
+  class GeneratedTransport
+    def auth_confirm_email(authorization:, token:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::AuthConfirmEmailRequest.new(token:)
+        response(
+          *apis.authentication.auth_confirm_email_with_http_info(
+            request, debug_return_type: 'String'
+          )
+        )
+      end
+    end
+
+    def auth_resend_confirmation(authorization:, email:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::AuthForgotPasswordRequest.new(email:)
+        response(
+          *apis.authentication.auth_resend_confirmation_with_http_info(
+            request, debug_return_type: 'String'
+          )
+        )
+      end
+    end
+  end
+end

data/lib/volcano/generated_transport_database.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Database operations for the internal generated transport.
+  class GeneratedTransport
+    def query_database_select(authorization:, database_name:, body:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::DatabaseSelectRequest.new(deep_symbolize(body))
+        data, status, headers = apis.database.query_database_select_with_http_info(
+          database_name,
+          request
+        )
+        response(data, status, headers)
+      end
+    end
+
+    def query_database_insert(authorization:, database_name:, body:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::DatabaseInsertRequest.new(deep_symbolize(body))
+        data, status, headers = apis.database.query_database_insert_with_http_info(
+          database_name,
+          request
+        )
+        response(data, status, headers)
+      end
+    end
+
+    def query_database_update(authorization:, database_name:, body:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::DatabaseUpdateRequest.new(deep_symbolize(body))
+        data, status, headers = apis.database.query_database_update_with_http_info(
+          database_name,
+          request
+        )
+        response(data, status, headers)
+      end
+    end
+
+    def query_database_delete(authorization:, database_name:, body:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::DatabaseDeleteRequest.new(deep_symbolize(body))
+        data, status, headers = apis.database.query_database_delete_with_http_info(
+          database_name,
+          request
+        )
+        response(data, status, headers)
+      end
+    end
+  end
+end

data/lib/volcano/generated_transport_email_change.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Email-change operations for the internal generated transport.
+  class GeneratedTransport
+    INVALID_EMAIL_CHANGE_RESPONSE = 'Expected a valid email-change acknowledgement'
+    private_constant :INVALID_EMAIL_CHANGE_RESPONSE
+
+    def auth_request_email_change(authorization:, new_email:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::AuthRequestEmailChangeRequest.new(new_email:)
+        data, status, headers = apis.authentication.auth_request_email_change_with_http_info(
+          request,
+          debug_return_type: 'String'
+        )
+        response(JSON.parse(data), status, headers)
+      end
+    rescue JSON::ParserError, TypeError => e
+      raise TypeError, INVALID_EMAIL_CHANGE_RESPONSE, cause: e
+    end
+
+    def auth_cancel_email_change(authorization:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        response(*apis.authentication.auth_cancel_email_change_with_http_info)
+      end
+    end
+
+    def auth_confirm_email_change(authorization:, token:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::AuthConfirmEmailChangeRequest.new(email_change_token: token)
+        body, status, headers = apis.authentication.auth_confirm_email_change_with_http_info(
+          request,
+          debug_return_type: 'String'
+        )
+        response(JSON.parse(body), status, headers)
+      end
+    rescue JSON::ParserError, TypeError => e
+      raise Error::AuthenticationError, MALFORMED_USER_PROFILE, cause: e
+    end
+  end
+end

data/lib/volcano/generated_transport_functions.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Preserves function-owned response bodies through the generated transport.
+  class GeneratedTransport
+    def resolve_function_for_invocation(authorization:, name:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        # Read the resolve body as JSON rather than the generated model: the
+        # model drops fields the vendored specification predates, and
+        # invoke_url is one of them.
+        data, status, headers = apis.functions.resolve_function_for_invocation_with_http_info(
+          name, debug_return_type: 'String'
+        )
+        response(resolve_body(data), status, headers)
+      end
+    end
+
+    def invoke_function(authorization:, function_id:, payload:)
+      invoke do
+        data, status, headers = function_http_response(authorization, function_id, payload)
+        response(function_body(data, headers), status, headers)
+      end
+    end
+
+    def invoke_function_url(authorization:, invoke_url:, payload:)
+      invoke do
+        data, status, headers = function_url_response(authorization, invoke_url, payload)
+        response(function_body(data, headers), status, headers)
+      end
+    end
+
+    private
+
+    def resolve_body(body)
+      return body unless body.is_a?(String)
+      return nil if body.empty?
+
+      JSON.parse(body)
+    rescue JSON::ParserError
+      nil
+    end
+
+    # The resolved endpoint is absolute and off the API host, so it cannot go
+    # through the generated client's configured base URL. The body still uses
+    # the invoke contract's { payload } envelope.
+    def function_url_response(authorization, invoke_url, payload)
+      request = Typhoeus::Request.new(
+        invoke_url,
+        method: :post,
+        body: JSON.generate(payload: payload),
+        headers: {
+          'Authorization' => "Bearer #{authorization}",
+          'Content-Type' => 'application/json',
+          'Accept' => 'application/json'
+        },
+        timeout: @timeout,
+        followlocation: false
+      )
+      result = request.run
+      raise Error::TransportError, (result.return_message || 'Volcano request failed') unless result.code.positive?
+
+      [result.body, result.code, result.headers || {}]
+    end
+
+    def function_http_response(authorization, function_id, payload)
+      apis = @api_factory.call(authorization)
+      request = Generated::FunctionInvocationRequest.new(payload: payload)
+      apis.functions.invoke_function_with_http_info(
+        function_id, request, follow_location: false, debug_return_type: 'String'
+      )
+    rescue Generated::ApiError => e
+      raise if e.code.to_i.zero?
+
+      [e.response_body, e.code.to_i, e.response_headers || {}]
+    end
+
+    def function_body(body, headers)
+      return nil if body.nil? || body.empty?
+
+      text = body.dup.force_encoding(Encoding::UTF_8).scrub.delete_prefix("\uFEFF")
+      return nil if text.empty?
+      return text unless function_json?(text, headers)
+
+      parsed = JSON.parse(text)
+      valid_function_encoding?(parsed) ? parsed : text
+    rescue JSON::ParserError
+      text
+    end
+
+    def valid_function_encoding?(value)
+      case value
+      when Hash then value.all? { |key, item| valid_function_encoding?(key) && valid_function_encoding?(item) }
+      when Array then value.all? { |item| valid_function_encoding?(item) }
+      when String then value.valid_encoding?
+      else true
+      end
+    end
+
+    def function_json?(text, headers)
+      return true if text.start_with?('{', '[')
+
+      headers.to_h.any? do |key, value|
+        key.casecmp?('Content-Type') && value.to_s.downcase.include?('application/json')
+      end
+    end
+  end
+end

data/lib/volcano/generated_transport_logs.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Volcano
+  class GeneratedTransport
+    # Generated OpenAPI operations used by the public logs facade.
+    module LogTransport
+      def search_project_logs(authorization:, project_id:, request:)
+        invoke do
+          apis = @api_factory.call(authorization)
+          body = Generated::LogSearchRequest.new(deep_symbolize(request))
+          data, status, headers = apis.logs.search_project_logs_with_http_info(
+            project_id, body, debug_return_type: 'String'
+          )
+          response(parse_body(data), status, headers)
+        end
+      end
+
+      def get_project_log_activity(authorization:, project_id:, request:)
+        invoke do
+          apis = @api_factory.call(authorization)
+          body = Generated::LogActivityRequest.new(deep_symbolize(request))
+          data, status, headers = apis.logs.get_project_log_activity_with_http_info(
+            project_id, body, debug_return_type: 'String'
+          )
+          response(parse_body(data), status, headers)
+        end
+      end
+    end
+    private_constant :LogTransport
+  end
+end

data/lib/volcano/generated_transport_oauth.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Volcano
+  # OAuth operations for the internal generated transport.
+  class GeneratedTransport
+    def auth_oauth_authorization_url(anon_key:, provider:, redirect_url:, client_state:)
+      oauth_authorization_api.auth_o_auth_authorize_with_http_info(
+        provider, anon_key,
+        redirect_url:, client_state:, response_mode: 'code'
+      ).first
+    end
+
+    def auth_oauth_exchange(authorization:, code:, redirect_url:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::AuthOAuthExchangeRequest.new(code:, redirect_url:)
+        response(*apis.oauth.auth_o_auth_exchange_with_http_info(request))
+      end
+    end
+
+    def auth_link_oauth_provider(authorization:, provider:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        response(*apis.oauth.auth_link_o_auth_provider_with_http_info(provider))
+      end
+    end
+
+    def auth_list_oauth_providers(authorization:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        response(*apis.oauth.auth_list_o_auth_providers_with_http_info)
+      end
+    end
+
+    def auth_unlink_oauth_provider(authorization:, provider:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        response(*apis.oauth.auth_unlink_o_auth_provider_with_http_info(provider))
+      end
+    end
+
+    def auth_get_oauth_provider_token(authorization:, provider:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        response(*apis.oauth.get_o_auth_provider_token_with_http_info(provider))
+      end
+    end
+
+    def auth_refresh_oauth_provider_token(authorization:, provider:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        response(*apis.oauth.refresh_o_auth_provider_token_with_http_info(provider))
+      end
+    end
+
+    def auth_call_oauth_api(authorization:, provider:, endpoint:, method:, body:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::CallOAuthProviderAPIRequest.new(endpoint:, method:, body:)
+        response(*apis.oauth.call_o_auth_provider_api_with_http_info(provider, request))
+      end
+    end
+  end
+end

data/lib/volcano/generated_transport_sessions.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Session-management operations for the internal generated transport.
+  class GeneratedTransport
+    def auth_get_my_sessions(authorization:, page:, limit:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        response(*apis.authentication.auth_get_my_sessions_with_http_info(page: page, limit: limit))
+      end
+    end
+
+    def auth_delete_all_my_sessions(authorization:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        response(*apis.authentication.auth_delete_all_my_sessions_with_http_info)
+      end
+    end
+
+    def auth_delete_my_session(authorization:, session_id:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        response(*apis.authentication.auth_delete_my_session_with_http_info(session_id))
+      end
+    end
+  end
+end

data/lib/volcano/generated_transport_storage.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Storage operations for the internal generated transport.
+  class GeneratedTransport
+    def upload_storage_object(authorization:, bucket_name:, path:, data:, content_type: nil)
+      invoke do
+        apis = @api_factory.call(authorization)
+        with_upload_file(path, data) do |file|
+          options = { content_type: content_type }.compact
+          result = apis.storage.upload_storage_object_with_http_info(bucket_name, path, file, options)
+          data_value, status, headers = result
+          return response(data_value, status, headers)
+        end
+      end
+    end
+
+    def download_storage_object(authorization:, bucket_name:, path:, byte_range: nil)
+      invoke do
+        apis = @api_factory.call(authorization)
+        options = { range: byte_range }.compact
+        data, status, headers = apis.storage.download_storage_object_with_http_info(
+          bucket_name, path, options
+        )
+        response(nil, status, headers, binary: binary_data(data))
+      end
+    end
+
+    def list_storage_objects(authorization:, bucket_name:, prefix:, limit:, cursor:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        options = { prefix: prefix.empty? ? nil : prefix, limit: limit, cursor: cursor }.compact
+        data, status, headers = apis.storage.list_storage_objects_with_http_info(bucket_name, options)
+        response(data, status, headers)
+      end
+    end
+
+    def delete_storage_object(authorization:, bucket_name:, path:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        data, status, headers = apis.storage.delete_storage_object_with_http_info(bucket_name, path)
+        response(data, status, headers)
+      end
+    end
+
+    def move_storage_object(authorization:, bucket_name:, from_path:, to_path:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::StorageMoveRequest.new(from: from_path, to: to_path)
+        data, status, headers = apis.storage.move_storage_object_with_http_info(bucket_name, request)
+        response(data, status, headers)
+      end
+    end
+
+    def copy_storage_object(authorization:, bucket_name:, from_path:, to_path:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::StorageCopyRequest.new(from: from_path, to: to_path)
+        data, status, headers = apis.storage.copy_storage_object_with_http_info(bucket_name, request)
+        response(data, status, headers)
+      end
+    end
+
+    def update_storage_object_visibility(authorization:, bucket_name:, path:, is_public:)
+      invoke do
+        apis = @api_factory.call(authorization)
+        request = Generated::StorageVisibilityRequest.new(is_public: is_public)
+        result = apis.storage.update_storage_object_visibility_with_http_info(
+          bucket_name, path, request
+        )
+        data, status, headers = result
+        response(data, status, headers)
+      end
+    end
+
+    private
+
+    def with_upload_file(path, data)
+      Tempfile.create(['volcano-sdk-upload', File.extname(path)], binmode: true) do |file|
+        file.write(data)
+        file.flush
+        yield file
+      end
+    end
+  end
+end