peal 0.1.0 → 0.3.0

data/lib/peal/channels/client.rb

@@ -0,0 +1,366 @@
+# frozen_string_literal: true
+
+module Peal
+  module Channels
+    class Client
+      # @param client [Peal::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Lists the channels connected to the workspace, oldest first. Their tokens are never shown. Needs channel:read.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :workspace_id
+      #
+      # @example
+      #   client.channels.list(workspace_id: "workspaceId")
+      #
+      # @return [Array[Peal::Types::Channel]]
+      def list(request_options: {}, **params)
+        params = Peal::Internal::Types::Utils.normalize_keys(params)
+        request = Peal::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "api/workspaces/#{URI.encode_uri_component(params[:workspace_id].to_s)}/channels",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Peal::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Peal::Internal::Types::Utils.coerce(Internal::Types::Array[Peal::Types::Channel], (response.body.to_s.empty? ? nil : JSON.parse(response.body, symbolize_names: true)))
+        else
+          error_class = Peal::Errors::ResponseError.subclass_for_code(code)
+          error_types = {
+            401 => Peal::Types::UnauthenticatedEncoded,
+            403 => Peal::Types::ForbiddenEncoded
+          }
+          error_body = Peal::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body, headers: response.to_hash)
+        end
+      end
+
+      # Lists the platforms this server can connect accounts of, in Peal's order. A platform that needs a setting the
+      # server lacks, such as an app registered on LinkedIn, X or Meta or a Google OAuth client, is left out. Needs
+      # channel:connect.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :workspace_id
+      #
+      # @example
+      #   client.channels.platforms(workspace_id: "workspaceId")
+      #
+      # @return [Peal::Types::ConnectablePlatforms]
+      def platforms(request_options: {}, **params)
+        params = Peal::Internal::Types::Utils.normalize_keys(params)
+        request = Peal::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "api/workspaces/#{URI.encode_uri_component(params[:workspace_id].to_s)}/channels/platforms",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Peal::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          (response.body.to_s.empty? ? nil : Peal::Types::ConnectablePlatforms.load(response.body))
+        else
+          error_class = Peal::Errors::ResponseError.subclass_for_code(code)
+          error_types = {
+            401 => Peal::Types::UnauthenticatedEncoded,
+            403 => Peal::Types::ForbiddenEncoded
+          }
+          error_body = Peal::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body, headers: response.to_hash)
+        end
+      end
+
+      # Starts connecting an account of the platform: answers with the platform's sign-in page, where the browser goes
+      # next. The connection is tied to the caller and the workspace, and must be completed within 15 minutes. On a
+      # server that bills, a workspace whose plan allows no more channels gets PlanLimitReached. Needs channel:connect.
+      #
+      # @param request_options [Hash]
+      # @param params [Peal::Channels::Types::ConnectChannel]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :workspace_id
+      # @option params [Peal::Types::Platform] :platform
+      #
+      # @example
+      #   client.channels.connect(
+      #     workspace_id: "workspaceId",
+      #     platform: "x"
+      #   )
+      #
+      # @return [Peal::Types::Authorization]
+      def connect(request_options: {}, **params)
+        params = Peal::Internal::Types::Utils.normalize_keys(params)
+        request_data = Peal::Channels::Types::ConnectChannel.new(params).to_h
+        non_body_param_names = %w[workspaceId platform]
+        body = request_data.except(*non_body_param_names)
+
+        request = Peal::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "api/workspaces/#{URI.encode_uri_component(params[:workspace_id].to_s)}/channels/connect/#{URI.encode_uri_component(params[:platform].to_s)}",
+          body: body,
+          request_options: request_options,
+          max_retries: 0
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Peal::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          (response.body.to_s.empty? ? nil : Peal::Types::Authorization.load(response.body))
+        else
+          error_class = Peal::Errors::ResponseError.subclass_for_code(code)
+          error_types = {
+            401 => Peal::Types::UnauthenticatedEncoded,
+            402 => Peal::Types::PlanLimitReachedEncoded,
+            403 => Peal::Types::ForbiddenEncoded
+          }
+          error_body = Peal::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body, headers: response.to_hash)
+        end
+      end
+
+      # Completes a connection with what the platform sent back: the account becomes a channel of the workspace, or the
+      # channel it reconnects takes its new tokens. When the sign-in reached several accounts, as the Pages a Facebook
+      # user manages, the answer lists them instead, to choose with chooseAccounts. Only the member who started the
+      # connection can complete it, once. A new account needs room in the workspace's plan (PlanLimitReached). Needs
+      # channel:connect.
+      #
+      # @param request_options [Hash]
+      # @param params [Peal::Channels::Types::ConnectCallback]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :workspace_id
+      # @option params [Peal::Types::Platform] :platform
+      #
+      # @example
+      #   client.channels.complete_connect(
+      #     workspace_id: "workspaceId",
+      #     platform: "x",
+      #     state: "state"
+      #   )
+      #
+      # @return [Peal::Types::ConnectOutcome]
+      def complete_connect(request_options: {}, **params)
+        params = Peal::Internal::Types::Utils.normalize_keys(params)
+        request_data = Peal::Channels::Types::ConnectCallback.new(params).to_h
+        non_body_param_names = %w[workspaceId platform]
+        body = request_data.except(*non_body_param_names)
+
+        request = Peal::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "api/workspaces/#{URI.encode_uri_component(params[:workspace_id].to_s)}/channels/connect/#{URI.encode_uri_component(params[:platform].to_s)}/callback",
+          body: body,
+          request_options: request_options,
+          max_retries: 0
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Peal::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          (response.body.to_s.empty? ? nil : Peal::Types::ConnectOutcome.load(response.body))
+        else
+          error_class = Peal::Errors::ResponseError.subclass_for_code(code)
+          error_types = {
+            401 => Peal::Types::UnauthenticatedEncoded,
+            402 => Peal::Types::PlanLimitReachedEncoded,
+            403 => Peal::Types::ForbiddenEncoded
+          }
+          error_body = Peal::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body, headers: response.to_hash)
+        end
+      end
+
+      # Connects the accounts the member chose among those a completed sign-in listed: each becomes a channel of the
+      # workspace, or reconnects the one it has. The new accounts chosen need room in the workspace's plan, all of them:
+      # otherwise none is connected (PlanLimitReached), and the choice can be made again with fewer. Only the member who
+      # completed the sign-in can choose, within 15 minutes, and once an account is connected: a choice that failed
+      # before connecting any can be made again. Needs channel:connect.
+      #
+      # @param request_options [Hash]
+      # @param params [Peal::Channels::Types::ChooseAccounts]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :workspace_id
+      # @option params [Peal::Types::Platform] :platform
+      #
+      # @example
+      #   client.channels.choose_accounts(
+      #     workspace_id: "workspaceId",
+      #     platform: "x",
+      #     account_ids: ["accountIds"],
+      #     selection: "selection"
+      #   )
+      #
+      # @return [Array[Peal::Types::Channel]]
+      def choose_accounts(request_options: {}, **params)
+        params = Peal::Internal::Types::Utils.normalize_keys(params)
+        request_data = Peal::Channels::Types::ChooseAccounts.new(params).to_h
+        non_body_param_names = %w[workspaceId platform]
+        body = request_data.except(*non_body_param_names)
+
+        request = Peal::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "api/workspaces/#{URI.encode_uri_component(params[:workspace_id].to_s)}/channels/connect/#{URI.encode_uri_component(params[:platform].to_s)}/accounts",
+          body: body,
+          request_options: request_options,
+          max_retries: 0
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Peal::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Peal::Internal::Types::Utils.coerce(Internal::Types::Array[Peal::Types::Channel], (response.body.to_s.empty? ? nil : JSON.parse(response.body, symbolize_names: true)))
+        else
+          error_class = Peal::Errors::ResponseError.subclass_for_code(code)
+          error_types = {
+            401 => Peal::Types::UnauthenticatedEncoded,
+            402 => Peal::Types::PlanLimitReachedEncoded,
+            403 => Peal::Types::ForbiddenEncoded
+          }
+          error_body = Peal::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body, headers: response.to_hash)
+        end
+      end
+
+      # Starts reconnecting a channel whose token stopped working or is about to: answers with the platform's sign-in
+      # page. Completing it must sign in to the same account. A channel the workspace has takes no room in its plan, so
+      # no plan limit refuses it. Needs channel:connect.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :workspace_id
+      # @option params [String] :channel_id
+      #
+      # @example
+      #   client.channels.reconnect(
+      #     workspace_id: "workspaceId",
+      #     channel_id: "channelId"
+      #   )
+      #
+      # @return [Peal::Types::Authorization]
+      def reconnect(request_options: {}, **params)
+        params = Peal::Internal::Types::Utils.normalize_keys(params)
+        request = Peal::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "api/workspaces/#{URI.encode_uri_component(params[:workspace_id].to_s)}/channels/#{URI.encode_uri_component(params[:channel_id].to_s)}/reconnect",
+          request_options: request_options,
+          max_retries: 0
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Peal::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          (response.body.to_s.empty? ? nil : Peal::Types::Authorization.load(response.body))
+        else
+          error_class = Peal::Errors::ResponseError.subclass_for_code(code)
+          error_types = {
+            401 => Peal::Types::UnauthenticatedEncoded,
+            403 => Peal::Types::ForbiddenEncoded
+          }
+          error_body = Peal::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body, headers: response.to_hash)
+        end
+      end
+
+      # Disconnects a channel from the workspace: the channel and the tokens Peal holds for it are deleted, and nothing
+      # more is posted on it. Needs channel:disconnect.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :workspace_id
+      # @option params [String] :channel_id
+      #
+      # @example
+      #   client.channels.disconnect(
+      #     workspace_id: "workspaceId",
+      #     channel_id: "channelId"
+      #   )
+      #
+      # @return [untyped]
+      def disconnect(request_options: {}, **params)
+        params = Peal::Internal::Types::Utils.normalize_keys(params)
+        request = Peal::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "DELETE",
+          path: "api/workspaces/#{URI.encode_uri_component(params[:workspace_id].to_s)}/channels/#{URI.encode_uri_component(params[:channel_id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Peal::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        return if code.between?(200, 299)
+
+        error_class = Peal::Errors::ResponseError.subclass_for_code(code)
+        error_types = {
+          401 => Peal::Types::UnauthenticatedEncoded,
+          403 => Peal::Types::ForbiddenEncoded
+        }
+        error_body = Peal::Errors::ResponseError.load_error_body(code, response.body, error_types)
+        raise error_class.new(response.body, code: code, body: error_body, headers: response.to_hash)
+      end
+    end
+  end
+end

