jbr 3.13.0 → 5.0.0

data/lib/jbr/listable.rb

@@ -3,11 +3,9 @@ module Jbr
   # a query by the page it asks for and by what every row of that page carries, so a list is
   # read either as records or as the IDs alone, each with a page sized to what it carries.
   module Listable
-    include Enumerable
-
     # Records a page, not forty and not a hundred: what an includes brings back is charged for
-    # on top of every row of it, so a page of jobs carrying their lines, their property and its
-    # client priced past what a bucket holds. Half the page costs half the query and loses
+    # on top of every row of it, so a page of jobs carrying their lines, their location and its
+    # customer priced past what a bucket holds. Half the page costs half the query and loses
     # nothing, since a walk simply reads more pages.
     PAGE = 20
 
@@ -19,58 +17,42 @@ module Jbr
     # starts, and a page is read only once the one before it runs out.
     def each(&) = walk(page).each(&)
 
-    # @param within [ActiveSupport::Duration, Numeric, nil] how far ahead to look, or nil for
-    #   as far ahead as the account is scheduled.
-    # @return [Listable] the same list, narrowed to what is scheduled from now on.
-    def upcoming(within = nil)
-      now = Time.now
-      narrowed after: now, before: (now + within if within)
-    end
-
-    # @param within [ActiveSupport::Duration, Numeric, nil] how far back to look, or nil for
-    #   as far back as the account goes.
-    # @return [Listable] the same list, narrowed to what started before now.
-    def past(within = nil)
-      now = Time.now
-      narrowed before: now, after: (now - within if within)
-    end
+    # The two halves of a schedule split at one moment rather than per page: read page by page
+    # the boundary would slide, and something could cross it unseen.
+    # @param from [Time, nil] the moment the window opens, or nothing for as far back as it goes.
+    # @param to [Time, nil] the moment the window closes, or nothing for as far ahead as it goes.
+    # @return [Collection] the same list, narrowed to what starts between the two.
+    def between(from, to) = narrowed(startAt: { after: from&.iso8601, before: to&.iso8601 }.compact)
 
     # The ID Jobber files each record under, and nothing else about it: the cheapest question
     # an account can be walked with, and the one to ask where every record is then read on its
-    # own through {#find}.
+    # own through `find`.
     # @return [Array<String>] every ID in the list, every page of them read.
     def ids = walk(ids_page).map(&:id)
 
   private
 
-    # The two halves of a schedule, split at the moment they are asked for rather than per
-    # page: read page by page the boundary would slide, and something could cross it unseen.
-    # The same moment is the near end of a window, so the far end is measured from it too.
-    def narrowed(after: nil, before: nil)
-      bounds = { after: after&.iso8601, before: before&.iso8601 }.compact
-      self.class.new oauth: @oauth, includes: @includes, filter: { startAt: bounds }
+    # Every narrowing lands in the one filter Jobber takes, so asking for a week and asking for
+    # a technician compose whichever way round a caller writes them.
+    def narrowed(**more)
+      self.class.new account: @account, includes: @includes, filter: @filter.to_h.merge(more)
     end
 
-    # Whether a moment falls in the stretch of the schedule the list was narrowed to, for
-    # anything answering one without asking Jobber. A record with no moment at all is in an
-    # open-ended upcoming list, since nothing has started it, and in no window, since a window
-    # is a stretch it would have to have fallen in.
     def scheduled?(at)
-      return true unless @filter
+      bounds = @filter&.dig :startAt
+      return true unless bounds
 
-      after, before = @filter[:startAt].values_at :after, :before
+      after, before = bounds.values_at :after, :before
       return before.nil? unless at
 
       (after.nil? || at >= Time.iso8601(after)) && (before.nil? || at <= Time.iso8601(before))
     end
 
-    # Every record a paged query answers, one at a time, a page read only once the one before
-    # it runs out. The filter is data: narrowed to nothing, the query narrows nothing.
     def walk(statement)
       Enumerator.new do |yielder|
         after = nil
         loop do
-          answered = @oauth.query statement, variables: { after: after, filter: @filter }.compact
+          answered = @account.query statement, variables: { after: after, filter: @filter }.compact
           current = answered.fetch field, {}
           current.fetch('nodes', []).each { |node| yielder << item(node) }
           break unless current.dig 'pageInfo', 'hasNextPage'

data/lib/jbr/logger.rb

