pdfmonkey 0.8.1 → 1.0.0

data/lib/pdfmonkey/adapter.rb

@@ -1,25 +1,54 @@
 # frozen_string_literal: true
 
+require 'json'
 require 'net/http'
 
 module Pdfmonkey
   class Adapter
+    HTTP_METHODS = %i[delete get post put].freeze
+
+    NETWORK_ERRORS = [
+      IOError,
+      SocketError,
+      Net::OpenTimeout,
+      Net::ReadTimeout,
+      Net::WriteTimeout,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::EHOSTUNREACH,
+      Errno::EPIPE,
+      Errno::ETIMEDOUT,
+      OpenSSL::SSL::SSLError
+    ].freeze
+
     def initialize(config: Pdfmonkey.configuration)
       @config = config
+      @connection = nil
     end
 
-    def call(method, resource)
-      response = send_request(method, resource)
+    def call(method, resource, params: {}, path: nil, extract: :member)
+      response = send_request(method, resource, params: params, path: path)
 
       case response
       when Net::HTTPNoContent then true
-      when Net::HTTPSuccess then extract_attributes(response, resource)
-      else extract_errors(response)
+      when Net::HTTPSuccess then extract_data(response, resource, extract)
+      else raise_api_error(response)
       end
-    rescue StandardError => e
-      { errors: [e.message], status: 'error' }
+    rescue *NETWORK_ERRORS => e
+      reset_connection
+      raise ConnectionError, e.message
+    end
+
+    def close
+      close_connection
+    end
+
+    def inspect
+      "#<#{self.class}>"
     end
 
+    private attr_reader :config
+
     private def build_delete_request(uri, _resource)
       Net::HTTP::Delete.new(uri, headers)
     end
@@ -34,26 +63,78 @@ module Pdfmonkey
       request
     end
 
-    private def extract_attributes(response, resource)
-      member = resource.class.const_get('MEMBER')
-      JSON.parse(response.body).fetch(member)
+    private def build_put_request(uri, resource)
+      request = Net::HTTP::Put.new(uri, headers)
+      request.body = resource.to_json
+      request
+    end
+
+    private def close_connection
+      @connection&.finish
+    rescue StandardError
+      nil
+    ensure
+      @connection = nil
+    end
+
+    private def connection
+      return @connection if @connection&.started?
+
+      close_connection
+
+      host_uri = URI(config.host)
+      http = Net::HTTP.new(host_uri.host, host_uri.port)
+      http.use_ssl = host_uri.scheme == 'https'
+      http.open_timeout = config.open_timeout
+      http.read_timeout = config.read_timeout
+      http.keep_alive_timeout = config.keep_alive_timeout
+      http.start
+      @connection = http
     end
 
-    private def extract_errors(response)
-      payload = JSON.parse(response.body)
-      errors =
-        if payload['error']
-          [payload['error']]
-        elsif payload['errors'].is_a?(Array)
-          payload['errors'].map { |error| error['detail'] }
-        elsif payload['errors'].is_a?(Hash)
-          payload['errors']
+    private def extract_data(response, resource, extract)
+      body = JSON.parse(response.body.to_s)
+
+      case extract
+      when :member
+        resource_class = resource.is_a?(Class) ? resource : resource.class
+        member = resource_class::MEMBER
+        body.fetch(member) do
+          raise ApiError.new(
+            "Missing '#{member}' key in response",
+            errors: [response.body],
+            status_code: response.code.to_i
+          )
         end
+      when :collection
+        body
+      else
+        raise ArgumentError, "Unknown extract mode: #{extract.inspect}"
+      end
+    rescue JSON::ParserError
+      raise ApiError.new(
+        'Invalid JSON in response body',
+        errors: [response.body],
+        status_code: response.code.to_i
+      )
+    end
 
-      { errors: errors, status: 'error' }
+    private def format_error_message(errors)
+      case errors
+      when Array then errors.join(', ')
+      when Hash
+        errors.map { |field, messages| "#{field}: #{Array(messages).join(', ')}" }.join('; ')
+      else errors.to_s
+      end
     end
 
     private def headers
