peal 0.1.0 → 0.3.0

data/lib/peal/analytics/client.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Peal
+  module Analytics
+    class Client
+      # @param client [Peal::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Sums up the posts published from `from` to `to`, both included and at most 366 days, as days run in `timeZone`
+      # (an IANA zone such as Europe/Paris): their latest counts in all and by channel, what they gained each day, and
+      # the five with the most engagement (likes, reposts, replies and quotes). Counts are read from the platforms every
+      # hour for 48 hours after a post goes live, then every day until it is 30 days old. Needs analytics: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
+      # @option params [Peal::Types::CalendarDay] :from
+      # @option params [String] :time_zone
+      # @option params [Peal::Types::CalendarDay] :to
+      #
+      # @example
+      #   client.analytics.summary(
+      #     workspace_id: "workspaceId",
+      #     from: "from",
+      #     time_zone: "timeZone",
+      #     to: "to"
+      #   )
+      #
+      # @return [Peal::Types::AnalyticsSummary]
+      def summary(request_options: {}, **params)
+        params = Peal::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["from"] = params[:from] if params.key?(:from)
+        query_params["timeZone"] = params[:time_zone] if params.key?(:time_zone)
+        query_params["to"] = params[:to] if params.key?(:to)
+
+        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)}/analytics/summary",
+          query: query_params,
+          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::AnalyticsSummary.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
+
+      # Answers with the counts of a post on each channel it went live on, over time. A post not published yet, or whose
+      # counts were not read yet, has no targets. Needs analytics: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
+      # @option params [String] :post_id
+      #
+      # @example
+      #   client.analytics.post(
+      #     workspace_id: "workspaceId",
+      #     post_id: "postId"
+      #   )
+      #
+      # @return [Peal::Types::PostAnalytics]
+      def post(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)}/analytics/posts/#{URI.encode_uri_component(params[:post_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
+        if code.between?(200, 299)
+          (response.body.to_s.empty? ? nil : Peal::Types::PostAnalytics.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
+    end
+  end
+end

data/lib/peal/analytics/types/post_analytics_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Peal
+  module Analytics
+    module Types
+      class PostAnalyticsRequest < Internal::Types::Model
+        field :workspace_id, -> { String }, optional: false, nullable: false, api_name: "workspaceId"
+
+        field :post_id, -> { String }, optional: false, nullable: false, api_name: "postId"
+      end
+    end
+  end
+end

data/lib/peal/analytics/types/summary_analytics_request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Peal
+  module Analytics
+    module Types
+      class SummaryAnalyticsRequest < Internal::Types::Model
+        field :workspace_id, -> { String }, optional: false, nullable: false, api_name: "workspaceId"
+
+        field :from, -> { String }, optional: false, nullable: false
+
+        field :time_zone, -> { String }, optional: false, nullable: false, api_name: "timeZone"
+
+        field :to, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/peal/api_keys/client.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Peal
+  module APIKeys
+    class Client
+      # @param client [Peal::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Lists the workspace's API keys. Needs apiKey: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.api_keys.list(workspace_id: "workspaceId")
+      #
+      # @return [Array[Peal::Types::APIKey]]
+      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)}/api-keys",
+          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::APIKey], (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
+
+      # Creates an API key for the workspace with some of the caller's permissions, and answers with the key itself,
+      # which is not shown again. Needs apiKey:create, and a signed-in member: API keys cannot create keys.
+      #
+      # @param request_options [Hash]
+      # @param params [Peal::APIKeys::Types::NewAPIKey]
+      # @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.api_keys.create(
+      #     workspace_id: "workspaceId",
+      #     name: "name",
+      #     permissions: ["analytics:read"]
+      #   )
+      #
+      # @return [Peal::Types::CreatedAPIKey]
+      def create(request_options: {}, **params)
+        params = Peal::Internal::Types::Utils.normalize_keys(params)
+        request_data = Peal::APIKeys::Types::NewAPIKey.new(params).to_h
+        non_body_param_names = %w[workspaceId]
+        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)}/api-keys",
+          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::CreatedAPIKey.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
+
+      # Revokes an API key of the workspace: it stops working at once. Needs apiKey:delete.
+      #
+      # @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] :api_key_id
+      #
+      # @example
+      #   client.api_keys.revoke(
+      #     workspace_id: "workspaceId",
+      #     api_key_id: "apiKeyId"
+      #   )
+      #
+      # @return [untyped]
+      def revoke(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)}/api-keys/#{URI.encode_uri_component(params[:api_key_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/api_keys/types/list_api_keys_request.rb

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

