enconvert 0.0.1

data/lib/enconvert/internal.rb

@@ -0,0 +1,153 @@
+# 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

data/lib/enconvert/results.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# V1 response types, returned as plain read-only Structs with snake_case
+# readers (e.g. `result.presigned_url`).
+module Enconvert
+  # Response of every single-file / single-page conversion.
+  ConversionResult = Struct.new(
+    :presigned_url, :object_key, :filename, :file_size, :conversion_time_seconds, :job_id,
+    keyword_init: true
+  )
+
+  # Response of {Client#get_job_status}. `status` is one of
+  # "processing", "success", "failed".
+  JobStatus = Struct.new(:status, :presigned_url, :object_key, :error, keyword_init: true)
+
+  # 202 response from an async batch submission (website conversions).
+  BatchSubmission = Struct.new(
+    :batch_id, :status, :url_count, :total_discovered, :discovery_method, :output_format,
+    keyword_init: true
+  )
+
+  # Per-URL entry in a batch status response.
+  BatchItem = Struct.new(:source_url, :status, :download_url, :output_file_size, :duration, keyword_init: true)
+
+  # Response of {Client#get_batch_status} / {Client#wait_for_batch}.
+  # `status` is one of "processing", "completed", "partial", "failed".
+  BatchStatus = Struct.new(
+    :batch_id, :status, :total, :completed, :failed, :in_progress, :output_mode, :zip_download_url, :items,
+    keyword_init: true
+  )
+end