enconvert 0.0.1 → 0.1.1

data/lib/enconvert/internal.rb

@@ -1,153 +1,159 @@
-# frozen_string_literal: true
-
-require "net/http"
-require "uri"
-require "json"
-require "securerandom"
-
-require_relative "formats"
-
-# Shared internal helpers used by both the V1 client and the V2 namespace.
-module Enconvert
-  module Internal
-    # Normalized `{ bytes, filename, content_type }` produced by
-    # {to_file_part}. Shared by the V1 file conversions (Client) and the
-    # V2 file-ingest path (V2#ingest_files).
-    FilePart = Struct.new(:bytes, :filename, :content_type, keyword_init: true)
-
-    # Authenticated, timeout-wrapped Net::HTTP wrapper bound to the client's
-    # base URL. Always sends the `X-API-Key` header (the presigned-URL
-    # download path in Client deliberately bypasses this class).
-    class Transport
-      REQUEST_CLASSES = {
-        get: Net::HTTP::Get,
-        post: Net::HTTP::Post,
-        patch: Net::HTTP::Patch,
-        delete: Net::HTTP::Delete
-      }.freeze
-
-      def initialize(api_key:, base_url:, timeout:)
-        @api_key = api_key
-        @base_url = base_url
-        @timeout = timeout
-      end
-
-      def request(method, path, headers: {}, body: nil)
-        uri = URI("#{@base_url}#{path}")
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == "https"
-        http.open_timeout = @timeout
-        http.read_timeout = @timeout
-
-        request_class = REQUEST_CLASSES.fetch(method) do
-          raise ArgumentError, "Unsupported HTTP method: #{method}"
-        end
-        req = request_class.new(uri)
-        req["X-API-Key"] = @api_key
-        headers.each { |key, value| req[key] = value }
-        req.body = body unless body.nil?
-
-        http.request(req)
-      end
-    end
-
-    module_function
-
-    # Shared error mapping for both V1 and V2. On HTTP >= 400, extracts a
-    # message from JSON `detail`/`error`/the raw body, then raises the
-    # matching typed error: 401/403 -> AuthenticationError, 402 -> QuotaError,
-    # 429 -> RateLimitError, else -> APIError(status, message).
-    def raise_for_status(resp)
-      status = resp.code.to_i
-      return if status < 400
-
-      message = extract_error_message(resp)
-      raise Enconvert::AuthenticationError, message if [401, 403].include?(status)
-      raise Enconvert::QuotaError, message if status == 402
-      raise Enconvert::RateLimitError, message if status == 429
-
-      raise Enconvert::APIError.new(status, message)
-    end
-
-    def extract_error_message(resp)
-      parsed = JSON.parse(resp.body.to_s)
-      if parsed.is_a?(Hash)
-        parsed["detail"] || parsed["error"] || JSON.generate(parsed)
-      else
-        JSON.generate(parsed)
-      end
-    rescue JSON::ParserError, TypeError
-      text = resp.body.to_s
-      text.empty? ? "HTTP #{resp.code}" : text
-    end
-
-    # snake_case-only-if-set serialization of PDF options. Accepts a Hash
-    # with symbol keys: page_size, page_width, page_height, orientation,
-    # margins, scale, grayscale, header, footer.
-    def serialize_pdf_options(o)
-      return {} if o.nil?
-
-      out = {}
-      out[:page_size] = o[:page_size] if o.key?(:page_size)
-      out[:page_width] = o[:page_width] if o.key?(:page_width)
-      out[:page_height] = o[:page_height] if o.key?(:page_height)
-      out[:orientation] = o[:orientation] if o.key?(:orientation)
-      out[:margins] = o[:margins] if o.key?(:margins)
-      out[:scale] = o[:scale] if o.key?(:scale)
-      out[:grayscale] = o[:grayscale] if o.key?(:grayscale)
-      out[:header] = o[:header] if o.key?(:header)
-      out[:footer] = o[:footer] if o.key?(:footer)
-      out
-    end
-
-    # A UUID4 with dashes removed (32 hex chars).
-    def new_job_id
-      SecureRandom.uuid.delete("-")
-    end
-
-    # Convert a FileInput into a normalized FilePart. Accepts:
-    #   - a filesystem path (String)
-    #   - raw bytes via any IO-like/readable object (File, StringIO, ...)
-    #   - a Hash wrapper { data:, filename:, content_type: }
-    def to_file_part(file)
-      if file.is_a?(Hash)
-        data = file[:data] || file["data"]
-        filename = file[:filename] || file["filename"]
-        content_type = file[:content_type] || file["content_type"]
-        bytes = data.respond_to?(:read) ? data.read : data.to_s
-        FilePart.new(bytes: bytes, filename: filename, content_type: content_type || Formats.mime_for(filename))
-      elsif file.is_a?(String)
-        bytes = File.binread(file)
-        filename = File.basename(file)
-        FilePart.new(bytes: bytes, filename: filename, content_type: Formats.mime_for(filename))
-      elsif file.respond_to?(:read)
-        FilePart.new(bytes: file.read, filename: "upload.bin", content_type: "application/octet-stream")
-      else
-        raise Enconvert::Error,
-              "Unsupported file input. Pass a path string, an IO/readable object, or { data:, filename: }."
-      end
-    end
-
-    # Build a multipart/form-data body from a flat list of field hashes
-    # (`{ name:, value:, filename?:, content_type?: }`). Multiple entries
-    # sharing the same `name` produce repeated parts — e.g. ingest_files'
-    # `files` field, one part per uploaded file.
-    def build_multipart(fields)
-      boundary = "EnconvertFormBoundary#{SecureRandom.hex(16)}"
-      crlf = "\r\n".b
-      buffer = +"".b
-      fields.each do |f|
-        buffer << "--#{boundary}".b << crlf
-        if f[:filename]
-          buffer << "Content-Disposition: form-data; name=\"#{f[:name]}\"; filename=\"#{f[:filename]}\"".b << crlf
-          buffer << "Content-Type: #{f[:content_type] || 'application/octet-stream'}".b << crlf << crlf
-        else
-          buffer << "Content-Disposition: form-data; name=\"#{f[:name]}\"".b << crlf << crlf
-        end
-        buffer << f[:value].to_s.b << crlf
-      end
-      buffer << "--#{boundary}--".b << crlf
-      [buffer, boundary]
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "securerandom"
+
+require_relative "formats"
+require_relative "version"
+
+# Shared internal helpers used by both the V1 client and the V2 namespace.
+module Enconvert
+  module Internal
+    # Normalized `{ bytes, filename, content_type }` produced by
+    # {to_file_part}. Shared by the V1 file conversions (Client) and the
+    # V2 file-ingest path (V2#ingest_files).
+    FilePart = Struct.new(:bytes, :filename, :content_type, keyword_init: true)
+
+    # Authenticated, timeout-wrapped Net::HTTP wrapper bound to the client's
+    # base URL. Always sends the `X-API-Key` and `User-Agent` headers (the
+    # presigned-URL download path in Client deliberately bypasses this class).
+    class Transport
+      REQUEST_CLASSES = {
+        get: Net::HTTP::Get,
+        post: Net::HTTP::Post,
+        patch: Net::HTTP::Patch,
+        delete: Net::HTTP::Delete
+      }.freeze
+
+      # Identifies SDK traffic to the gateway (surface attribution).
+      USER_AGENT = "enconvert-sdk/#{Enconvert::VERSION} (ruby)".freeze
+
+      def initialize(api_key:, base_url:, timeout:, user_agent: nil)
+        @api_key = api_key
+        @base_url = base_url
+        @timeout = timeout
+        @user_agent = user_agent || USER_AGENT
+      end
+
+      def request(method, path, headers: {}, body: nil)
+        uri = URI("#{@base_url}#{path}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = @timeout
+        http.read_timeout = @timeout
+
+        request_class = REQUEST_CLASSES.fetch(method) do
+          raise ArgumentError, "Unsupported HTTP method: #{method}"
+        end
+        req = request_class.new(uri)
+        req["X-API-Key"] = @api_key
+        req["User-Agent"] = @user_agent
+        headers.each { |key, value| req[key] = value }
+        req.body = body unless body.nil?
+
+        http.request(req)
+      end
+    end
+
+    module_function
+
+    # Shared error mapping for both V1 and V2. On HTTP >= 400, extracts a
+    # message from JSON `detail`/`error`/the raw body, then raises the
+    # matching typed error: 401/403 -> AuthenticationError, 402 -> QuotaError,
+    # 429 -> RateLimitError, else -> APIError(status, message).
+    def raise_for_status(resp)
+      status = resp.code.to_i
+      return if status < 400
+
+      message = extract_error_message(resp)
+      raise Enconvert::AuthenticationError, message if [401, 403].include?(status)
+      raise Enconvert::QuotaError, message if status == 402
+      raise Enconvert::RateLimitError, message if status == 429
+
+      raise Enconvert::APIError.new(status, message)
+    end
+
+    def extract_error_message(resp)
+      parsed = JSON.parse(resp.body.to_s)
+      if parsed.is_a?(Hash)
+        parsed["detail"] || parsed["error"] || JSON.generate(parsed)
+      else
+        JSON.generate(parsed)
+      end
+    rescue JSON::ParserError, TypeError
+      text = resp.body.to_s
+      text.empty? ? "HTTP #{resp.code}" : text
+    end
+
+    # snake_case-only-if-set serialization of PDF options. Accepts a Hash
+    # with symbol keys: page_size, page_width, page_height, orientation,
+    # margins, scale, grayscale, header, footer.
+    def serialize_pdf_options(o)
+      return {} if o.nil?
+
+      out = {}
+      out[:page_size] = o[:page_size] if o.key?(:page_size)
+      out[:page_width] = o[:page_width] if o.key?(:page_width)
+      out[:page_height] = o[:page_height] if o.key?(:page_height)
+      out[:orientation] = o[:orientation] if o.key?(:orientation)
+      out[:margins] = o[:margins] if o.key?(:margins)
+      out[:scale] = o[:scale] if o.key?(:scale)
+      out[:grayscale] = o[:grayscale] if o.key?(:grayscale)
+      out[:header] = o[:header] if o.key?(:header)
+      out[:footer] = o[:footer] if o.key?(:footer)
+      out
+    end
+
+    # A UUID4 with dashes removed (32 hex chars).
+    def new_job_id
+      SecureRandom.uuid.delete("-")
+    end
+
+    # Convert a FileInput into a normalized FilePart. Accepts:
+    #   - a filesystem path (String)
+    #   - raw bytes via any IO-like/readable object (File, StringIO, ...)
+    #   - a Hash wrapper { data:, filename:, content_type: }
+    def to_file_part(file)
+      if file.is_a?(Hash)
+        data = file[:data] || file["data"]
+        filename = file[:filename] || file["filename"]
+        content_type = file[:content_type] || file["content_type"]
+        bytes = data.respond_to?(:read) ? data.read : data.to_s
+        FilePart.new(bytes: bytes, filename: filename, content_type: content_type || Formats.mime_for(filename))
+      elsif file.is_a?(String)
+        bytes = File.binread(file)
+        filename = File.basename(file)
+        FilePart.new(bytes: bytes, filename: filename, content_type: Formats.mime_for(filename))
+      elsif file.respond_to?(:read)
+        FilePart.new(bytes: file.read, filename: "upload.bin", content_type: "application/octet-stream")
+      else
+        raise Enconvert::Error,
+              "Unsupported file input. Pass a path string, an IO/readable object, or { data:, filename: }."
+      end
+    end
+
+    # Build a multipart/form-data body from a flat list of field hashes
+    # (`{ name:, value:, filename?:, content_type?: }`). Multiple entries
+    # sharing the same `name` produce repeated parts — e.g. ingest_files'
+    # `files` field, one part per uploaded file.
+    def build_multipart(fields)
+      boundary = "EnconvertFormBoundary#{SecureRandom.hex(16)}"
+      crlf = "\r\n".b
+      buffer = +"".b
+      fields.each do |f|
+        buffer << "--#{boundary}".b << crlf
+        if f[:filename]
+          buffer << "Content-Disposition: form-data; name=\"#{f[:name]}\"; filename=\"#{f[:filename]}\"".b << crlf
+          buffer << "Content-Type: #{f[:content_type] || 'application/octet-stream'}".b << crlf << crlf
+        else
+          buffer << "Content-Disposition: form-data; name=\"#{f[:name]}\"".b << crlf << crlf
+        end
+        buffer << f[:value].to_s.b << crlf
+      end
+      buffer << "--#{boundary}--".b << crlf
+      [buffer, boundary]
+    end
+  end
+end