data/lib/peal/channels/types/choose_accounts.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Peal
+  module Channels
+    module Types
+      class ChooseAccounts < Internal::Types::Model
+        field :workspace_id, -> { String }, optional: false, nullable: false, api_name: "workspaceId"
+
+        field :platform, -> { Peal::Types::Platform }, optional: false, nullable: false
+
+        field :account_ids, -> { Internal::Types::Array[String] }, optional: false, nullable: false, api_name: "accountIds"
+
+        field :selection, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/peal/channels/types/connect_callback.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Peal
+  module Channels
+    module Types
+      class ConnectCallback < Internal::Types::Model
+        field :workspace_id, -> { String }, optional: false, nullable: false, api_name: "workspaceId"
+
+        field :platform, -> { Peal::Types::Platform }, optional: false, nullable: false
+
+        field :code, -> { String }, optional: true, nullable: false
+
+        field :error, -> { String }, optional: true, nullable: false
+
+        field :iss, -> { String }, optional: true, nullable: false
+
+        field :state, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/peal/channels/types/connect_channel.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Peal
+  module Channels
+    module Types
+      class ConnectChannel < Internal::Types::Model
+        field :workspace_id, -> { String }, optional: false, nullable: false, api_name: "workspaceId"
+
+        field :platform, -> { Peal::Types::Platform }, optional: false, nullable: false
+
+        field :handle, -> { String }, optional: true, nullable: false
+
+        field :instance, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/peal/channels/types/disconnect_channels_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Peal
+  module Channels
+    module Types
+      class DisconnectChannelsRequest < Internal::Types::Model
+        field :workspace_id, -> { String }, optional: false, nullable: false, api_name: "workspaceId"
+
+        field :channel_id, -> { String }, optional: false, nullable: false, api_name: "channelId"
+      end
+    end
+  end
+end