+      if config.private_key.nil? || config.private_key.to_s.strip.empty?
+        raise Pdfmonkey::Error,
+              'No API key configured. Set ENV["PDFMONKEY_PRIVATE_KEY"] or ' \
+              'use Pdfmonkey.configure { |c| c.private_key = "..." }'
+      end
+
       {
         'Authorization' => "Bearer #{config.private_key}",
         'Content-Type' => 'application/json',
@@ -61,23 +142,65 @@ module Pdfmonkey
       }
     end
 
-    private def send_request(method, resource)
-      uri = URI(url_for(resource))
-      request = send("build_#{method}_request", uri, resource)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = (uri.scheme == 'https')
-      http.request(request)
+    private def parse_error_body(response)
+      payload = JSON.parse(response.body.to_s)
+
+      if payload['error']
+        [payload['error']]
+      elsif payload['errors'].is_a?(Array)
+        extract_error_messages(payload['errors'])
+      elsif payload['errors'].is_a?(Hash)
+        payload['errors']
+      else
+        [response.body]
+      end
+    rescue JSON::ParserError
+      [response.body]
     end
 
-    private def url_for(resource)
-      collection = resource.class.const_get('COLLECTION')
-      endpoint = "#{config.host}/#{config.namespace}/#{collection}"
-      endpoint += "/#{resource.id}" if resource.id
-      endpoint
+    private def extract_error_messages(errors)
+      errors.filter_map do |error|
+        next error.to_s unless error.is_a?(Hash)
+
+        error['detail'] || error['message'] || error.to_json
+      end
+    end
+
+    private def raise_api_error(response)
+      errors = parse_error_body(response)
+
+      raise ApiError.new(
+        format_error_message(errors),
+        errors: errors,
+        status_code: response.code.to_i
+      )
     end
 
-    private
+    private def reset_connection
+      close_connection
+    end
+
+    private def send_request(method, resource, params: {}, path: nil)
+      raise ArgumentError, "Unsupported HTTP method: #{method.inspect}" unless HTTP_METHODS.include?(method)
+
+      uri = URI(url_for(resource, params: params, path: path))
+      request = send("build_#{method}_request", uri, resource)
+      connection.request(request)
+    end
 
-    attr_reader :config
+    private def url_for(resource, params: {}, path: nil)
+      if path
+        endpoint = "#{config.host}/#{config.namespace}/#{path}"
+      else
+        resource_class = resource.is_a?(Class) ? resource : resource.class
+        collection = resource_class::COLLECTION
+        endpoint = "#{config.host}/#{config.namespace}/#{collection}"
+        endpoint += "/#{resource.id}" if !resource.is_a?(Class) && resource.id
+      end
+
+      endpoint += "?#{URI.encode_www_form(params)}" unless params.empty?
+
+      endpoint
+    end
   end
 end

data/lib/pdfmonkey/collection.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pdfmonkey
+  class Collection
+    include Enumerable
+
+    attr_reader :items, :current_page, :total_pages,
+                :next_page_number, :prev_page_number
+
+    def initialize(items:, meta:, page_fetcher:)
+      @items = items.dup.freeze
+      @current_page = meta['current_page']
+      @total_pages = meta['total_pages']
+      @next_page_number = meta['next_page']
+      @prev_page_number = meta['prev_page']
+      @page_fetcher = page_fetcher
+    end
+
+    def each(&)
+      items.each(&)
+    end
+
+    def next_page
+      return unless next_page_number
+
+      page_fetcher.call(next_page_number)
+    end
+
+    def prev_page
+      return unless prev_page_number
+
+      page_fetcher.call(prev_page_number)
+    end
+
+    private attr_reader :page_fetcher
+  end
+end

data/lib/pdfmonkey/configuration.rb

@@ -2,16 +2,25 @@
 
 module Pdfmonkey
   class Configuration
-    attr_accessor :host
-    attr_accessor :namespace
-    attr_accessor :private_key
-    attr_accessor :user_agent
+    attr_accessor :host, :keep_alive_timeout, :namespace,
+                  :open_timeout, :poll_interval, :private_key, :read_timeout
 
     def initialize
       @host = 'https://api.pdfmonkey.io'
