halfpipe 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dc40923fa2235403dd30cf796bb0d7d807507b401e39c3a079af2be4f1f83a3d
+  data.tar.gz: 7c790b80900bae25d6dc295046ad08f491e5c977a85dbd999e06d753f01350ea
+SHA512:
+  metadata.gz: 9dc32cd78f4781b1b875476fa5602e34cd3ff26a8b46dba908bfc7de4578f801586547eea4d978fe7a2e6a2d3d0d9ef8b6e2fc872d79005620c11de4aedb4880
+  data.tar.gz: 1b1e23c59b58011e6ca7fedced7373138ebb98a63e7ea50cefd3a301f7ef894f72bc8734308fff40e924c0876620c477c06260cbf34b528d19b16c43521e64bd

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard
+ruby_version: 3.0

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## [0.0.1] - 2022-01-13
+
+- Initial release

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake"
+gem "minitest"
+gem "standard"
+gem "dotenv"
+gem "pry"

data/Gemfile.lock

@@ -0,0 +1,56 @@
+PATH
+  remote: .
+  specs:
+    halfpipe (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    coderay (1.1.3)
+    dotenv (2.7.6)
+    method_source (1.0.0)
+    minitest (5.15.0)
+    parallel (1.21.0)
+    parser (3.1.0.0)
+      ast (~> 2.4.1)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.2.0)
+    rexml (3.2.5)
+    rubocop (1.24.1)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.15.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.15.1)
+      parser (>= 3.0.1.1)
+    rubocop-performance (1.13.1)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.11.0)
+    standard (1.6.0)
+      rubocop (= 1.24.1)
+      rubocop-performance (= 1.13.1)
+    unicode-display_width (2.1.0)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  dotenv
+  halfpipe!
+  minitest
+  pry
+  rake
+  standard
+
+BUNDLED WITH
+   2.3.3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Test Double, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,304 @@
+<img src="https://user-images.githubusercontent.com/79303/149438778-ab0e7337-cf3a-4db8-8c03-0f04ccd83179.jpg" width="90%"/>
+
+# Halfpipe - a Pipedrive client that doesn't do half of what you want
+
+If you're scouring [RubyGems.org](https://rubygems.org) for a general-purpose
+client to the [Pipedrive](https://www.pipedrive.com)
+[API](https://developers.pipedrive.com/docs/api/v1), this is probably not the
+gem for you ([here's why](#why-doesnt-this-gem-do-what-i-want)). Here's what it
+does and how to use it anyway.
+
+Halfpipe's API is split between compound actions (read: features we needed
+ourselves) and an assortment of wrapped HTTP endpoints (aka stuff we needed in
+order to implement those actions). Most methods return
+[Structs](https://ruby-doc.org/core-3.0.0/Struct.html) encapsulating the minimum
+number of attributes needed to accomplish these actions.
+
+If Halfpipe doesn't do what you're looking for, you might consider just using
+its [Http](#halfpipehttp) methods, since they at least handle HTTP request
+authentication, pagination, and rate limiting for you.
+
+# Setup
+
+Add this to your Gemfile and kickflip it:
+
+```ruby
+gem "halfpipe"
+```
+
+For configuration, the gem needs your Pipedrive subdomain and [API
+Token](https://pipedrive.readme.io/docs/how-to-find-the-api-token). If your
+subdomain is `"alwaysbeselling"` and your API token is stored in an environment
+variable named `PIPEDRIVE_API_TOKEN`, you can configure Halfpipe like this:
+
+```ruby
+Halfpipe.config(
+  subdomain: "alwaysbeselling"
+  api_token: ENV["PIPEDRIVE_API_TOKEN"]
+)
+```
+
+# Primary API
+
+## Halfpipe.create_deal_for_person
+
+Test Double [has a contact form](https://testdouble.com/contact) that takes a
+handful of inputs and uses it to create a deal in Pipedrive so we can stay
+organized. To do this seemingly simple thing requires numerous interactions with
+the Pipedrive API: find-or-create the
+[person](https://developers.pipedrive.com/docs/api/v1/Persons), find the first
+[stage](https://developers.pipedrive.com/docs/api/v1/Stages) of the intended
+[pipeline](https://developers.pipedrive.com/docs/api/v1/Pipelines), find any
+custom [deal fields](https://developers.pipedrive.com/docs/api/v1/DealFields)
+that we want to set, create the
+[deal](https://developers.pipedrive.com/docs/api/v1/Deals), and then (finally!)
+attach a [note](https://developers.pipedrive.com/docs/api/v1/Notes) to the deal.
+
+To accomplish this, here's what Halfpipe offers:
+
+```ruby
+Halfpipe.create_deal_for_person(
+  name: "Person Face",
+  email: "person.face@example.com",
+  deal_title: "Person Face lead via Halfpipe",
+  custom_deal_fields: {
+    "How they heard about us" => "A GitHub README",
+    "Inbound CTA" => "halfpipe-github-readme"
+  },
+  note_content: "Greetings!",
+  pipeline_name: "Halfpipe Leads"
+)
+```
+
+**[Heads up:** any `custom_deal_fields` you send need to be an exact textual
+match for a [field](https://support.pipedrive.com/en/article/custom-fields)
+configured in your Pipedrive instance or, failing that, boil down to the same
+string when stripped of extraneous whitespace and punctuation (e.g.
+`how_they_heard_about_us` and `inbound_cta` above).**]**
+
+# Supporting API
+
+Halfpipe is unapologetically *not* a complete wrapper for Pipedrive's API
+and instead only provides methods that we had to write in support of this gem's
+[Primary API](#primary-api), so YMMV (but this is open source, so it's already
+YMMV).
+
+## Halfpipe::Api::Persons
+
+### Halfpipe::Api::Persons.find_by_email(email)
+
+This method will return the first person in Pipedrive with an e-mail that's an
+exact match for what you provide:
+
+```ruby
+> person = Halfpipe::Api::Persons.find_by_email("person.face@example.com")
+=> #<struct Halfpipe::Person
+ id=9,
+ name="Person Face",
+ email="person.face@example.com",
+ organization_id=2>
+```
+
+### Halfpipe::Api::Persons.create(name:, email:)
+
+This method will create a new person with the provided name & e-mail address,
+returning a `Struct` that includes the resulting ID:
+
+```ruby
+> person = Halfpipe::Api::Persons.create(
+  name: "A person",
+  email: "person.face@example.com"
+)
+=> #<struct Halfpipe::Person
+ id=10,
+ name="A person",
+ email="person.face@example.com",
+ organization_id=nil>
+```
+
+## Halfpipe::Api::Deals
+
+### Halfpipe::Api::Deals.create(title:, stage_id: nil, person_id: nil, organization_id: nil, custom_fields: {})
+
+This method creates a new deal with the properties you pass it. Only `title` and
+either `person_id` or `organization_id` is required:
+
+```ruby
+> deal = Halfpipe::Api::Deals.create(title: "A deal!", organization_id: 1)
+=> #<struct Halfpipe::Deal
+ id=31,
+ title="A deal!",
+ stage_id=1,
+ person_id=nil,
+ organization_id=1>
+```
+
+## Halfpipe::Api::DealFields
+
+### Halfpipe::Api::DealFields.get
+
+This method retrieves all the custom fields you've defined for deals in your
+Pipedrive instance. Why was this necessary for the gem? We need to fetch
+these `DealField` entities and map the string name of any custom fields to the
+hash key assigned by Pipedrive.
+
+```ruby
+> deal_fields = Halfpipe::Api::DealFields.get
+=> [#<struct Halfpipe::DealField key="title", name="Title", symbol="title">,
+ #<struct Halfpipe::DealField key="creator_user_id", name="Creator", symbol="creator">,
+ #<struct Halfpipe::DealField key="user_id", name="Owner", symbol="owner">,
+ #<struct Halfpipe::DealField key="value", name="Value", symbol="value">,
+ #… etc…
+]
+```
+
+## Halfpipe::Api::Stages
+
+### Halfpipe::Api::Stages.find_first_stage_by_pipeline_name(pipeline_name)
+
+This method will return the first stage in the first Pipedrive with the given
+`pipeline_name`.
+
+```ruby
+> stage = Halfpipe::Api::Stages.find_first_stage_by_pipeline_name("Pipeline")
+=> #<struct Halfpipe::Stage
+ id=1,
+ pipeline_id=1,
+ name="Qualified">
+```
+
+## Halfpipe::Api::Notes
+
+### Halfpipe::Api::Notes.create(content:, deal_id: nil, person_id: nil, organization_id: nil)
+
+This method creates notes and attaches them to the provided deal, person, and/or
+organization (at least one is required).
+
+```ruby
+> note = Halfpipe::Api::Notes.create(person_id: 1, content: "Greetings!")
+=> #<struct Halfpipe::Note
+ id=11,
+ content="Greetings!",
+ deal_id=nil,
+ person_id=1,
+ organization_id=nil>
+```
+
+## Halfpipe::Http
+
+### Halfpipe::Http.get(path, params: {}, start: 0)
+
+This method will send a `GET` request on your behalf, appending the required
+`api_token` query parameter along with whatever other params you send.
+Additionally, it will paginate throughout _all_ the results that your query
+might return. Until the job is done, it'll even wait whatever retry amount the
+API's `x-ratelimit-reset` header tells it to wait!
+
+You can use this method to fetch stuff that isn't supported by the rest of the
+API. You'll just get hashes back instead of custom `Struct` instances:
+
+```ruby
+> pipelines = Halfpipe::Http.get("/pipelines")
+=> [{"id"=>1,
+  "name"=>"Pipeline",
+  "url_title"=>"default",
+  "order_nr"=>1,
+  "active"=>true,
+  "deal_probability"=>false,
+  "add_time"=>"2022-01-04 12:35:34",
+  "update_time"=>nil,
+  "selected"=>true},
+ {"id"=>2,
+  "name"=>"Test Double Leads",
+  "url_title"=>"Test-Double-Leads",
+  "order_nr"=>2,
+  "active"=>true,
+  "deal_probability"=>true,
+  "add_time"=>"2022-01-07 16:14:08",
+  "update_time"=>"2022-01-07 16:14:08",
+  "selected"=>false}]
+```
+
+### Halfpipe::Http.post(path, params: {})
+
+This method is a straightforward wrapper of
+[Net::HTTP.post_form](https://ruby-doc.org/stdlib-3.0.0/libdoc/net/http/rdoc/Net/HTTP.html#method-c-post_form):
+
+```ruby
+> organization = Halfpipe::Http.post("/organizations", params: {name: "An org"})
+=> {"id"=>3,
+ "company_id"=>10804948,
+ "owner_id"=>
+  {"id"=>853119,
+   "name"=>"Justin Searls",
+   # etc.
+  },
+ "name"=>"An org",
+ "open_deals_count"=>0,
+ "related_open_deals_count"=>0,
+ "closed_deals_count"=>0,
+ # etc.
+}
+```
+
+### Halfpipe::Http.delete(path, params: {})
+
+Fair warning: the gem only uses this method to clean up test data:
+
+```ruby
+> Halfpipe::Http.delete("/notes/#{id}")
+=> # The Net::Http::Response
+```
+
+## Why doesn't this gem do what I want?
+
+Pipedrive—and
+[CRM](https://en.wikipedia.org/wiki/Customer_relationship_management) tools
+generally—are devilishly simple. At their most basic, they only require a
+half-dozen models ("Person", "Lead", "Deal", etc.) and their core functionality
+can easily be expressed with familiar CRUD actions ("create a new deal", "change
+the status of this deal")… what's so hard about that?
+
+Here's the tricky part: lying just beneath the surface of every CRM tool, there
+is an entire [key-value
+database](https://en.wikipedia.org/wiki/Key–value_database), and the users
+(usually salespeople) are its
+[DBAs](https://en.wikipedia.org/wiki/Database_administrator). Each of a CRM's
+seemingly-simple models might have infinitely many custom fields defined by the
+user—sometimes more than one with the same name! Each field can be one of any
+number of types, including compound types composed of other fields! And, of
+course, each record can be linked to one or more of any other type of record,
+and there's nothing to stop a custom field from defining additional
+associations!
+
+As if that weren't enough, a CRM needs to serve as an authoritative source of
+record for a company's prospects, customers, and contacts despite the fact that
+its interactions with those people occur in countless other systems far beyond
+the CRM tool's purview. As a result, most CRMs optimize for two user experiences
+that are relevant to think about for anyone hoping to integrate with them:
+
+1. Low-friction data ingestion across numerous points of ingress: phone, e-mail,
+   web, newsletter, ad networks, partner sites, etc.
+2. Sophisticated sanitization, de-duplication, and merging of the data chaos
+   that inevitably results from Step 1
+
+So, if you're building a general-purpose API client or an application that
+aspires to provide a comprehensive view of a CRM's data, you need to prepare for
+every eventuality. To recap: every record has infinitely many nested attributes
+with names you can't easily know (and which may not be unique), each field
+having types defined by the user, and which could be associated with every other
+record multiple times over. And you have to be careful how you store things,
+since yesterday's ID for any given could be an entirely different ID tomorrow if
+someone clicked "Merge" in a way you didn't expect.
+
+And that's why this gem doesn't get fancy. It just provides a handful of actions
+we find useful against Pipedrive CRM and then bails out. 🛹
+
+## Code of Conduct
+
+This project follows Test Double's [code of
+conduct](https://testdouble.com/code-of-conduct) for all community interactions,
+including (but not limited to) one-on-one communications, public posts/comments,
+code reviews, pull requests, and GitHub issues. If violations occur, Test Double
+will take any action they deem appropriate for the infraction, up to and
+including blocking a user from the organization's repositories.

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "standard/rake"
+
+task default: %i[test standard:fix]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "dotenv/load"
+require "halfpipe"
+
+Halfpipe.config(
+  api_token: ENV["PIPEDRIVE_API_KEY"],
+  subdomain: ENV["PIPEDRIVE_SUBDOMAIN"]
+)
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/halfpipe.gemspec

@@ -0,0 +1,28 @@
+require_relative "lib/halfpipe/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "halfpipe"
+  spec.version = Halfpipe::VERSION
+  spec.authors = ["Justin Searls"]
+  spec.email = ["searls@gmail.com"]
+
+  spec.summary = "A Pipedrive client that doesn't do half of what you want"
+  spec.homepage = "https://github.com/testdouble/halfpipe"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

data/lib/halfpipe/api/deal_fields.rb

@@ -0,0 +1,15 @@
+module Halfpipe
+  module Api
+    module DealFields
+      def self.get
+        Http.get("/dealFields").map { |json|
+          DealField.new(
+            key: json["key"],
+            name: json["name"],
+            symbol: Halfpipe::Strings.deform(json["name"])
+          )
+        }
+      end
+    end
+  end
+end

data/lib/halfpipe/api/deals.rb

@@ -0,0 +1,45 @@
+require_relative "deal_fields"
+
+module Halfpipe
+  module Api
+    module Deals
+      def self.create(title:, stage_id: nil, person_id: nil, organization_id: nil, custom_fields: {})
+        pipedrive_keyed_custom_fields = map_custom_fields(custom_fields)
+        json = Http.post("/deals", params: {
+          title: title,
+          stage_id: stage_id,
+          person_id: person_id,
+          org_id: organization_id
+        }.merge(pipedrive_keyed_custom_fields).compact)
+
+        Deal.new(
+          id: json["id"],
+          stage_id: json["stage_id"],
+          person_id: json.dig("person_id", "value"),
+          organization_id: json.dig("org_id", "value"),
+          title: title
+        )
+      end
+      class << self
+        private
+
+        def map_custom_fields(custom_fields)
+          pipedrive_fields = DealFields.get
+          custom_fields.map { |name, value|
+            pipedrive_field = pipedrive_fields.find { |pipedrive_field|
+              pipedrive_field.name == name
+            } || pipedrive_fields.find { |pipedrive_field|
+              pipedrive_field.name == Halfpipe::Strings.deform(name)
+            }
+            if pipedrive_field.nil?
+              raise Error.new <<~MSG
+                Failed to find custom deal field in Pipedrive named #{name.inspect}
+              MSG
+            end
+            [pipedrive_field.key, value]
+          }.to_h
+        end
+      end
+    end
+  end
+end

data/lib/halfpipe/api/notes.rb

@@ -0,0 +1,21 @@
+module Halfpipe
+  module Api
+    module Notes
+      def self.create(content:, deal_id: nil, person_id: nil, organization_id: nil)
+        json = Http.post("/notes", params: {
+          content: content,
+          deal_id: deal_id,
+          person_id: person_id,
+          org_id: organization_id
+        })
+        Note.new(
+          id: json["id"],
+          content: content,
+          deal_id: deal_id,
+          person_id: person_id,
+          organization_id: organization_id
+        )
+      end
+    end
+  end
+end

data/lib/halfpipe/api/persons.rb

@@ -0,0 +1,35 @@
+module Halfpipe
+  module Api
+    module Persons
+      def self.find_by_email(email)
+        json = Http.get("/persons/search", params: {
+          term: email,
+          fields: "email",
+          exact_match: true
+        }).first&.fetch("item")
+
+        unless json.nil?
+          Person.new(
+            id: json["id"],
+            name: json["name"],
+            email: email,
+            organization_id: json.dig("organization", "id")
+          )
+        end
+      end
+
+      def self.create(name:, email:)
+        json = Http.post("/persons", params: {
+          name: name,
+          email: email
+        })
+
+        Person.new(
+          id: json["id"],
+          name: json["name"],
+          email: email
+        )
+      end
+    end
+  end
+end

data/lib/halfpipe/api/stages.rb

@@ -0,0 +1,19 @@
+module Halfpipe
+  module Api
+    module Stages
+      def self.find_first_stage_by_pipeline_name(pipeline_name)
+        json = Http.get("/stages").select { |json|
+          json["pipeline_name"] == pipeline_name
+        }.min_by { |json| json["order_nr"] }
+
+        unless json.nil?
+          Stage.new(
+            id: json["id"],
+            pipeline_id: json["pipeline_id"],
+            name: json["name"]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/halfpipe/config.rb

@@ -0,0 +1,15 @@
+module Halfpipe
+  class Config
+    attr_accessor :api_token, :subdomain, :debug
+
+    def initialize
+      @debug = false
+    end
+
+    def set(**attrs)
+      @api_token = attrs[:api_token] if attrs.key?(:api_token)
+      @subdomain = attrs[:subdomain] if attrs.key?(:subdomain)
+      @debug = attrs[:debug] if attrs.key?(:debug)
+    end
+  end
+end

data/lib/halfpipe/creates_deal_for_person.rb

@@ -0,0 +1,50 @@
+require_relative "api/persons"
+require_relative "api/stages"
+require_relative "api/deals"
+require_relative "api/notes"
+
+module Halfpipe
+  class CreatesDealForPerson
+    Result = Struct.new(:stage, :person, :deal, :note, keyword_init: true)
+
+    def call(
+      name:, email:, deal_title:,
+      custom_deal_fields:, note_content:, pipeline_name:
+    )
+      stage = Api::Stages.find_first_stage_by_pipeline_name(pipeline_name)
+      person = find_or_create_person(name: name, email: email)
+      deal = Api::Deals.create(
+        stage_id: stage.id,
+        person_id: person.id,
+        organization_id: person.organization_id,
+        title: deal_title,
+        custom_fields: custom_deal_fields
+      )
+      unless note_content.nil?
+        note = Api::Notes.create(
+          content: note_content,
+          deal_id: deal.id,
+          person_id: person.id,
+          organization_id: person.organization_id
+        )
+      end
+
+      Result.new(
+        stage: stage,
+        person: person,
+        deal: deal,
+        note: note
+      )
+    end
+
+    private
+
+    def find_or_create_person(name:, email:)
+      Api::Persons.find_by_email(email) ||
+        Api::Persons.create(
+          name: name,
+          email: email
+        )
+    end
+  end
+end

data/lib/halfpipe/http.rb

@@ -0,0 +1,97 @@
+require "net/http"
+require "json"
+
+module Halfpipe
+  module Http
+    def self.get(path, params: {}, start: 0)
+      uri = URI(url_for(path))
+      uri.query = URI.encode_www_form(params.merge(
+        api_token: Halfpipe.config.api_token,
+        start: start
+      ))
+      Log.debug("GETting #{uri}")
+      res = Net::HTTP.get_response(uri)
+      json = parse_json(res)
+
+      if rate_limited?(res)
+        wait_time = res["x-ratelimit-reset"].to_i
+        puts "Reached rate limit, sleeping #{wait_time}"
+        sleep wait_time
+        get(path, params: params, start: start)
+      else
+        raise_failure_maybe!(res, json)
+
+        # Search results are not on data, but data.items
+        results = if !json["data"].respond_to?(:key?) || !json["data"]&.key?("items")
+          json["data"]
+        else
+          json.dig("data", "items")
+        end
+
+        if json.dig("additional_data", "pagination", "more_items_in_collection")
+          results += get(
+            path,
+            params: params,
+            start: json.dig("additional_data", "pagination", "next_start")
+          )
+        end
+        results
+      end
+    end
+
+    def self.post(path, params: {})
+      uri = URI("#{url_for(path)}?api_token=#{Halfpipe.config.api_token}")
+      Log.debug("POSTing #{uri} with: #{params.inspect}")
+      res = Net::HTTP.post_form(uri, params)
+      json = parse_json(res)
+      raise_failure_maybe!(res, json)
+      json["data"]
+    end
+
+    def self.delete(path, params: {})
+      http = Net::HTTP.new("#{Halfpipe.config.subdomain}.pipedrive.com", 443)
+      http.use_ssl = true
+      query = URI.encode_www_form(params.merge(
+        api_token: Halfpipe.config.api_token
+      ))
+      path = "/api/v1#{path}?#{query}"
+      Log.debug("DELETEing #{path}")
+      res = http.delete(path)
+      unless res.is_a?(Net::HTTPSuccess)
+        raise Error.new <<~MSG
+          Deletion of #{path.inspect} failed with #{res.code}:
+
+          #{res.body}
+        MSG
+      end
+    end
+
+    class << self
+      private
+
+      def url_for(path)
+        "https://#{Halfpipe.config.subdomain}.pipedrive.com/api/v1#{path}"
+      end
+
+      def parse_json(res)
+        JSON.parse(res.body)
+      rescue
+        nil
+      end
+
+      def rate_limited?(res)
+        res.code == "429" || res["x-ratelimit-remaining"].to_i < 1
+      end
+
+      def raise_failure_maybe!(res, json)
+        return if res.is_a?(Net::HTTPSuccess) && json&.fetch("success")
+        raise Error.new <<~MSG
+          Pipedrive request failed with status code #{res.code}
+
+          Response body:
+          #{json.inspect}
+        MSG
+      end
+    end
+  end
+end

data/lib/halfpipe/log.rb

@@ -0,0 +1,8 @@
+module Halfpipe
+  module Log
+    def self.debug(msg)
+      return unless Halfpipe.config.debug
+      puts msg
+    end
+  end
+end

data/lib/halfpipe/strings.rb

@@ -0,0 +1,7 @@
+module Halfpipe
+  module Strings
+    def self.deform(s)
+      s.strip.downcase.gsub(/[[:punct:]]/, "").gsub(/\s+/, "_")
+    end
+  end
+end

data/lib/halfpipe/values.rb

@@ -0,0 +1,7 @@
+module Halfpipe
+  Person = Struct.new(:id, :name, :email, :organization_id, keyword_init: true)
+  Stage = Struct.new(:id, :pipeline_id, :name, keyword_init: true)
+  Deal = Struct.new(:id, :title, :stage_id, :person_id, :organization_id, keyword_init: true)
+  DealField = Struct.new(:key, :name, :symbol, keyword_init: true)
+  Note = Struct.new(:id, :content, :deal_id, :person_id, :organization_id, keyword_init: true)
+end

data/lib/halfpipe/version.rb

@@ -0,0 +1,3 @@
+module Halfpipe
+  VERSION = "0.0.1"
+end

data/lib/halfpipe.rb

@@ -0,0 +1,31 @@
+require_relative "halfpipe/version"
+require_relative "halfpipe/strings"
+require_relative "halfpipe/config"
+require_relative "halfpipe/log"
+require_relative "halfpipe/http"
+require_relative "halfpipe/values"
+require_relative "halfpipe/creates_deal_for_person"
+
+module Halfpipe
+  class Error < StandardError; end
+
+  def self.create_deal_for_person(
+    email:, deal_title:, name: nil,
+    custom_deal_fields: {}, note_content: nil, pipeline_name: nil
+  )
+    CreatesDealForPerson.new.call(
+      name: name,
+      email: email,
+      deal_title: deal_title,
+      custom_deal_fields: custom_deal_fields,
+      note_content: note_content,
+      pipeline_name: pipeline_name
+    )
+  end
+
+  def self.config(**attrs)
+    (@config ||= Config.new).tap do |config|
+      config.set(**attrs)
+    end
+  end
+end

data/sig/halfpipe.rbs

@@ -0,0 +1,4 @@
+module Halfpipe
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: halfpipe
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Justin Searls
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-01-19 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- searls@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- halfpipe.gemspec
+- lib/halfpipe.rb
+- lib/halfpipe/api/deal_fields.rb
+- lib/halfpipe/api/deals.rb
+- lib/halfpipe/api/notes.rb
+- lib/halfpipe/api/persons.rb
+- lib/halfpipe/api/stages.rb
+- lib/halfpipe/config.rb
+- lib/halfpipe/creates_deal_for_person.rb
+- lib/halfpipe/http.rb
+- lib/halfpipe/log.rb
+- lib/halfpipe/strings.rb
+- lib/halfpipe/values.rb
+- lib/halfpipe/version.rb
+- sig/halfpipe.rbs
+homepage: https://github.com/testdouble/halfpipe
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/testdouble/halfpipe
+  source_code_uri: https://github.com/testdouble/halfpipe
+  changelog_uri: https://github.com/testdouble/halfpipe/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: A Pipedrive client that doesn't do half of what you want
+test_files: []