data/lib/peal/channels/types/list_channels_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Peal
+  module Channels
+    module Types
+      class ListChannelsRequest < Internal::Types::Model
+        field :workspace_id, -> { String }, optional: false, nullable: false, api_name: "workspaceId"
+      end
+    end
+  end
+end

data/lib/peal/channels/types/platforms_channels_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Peal
+  module Channels
+    module Types
+      class PlatformsChannelsRequest < Internal::Types::Model
+        field :workspace_id, -> { String }, optional: false, nullable: false, api_name: "workspaceId"
+      end
+    end
+  end
+end

data/lib/peal/channels/types/reconnect_channels_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Peal
+  module Channels
+    module Types
+      class ReconnectChannelsRequest < Internal::Types::Model
+        field :workspace_id, -> { String }, optional: false, nullable: false, api_name: "workspaceId"
+
+        field :channel_id, -> { String }, optional: false, nullable: false, api_name: "channelId"
+      end
+    end
+  end
+end

data/lib/peal/client.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Peal
+  class Client
+    # @param token [String]
+    # @param base_url [String, nil]
+    # @param max_retries [Integer]
+    # @param timeout [Numeric]
+    #
+    # @return [void]
+    def initialize(token:, base_url: nil, max_retries: 2, timeout: 60)
+      @raw_client = Peal::Internal::Http::RawClient.new(
+        base_url: base_url || Peal::Environment::DEFAULT,
+        headers: {
+          "X-Fern-Language" => "Ruby",
+          Authorization: "Bearer #{token}"
+        },
+        max_retries: max_retries,
+        timeout: timeout
+      )
+    end
+
+    # @return [Peal::System::Client]
+    def system
+      @system ||= Peal::System::Client.new(client: @raw_client)
+    end
+
+    # @return [Peal::Session::Client]
+    def session
+      @session ||= Peal::Session::Client.new(client: @raw_client)
+    end
+
+    # @return [Peal::APIKeys::Client]
+    def api_keys
+      @api_keys ||= Peal::APIKeys::Client.new(client: @raw_client)
+    end
+
+    # @return [Peal::Channels::Client]
+    def channels
+      @channels ||= Peal::Channels::Client.new(client: @raw_client)
+    end
+
+    # @return [Peal::Posts::Client]
+    def posts
+      @posts ||= Peal::Posts::Client.new(client: @raw_client)
+    end
+
+    # @return [Peal::Media::Client]
+    def media
+      @media ||= Peal::Media::Client.new(client: @raw_client)
+    end
+
+    # @return [Peal::Notices::Client]
+    def notices
+      @notices ||= Peal::Notices::Client.new(client: @raw_client)
+    end
+
+    # @return [Peal::NotificationPreferences::Client]
+    def notification_preferences
+      @notification_preferences ||= Peal::NotificationPreferences::Client.new(client: @raw_client)
+    end
+
+    # @return [Peal::Assistant::Client]
+    def assistant
+      @assistant ||= Peal::Assistant::Client.new(client: @raw_client)
+    end
+
+    # @return [Peal::Members::Client]
+    def members
+      @members ||= Peal::Members::Client.new(client: @raw_client)
+    end
+
+    # @return [Peal::Invitations::Client]
+    def invitations
+      @invitations ||= Peal::Invitations::Client.new(client: @raw_client)
+    end
+
+    # @return [Peal::Billing::Client]
+    def billing
+      @billing ||= Peal::Billing::Client.new(client: @raw_client)
+    end
+
+    # @return [Peal::Analytics::Client]
+    def analytics
+      @analytics ||= Peal::Analytics::Client.new(client: @raw_client)
+    end
+
+    # @return [Peal::Tiktok::Client]
+    def tiktok
+      @tiktok ||= Peal::Tiktok::Client.new(client: @raw_client)
+    end
+  end
+end

data/lib/peal/environment.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Peal
+  class Environment
+    DEFAULT = "https://app.peal.social"
+  end
+end

data/lib/peal/errors/api_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Peal
+  module Errors
+    class ApiError < StandardError
+    end
+  end
+end

data/lib/peal/errors/client_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Peal
+  module Errors
+    class ClientError < ResponseError
+    end
+
+    class UnauthorizedError < ClientError
+    end
+
+    class ForbiddenError < ClientError
+    end
+
+    class NotFoundError < ClientError
+    end
+  end
+end

data/lib/peal/errors/connection_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Peal
+  module Errors
+    # Raised when the request fails before a response is received: the connection is refused,
+    # reset or closed early, the host name cannot be resolved, or the TLS handshake fails.
+    # The original exception is available as `cause`.
+    class ConnectionError < ApiError
+    end
+  end
+end

data/lib/peal/errors/redirect_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Peal
+  module Errors
+    class RedirectError < ResponseError
+    end
+  end
+end