+      @keep_alive_timeout = 30
       @namespace = 'api/v1'
-      @private_key = ENV['PDFMONKEY_PRIVATE_KEY']
-      @user_agent = 'Ruby'
+      @open_timeout = 30
+      @poll_interval = 0.5
+      @private_key = ENV.fetch('PDFMONKEY_PRIVATE_KEY', nil)
+      @read_timeout = 30
+    end
+
+    def user_agent
+      "pdfmonkey-ruby/#{Pdfmonkey::VERSION}"
+    end
+
+    def inspect
+      "#<#{self.class} host=#{host.inspect} namespace=#{namespace.inspect}>"
     end
   end
 

data/lib/pdfmonkey/current_user.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pdfmonkey
+  class CurrentUser < Resource
+    ATTRIBUTES = %i[
+      auth_token
+      available_documents
+      block_resources
+      created_at
+      current_plan
+      current_plan_interval
+      desired_name
+      email
+      errors
+      id
+      lang
+      paying_customer
+      share_links
+      trial_ends_on
+      updated_at
+    ].freeze
+
+    COLLECTION = 'current_users'
+    MEMBER = 'current_user'
+
+    def_delegators :attributes, *ATTRIBUTES
+
+    def self.fetch
+      adapter = Pdfmonkey::Adapter.new
+      attrs = adapter.call(:get, self, path: 'current_user')
+      resource_attrs = attrs.transform_keys(&:to_sym)
+      resource_attrs.delete(:adapter)
+      new(adapter: adapter, **resource_attrs)
+    end
+  end
+end

data/lib/pdfmonkey/document.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-require 'json'
-require 'ostruct'
-
 module Pdfmonkey
-  class Document
-    extend Forwardable
+  class Document < Resource
+    include Fetchable
+    include Creatable
+    include Updatable
+    include Deletable
 
     ATTRIBUTES = %i[
       app_id
@@ -20,6 +19,7 @@ module Pdfmonkey
       generation_logs
       id
       meta
+      output_type
       payload
       preview_url
       public_share_link
@@ -28,78 +28,106 @@ module Pdfmonkey
     ].freeze
 
     COMPLETE_STATUSES = %w[error failure success].freeze
+    FAILURE_STATUSES = %w[error failure].freeze
     COLLECTION = 'documents'
     MEMBER = 'document'
 
-    attr_reader :attributes
     def_delegators :attributes, *ATTRIBUTES
 
-    def self.delete(document_id)
-      new(id: document_id).delete!
+    def self.generate!(*args, document_template_id: nil, payload: nil, meta: nil)
+      document_template_id, payload, meta =
+        resolve_document_args(args, document_template_id, payload, meta, __method__)
+      validate_template_id!(document_template_id)
+
+      generate(document_template_id: document_template_id, payload: payload, meta: meta)
+        .send(:poll_until_done!)
     end
 
-    def self.fetch(document_id)
-      new(id: document_id).reload!
+    def self.generate(*args, document_template_id: nil, payload: nil, meta: nil)
+      create_document('pending', args, document_template_id, payload, meta, __method__)
     end
 
-    def self.generate!(document_template_id, payload, meta = {})
-      document = generate(document_template_id, payload, meta)
-      document.reload! until document.done?
-      document
+    def self.create_draft(*args, document_template_id: nil, payload: nil, meta: nil)
+      create_document('draft', args, document_template_id, payload, meta, __method__)
     end
 
-    def self.generate(template_id, payload, meta = {})
-      document = new(
-        document_template_id: template_id,
-        meta: meta.to_json,
-        payload: payload.to_json,
-        status: 'pending')
+    private_class_method def self.create_document(status, args, document_template_id, payload, meta, method_name)
+      document_template_id, payload, meta =
+        resolve_document_args(args, document_template_id, payload, meta, method_name)
+      validate_template_id!(document_template_id)
+
+      new(
+        document_template_id: document_template_id,
+        meta: json_encode(meta),
+        payload: json_encode(payload),
+        status: status
+      ).save
+    end
 
