printavo-ruby 0.18.1 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2291442eb2c04c3ead1543773bcd188723de181093941cdc8519681b5b43e4b
-  data.tar.gz: 00274b8c115044888d4099465521acf974c0356261130eb6aacaa21f1d4aa5ce
+  metadata.gz: 6ad593920d96da45a59747ebfaab7fce5d5a1b411e0f6afa781bca1fefcca158
+  data.tar.gz: 6eb415c85c7566986565daddcd6ebd5065d87af95680599ba0b4717892de20e0
 SHA512:
-  metadata.gz: fdd286fc6a29e0313aed8f7ebbea302f7737e17f44144a524396eadcde292d70d9a87b610d22ec3bd692a9a93572d7bb844c861c71dd1e87435c59a3cd465ade
-  data.tar.gz: 29719257b52dfd20f4f9da862e3ccca5df84f8dc64dfb564421a73cbe1b88e46e2a5b36891066ed1e43607e30a3e9a9c6ceecdb3697ac85ce53c2eb1a17b9afa
+  metadata.gz: d95dc0294fe872e6db56d48ab7309c668f24edc5caadf22a5f1333407cac2f31d6845fef845c0cd126ba05cc5033e0ea776ec74768da609fd6878fb1d65fe8d3
+  data.tar.gz: c6b9e54ecd0491b4ffafcf9761473a967d180e1a0bac454ea22c511f1227ba5ec6198361e28303d7db58a4b2cb6fb5f24522820b95ba6add7ada251fe240e235

data/README.md