@@ -0,0 +1,13 @@
+require 'logger'
+
+module Jbr
+  class << self
+    # Where this gem says what it could not do, for the things it carries on from rather than
+    # raises. An app with a log of its own points this at it.
+    # @return [Logger] somewhere to write, standard error until an app names somewhere better.
+    def logger = @logger ||= Logger.new($stderr)
+
+    # @return [Logger] where to write.
+    attr_writer :logger
+  end
+end

data/lib/jbr/mock/account.rb

@@ -1,15 +1,36 @@
 module Jbr
-  # The account that reads from {Jbr.mock} instead of Jobber.
+  # Credentials that answer from {Jbr.mock} instead of Jobber.
   class Mock::Account < Account
-    # @return [Object, nil] the values the app asked for, and 'account-01' for an ID it did not.
-    def id = node.fetch :id, 'account-01'
+    # @return [Company::Business] business the app named, under `account-01` where it named
+    #   no ID.
+    def business = Company::Business.new node: { id: 'account-01' }.merge(Jbr.mock.business.to_h)
 
-    def name = node[:name]
+    # @return [Mock::Jobs] jobs the app listed.
+    def jobs = Mock::Jobs.new account: self
 
-    def phone = node[:phone]
+    # @return [Mock::Visits] visits the app listed.
+    def visits = Mock::Visits.new account: self
 
-  private
+    # @return [Mock::Technicians] technicians the app listed.
+    def technicians = Mock::Technicians.new account: self
 
-    def node = Jbr.mock.account.to_h
+    # @return [Mock::Quotes] the one quote the app named.
+    def quotes = Mock::Quotes.new
+
+    # @return [Mock::Leads] the one lead the app named.
+    def leads = Mock::Leads.new
+
+    # @return [Mock::Invoices] the one invoice the app named.
+    def invoices = Mock::Invoices.new
+
+    # Revoking a mocked token asks nobody.
+    def delete; end
+
+    # @return [Hash] canned credentials, unless the app asked for a refusal.
+    def self.post(_)
+      raise Error, Jbr.mock.oauth_error if Jbr.mock.oauth_error
+
+      { access_token: 'mock-token', refresh_token: 'mock-token', expires_at: Time.now + 3600 }
+    end
   end
 end

data/lib/jbr/mock/invoice.rb

@@ -1,18 +1,14 @@
 module Jbr
-  # An invoice that reads from {Jbr.mock} instead of Jobber.
+  # An invoice an app under test named, keyed by the readers' names rather than Jobber's.
   class Mock::Invoice < Invoice
-    # @return [Mock::Invoice] itself, carrying the mocked IDs and total.
-    def find(_)
-      @id = Jbr.mock.invoice[:id]
-      @job_id = Jbr.mock.invoice[:job_id]
-      @total = Jbr.mock.invoice[:total]
+    # The mock spells every key as the reader is named.
+    def self.keys = {}
 
-      self
-    end
+    # @return [Company::Job, nil] job the app named beside the invoice.
+    def job = record Company::Job, :job
 
-    # @return [Time, nil] the dates the app asked for.
-    def issued_at = Jbr.mock.invoice[:issued_at]
+  private
 
-    def completed_at = Jbr.mock.invoice[:completed_at]
+    def completed_at = time :completed_at
   end
 end

data/lib/jbr/mock/invoices.rb

@@ -0,0 +1,7 @@
+module Jbr
+  # The one invoice an app under test asked {Jbr.mock} to answer with.
+  class Mock::Invoices
+    # @return [Mock::Invoice, nil] invoice the app named, whatever ID is asked for.
+    def find(_id) = (Mock::Invoice.new node: Jbr.mock.invoice if Jbr.mock.invoice)
+  end
+end

data/lib/jbr/mock/jobs.rb

@@ -3,20 +3,24 @@ module Jbr
   # narrowing a list, and reading it as records or as IDs, is the same code a real one runs.
   class Mock::Jobs < Jobs
     # The job filed under that ID where the app listed one, and otherwise the single job it
-    # named — which is every app that mocks a lookup without mocking a list.
-    # @return [Mock::Job] the job asked for.
-    def find(id) = Mock::Job.new node: listed(id) || Jbr.mock.job
+    # named, which is every app that mocks a lookup without mocking a list.
+    # @param id [String] ID the app filed the job under.
+    # @return [Company::Job, nil] job asked for, nil where the app named none.
+    def find(id)
+      node = listed(id) || Jbr.mock.job
+      Company::Job.new node: node if node
+    end
 
   private
 
     def walk(_statement)