-      document.send(:save)
+    private_class_method def self.validate_template_id!(template_id)
+      return unless template_id.nil? || template_id.to_s.strip.empty?
+
+      raise ArgumentError, 'document_template_id is required'
     end
 
-    def initialize(adapter: Pdfmonkey::Adapter.new, **attributes)
-      @adapter = adapter
-      @attributes = OpenStruct.new(ATTRIBUTES.zip([]).to_h)
-      update(attributes)
+    private_class_method def self.json_encode(value)
+      case value
+      when nil then nil
+      when String then value
+      else value.to_json
+      end
     end
 
-    def delete!
-      adapter.call(:delete, self)
+    private_class_method def self.resolve_document_args(args, kw_template_id, kw_payload, meta, method_name)
+      if args.any?
+        warn "[PDFMonkey] Positional arguments for Document.#{method_name} are deprecated. " \
+             'Use keyword arguments instead: ' \
+             "Document.#{method_name}(document_template_id:, payload:, meta:)",
+             uplevel: 2
+        [args[0], args[1], args[2] || meta]
+      else
+        [kw_template_id, kw_payload, meta]
+      end
     end
 
-    def done?
-      COMPLETE_STATUSES.include?(status)
+    def self.list_cards(**)
+      Pdfmonkey::DocumentCard.list(**)
     end
 
-    def reload!
-      attributes = adapter.call(:get, self)
-      update(attributes)
-      self
+    def self.fetch_card(id)
+      Pdfmonkey::DocumentCard.fetch(id)
     end
 
-    def to_json
-      attrs = attributes.to_h
-      attrs.delete(:errors)
+    def self.fetch_full(id)
+      fetch(id)
+    end
 
-      { document: attrs }.to_json
+    def generate
+      update!(status: 'pending')
     end
 
-    private def save
-      attributes = adapter.call(:post, self)
-      update(attributes)
-      self
+    def generate!
+      generate
+      poll_until_done!
     end
 
-    private def update(new_attributes)
-      new_attributes.each do |key, value|
-        sym_key = key.to_sym
-        attributes[sym_key] = value if ATTRIBUTES.include?(sym_key)
-      end
+    def done?
+      COMPLETE_STATUSES.include?(status)
     end
 
-    private
+    private def poll_until_done!
+      until done?
+        sleep(Pdfmonkey.configuration.poll_interval)
+        reload!
+      end
 
-    attr_reader :adapter
+      if FAILURE_STATUSES.include?(status)
+        message = 'Document generation failed'
+        message += ": #{failure_cause}" if failure_cause
+        raise Pdfmonkey::GenerationError.new(message, document: self)
+      end
+
+      self
+    end
   end
 end

data/lib/pdfmonkey/document_card.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pdfmonkey
+  class DocumentCard < Resource
+    include Fetchable
+    include Listable
+
+    ATTRIBUTES = %i[
+      app_id
+      created_at
+      document_template_id
+      document_template_identifier
+      download_url
+      errors
+      failure_cause
+      filename
+      id
+      meta
+      output_type
+      preview_url
+      public_share_link
+      status
+      updated_at
+    ].freeze
+
+    COLLECTION = 'document_cards'
+    MEMBER = 'document_card'
+
+    FILTERS = {
+      document_template_id: 'q[document_template_id]',
+      status: 'q[status]',
+      workspace_id: 'q[workspace_id]',
+      updated_since: 'q[updated_since]'
+    }.freeze
+
+    def_delegators :attributes, *ATTRIBUTES
+
+    def self.list(page: 1, **)
+      super
+    end
+
+    def to_document
+      Pdfmonkey::Document.fetch(id)
+    end
+  end
+end

data/lib/pdfmonkey/engine.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pdfmonkey
+  class Engine < Resource
+    include Listable
+
+    ATTRIBUTES = %i[
+      deprecated_on
+      errors
+      id
+      name
+    ].freeze
+
+    COLLECTION = 'pdf_engines'
+    MEMBER = 'pdf_engine'
+
+    def_delegators :attributes, *ATTRIBUTES
+  end
+end