@@ -22,6 +22,7 @@ A framework-agnostic Ruby SDK for the [Printavo](https://www.printavo.com) Graph
 - Full [Printavo v2 GraphQL API](https://www.printavo.com/docs/api/v2) support
 - Resource-oriented interface: `client.customers.all`, `client.orders.find(id)`
 - Raw GraphQL access: `client.graphql.query("{ ... }")`
+- Sanitized GraphQL response envelopes that preserve partial data and errors
 - Rich domain models: `order.status`, `order.status?(:in_production)`, `order.customer`
 - Rack-compatible webhook signature verification
 - Multi-client support — no globals required
@@ -88,6 +89,60 @@ puts customer.full_name   # => "Jane Smith"
 puts customer.company     # => "Acme Shirts"
 ```
 
+### Bounded Contact Pages
+
+```ruby
+page = client.contacts.page(
+  first: 50,
+  after: previous_cursor,
+  primary_only: true,
+  sort_on: Printavo::Enums::ContactSortField::CONTACT_NAME
+)
+
+page.records.each { |contact| puts contact.full_name }
+next_cursor = page.end_cursor if page.has_next_page
+
+# Partial GraphQL responses preserve successful records and sanitized errors.
+warn(page.errors.inspect) unless page.success?
+```
+
+`contacts.page` performs exactly one request and caps `first` at 100. It never
+follows the next cursor automatically.
+
+`page.response_payload` contains the exact frozen binary HTTP response body
+captured before JSON parsing. It is intentionally omitted from ordinary
+inspection and serialization because provider responses may contain private
+customer data. Persist or log it only through an explicit encrypted evidence
+boundary.
+
+Captured contact responses can be replayed through the same SDK parser without
+provider access:
+
+```ruby
+replayed_page = client.contacts.page_from_response_payload(
+  page.response_payload,
+  metadata: page.metadata
+)
+```
+
+### GraphQL Response Envelopes
+
+```ruby
+envelope = client.graphql.query_envelope(
+  "query Contact($id: ID!) { contact(id: $id) { id email } }",
+  variables: { id: "123" }
+)
+
+envelope.data
+envelope.errors
+envelope.metadata
+envelope.partial?
+```
+
+`query` and `mutate` retain their strict behavior and raise `Printavo::ApiError`
+when GraphQL errors are present. Envelope methods preserve partial data without
+retaining credentials, raw HTTP objects, or provider response bodies.
+
 ### Orders
 
 ```ruby

data/docs/CHANGELOG.md

@@ -6,6 +6,75 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.20.0] - 2026-08-17
+
+### Added
+- `ResponseEnvelope#response_payload` exposes the exact immutable binary HTTP
+  response bytes captured before JSON parsing.
+- `Page#response_payload` carries the exact payload for bounded contact pages.
+- `GraphqlClient#envelope_from_response_payload` and
+  `Contacts#page_from_response_payload` rehydrate captured responses through
+  the same validation, sanitization, and page-building path without network I/O.
+
+### Security
+- Raw response payloads remain excluded from `ResponseEnvelope#to_h` and from
+  ordinary `ResponseEnvelope` and `Page` inspection. They may contain private
+  provider data and must be handled through an explicit evidence boundary.
+
+## [0.19.0] - 2026-07-29
+
+### Added
+- `Contacts#page` for one bounded contacts request with cursor, primary-contact,
+  query, and documented sort controls
+- `GraphqlClient#query_envelope` and `#mutate_envelope` for deeply immutable
+  partial data, sanitized errors, and allowlisted response metadata
+- `Page#errors`, `#metadata`, `#success?`, and `#partial?`
+
+### Security
+- Provider transport failures now raise an identifier-only `TransportError`
+  without retaining a Faraday exception cause or response body
+- GraphQL error details retain only allowlisted fields and redact configured
+  email and token values
+
+## [0.18.1] - 2026-04-05
+
+### Added
+- `examples/diagramming/workflow_diagram.rb` — generates Printavo status
+  workflows as ASCII, Mermaid, DOT, or SVG
+- `examples/reporting/sales_report.rb` — summarizes invoice revenue for common
+  and custom reporting periods
+- `examples/reporting/sales_tax_report.rb` — provides invoice-level sales-tax
+  estimates and fee-level taxable detail
+- `examples/reporting/customers_export.rb` — exports customer data to CSV,
+  XLSX, XLS, vCard, HubSpot, Salesforce, Mailchimp, Constant Contact, Beehiiv,
+  Brevo, and ActiveCampaign formats
+- `examples/reporting/outstanding_tasks.rb` — reports outstanding tasks by due
+  period and assignee and generates an HTML calendar
+- `docs/VISUALIZATION.md` — documents the standalone workflow-diagram example,
+  supported formats, dependencies, and usage
+
+### Changed
+- GitHub Actions now use Node.js 24-compatible `actions/checkout@v4.3.1` and
+  `actions/upload-artifact@v4.6.2`
+
+## [0.18.0] - 2026-04-05
+
+### Added
+- Optional `cache:` and `default_ttl:` arguments on `Printavo::Client`; the
+  cache accepts any store implementing the `Rails.cache`-compatible
+  `fetch(key, expires_in:) { }` and `delete(key)` interface
+- `Printavo::MemoryStore` — a thread-safe, TTL-aware in-memory cache for
+  applications that do not use Rails or an external cache
+- Automatic GraphQL query caching with stable SHA-256 keys derived from the
+  normalized query document and variables
+- Cache adapter and memory-store coverage in the client and GraphQL client
+  specs
+
+### Changed
+- GraphQL mutations always bypass the cache
+- `docs/CACHING.md` now documents `Rails.cache`, `Printavo::MemoryStore`,
+  custom stores, cache-key generation, and mutation behavior
+
 ## [0.17.0] - 2026-04-01
 
 ### Added

data/lib/printavo/client.rb

@@ -47,7 +47,12 @@ module Printavo
         max_retries: max_retries,
         retry_on_rate_limit: retry_on_rate_limit
       ).build
-      @graphql = GraphqlClient.new(connection, cache: cache, default_ttl: default_ttl)
+      @graphql = GraphqlClient.new(
+        connection,
+        cache: cache,
+        default_ttl: default_ttl,
+        sensitive_values: [email, token]
+      )
     end
 
     def account

data/lib/printavo/connection.rb

@@ -29,7 +29,7 @@ module Printavo
         f.headers['email']        = @email
         f.headers['token']        = @token
         f.request :retry, **retry_options
-        f.response :json
+        f.response :json, preserve_raw: true
         f.options.timeout      = @timeout
         f.options.open_timeout = @timeout
         f.adapter Faraday.default_adapter

data/lib/printavo/errors.rb