-      Enumerator.new { |yielder| selected.each { |job| yielder << Mock::Job.new(node: job) } }
+      Enumerator.new do |yielder|
+        selected.each { |node| yielder << Company::Job.new(node: node) }
+      end
     end
 
     def selected = Jbr.mock.jobs.select { |job| scheduled? job[:scheduled_at] }
 
-    # Only a real list is looked through: an app that mocked the list as something raising
-    # was mocking the walk failing, and a lookup is a question of its own.
     def listed(id) = (Jbr.mock.jobs.find { |job| job[:id] == id } if Jbr.mock.jobs.is_a? Array)
   end
 end

data/lib/jbr/mock/leads.rb

@@ -0,0 +1,7 @@
+module Jbr
+  # The one lead an app under test asked {Jbr.mock} to answer with.
+  class Mock::Leads
+    # @return [Company::Lead] lead the app named, whatever was asked to be filed.
+    def create(**) = Company::Lead.new node: Jbr.mock.lead.to_h
+  end
+end

data/lib/jbr/mock/quote.rb

@@ -1,12 +1,7 @@
 module Jbr
-  # A quote that reads from {Jbr.mock} instead of Jobber.
+  # A quote an app under test named, its lead under the mock's own key rather than Jobber's.
   class Mock::Quote < Quote
-    # @return [Mock::Quote] itself, carrying the mocked IDs.
-    def find(_)
-      @id = Jbr.mock.quote[:id]
-      @request_id = Jbr.mock.quote[:request_id]
-
-      self
-    end
+    # @return [Company::Lead, nil] lead the app named beside the quote.
+    def lead = record Company::Lead, :lead
   end
 end

data/lib/jbr/mock/quotes.rb

@@ -0,0 +1,7 @@
+module Jbr
+  # The one quote an app under test asked {Jbr.mock} to answer with.
+  class Mock::Quotes
+    # @return [Mock::Quote, nil] quote the app named, whatever ID is asked for.
+    def find(_id) = (Mock::Quote.new node: Jbr.mock.quote if Jbr.mock.quote)
+  end
+end

data/lib/jbr/mock/technicians.rb

@@ -0,0 +1,12 @@
+module Jbr
+  # The technicians an app under test asked {Jbr.mock} to answer with.
+  class Mock::Technicians < Technicians
+  private
+
+    def walk(_statement)
+      Enumerator.new do |yielder|
+        Jbr.mock.technicians.to_a.each { |node| yielder << Company::Technician.new(node: node) }
+      end
+    end
+  end
+end

data/lib/jbr/mock/visit.rb

@@ -1,23 +1,16 @@
 module Jbr
-  # A visit that reads from {Jbr.mock} instead of Jobber.
+  # A visit an app under test listed, keyed by the vocabulary's names rather than Jobber's.
   class Mock::Visit < Visit
-    # @return [Object, nil] the values the app asked for.
-    def id = @node[:id]
+    # The mock spells every key as the reader is named.
+    def self.keys = {}
 
-    def title = @node[:title]
+    # @return [Array<Company::Technician>] whoever the app said the visit is booked for.
+    def technicians = records Company::Technician, :technicians
 
-    def job_id = @node[:job_id]
+    # @return [Company::Lead, nil] lead the app said the visit was booked against.
+    def lead = record Company::Lead, :lead
 
-    def client = Mock::Client.new(node: @node.fetch(:client, {}))
-
-    def property = Mock::Property.new(node: @node.fetch(:property, {}))
-
-    def all_day? = @node[:all_day]
-
-    def client_confirmed? = @node[:client_confirmed]
-
-    def starts_at = @node[:starts_at]
-
-    def ends_at = @node[:ends_at]
+    # @return [Company::Location, nil] where the app said the visit is.
+    def location = record Company::Location, :location
   end
 end

data/lib/jbr/mock/visits.rb

@@ -1,18 +1,51 @@
 module Jbr
   # The visits an app under test asked {Jbr.mock} to answer with. Only the walk is mocked:
-  # narrowing a list, and reading it as records or as IDs, is the same code a real one runs.
+  # narrowing a list, and reading it as records or as IDs, is the same code a real one runs,
+  # so a list nothing narrowed refuses here exactly as Jobber refuses it.
   class Mock::Visits < Visits
