rcs 2.0.5.pre.rc.1 → 2.0.5

data/lib/pinnacle/types/vetting_results.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Types
-    class VettingResults < Internal::Types::Model
-      field :success, -> { Internal::Types::Boolean }, optional: false, nullable: false
-    end
-  end
-end

data/lib/pinnacle/types/webhook_event_enum.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Types
-    module WebhookEventEnum
-      extend Pinnacle::Internal::Types::Enum
-
-      MESSAGE_STATUS = "MESSAGE.STATUS"
-      MESSAGE_RECEIVED = "MESSAGE.RECEIVED"
-    end
-  end
-end

data/lib/pinnacle/types/webhook_result.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Types
-    # Response containing all webhooks that match the requested identifiers.
-    # Only includes the essential webhook information needed for identification and management.
-    class WebhookResult < Internal::Types::Model
-      field :webhooks, -> { Internal::Types::Array[Pinnacle::Types::Webhooks] }, optional: false, nullable: false
-    end
-  end
-end

data/lib/pinnacle/types/webhooks.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Types
-    # Webhook configuration that defines where event notifications are sent.
-    class Webhooks < Internal::Types::Model
-      field :endpoint, -> { String }, optional: false, nullable: false
-      field :id, -> { String }, optional: false, nullable: false
-      field :name, -> { String }, optional: false, nullable: false
-    end
-  end
-end

data/lib/pinnacle/types/zod_error.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Types
-    class ZodError < Internal::Types::Model
-      field :description, -> { String }, optional: false, nullable: false
-      field :errors, -> { Internal::Types::Hash[String, Object] }, optional: false, nullable: false
-    end
-  end
-end

data/lib/pinnacle/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  VERSION = "2.0.5-rc.1"
-end

data/lib/pinnacle/webhooks/client.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Webhooks
-    class Client
-      # @param client [Pinnacle::Internal::Http::RawClient]
-      #
-      # @return [void]
-      def initialize(client:)
-        @client = client
-      end
-
-      # Retrieve all webhook that are set up to receive events for specific URLs or phone numbers.
-      #
-      # @param request_options [Hash]
-      # @param params [Pinnacle::Webhooks::Types::GetWebhookParams]
-      # @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
-      #
-      # @return [Pinnacle::Types::WebhookResult]
-      def get(request_options: {}, **params)
-        params = Pinnacle::Internal::Types::Utils.normalize_keys(params)
-        body_prop_names = %i[identifiers]
-        body_bag = params.slice(*body_prop_names)
-
-        request = Pinnacle::Internal::JSON::Request.new(
-          base_url: request_options[:base_url],
-          method: "POST",
-          path: "webhooks",
-          body: Pinnacle::Webhooks::Types::GetWebhookParams.new(body_bag).to_h,
-          request_options: request_options
-        )
-        begin
-          response = @client.send(request)
-        rescue Net::HTTPRequestTimeout
-          raise Pinnacle::Errors::TimeoutError
-        end
-        code = response.code.to_i
-        if code.between?(200, 299)
-          Pinnacle::Types::WebhookResult.load(response.body)
-        else
-          error_class = Pinnacle::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
-        end
-      end
-    end
-  end
-end

data/lib/pinnacle/webhooks/types/get_webhook_params.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Webhooks
-    module Types
-      class GetWebhookParams < Internal::Types::Model
-        field :identifiers, -> { Internal::Types::Array[String] }, optional: false, nullable: false
-      end
-    end
-  end
-end

data/lib/pinnacle/wrapper/messages/client.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Pinnacle
-  module Wrapper
-    module Messages
-      class Client < Pinnacle::Messages::Client
-        # Process incoming webhook request with signature validation.
-        #
-        # @example Process a webhook request
-        #   client = Pinnacle::Client.new(api_key: "your-api-key")
-        #   request = {
-        #     headers: { "PINNACLE-SIGNING-SECRET" => "your-secret" },
-        #     body: '{"type": "MESSAGE.RECEIVED", ...}'
-        #   }
-        #   event = client.messages.process(request)
-        #
-        # @param request [Hash] Request with :headers and :body keys
-        # @param secret [String, nil] Webhook secret (falls back to PINNACLE_SIGNING_SECRET env var)
-        #
-        # @return [Pinnacle::Types::MessageEvent, Pinnacle::Types::UserEvent]
-        # @raise [Pinnacle::Errors::UnauthorizedError] If webhook signature is invalid or missing
-        # @raise [Pinnacle::Errors::ClientError] If request body cannot be parsed
-        def process(request, secret: nil)
-          headers = request[:headers] || request["headers"] || {}
-          body = request[:body] || request["body"]
-
-          header_secret = headers["PINNACLE-SIGNING-SECRET"] ||
-                          headers["pinnacle-signing-secret"] ||
-                          headers["Pinnacle-Signing-Secret"]
-
-          env_secret = secret || ENV.fetch("PINNACLE_SIGNING_SECRET", nil)
-
-          if header_secret.nil?
-            raise Pinnacle::Errors::UnauthorizedError.new(
-              "Failed to get PINNACLE-SIGNING-SECRET header from request",
-              code: 401
-            )
-          end
-
-          if env_secret.nil?
-            raise Pinnacle::Errors::UnauthorizedError.new(
-              "Set PINNACLE_SIGNING_SECRET env var or pass secret argument",
-              code: 401
-            )
-          end
-
-          if header_secret != env_secret
-            raise Pinnacle::Errors::UnauthorizedError.new(
-              "Invalid webhook signature",
-              code: 401
-            )
-          end
-
-          parsed = body.is_a?(String) ? JSON.parse(body) : body
-
-          if parsed["type"] == "USER.TYPING"
-            Pinnacle::Types::UserEvent.coerce(parsed)
-          else
-            Pinnacle::Types::MessageEvent.coerce(parsed)
-          end
-        rescue JSON::ParserError => e
-          raise Pinnacle::Errors::ClientError.new(
-            "Invalid message event format: #{e.message}",
-            code: 400
-          )
-        end
-      end
-    end
-  end
-end