@@ -10,6 +10,8 @@ module Printavo
 
   class NotFoundError < Error; end
 
+  class TransportError < Error; end
+
   class ApiError < Error
     attr_reader :response
 

data/lib/printavo/graphql/contacts/all.graphql

@@ -0,0 +1,36 @@
+query Contacts(
+  $first: Int
+  $after: String
+  $primaryOnly: Boolean
+  $query: String
+  $sortOn: ContactSortField
+  $sortDescending: Boolean
+) {
+  contacts(
+    first: $first
+    after: $after
+    primaryOnly: $primaryOnly
+    query: $query
+    sortOn: $sortOn
+    sortDescending: $sortDescending
+  ) {
+    nodes {
+      id
+      firstName
+      lastName
+      fullName
+      email
+      phone
+      fax
+      createdAt
+      updatedAt
+      customer {
+        id
+      }
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}

data/lib/printavo/graphql_client.rb

@@ -6,15 +6,29 @@ require 'json'
 
 module Printavo
   class GraphqlClient
+    SAFE_ERROR_EXTENSION_KEYS = %w[classification code].freeze
+    SAFE_METADATA_HEADERS = %w[
+      retry-after
+      x-request-id
+      x-ratelimit-limit
+      x-ratelimit-remaining
+      x-ratelimit-reset
+    ].freeze
+
     # @param connection  [Faraday::Connection]
     # @param cache       [#fetch, #delete, nil] any cache store implementing
     #                    +fetch(key, expires_in:) { }+ and +delete(key)+,
     #                    e.g. +Rails.cache+, +Printavo::MemoryStore.new+, or +nil+
     # @param default_ttl [Integer] default TTL in seconds applied to cached queries (default: 300)
-    def initialize(connection, cache: nil, default_ttl: 300)
+    # @param sensitive_values [Array<String>] credentials to redact from provider messages
+    def initialize(connection, cache: nil, default_ttl: 300, sensitive_values: [])
       @connection  = connection
       @cache       = cache
       @default_ttl = default_ttl
+      @sensitive_values = sensitive_values.filter_map do |value|
+        string = value.to_s
+        string unless string.empty?
+      end.freeze
     end
 
     # Executes a GraphQL query and returns the parsed `data` hash.
@@ -61,6 +75,40 @@ module Printavo
       execute(mutation_string, variables: variables)
     end
 
+    # Executes a GraphQL query without discarding partial data when GraphQL
+    # errors are present. HTTP and transport failures still raise their
+    # identifier-only SDK exceptions.
+    #
+    # @return [Printavo::ResponseEnvelope]
+    def query_envelope(query_string, variables: {})
+      execute_envelope(query_string, variables: variables)
+    end
+
+    # Mutation equivalent of #query_envelope. Callers must decide whether a
+    # partial mutation response represents an uncertain write.
+    #
+    # @return [Printavo::ResponseEnvelope]
+    def mutate_envelope(mutation_string, variables: {})
+      execute_envelope(mutation_string, variables: variables)
+    end
+
+    # Rehydrates one captured GraphQL response without performing network I/O.
+    # The exact payload remains attached to the immutable envelope while parsed
+    # data and errors follow the same validation and sanitization as live calls.
+    def envelope_from_response_payload(response_payload, metadata: {})
+      raise ArgumentError, 'response_payload must be a String' unless response_payload.is_a?(String)
+
+      payload = response_payload.b.dup.freeze
+      body = JSON.parse(payload)
+      build_envelope(
+        body: body,
+        metadata: safe_metadata_hash(metadata),
+        response_payload: payload
+      )
+    rescue JSON::ParserError
+      malformed_envelope(metadata: safe_metadata_hash(metadata), response_payload: payload)
+    end
+
     # Iterates all pages of a paginated GraphQL query, yielding each page's
     # nodes array. The query must accept `$first: Int` and `$after: String`
     # variables, and the target connection must expose `nodes` and `pageInfo`.
@@ -106,28 +154,121 @@ module Printavo
     end
 
     def execute(document, variables: {})
-      response = @connection.post('') do |req|
-        req.body = JSON.generate(query: document, variables: variables)
-      end
-      handle_response(response)
+      envelope = execute_envelope(document, variables: variables)
+      return envelope.data if envelope.success?
+
+      messages = envelope.errors.map { |error| error.fetch('message') }.join(', ')
+      raise ApiError.new(messages, response: { 'errors' => envelope.errors }.freeze)
     end
 
-    def handle_response(response)
-      body = response.body
+    def execute_envelope(document, variables: {})
+      response = @connection.post('') { |request| request.body = JSON.generate(query: document, variables: variables) }
+      handle_envelope(response)
+    rescue Faraday::ParsingError => e
+      handle_envelope(e.response)
+    rescue Faraday::Error
+      raise TransportError, 'Printavo transport request failed', cause: nil
+    end
 
+    def handle_envelope(response)
       case response.status
       when 401 then raise AuthenticationError, 'Invalid credentials — check your email and token'
       when 429 then raise RateLimitError, 'Printavo rate limit exceeded (10 req/5 sec)'
       when 404 then raise NotFoundError, 'Resource not found'
       end
 
-      errors = body.is_a?(Hash) ? body['errors'] : nil
-      if errors&.any?
-        messages = errors.map { |e| e['message'] }.join(', ')
-        raise ApiError.new(messages, response: body)
+      build_envelope(
+        body: response.body,
+        metadata: safe_metadata_hash(response.headers.to_h),
+        response_payload: raw_response_payload(response)
+      )
+    end
+
+    def build_envelope(body:, metadata:, response_payload:)
+      return malformed_envelope(metadata: metadata, response_payload: response_payload) unless valid_envelope?(body)
+
+      ResponseEnvelope.new(
+        data: body['data'],
+        errors: sanitize_errors(body.fetch('errors', [])),
+        metadata: metadata,
+        response_payload: response_payload
+      )
+    end
+
+    def valid_envelope?(body)
+      return false unless body.is_a?(Hash) && (body.key?('data') || body.key?('errors'))
+      return false unless body['data'].nil? || body['data'].is_a?(Hash)
+
+      errors = body.fetch('errors', [])
+      errors.is_a?(Array) && errors.all?(Hash)
+    end
+
+    def malformed_envelope(metadata:, response_payload:)
+      ResponseEnvelope.new(
+        data: nil,
+        errors: [
+          {
+            'message' => 'Malformed GraphQL response',
+            'extensions' => { 'code' => 'MALFORMED_RESPONSE' }
+          }
+        ],
+        metadata: metadata,
+        response_payload: response_payload
+      )
+    end
+
+    def raw_response_payload(response)
+      payload = response.env[:raw_body] || response.body
+      payload if payload.is_a?(String)
+    end
+
+    def sanitize_errors(errors)
+      errors.map do |error|
+        {
+          'message' => redact(error.fetch('message', 'GraphQL request failed').to_s)[0, 500],
+          'path' => sanitize_path(error['path']),
+          'locations' => sanitize_locations(error['locations']),
+          'extensions' => sanitize_extensions(error['extensions'])
+        }.compact
+      end
+    end
+
+    def sanitize_path(path)
+      return unless path.is_a?(Array)
+
+      path.select { |part| part.is_a?(String) || part.is_a?(Integer) }
+    end
+
+    def sanitize_locations(locations)
+      return unless locations.is_a?(Array)
+
+      locations.filter_map do |location|
+        next unless location.is_a?(Hash)
+
+        line = location['line']
+        column = location['column']
+        { 'line' => line, 'column' => column } if line.is_a?(Integer) && column.is_a?(Integer)
+      end
+    end
+
+    def sanitize_extensions(extensions)
+      return unless extensions.is_a?(Hash)
+
+      extensions.slice(*SAFE_ERROR_EXTENSION_KEYS).transform_values { |value| redact(value.to_s)[0, 100] }
+    end
+
+    def safe_metadata_hash(value)
+      raise ArgumentError, 'metadata must be a Hash' unless value.is_a?(Hash)
+
+      headers = value.transform_keys { |key| key.to_s.downcase }
+      SAFE_METADATA_HEADERS.each_with_object({}) do |header, metadata|
+        value = headers[header]
+        metadata[header] = redact(value.to_s)[0, 100] unless value.nil?
       end
+    end
 
-      body.is_a?(Hash) ? body['data'] : body
+    def redact(value)
+      @sensitive_values.reduce(value.dup) { |result, secret| result.gsub(secret, '[FILTERED]') }
     end
 
     # Resolves a dot-separated path against a nested hash.

data/lib/printavo/page.rb

@@ -14,9 +14,32 @@ module Printavo
   #   client.customers.each_page(first: 10) do |records|
   #     records.each { |c| puts c.full_name }
   #   end
-  Page = Struct.new(:records, :has_next_page, :end_cursor, keyword_init: true) do
+  Page = Struct.new(
+    :records,
+    :has_next_page,
+    :end_cursor,
+    :errors,
+    :metadata,
+    :response_payload,
+    keyword_init: true
+  ) do
+    def initialize(**attributes)
+      payload = attributes[:response_payload]
+      raise ArgumentError, 'response_payload must be a String' if payload && !payload.is_a?(String)
+
+      payload = payload.b.dup.freeze if payload
+      super(**attributes.merge(response_payload: payload))
+    end
+
     def to_a    = records
     def size    = records.size
     def empty?  = records.empty?
+    def success? = Array(errors).empty?
+    def partial? = records.any? && !success?
+
+    def inspect
+      "#<#{self.class} records=#{records.inspect} has_next_page=#{has_next_page.inspect} " \
+        "end_cursor=#{end_cursor.inspect} errors=#{errors.inspect} metadata=#{metadata.inspect}>"
+    end
   end
 end

data/lib/printavo/resources/contacts.rb

@@ -4,11 +4,40 @@
 module Printavo
   module Resources
     class Contacts < Base
+      ALL_QUERY       = File.read(File.join(__dir__, '../graphql/contacts/all.graphql')).freeze
       FIND_QUERY      = File.read(File.join(__dir__, '../graphql/contacts/find.graphql')).freeze
       CREATE_MUTATION = File.read(File.join(__dir__, '../graphql/contacts/create.graphql')).freeze
       DELETE_MUTATION = File.read(File.join(__dir__, '../graphql/contacts/delete.graphql')).freeze
       UPDATE_MUTATION = File.read(File.join(__dir__, '../graphql/contacts/update.graphql')).freeze
 
+      MAX_PAGE_SIZE = 100
+      PAGE_FILTERS = %i[primary_only query sort_descending sort_on].freeze
+
+      def all(first: 25, after: nil, **filters)
+        page(first: first, after: after, **filters).records
+      end
+
+      # Fetches one bounded contact page while preserving sanitized partial
+      # GraphQL errors. This method never follows the next cursor.
+      #
+      # @return [Printavo::Page]
+      def page(first: 25, after: nil, **filters)
+        validate_page!(first: first, filters: filters)
+        envelope = @graphql.query_envelope(
+          ALL_QUERY,
+          variables: contact_variables(first: first, after: after, filters: filters)
+        )
+        build_page(envelope)
+      end
+
+      # Rebuilds a captured contacts page through the SDK parser without
+      # performing provider network I/O.
+      def page_from_response_payload(response_payload, metadata: {})
+        build_page(
+          @graphql.envelope_from_response_payload(response_payload, metadata: metadata)
+        )
+      end
+
       # Finds a contact by ID.
       #
       # @param id [String, Integer]
@@ -57,6 +86,47 @@ module Printavo
         @graphql.mutate(DELETE_MUTATION, variables: { id: id.to_s })
         nil
       end
+
+      private
+
+      def validate_page!(first:, filters:)
+        unless first.is_a?(Integer) && first.between?(1, MAX_PAGE_SIZE)
+          raise ArgumentError, "first must be between 1 and #{MAX_PAGE_SIZE}"
+        end
+
+        unknown_filters = filters.keys - PAGE_FILTERS
+        raise ArgumentError, "unknown contact filters: #{unknown_filters.join(', ')}" if unknown_filters.any?
+
+        sort_on = filters[:sort_on]
+        return if sort_on.nil? || Enums::ContactSortField::ALL.include?(sort_on)
+
+        raise ArgumentError, 'sort_on must be a Printavo::Enums::ContactSortField value'
+      end
+
+      def contact_variables(first:, after:, filters:)
+        {
+          first: first,
+          after: after,
+          primaryOnly: filters[:primary_only],
+          query: filters[:query],
+          sortOn: filters[:sort_on],
+          sortDescending: filters[:sort_descending]
+        }
+      end
+
+      def build_page(envelope)
+        connection = envelope.data&.fetch('contacts', nil) || {}
+        records = Array(connection['nodes']).map { |attrs| Printavo::Contact.new(attrs) }
+        page_info = connection.fetch('pageInfo', {})
+        Printavo::Page.new(
+          records: records,
+          has_next_page: page_info.fetch('hasNextPage', false),
+          end_cursor: page_info['endCursor'],
+          errors: envelope.errors,
+          metadata: envelope.metadata,
+          response_payload: envelope.response_payload
+        )
+      end
     end
   end
 end

data/lib/printavo/response_envelope.rb

@@ -0,0 +1,56 @@
+# lib/printavo/response_envelope.rb
+# frozen_string_literal: true
+
+module Printavo
+  class ResponseEnvelope
+    attr_reader :data, :errors, :metadata, :response_payload
+
+    def initialize(data:, errors: [], metadata: {}, response_payload: nil)
+      @data = immutable_copy(data)
+      @errors = immutable_copy(errors)
+      @metadata = immutable_copy(metadata)
+      @response_payload = immutable_payload(response_payload)
+      freeze
+    end
+
+    def success?
+      errors.empty?
+    end
+
+    def partial?
+      !data.nil? && errors.any?
+    end
+
+    def to_h
+      { 'data' => data, 'errors' => errors, 'metadata' => metadata }.freeze
+    end
+
+    def inspect
+      "#<#{self.class} data=#{data.inspect} errors=#{errors.inspect} metadata=#{metadata.inspect}>"
+    end
+
+    private
+
+    def immutable_payload(value)
+      return if value.nil?
+      raise ArgumentError, 'response_payload must be a String' unless value.is_a?(String)
+
+      value.b.dup.freeze
+    end
+
+    def immutable_copy(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, item), copy|
+          copy[key.to_s.freeze] = immutable_copy(item)
+        end.freeze
+      when Array
+        value.map { |item| immutable_copy(item) }.freeze
+      when String
+        value.dup.freeze
+      else
+        value
+      end
+    end
+  end
+end

data/lib/printavo/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Printavo
-  VERSION = '0.18.1'
+  VERSION = '0.20.0'
 end

data/lib/printavo.rb

@@ -10,6 +10,7 @@ require_relative 'printavo/config'
 require_relative 'printavo/connection'
 require_relative 'printavo/enums'
 require_relative 'printavo/errors'
+require_relative 'printavo/response_envelope'
 require_relative 'printavo/graphql_client'
 require_relative 'printavo/memory_store'
 require_relative 'printavo/page'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: printavo-ruby
 version: !ruby/object:Gem::Version
-  version: 0.18.1
+  version: 0.20.0
 platform: ruby
 authors:
 - Stan Carver II
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-05 00:00:00.000000000 Z
+date: 2026-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.14'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.14'
 - !ruby/object:Gem::Dependency
   name: faraday-retry
   requirement: !ruby/object:Gem::Requirement
@@ -320,6 +320,7 @@ files:
 - lib/printavo/graphql/approval_requests/unapprove.graphql
 - lib/printavo/graphql/categories/all.graphql
 - lib/printavo/graphql/categories/find.graphql
+- lib/printavo/graphql/contacts/all.graphql
 - lib/printavo/graphql/contacts/create.graphql
 - lib/printavo/graphql/contacts/delete.graphql
 - lib/printavo/graphql/contacts/find.graphql
@@ -544,6 +545,7 @@ files:
 - lib/printavo/resources/types_of_work.rb
 - lib/printavo/resources/users.rb
 - lib/printavo/resources/vendors.rb
+- lib/printavo/response_envelope.rb
 - lib/printavo/version.rb
 - lib/printavo/webhooks.rb
 homepage: https://github.com/scarver2/printavo-ruby