-    # @return [Mock::Visit] the visit the app listed under that ID.
-    def find(id) = Mock::Visit.new node: listed(id)
+    # Jobber will not book a moment that names no zone, so neither will this: an app whose
+    # tests pass a bare Time would otherwise only learn of it in production.
+    # @return [Mock::Visit] stop the app listed as its lead, booked for the hour asked for.
+    def create(starts_at:, ends_at:, technicians:, **)
+      zone_of starts_at
+      Mock::Visit.new node: { id: 'visit-01', starts_at: starts_at, ends_at: ends_at,
+                              technicians: technicians.map { |each| { id: each.id } },
+                              lead: Jbr.mock.lead.to_h, }
+    end
 
   private
 
     def walk(_statement)
-      Enumerator.new { |yielder| selected.each { |it| yielder << Mock::Visit.new(node: it) } }
+      Enumerator.new do |yielder|
+        selected.each { |node| yielder << Mock::Visit.new(node: node) }
+      end
+    end
+
+    def selected
+      Jbr.mock.visits.select do |visit|
+        scheduled?(visit[:starts_at]) && assigned?(visit) && kind?(visit)
+      end
+    end
+
+    def scheduled?(at)
+      window = @filter&.dig :occursWithin
+      return true unless window && at
+
+      at >= Time.iso8601(window[:startAt]) && at <= Time.iso8601(window[:endAt])
     end
 
-    def selected = Jbr.mock.visits.select { |visit| scheduled? visit[:starts_at] }
+    def assigned?(visit)
+      wanted = @filter&.dig :assignedTo
+      return true unless wanted
+
+      Array(visit[:technicians]).any? { |technician| wanted.include? technician[:id] }
+    end
 
-    def listed(id) = Jbr.mock.visits.to_a.find { |visit| visit[:id] == id }.to_h
+    def kind?(visit)
+      kind = @filter&.dig :scheduleItemType
+      return true unless kind
+
+      kind == 'VISIT' ? !visit[:job].nil? : !visit[:lead].nil?
+    end
   end
 end

data/lib/jbr/mock.rb

@@ -1,8 +1,21 @@
 module Jbr
-  # What an app under test wants Jobber to answer.
+  # What an app under test wants Jobber to answer, by the vocabulary's names.
   class Mock
-    # The canned answers, each read by the matching Mock resource.
-    attr_accessor :account, :quote, :job, :invoice, :request, :visits, :jobs, :oauth_url,
-      :oauth_error
+    # The canned answers, each read by the matching mock collection.
+    attr_accessor :business, :quote, :job, :invoice, :lead, :jobs, :visits, :technicians,
+      :oauth_url, :oauth_error
+  end
+
+  class << self
+    # Touching it once turns every account over to its mock counterpart.
+    # @return [Mock] answers this process gives, created on first use.
+    def mock = @mock ||= Mock.new
+
+    # @return [Boolean] whether an app under test has switched Jobber off.
+    def mocked? = !@mock.nil?
+
+    # Set to nil, hands the accounts back to Jobber.
+    # @return [Mock, nil] answers this process gives.
+    attr_writer :mock
   end
 end

data/lib/jbr/phone.rb

@@ -4,20 +4,17 @@ module Jbr
     # What Jobber is asked for wherever a client is read: the number, and what ranks it.
     SELECTION = 'phones { normalizedPhoneNumber smsAllowed primary }'
 
-    # Ten digits whose area code and exchange open with 2 through 9, behind the E.164 +1.
-    NORTH_AMERICAN = /\A\+1([2-9]\d{2}[2-9]\d{6})\z/
-
-    # The number to reach a client on, without its country code.
-    # @param phones [Array<Hash>, nil] the numbers as Jobber answered them.
-    # @return [String, nil] the ten digits to call, or nil where none can be dialed.
+    # The primary number first, then one that takes texts, then the rest as filed; the first
+    # of them that can be dialed is the one.
+    # @param phones [Array<Hash>, nil] numbers as Jobber answered them.
+    # @return [String, nil] ten digits to call, or nil where none can be dialed.
     def self.from(phones)
       # The index breaks a tie because sort_by does not: two equally ranked numbers would
       # otherwise swap between runs, and the client would answer a different phone each time.
       ranked = Array(phones).each_with_index.sort_by do |phone, index|
         [ phone['primary'] ? 0 : 1, phone['smsAllowed'] ? 0 : 1, index ]
       end
-      numbers = ranked.lazy.map { |phone, _| phone['normalizedPhoneNumber'].to_s }
-      numbers.filter_map { |number| number[NORTH_AMERICAN, 1] }.first
+      ranked.lazy.filter_map { |phone, _| Company::Phone.from phone['normalizedPhoneNumber'] }.first
     end
   end
 end

data/lib/jbr/querying.rb