data/lib/peal/api_keys/types/new_api_key.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Peal
+  module APIKeys
+    module Types
+      class NewAPIKey < Internal::Types::Model
+        field :workspace_id, -> { String }, optional: false, nullable: false, api_name: "workspaceId"
+
+        field :expires_in_days, -> { Integer }, optional: true, nullable: false, api_name: "expiresInDays"
+
+        field :name, -> { String }, optional: false, nullable: false
+
+        field :permissions, -> { Internal::Types::Array[Peal::Types::Permission] }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/peal/api_keys/types/revoke_api_keys_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Peal
+  module APIKeys
+    module Types
+      class RevokeAPIKeysRequest < Internal::Types::Model
+        field :workspace_id, -> { String }, optional: false, nullable: false, api_name: "workspaceId"
+
+        field :api_key_id, -> { String }, optional: false, nullable: false, api_name: "apiKeyId"
+      end
+    end
+  end
+end

data/lib/peal/assistant/client.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Peal
+  module Assistant
+    class Client
+      # @param client [Peal::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Tells whether the server has a language model, so clients show the assistant or hide it, and how many requests
+      # the workspace has left today. Needs assistant:use.
+      #
+      # @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.assistant.status(workspace_id: "workspaceId")
+      #
+      # @return [Peal::Types::AssistantStatus]
+      def status(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)}/assistant",
+          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::AssistantStatus.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
+
+      # Asks the language model to rewrite, shorten or translate a post's text, or to suggest hashtags for it, and
+      # answers once the whole suggestion is checked. The text is sent to the model as data, never as instructions. Each
+      # request counts toward the workspace's daily quota, unless the model's provider could not be reached. Needs
+      # assistant:use.
+      #
+      # @param request_options [Hash]
+      # @param params [Peal::Assistant::Types::SuggestionRequest]
+      # @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.assistant.suggest(
+      #     workspace_id: "workspaceId",
+      #     text: "text"
+      #   )
+      #
+      # @return [Peal::Types::Suggestion]
+      def suggest(request_options: {}, **params)
+        params = Peal::Internal::Types::Utils.normalize_keys(params)
+        request_data = Peal::Assistant::Types::SuggestionRequest.new(params).to_h
+        non_body_param_names = %w[workspaceId]
+        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)}/assistant/suggestions",
+          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::Suggestion.load(response.body))
+        else
+          error_class = Peal::Errors::ResponseError.subclass_for_code(code)
+          error_types = {
+            401 => Peal::Types::UnauthenticatedEncoded,
+            403 => Peal::Types::ForbiddenEncoded,
+            429 => Peal::Types::AssistantQuotaExceededEncoded
+          }
+          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
+end

data/lib/peal/assistant/types/status_assistant_request.rb

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

data/lib/peal/assistant/types/suggestion_request.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Peal
+  module Assistant
+    module Types
+      class SuggestionRequest < Internal::Types::Model
+        field :workspace_id, -> { String }, optional: false, nullable: false, api_name: "workspaceId"
+
+        field :action, -> { Peal::Types::AssistantAction }, optional: false, nullable: false
+
+        field :text, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/peal/billing/client.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Peal
+  module Billing
+    class Client
+      # @param client [Peal::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Answers with the workspace's plan, the subscription that buys it, what each limit allows, how much of it the
+      # workspace uses, and every plan to compare. On a server that does not bill, nothing is limited. Needs
+      # billing: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.billing.get(workspace_id: "workspaceId")
+      #
+      # @return [Peal::Types::Billing]
+      def get(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)}/billing",
+          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::Billing.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
+    end
+  end
+end

data/lib/peal/billing/types/get_billing_request.rb

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