data/lib/pinnacle/wrapper/tools/client.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Wrapper
-    module Tools
-      class Client < Pinnacle::Tools::Client
-        # @return [Pinnacle::Wrapper::Tools::FileUploader]
-        def file
-          @file ||= Pinnacle::Wrapper::Tools::FileUploader.new(client: @client)
-        end
-      end
-    end
-  end
-end

data/lib/pinnacle/wrapper/tools/file_uploader.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-require "net/http"
-require "uri"
-
-module Pinnacle
-  module Wrapper
-    module Tools
-      class FileUploader < Pinnacle::Tools::File::Client
-        SUPPORTED_MIME_TYPES = Set.new(
-          [
-            "audio/mpeg", "audio/mp4", "audio/ogg", "audio/aac",
-            "audio/webm", "audio/wav", "audio/3gpp", "audio/amr",
-            "video/mp4", "video/mpeg", "video/quicktime", "video/webm",
-            "video/3gpp", "video/H264", "video/x-m4v",
-            "image/jpeg", "image/png", "image/gif", "image/bmp",
-            "image/tiff", "image/webp",
-            "application/pdf", "text/csv", "application/rtf",
-            "text/vcard", "text/calendar"
-          ]
-        ).freeze
-
-        MIME_TYPES = {
-          ".mp3" => "audio/mpeg",
-          ".mp4" => "video/mp4",
-          ".ogg" => "audio/ogg",
-          ".aac" => "audio/aac",
-          ".webm" => "video/webm",
-          ".wav" => "audio/wav",
-          ".3gp" => "video/3gpp",
-          ".3gpp" => "video/3gpp",
-          ".amr" => "audio/amr",
-          ".mpeg" => "video/mpeg",
-          ".mpg" => "video/mpeg",
-          ".mov" => "video/quicktime",
-          ".m4v" => "video/x-m4v",
-          ".jpg" => "image/jpeg",
-          ".jpeg" => "image/jpeg",
-          ".png" => "image/png",
-          ".gif" => "image/gif",
-          ".bmp" => "image/bmp",
-          ".tiff" => "image/tiff",
-          ".tif" => "image/tiff",
-          ".webp" => "image/webp",
-          ".pdf" => "application/pdf",
-          ".csv" => "text/csv",
-          ".rtf" => "application/rtf",
-          ".vcf" => "text/vcard",
-          ".vcard" => "text/vcard",
-          ".ics" => "text/calendar"
-        }.freeze
-
-        # Upload a file from local filesystem.
-        #
-        # @example Upload a file
-        #   client = Pinnacle::Client.new(api_key: "your-api-key")
-        #   url = client.tools.file.upload_from_path("/path/to/image.png")
-        #   puts url # => "https://..."
-        #
-        # @example Upload with custom name
-        #   url = client.tools.file.upload_from_path(
-        #     "/path/to/image.png",
-        #     name: "my-custom-name.png"
-        #   )
-        #
-        # @param file_path [String] Path to the file
-        # @param name [String, nil] Override filename
-        # @param options [Hash, nil] Upload options
-        # @param request_options [Hash] Additional request options
-        #
-        # @return [String] Download URL
-        # @raise [Pinnacle::Errors::NotFoundError] If file not found
-        # @raise [Pinnacle::Errors::ClientError] If path is a directory
-        # @raise [Pinnacle::Errors::ServerError] If upload fails
-        def upload_from_path(file_path, name: nil, options: nil, request_options: {})
-          unless ::File.exist?(file_path)
-            raise Pinnacle::Errors::NotFoundError.new(
-              "File not found: #{file_path}",
-              code: 404
-            )
-          end
-
-          if ::File.directory?(file_path)
-            raise Pinnacle::Errors::ClientError.new(
-              "Path is a directory, not a file: #{file_path}",
-              code: 400
-            )
-          end
-
-          size = ::File.size(file_path)
-          file_name = name || ::File.basename(file_path)
-          content_type = get_mime_type(file_path)
-
-          upload_result = upload(
-            content_type: content_type,
-            size: size,
-            name: file_name,
-            options: options,
-            request_options: request_options
-          )
-
-          if upload_result.upload_url
-            uri = URI.parse(upload_result.upload_url)
-            file_content = ::File.binread(file_path)
-
-            http = Net::HTTP.new(uri.host, uri.port)
-            http.use_ssl = uri.scheme == "https"
-
-            request = Net::HTTP::Put.new(uri.request_uri)
-            request["Content-Type"] = content_type
-            request.body = file_content
-
-            response = http.request(request)
-
-            unless response.is_a?(Net::HTTPSuccess)
-              raise Pinnacle::Errors::ServerError.new(
-                "Failed to upload file: #{response.code}",
-                code: response.code.to_i
-              )
-            end
-          end
-
-          upload_result.download_url
-        end
-
-        private
-
-        def get_mime_type(file_path)
-          ext = ::File.extname(file_path).downcase
-          mime_type = MIME_TYPES[ext]
-
-          return "application/octet-stream" unless mime_type
-
-          if SUPPORTED_MIME_TYPES.include?(mime_type)
-            mime_type
-          else
-            base_type = mime_type.split("/").first
-            if %w[audio video image].include?(base_type)
-              warn "MIME type #{mime_type} may not be fully supported. Proceeding anyway."
-              mime_type
-            else
-              "application/octet-stream"
-            end
-          end
-        end
-      end
-    end
-  end
-end