@@ -0,0 +1,68 @@
+module Jbr
+  # What credentials do with a statement: post it to Jobber, refresh a stale token once, and
+  # raise every refusal as a {Error} so a caller rescues one class.
+  module Querying
+    # Where every query and mutation is posted.
+    ENDPOINT = 'https://api.getjobber.com/api/graphql'
+
+    # The version of the schema every statement is written against.
+    HEADERS = { 'X-JOBBER-GRAPHQL-VERSION' => '2026-04-22' }
+
+    # How Jobber says the grant does not cover what was asked for: `An object of type User was
+    # hidden due to permissions`. It codes this one not at all, so the words are the only signal
+    # there is, and it names the type in them. An app granted its scopes before a reader existed
+    # would break on every query carrying that reader; this way it carries on a field short.
+    HIDDEN = /hidden due to permissions/
+
+    # The mutation that revokes the app on the account.
+    DISCONNECT = <<~GRAPHQL
+      mutation Disconnect {
+        appDisconnect {
+          app { name author }
+          userErrors { message }
+        }
+      }
+    GRAPHQL
+
+    # Nothing here ever sleeps: where Jobber holds the app to a limit it says so, and a caller
+    # asking from a background job has a queue that will bring the whole job back later.
+    # @param statement [String] query or mutation to run.
+    # @param variables [Hash] what the statement takes.
+    # @return [Hash] data Jobber answered: empty where the credentials are dead, and short of
+    #   whatever the grant does not cover, which Jobber hides rather than answers.
+    # @raise [Throttled] where Jobber refused the statement for what it costs.
+    # @raise [Error] where Jobber refused the statement, or took a mutation and would not act.
+    def query(statement, variables: {})
+      data = client.query statement, variables: variables
+      refusals = user_errors(data).map { |error| error['message'] }
+      raise Error, refusals.join('; ') if refusals.any?
+
+      data
+    rescue GraphQL::Unauthorized
+      refresh ? retry : {}
+    rescue GraphQL::Throttled => error
+      raise Throttled, error.message
+    rescue GraphQL::Error => error
+      raise Error, error.message unless error.message.match? HIDDEN
+
+      Jbr.logger.warn 'Jobber hid what this app is not granted. Tick the scope for the type it ' \
+                      "names and have the account authorize again. #{error.message}"
+      error.data.to_h
+    end
+
+    # Revoke the credentials on the account. Dead ones have nothing left to revoke.
+    def delete
+      client.query DISCONNECT
+    rescue GraphQL::Unauthorized
+    end
+
+  private
+
+    def client = GraphQL::Client.new endpoint: ENDPOINT, token: @access_token, headers: HEADERS
+
+    def user_errors(data)
+      fields = data.each_value.select { |field| field.is_a? Hash }
+      fields.flat_map { |field| Array(field['userErrors']) }
+    end
+  end
+end

data/lib/jbr/reader.rb

@@ -0,0 +1,9 @@
+module Jbr
+  # What every kind reached through the credentials shares: the credentials.
+  class Reader
+    # @param account [Account] credentials to reach Jobber with.
+    def initialize(account:)
+      @account = account
+    end
+  end
+end

data/lib/jbr/reading.rb

@@ -0,0 +1,15 @@
+module Jbr
+  # What a list read through the credentials holds: what to reach Jobber with, what to bring
+  # back beside each record, and what the list was narrowed to. A list of visits answers the
+  # vocabulary's own {Company::Visits} rather than {Collection}, so the three live here.
+  module Reading
+    # @param account [Account] credentials to reach Jobber with.
+    # @param includes [Hash] what to bring back beside each record, by name.
+    # @param filter [Hash, nil] what the list was narrowed to, in the shape Jobber filters by.
+    def initialize(account:, includes: {}, filter: nil)
+      @account = account
+      @includes = includes
+      @filter = filter
+    end
+  end
+end

data/lib/jbr/refreshing.rb

@@ -5,18 +5,12 @@ module Jbr
   module Refreshing
   private
 
-    # With no store there is nobody to compare against: refresh, and leave what we end up
-    # holding for the caller to persist.
     def refresh
       return exchange unless @store
 
       @store.exclusively { |stored| renew stored }
     end
 
-    # Under the store's lock, holding what it says right now. A token that is no longer the one
-    # we tried is one somebody else has already replaced, and adopting it asks Jobber nothing —
-    # which is what keeps a queue of workers from refreshing a hundred times over, each with a
-    # refresh token the first of them has already spent.
     def renew(stored)
       return adopt stored if stored[:access_token] != @access_token
 
