galaxy-ruby 0.2.0

data/lib/galaxy-ruby/resources/planets.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module ScalarGalaxy
+  module Resources
+    # Everything about planets
+    class Planets
+      # Time to play god and create a new planet. What do you think? Ah, don't think too
+      # much. What could go wrong anyway?
+      #
+      # @overload create(id:, name:, atmosphere: nil, creator: nil, description: nil, discovered_at: nil, failure_callback_url: nil, habitability_index: nil, image: nil, last_updated: nil, physical_properties: nil, satellites: nil, success_callback_url: nil, tags: nil, type: nil, request_options: {})
+      #
+      # @param id [Integer]
+      #
+      # @param name [String]
+      #
+      # @param atmosphere [Array<ScalarGalaxy::Models::Planet::Atmosphere>] Atmospheric composition
+      #
+      # @param creator [ScalarGalaxy::Models::User] A user
+      #
+      # @param description [String, nil]
+      #
+      # @param discovered_at [Time]
+      #
+      # @param failure_callback_url [String] URL which gets invoked upon a failed operation
+      #
+      # @param habitability_index [Float] A score from 0 to 1 indicating potential habitability
+      #
+      # @param image [String, nil]
+      #
+      # @param last_updated [Time]
+      #
+      # @param physical_properties [ScalarGalaxy::Models::Planet::PhysicalProperties]
+      #
+      # @param satellites [Array<Object>]
+      #
+      # @param success_callback_url [String] URL which gets invoked upon a successful operation
+      #
+      # @param tags [Array<String>]
+      #
+      # @param type [Symbol, ScalarGalaxy::Models::Planet::Type]
+      #
+      # @param request_options [ScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [ScalarGalaxy::Models::Planet]
+      #
+      # @see ScalarGalaxy::Models::PlanetCreateParams
+      def create(params)
+        parsed, options = ScalarGalaxy::PlanetCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "planets",
+          body: parsed,
+          model: ScalarGalaxy::Planet,
+          options: options
+        )
+      end
+
+      # You'll better learn a little bit more about the planets. It might come in handy
+      # once space travel is available for everyone.
+      #
+      # @overload retrieve(planet_id, request_options: {})
+      #
+      # @param planet_id [Integer] The ID of the planet to get
+      #
+      # @param request_options [ScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [ScalarGalaxy::Models::Planet]
+      #
+      # @see ScalarGalaxy::Models::PlanetRetrieveParams
+      def retrieve(planet_id, params = {})
+        @client.request(
+          method: :get,
+          path: ["planets/%1$s", planet_id],
+          model: ScalarGalaxy::Planet,
+          options: params[:request_options]
+        )
+      end
+
+      # Sometimes you make mistakes, that's fine. No worries, you can update all
+      # planets.
+      #
+      # @overload update(planet_id, id:, name:, atmosphere: nil, creator: nil, description: nil, discovered_at: nil, failure_callback_url: nil, habitability_index: nil, image: nil, last_updated: nil, physical_properties: nil, satellites: nil, success_callback_url: nil, tags: nil, type: nil, request_options: {})
+      #
+      # @param planet_id [Integer] The ID of the planet to get
+      #
+      # @param id [Integer]
+      #
+      # @param name [String]
+      #
+      # @param atmosphere [Array<ScalarGalaxy::Models::Planet::Atmosphere>] Atmospheric composition
+      #
+      # @param creator [ScalarGalaxy::Models::User] A user
+      #
+      # @param description [String, nil]
+      #
+      # @param discovered_at [Time]
+      #
+      # @param failure_callback_url [String] URL which gets invoked upon a failed operation
+      #
+      # @param habitability_index [Float] A score from 0 to 1 indicating potential habitability
+      #
+      # @param image [String, nil]
+      #
+      # @param last_updated [Time]
+      #
+      # @param physical_properties [ScalarGalaxy::Models::Planet::PhysicalProperties]
+      #
+      # @param satellites [Array<Object>]
+      #
+      # @param success_callback_url [String] URL which gets invoked upon a successful operation
+      #
+      # @param tags [Array<String>]
+      #
+      # @param type [Symbol, ScalarGalaxy::Models::Planet::Type]
+      #
+      # @param request_options [ScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [ScalarGalaxy::Models::Planet]
+      #
+      # @see ScalarGalaxy::Models::PlanetUpdateParams
+      def update(planet_id, params)
+        parsed, options = ScalarGalaxy::PlanetUpdateParams.dump_request(params)
+        @client.request(
+          method: :put,
+          path: ["planets/%1$s", planet_id],
+          body: parsed,
+          model: ScalarGalaxy::Planet,
+          options: options
+        )
+      end
+
+      # This endpoint was used to delete planets. Unfortunately, that caused a lot of
+      # trouble for planets with life. So, this endpoint is now deprecated and should
+      # not be used anymore.
+      #
+      # @overload delete(planet_id, request_options: {})
+      #
+      # @param planet_id [Integer] The ID of the planet to get
+      #
+      # @param request_options [ScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [nil]
+      #
+      # @see ScalarGalaxy::Models::PlanetDeleteParams
+      def delete(planet_id, params = {})
+        @client.request(
+          method: :delete,
+          path: ["planets/%1$s", planet_id],
+          model: NilClass,
+          options: params[:request_options]
+        )
+      end
+
+      # Got a crazy good photo of a planet? Share it with the world!
+      #
+      # @overload delte_image(planet_id, image: nil, request_options: {})
+      #
+      # @param planet_id [Integer] The ID of the planet to get
+      #
+      # @param image [Pathname, StringIO, IO, String, ScalarGalaxy::FilePart] The image file to upload
+      #
+      # @param request_options [ScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [ScalarGalaxy::Models::PlanetDelteImageResponse]
+      #
+      # @see ScalarGalaxy::Models::PlanetDelteImageParams
+      def delte_image(planet_id, params = {})
+        parsed, options = ScalarGalaxy::PlanetDelteImageParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: ["planets/%1$s/image", planet_id],
+          headers: {
+            "content-type" => "multipart/form-data"
+          },
+          body: parsed,
+          model: ScalarGalaxy::Models::PlanetDelteImageResponse,
+          options: options
+        )
+      end
+
+      # It's easy to say you know them all, but do you really? Retrieve all the planets
+      # and check whether you missed one.
+      #
+      # @overload list_all_data(limit: nil, offset: nil, request_options: {})
+      #
+      # @param limit [Integer] The number of items to return
+      #
+      # @param offset [Integer] The number of items to skip before starting to collect the result set
+      #
+      # @param request_options [ScalarGalaxy::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [ScalarGalaxy::Models::PlanetListAllDataResponse]
+      #
+      # @see ScalarGalaxy::Models::PlanetListAllDataParams
+      def list_all_data(params = {})
+        parsed, options = ScalarGalaxy::PlanetListAllDataParams.dump_request(params)
+        query = ScalarGalaxy::Internal::Util.encode_query_params(parsed)
+        @client.request(
+          method: :get,
+          path: "planets",
+          query: query,
+          model: ScalarGalaxy::Models::PlanetListAllDataResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [ScalarGalaxy::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/galaxy-ruby/resources/webhooks.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ScalarGalaxy
+  module Resources
+    class Webhooks
+      # @param payload [String] The raw webhook payload as a string
+      #
+      # @param headers [Hash{String=>String}] The raw HTTP headers that came with the payload
+      #
+      # @param key [String, nil] The webhook signing key
+      #
+      # @return [ScalarGalaxy::Models::NewPlanetWebhookEvent]
+      def unwrap(payload, headers:, key: @client.webhook_secret)
+        if key.nil?
+          raise ArgumentError.new(
+            "Cannot verify a webhook without a key on either the client's webhook_secret or passed in as an argument"
+          )
+        end
+
+        ::StandardWebhooks::Webhook.new(key).verify(payload, headers)
+
+        parsed = JSON.parse(payload, symbolize_names: true)
+        ScalarGalaxy::Internal::Type::Converter.coerce(ScalarGalaxy::Models::UnwrapWebhookEvent, parsed)
+      end
+
+      # @api private
+      #
+      # @param client [ScalarGalaxy::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/galaxy-ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ScalarGalaxy
+  VERSION = "0.2.0" # x-release-please-version
+end

data/lib/galaxy-ruby.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Standard libraries.
+# rubocop:disable Lint/RedundantRequireStatement
+require "English"
+require "cgi"
+require "date"
+require "erb"
+require "etc"
+require "json"
+require "net/http"
+require "openssl"
+require "pathname"
+require "rbconfig"
+require "securerandom"
+require "set"
+require "stringio"
+require "time"
+require "uri"
+# rubocop:enable Lint/RedundantRequireStatement
+
+# We already ship the preferred sorbet manifests in the package itself.
+# `tapioca` currently does not offer us a way to opt out of unnecessary compilation.
+if Object.const_defined?(:Tapioca) && caller.chain([$PROGRAM_NAME]).chain(ARGV).any?(/tapioca/) &&
+   ARGV.none?(/dsl/)
+  return
+end
+
+# Gems.
+require "connection_pool"
+require "standardwebhooks"
+
+# Package files.
+require_relative "galaxy-ruby/version"
+require_relative "galaxy-ruby/internal/util"
+require_relative "galaxy-ruby/internal/type/converter"
+require_relative "galaxy-ruby/internal/type/unknown"
+require_relative "galaxy-ruby/internal/type/boolean"
+require_relative "galaxy-ruby/internal/type/file_input"
+require_relative "galaxy-ruby/internal/type/enum"
+require_relative "galaxy-ruby/internal/type/union"
+require_relative "galaxy-ruby/internal/type/array_of"
+require_relative "galaxy-ruby/internal/type/hash_of"
+require_relative "galaxy-ruby/internal/type/base_model"
+require_relative "galaxy-ruby/internal/type/base_page"
+require_relative "galaxy-ruby/internal/type/request_parameters"
+require_relative "galaxy-ruby/internal"
+require_relative "galaxy-ruby/request_options"
+require_relative "galaxy-ruby/file_part"
+require_relative "galaxy-ruby/errors"
+require_relative "galaxy-ruby/internal/transport/base_client"
+require_relative "galaxy-ruby/internal/transport/pooled_net_requester"
+require_relative "galaxy-ruby/client"
+require_relative "galaxy-ruby/models/credentials"
+require_relative "galaxy-ruby/models/planet"
+require_relative "galaxy-ruby/models/authentication_create_token_params"
+require_relative "galaxy-ruby/models/authentication_create_token_response"
+require_relative "galaxy-ruby/models/authentication_create_user_params"
+require_relative "galaxy-ruby/models/authentication_list_me_params"
+require_relative "galaxy-ruby/models/celestial_body"
+require_relative "galaxy-ruby/models/celestial_body_create_params"
+require_relative "galaxy-ruby/models/new_planet_webhook_event"
+require_relative "galaxy-ruby/models/planet_create_params"
+require_relative "galaxy-ruby/models/planet_delete_params"
+require_relative "galaxy-ruby/models/planet_delte_image_params"
+require_relative "galaxy-ruby/models/planet_delte_image_response"
+require_relative "galaxy-ruby/models/planet_list_all_data_params"
+require_relative "galaxy-ruby/models/planet_list_all_data_response"
+require_relative "galaxy-ruby/models/planet_retrieve_params"
+require_relative "galaxy-ruby/models/planet_update_params"
+require_relative "galaxy-ruby/models/unwrap_webhook_event"
+require_relative "galaxy-ruby/models/user"
+require_relative "galaxy-ruby/models/webhook_unwrap_params"
+require_relative "galaxy-ruby/models"
+require_relative "galaxy-ruby/resources/planets"
+require_relative "galaxy-ruby/resources/celestial_bodies"
+require_relative "galaxy-ruby/resources/authentication"
+require_relative "galaxy-ruby/resources/webhooks"

data/rbi/galaxy-ruby/client.rbi

@@ -0,0 +1,128 @@
+# typed: strong
+
+module ScalarGalaxy
+  class Client < ScalarGalaxy::Internal::Transport::BaseClient
+    DEFAULT_MAX_RETRIES = 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS = T.let(60.0, Float)
+
+    DEFAULT_INITIAL_RETRY_DELAY = T.let(0.5, Float)
+
+    DEFAULT_MAX_RETRY_DELAY = T.let(8.0, Float)
+
+    ENVIRONMENTS =
+      T.let(
+        {
+          production: "https://galaxy.scalar.com",
+          void: "https://void.scalar.com/"
+        },
+        T::Hash[Symbol, String]
+      )
+
+    sig { returns(String) }
+    attr_reader :bearer_auth
+
+    sig { returns(String) }
+    attr_reader :basic_auth_username
+
+    sig { returns(String) }
+    attr_reader :basic_auth_password
+
+    sig { returns(String) }
+    attr_reader :api_key_header
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :api_key_query
+
+    sig { returns(String) }
+    attr_reader :api_key_cookie
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :o_auth2
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :open_id_connect
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :webhook_secret
+
+    # Everything about planets
+    sig { returns(ScalarGalaxy::Resources::Planets) }
+    attr_reader :planets
+
+    # Celestial bodies are the planets and satellites in the Scalar Galaxy.
+    sig { returns(ScalarGalaxy::Resources::CelestialBodies) }
+    attr_reader :celestial_bodies
+
+    # Some endpoints are public, but some require authentication. We provide all the
+    # required endpoints to create an account and authorize yourself.
+    sig { returns(ScalarGalaxy::Resources::Authentication) }
+    attr_reader :authentication
+
+    sig { returns(ScalarGalaxy::Resources::Webhooks) }
+    attr_reader :webhooks
+
+    # @api private
+    sig { override.returns(T::Hash[String, String]) }
+    private def auth_headers
+    end
+
+    # Creates and returns a new client for interacting with the API.
+    sig do
+      params(
+        bearer_auth: T.nilable(String),
+        basic_auth_username: T.nilable(String),
+        basic_auth_password: T.nilable(String),
+        api_key_header: T.nilable(String),
+        api_key_query: T.nilable(String),
+        api_key_cookie: T.nilable(String),
+        o_auth2: T.nilable(String),
+        open_id_connect: T.nilable(String),
+        webhook_secret: T.nilable(String),
+        environment: T.nilable(T.any(Symbol, String)),
+        base_url: T.nilable(String),
+        max_retries: Integer,
+        timeout: Float,
+        initial_retry_delay: Float,
+        max_retry_delay: Float
+      ).returns(T.attached_class)
+    end
+    def self.new(
+      # JWT Bearer token authentication Defaults to `ENV["BEARER_AUTH"]`
+      bearer_auth: ENV["BEARER_AUTH"],
+      # Defaults to `ENV["BASIC_AUTH_USERNAME"]`
+      basic_auth_username: ENV["BASIC_AUTH_USERNAME"],
+      # Defaults to `ENV["BASIC_AUTH_PASSWORD"]`
+      basic_auth_password: ENV["BASIC_AUTH_PASSWORD"],
+      # API key request header Defaults to `ENV["API_KEY_HEADER"]`
+      api_key_header: ENV["API_KEY_HEADER"],
+      # API key query parameter Defaults to `ENV["API_KEY_QUERY"]`
+      api_key_query: ENV["API_KEY_QUERY"],
+      # API key browser cookie Defaults to `ENV["API_KEY_COOKIE"]`
+      api_key_cookie: ENV["API_KEY_COOKIE"],
+      # OAuth 2.0 authentication Defaults to `ENV["SCALAR_O_AUTH2"]`
+      o_auth2: ENV["SCALAR_O_AUTH2"],
+      # OpenID Connect Authentication Defaults to `ENV["SCALAR_OPEN_ID_CONNECT"]`
+      open_id_connect: ENV["SCALAR_OPEN_ID_CONNECT"],
+      # Secret used to verify incoming webhook signatures. Defaults to
+      # `ENV["SCALAR_WEBHOOK_SECRET"]`
+      webhook_secret: ENV["SCALAR_WEBHOOK_SECRET"],
+      # Specifies the environment to use for the API.
+      #
+      # Each environment maps to a different base URL:
+      #
+      # - `production` corresponds to `https://galaxy.scalar.com`
+      # - `void` corresponds to `https://void.scalar.com/`
+      environment: nil,
+      # Override the default base URL for the API, e.g.,
+      # `"https://api.example.com/v2/"`. Defaults to `ENV["SCALAR_BASE_URL"]`
+      base_url: ENV["SCALAR_BASE_URL"],
+      # Max number of retries to attempt after a failed retryable request.
+      max_retries: ScalarGalaxy::Client::DEFAULT_MAX_RETRIES,
+      timeout: ScalarGalaxy::Client::DEFAULT_TIMEOUT_IN_SECONDS,
+      initial_retry_delay: ScalarGalaxy::Client::DEFAULT_INITIAL_RETRY_DELAY,
+      max_retry_delay: ScalarGalaxy::Client::DEFAULT_MAX_RETRY_DELAY
+    )
+    end
+  end
+end

data/rbi/galaxy-ruby/errors.rbi

@@ -0,0 +1,205 @@
+# typed: strong
+
+module ScalarGalaxy
+  module Errors
+    class Error < StandardError
+      sig { returns(T.nilable(StandardError)) }
+      attr_accessor :cause
+    end
+
+    class ConversionError < ScalarGalaxy::Errors::Error
+      sig { returns(T.nilable(StandardError)) }
+      def cause
+      end
+
+      # @api private
+      sig do
+        params(
+          on: T::Class[StandardError],
+          method: Symbol,
+          target: T.anything,
+          value: T.anything,
+          cause: T.nilable(StandardError)
+        ).returns(T.attached_class)
+      end
+      def self.new(on:, method:, target:, value:, cause: nil)
+      end
+    end
+
+    class APIError < ScalarGalaxy::Errors::Error
+      sig { returns(URI::Generic) }
+      attr_accessor :url
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :status
+
+      sig { returns(T.nilable(T::Hash[String, String])) }
+      attr_accessor :headers
+
+      sig { returns(T.nilable(T.anything)) }
+      attr_accessor :body
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: T.nilable(Integer),
+          headers: T.nilable(T::Hash[String, String]),
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        headers: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: nil
+      )
+      end
+    end
+
+    class APIConnectionError < ScalarGalaxy::Errors::APIError
+      sig { returns(NilClass) }
+      attr_accessor :status
+
+      sig { returns(NilClass) }
+      attr_accessor :body
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: NilClass,
+          headers: T.nilable(T::Hash[String, String]),
+          body: NilClass,
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        headers: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: "Connection error."
+      )
+      end
+    end
+
+    class APITimeoutError < ScalarGalaxy::Errors::APIConnectionError
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: NilClass,
+          headers: T.nilable(T::Hash[String, String]),
+          body: NilClass,
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        headers: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: "Request timed out."
+      )
+      end
+    end
+
+    class APIStatusError < ScalarGalaxy::Errors::APIError
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: Integer,
+          headers: T.nilable(T::Hash[String, String]),
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.for(
+        url:,
+        status:,
+        headers:,
+        body:,
+        request:,
+        response:,
+        message: nil
+      )
+      end
+
+      sig { returns(Integer) }
+      attr_accessor :status
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: Integer,
+          headers: T.nilable(T::Hash[String, String]),
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status:,
+        headers:,
+        body:,
+        request:,
+        response:,
+        message: nil
+      )
+      end
+    end
+
+    class BadRequestError < ScalarGalaxy::Errors::APIStatusError
+      HTTP_STATUS = 400
+    end
+
+    class AuthenticationError < ScalarGalaxy::Errors::APIStatusError
+      HTTP_STATUS = 401
+    end
+
+    class PermissionDeniedError < ScalarGalaxy::Errors::APIStatusError
+      HTTP_STATUS = 403
+    end
+
+    class NotFoundError < ScalarGalaxy::Errors::APIStatusError
+      HTTP_STATUS = 404
+    end
+
+    class ConflictError < ScalarGalaxy::Errors::APIStatusError
+      HTTP_STATUS = 409
+    end
+
+    class UnprocessableEntityError < ScalarGalaxy::Errors::APIStatusError
+      HTTP_STATUS = 422
+    end
+
+    class RateLimitError < ScalarGalaxy::Errors::APIStatusError
+      HTTP_STATUS = 429
+    end
+
+    class InternalServerError < ScalarGalaxy::Errors::APIStatusError
+      HTTP_STATUS = T.let((500..), T::Range[Integer])
+    end
+  end
+end

data/rbi/galaxy-ruby/file_part.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module ScalarGalaxy
+  class FilePart
+    sig { returns(T.any(Pathname, StringIO, IO, String)) }
+    attr_reader :content
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :content_type
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :filename
+
+    # @api private
+    sig { returns(String) }
+    private def read
+    end
+
+    sig { params(a: T.anything).returns(String) }
+    def to_json(*a)
+    end
+
+    sig { params(a: T.anything).returns(String) }
+    def to_yaml(*a)
+    end
+
+    sig do
+      params(
+        content: T.any(Pathname, StringIO, IO, String),
+        filename: T.nilable(T.any(Pathname, String)),
+        content_type: T.nilable(String)
+      ).returns(T.attached_class)
+    end
+    def self.new(content, filename: nil, content_type: nil)
+    end
+  end
+end