@@ -37,8 +31,6 @@ module Jbr
       true
     end
 
-    # Refused while holding the freshest refresh token there is, so the grant itself is dead
-    # rather than our copy being behind.
     def refused
       @invalid_at = Time.now
       @store&.write self

data/lib/jbr/resources/customer.rb

@@ -0,0 +1,23 @@
+module Jbr
+  # A person the business works for, who Jobber calls a client.
+  class Customer < Company::Customer
+    # The node keys Jobber spells otherwise than the vocabulary.
+    def self.keys = { name: :firstName, surname: :lastName }
+
+    # What Jobber calls each flat field of a client. The phones nest: see {Phone}.
+    FIELDS = 'id firstName lastName companyName email'
+
+    # What to ask for wherever a record names its client.
+    SELECTION = "client { #{FIELDS} #{Phone::SELECTION} }"
+
+    # Jobber files nobody without one name or the other, so there is always one to call them.
+    # @return [String, nil] first name, or the business's name where a person has none.
+    def name = super.presence || attribute(:companyName).presence
+
+    # @return [String, nil] ten digits they are reached on, nil where none can be dialed.
+    def phone = Phone.from @node[:phones]
+
+    # @return [Array<Location>] places on their file, where the query asked for them.
+    def locations = @node.dig(:clientProperties, :nodes).to_a.map { |node| Location.new node: node }
+  end
+end

data/lib/jbr/resources/invoice.rb

@@ -0,0 +1,29 @@
+module Jbr
+  # A bill the business issued for finished work, which Jobber alone answers for.
+  class Invoice < Company::Resource
+    # What every invoice reads.
+    def self.attributes = %i[id amount completed_at issued_at]
+
+    # The node keys Jobber spells otherwise than the readers.
+    def self.keys = { amount: :total, issued_at: :issuedDate }
+
+    # Jobber lists the jobs an invoice bills, and one it bills one.
+    # @return [Job, nil] job the invoice bills, where Jobber listed one.
+    def job
+      node = @node.dig :jobs, :nodes, 0
+      Job.new node: node if node
+    end
+
+    # @return [BigDecimal, nil] what the invoice comes to, in dollars.
+    def amount = decimal :amount
+
+    # @return [Time, nil] moment the billed work was finished, or the bill issued where undated.
+    def fulfilled_at = completed_at || issued_at
+
+  private
+
+    def completed_at = job&.completed_at
+
+    def issued_at = time :issued_at
+  end
+end

data/lib/jbr/resources/job.rb

@@ -0,0 +1,20 @@
+module Jbr
+  # Work the business accepted and scheduled.
+  class Job < Company::Job
+    # The node keys Jobber spells otherwise than the vocabulary.
+    def self.keys
+      { description: :title, notes: :instructions, created_at: :createdAt,
+        scheduled_at: :startAt, completed_at: :completedAt, amount: :total, }
+    end
+
+    # @return [Quote, nil] quote the job was won with, where Jobber filed one beside it.
+    def quote = record Quote, :quote
+
+    # @return [Array<Line>] lines the job is made of, empty where the query never asked for
+    #   them: a page costs what it carries, so nothing nested arrives unasked.
+    def lines = @node.dig(:lineItems, :nodes).to_a.map { |node| Line.new node: node }
+
+    # @return [Location, nil] where the work happens, where it came back beside the job.
+    def location = record Location, :property
+  end
+end

data/lib/jbr/resources/lead.rb

@@ -0,0 +1,7 @@
+module Jbr
+  # Somebody who asked the business for work, which Jobber files as a request.
+  class Lead < Company::Lead
+    # @return [Customer, nil] client the request was opened against.
+    def customer = record Customer, :client
+  end
+end

data/lib/jbr/resources/line.rb

@@ -0,0 +1,15 @@
+module Jbr
+  # One line of the work a job is made of.
+  class Line < Company::Line
+    # The node keys Jobber spells otherwise than the vocabulary.
+    def self.keys = { amount: :totalPrice }
+
+    # The most lines to read off one record. Bounded because Jobber prices a connection by the
+    # page it is asked for and prices an unbounded one at its own maximum, so the lines of a
+    # page of jobs were charged for as though every job had the largest job's worth of them.
+    PAGE = 20
+
+    # What to ask for wherever a record lists the lines it is made of.
+    SELECTION = "lineItems(first: #{PAGE}) { nodes { #{node_keys.join ' '} } }"
+  end
+end