open_fda_api 0.0.5 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b43a53d3d7cd5c3390f024979ac198ba6ee4d79ac0bd43cdf60caaaebfe230bc
-  data.tar.gz: 7720bc8e73810774e0a88b2b0579b3cfa91d320952d6ab090dac1215c596164e
+  metadata.gz: ea876aa2b2ba1588293e37e59f95271ec0361215a5fa68ce1cbfb447eba764d0
+  data.tar.gz: 1c19caa9c5e140dcefa5cbeee8acaa1fd1c48d6553b36f55b86505664ef10301
 SHA512:
-  metadata.gz: c2616cbb3fa9a3c648d6e46084a81e0e5f03e14ab57ca5b08628a3cfb7e16b1fa3b99fddea95d4e1b5ba749e4e946092ccb20b0e5caa6806ba3769a3b95d6839
-  data.tar.gz: 902d27c4d41762a2557f5ac2a6126df84d3b71ffbe7b82a209210bb88b1acc5783e77f35506ec4d4f50758399a8adfb782c110a1f1b022c8eb975d6c2641b9d5
+  metadata.gz: 73786ceb0a046b754ad438c67393f3c7baa5c8205266d21df276be6e69ba06bbd5ed94488941364347bbccf0e69ca93874f7db1ad7f1c2bb942a5ae81798413c
+  data.tar.gz: 2f5b335ae39a62f77d72e436caf06a9b7304e02c3c0c81057a082ceb416ad2dff936003c98b7ac36c57fef47a3d64c58b6c4c215c0cbf7acc2ad6e2ecf33798c

data/CHANGELOG.md

@@ -1,4 +1,36 @@
-## [Unreleased]
+## openFDA API
+
+## [0.0.13] - 2022-01-27
+- Set API key if it is available and send it in with every request
+
+## [0.0.12] - 2022-01-24
+- Animal & Veterinary Endpoint
+- Tobacco Endpoint
+- Other Endpoint
+
+## [0.0.11] - 2022-01-24
+- Include Food endpoints
+
+## [0.0.10] - 2022-01-24
+- Include Device endpoints
+- Pull out Endpoint common behavior to a base class
+
+## [0.0.9] - 2022-01-24
+- Filled out the following Drug endpoints:
+  - product_labeling
+  - ndc_directory
+  - recall_enforcement_reports
+  - drugs_at_fda
+
+## [0.0.8] - 2022-01-24
+- Delete the `OpenFdaApi.client` method since its only function was to forward messages
+
+## [0.0.7] - 2022-01-23
+- Use Faraday instead of using Net::HTTP directly
+- Introduce `QueryInputs` to group query params passed in together
+
+## [0.0.6] - 2022-01-21
+- Support for more query fields
 
 ## [0.0.5] - 2022-01-20
 - Validate, against search fields given to us from openFDA API, when building queries.

data/Gemfile.lock

@@ -1,7 +1,9 @@
 PATH
   remote: .
   specs:
-    open_fda_api (0.0.4)
+    open_fda_api (0.0.12)
+      faraday (~> 1.9)
+      faraday_middleware (~> 1.2)
 
 GEM
   remote: https://rubygems.org/
@@ -9,7 +11,33 @@ GEM
     ast (2.4.2)
     coderay (1.1.3)
     diff-lcs (1.5.0)
+    faraday (1.9.3)
+      faraday-em_http (~> 1.0)
+      faraday-em_synchrony (~> 1.0)
+      faraday-excon (~> 1.1)
+      faraday-httpclient (~> 1.0)
+      faraday-multipart (~> 1.0)
+      faraday-net_http (~> 1.0)
+      faraday-net_http_persistent (~> 1.0)
+      faraday-patron (~> 1.0)
+      faraday-rack (~> 1.0)
+      faraday-retry (~> 1.0)
+      ruby2_keywords (>= 0.0.4)
+    faraday-em_http (1.0.0)
+    faraday-em_synchrony (1.0.0)
+    faraday-excon (1.1.0)
+    faraday-httpclient (1.0.1)
+    faraday-multipart (1.0.3)
+      multipart-post (>= 1.2, < 3)
+    faraday-net_http (1.0.1)
+    faraday-net_http_persistent (1.2.0)
+    faraday-patron (1.0.0)
+    faraday-rack (1.0.0)
+    faraday-retry (1.0.3)
+    faraday_middleware (1.2.0)
+      faraday (~> 1.0)
     method_source (1.0.0)
+    multipart-post (2.1.1)
     parallel (1.21.0)
     parser (3.1.0.0)
       ast (~> 2.4.1)
@@ -45,6 +73,7 @@ GEM
     rubocop-ast (1.15.1)
       parser (>= 3.0.1.1)
     ruby-progressbar (1.11.0)
+    ruby2_keywords (0.0.5)
     unicode-display_width (2.1.0)
 
 PLATFORMS

data/README.md

@@ -16,37 +16,95 @@ And then execute:
 bundle install
 ```
 
-## Documentation
-
-There are 5 main category of endpoints that openFDA API provides: Drug, Device, Food, Other, and Tobacco.
-
-Each category has further subcategories. Everything is accessible from the `OpenFdaApi.client`.
+## Usage
 
+```ruby
+client = OpenFdaApi::Client.new
+# or if you have registered an API key
+client = OpenFdaApi::Client.new(api_key: ENV['OPEN_FDA_API_KEY'])
+
+# First 20 results where (fieldA=foo AND fieldB=bar) OR (fieldC=baz AND fieldA exists)
+# Sorted by (fieldD) in descending order
+# Skip the first 8 results
+args = { 
+  search: [{"fieldA" => "foo", "fieldB" => "bar"}, {"fieldC" => "baz", "_exists_" => "fieldA"}],
+  sort: [{"fieldD" => "desc"}],
+  skip: 8,
+  limit: 20 
+}
+
+# Animal & Veterinary API
+client.animal_and_veterinary.adverse_events(args)
+
+# Drug API
+client.drugs.adverse_events(args)
+client.drugs.product_labeling(args)
+client.drugs.ndc_directory(args)
+client.drugs.recall_enforcement_reports(args)
+client.drugs.drugs_at_fda(args)
+
+# Device API
+client.device.premarket_510ks(args)
+client.device.classification(args)
+client.device.recall_enforcement_reports(args)
+client.device.adverse_events(args)
+client.device.premarket_approval(args)
+client.device.recalls(args)
+client.device.registrations_and_listings(args)
+client.device.covid19_serological_tests(args)
+client.device.unique_device_identifier(args)
+
+# Food API
+client.food.recall_enforcement_reports(args)
+client.food.adverse_events(args)
+
+# Other API
+client.other.nsde(args)
+client.other.substance_data_reports(args)
+
+# Tobacco API
+client.tobacco.problem_reports(args)
+```
 
-### Drug
+### Querying
 
-The Drug API has the following endpoints: Adverse Events, Product Labeling, NDC Directory, Recall Enforcement Reports, and Drugs@FDA.
+The openFDA API can be queried with these arguments: `search`, `sort`, `count`, `skip`, and `limit`.
 
-Here's how you interact with each:
+`search`, `sort`, and `count` have the same format. They are arrays of hashes. Each hash has a set of fields and values
+that are ANDed together and all the elements in the array are ORed together. Here are some examples to illustrate:
 
-#### Adverse Events
 ```ruby
-require 'open_fda_api'
-
-client = OpenFdaApi.client
-drugs_api = client.drugs
-
-arguments = [{"patient.reaction.reactionmeddrapt"=>"fatigue"}, {"occurcountry"=>"ca"}]
-drugs_api.adverse_events(search_arguments: arguments) # => {"meta" => {...}, "results" => [...]}
+# Default arguments
+args = {
+  search: [],
+  sort:   [],
+  count:  [],
+  skip:   0,
+  limit:  1,
+}
+
+# Search for a single field
+args = {
+  search: [{ fieldA: "value" }]
+}
+
+# Search for field A AND field B
+args = {
+  search: [{ fieldA: "value", fieldB: "other value" }]
+}
+
+# Search for field A OR field B
+args = {
+  search: [{ fieldA: "value"}, { fieldB: "other value" }]
+}
+
+# Search for field A or field B, and skip the first 10 results
+args = {
+  search: [{ fieldA: "value"}, { fieldB: "other value" }],
+  skip: 10
+}
 ```
 
-### Device (Not Implemented Yet)
-### Food (Not Implemented Yet)
-### Other (Not Implemented Yet)
-### Tobacco (Not Implemented Yet)
-
-
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.

data/bin/console

@@ -11,5 +11,8 @@ require "open_fda_api"
 # require "pry"
 # Pry.start
 
+client = OpenFdaApi::Client.new
+puts "Client is ready: #{client}"
+
 require "irb"
 IRB.start(__FILE__)

data/lib/open_fda_api/animal_and_veterinary.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module OpenFdaApi
+  # Interact with the Animal & Veterinary API Endpoint:
+  #  - Adverse Events
+  class AnimalAndVeterinary < Endpoint
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/animalandveterinary/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/animalandveterinary/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/animalandveterinary/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def adverse_events(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "event.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    private
+
+    def endpoint_path
+      "/animalandveterinary"
+    end
+  end
+end

data/lib/open_fda_api/client.rb

@@ -1,18 +1,54 @@
 # frozen_string_literal: true
 
-require_relative "./drugs"
+require "faraday"
+require "faraday_middleware"
 
 module OpenFdaApi
   # Gives you access to the main nouns in the openFDA API
   class Client
-    attr_reader :api_key
+    attr_reader :api_key, :adapter
 
-    def initialize(api_key: nil)
+    BASE_URL = "https://api.fda.gov"
+
+    def initialize(api_key: nil, adapter: Faraday.default_adapter, stubs: nil)
       @api_key = api_key
+      @adapter = adapter
+      @stubs   = stubs
     end
 
     def drugs
-      OpenFdaApi::Drugs.new
+      OpenFdaApi::Drugs.new(self)
+    end
+
+    def device
+      OpenFdaApi::Device.new(self)
+    end
+
+    def food
+      OpenFdaApi::Food.new(self)
+    end
+
+    def animal_and_veterinary
+      OpenFdaApi::AnimalAndVeterinary.new(self)
+    end
+
+    def tobacco
+      OpenFdaApi::Tobacco.new(self)
+    end
+
+    def other
+      OpenFdaApi::Other.new(self)
+    end
+
+    def connection
+      @connection ||= Faraday.new(BASE_URL) do |conn|
+        conn.request :json
+
+        conn.response :dates
+        conn.response :json, content_type: "application/json"
+
+        conn.adapter adapter, @stubs
+      end
     end
   end
 end

data/lib/open_fda_api/device.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module OpenFdaApi
+  # Interact with the Device API Endpoint:
+  #  - 501(k)
+  #  - Classification
+  #  - Recall Enforcement Reports
+  #  - Adverse Events
+  #  - Pre-market Approval
+  #  - Recalls
+  #  - Registrations and Listings
+  #  - Covid19 Serological Testing Evaluations
+  #  - Unique Device Identifier
+  class Device < Endpoint
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/device/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/device/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/device/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def adverse_events(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "event.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {})
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/device/classification/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/device/classification/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/device/classification/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def classification(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "classification.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/device/510k/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/device/510k/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/device/510k/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def premarket_510ks(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "510k.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/device/enforcement/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/device/enforcement/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/device/enforcement/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def recall_enforcement_reports(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "enforcement.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/device/pma/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/device/pma/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/device/pma/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def premarket_approval(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "pma.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/device/recall/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/device/recall/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/device/recall/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def recalls(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "recall.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/device/registrationlisting/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/device/registrationlisting/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/device/registrationlisting/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def registrations_and_listings(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "registrationlisting.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/device/covid19serology/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/device/covid19serology/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/device/covid19serology/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def covid19_serological_tests(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "covid19serology.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/device/udi/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/device/udi/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/device/udi/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def unique_device_identifier(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "udi.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    private
+
+    def endpoint_path
+      "/device"
+    end
+  end
+end

data/lib/open_fda_api/drugs.rb

@@ -1,52 +1,88 @@
 # frozen_string_literal: true
 
-require "net/http"
-require "json"
 require "yaml"
-require "open_fda_api/query_builder"
 
 module OpenFdaApi
   # Interact with the Drugs API Endpoint:
-  # - Adverse Events
+  #  - Adverse Events
   #  - Product Labeling
   #  - NDC Directory
   #  - Recall Enforcement Reports
   #  - Drugs@FDA)
-  class Drugs
-    def initialize
-      @host = "api.fda.gov"
-      @path_base = "/drug"
+  class Drugs < Endpoint
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def adverse_events(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "event.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, self.class.valid_adverse_events_fields)
+      make_request(endpoint, query)
     end
 
-    # The openFDA drug adverse event API returns data that has been collected from the
-    # FDA Adverse Event Reporting System (FAERS), a database that contains information on
-    # adverse event and medication error reports submitted to FDA.
-    #
-    # @param search_arguments [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
     # @return Response from the API parsed as JSON
-    def adverse_events(search_arguments: [])
-      endpoint = "/event.json"
-      query    = build_query(search_arguments, self.class.valid_adverse_events_fields)
-      url      = build_url(endpoint, query)
-      make_request(url)
+    def product_labeling(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "label.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
     end
 
-    def self.valid_adverse_events_fields
-      @valid_adverse_events_fields ||= ::YAML.load_file("#{__dir__}/adverse_events_fields.yml")
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def ndc_directory(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "ndc.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
     end
 
-    private
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def recall_enforcement_reports(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "enforcement.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
 
-    def build_url(endpoint, query)
-      URI::HTTPS.build(host: @host, path: @path_base + endpoint, query: query)
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/drug/event/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def drugs_at_fda(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "drugsfda.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
     end
 
-    def build_query(search_arguments, valid_search_fields)
-      QueryBuilder.new(search: search_arguments, valid_search_fields: valid_search_fields).build_query
+    def self.valid_adverse_events_fields
+      @valid_adverse_events_fields ||= ::YAML.load_file("#{__dir__}/adverse_events_fields.yml")
     end
 
-    def make_request(url)
-      JSON.parse(Net::HTTP.get(url))
+    private
+
+    def endpoint_path
+      "/drug"
     end
   end
 end

data/lib/open_fda_api/endpoint.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OpenFdaApi
+  # Base class for all endpoints to share behavior like building queries and making requests
+  class Endpoint
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def build_query(query_input, valid_search_fields)
+      QueryBuilder.new(query_input: query_input, valid_search_fields: valid_search_fields).build_query
+    end
+
+    def build_inputs(search:, sort:, count:, skip:, limit:)
+      QueryInputs.new(search: search, sort: sort, count: count, skip: skip, limit: limit, api_key: client.api_key)
+    end
+
+    def make_request(endpoint, query)
+      url = "#{endpoint_path}/#{endpoint}"
+      if query.empty?
+        client.connection.get(url)
+      else
+        client.connection.get(url, query)
+      end.body
+    end
+  end
+end

data/lib/open_fda_api/food.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module OpenFdaApi
+  # Interact with the Food API Endpoint:
+  #  - Adverse Events
+  #  - Recall Enforcement Reports
+  class Food < Endpoint
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/food/enforcement/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/food/enforcement/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/food/enforcement/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def adverse_events(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "event.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/food/enforcement/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/food/enforcement/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/food/enforcement/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def recall_enforcement_reports(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "enforcement.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    private
+
+    def endpoint_path
+      "/food"
+    end
+  end
+end

data/lib/open_fda_api/other.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module OpenFdaApi
+  # Interact with the Other API Endpoint:
+  #  - NSDE
+  #  - Substance Data Reports
+  class Other < Endpoint
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/other/nsde/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/other/nsde/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/other/nsde/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def nsde(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "nsde.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/other/substance/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/other/substance/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/other/substance/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def substance_data_reports(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "substance.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    private
+
+    def endpoint_path
+      "/other"
+    end
+  end
+end

data/lib/open_fda_api/query_builder.rb

@@ -25,53 +25,71 @@ module OpenFdaApi
   #   Use in combination with limit to paginate results. Currently, the largest allowed value for the skip parameter
   #   is 25000. See Paging if you require paging through larger result sets.
   class QueryBuilder
-    # @param [Array<Hash>] search
-    def initialize(valid_search_fields:, search: [], sort: [], count: [], skip: 0)
-      validate_arguments!(valid_search_fields, search: search, sort: sort, count: count, skip: skip)
-      @search = build_search_string(search)
+    # @param [Hash] valid_search_fields
+    # @param [QueryInputs] query_input
+    def initialize(query_input:, valid_search_fields:)
+      # TODO: Turn validations back on once we get basic functionality working; need to flex on different field types
+      # validate_arguments!(valid_search_fields, query_input: query_input)
+      warn "You've passed in a valid_search_fields arg but it isn't being used right now..." if valid_search_fields
+      @search  = build_query_string(query_fields: query_input.search)
+      @sort    = build_query_string(query_fields: query_input.sort)
+      @count   = build_query_string(query_fields: query_input.count)
+      @skip    = build_skip_string(query_input.skip)
+      @limit   = query_input.limit
+      @api_key = query_input.api_key
     end
 
-    # @return [String] the query string portion of a request
+    # @return [Hash] the query string portion of a request
     def build_query
-      # TODO: We currently just build a very basic search string for simple examples like "search=a:b+AND+c:d",
-      # but it is possible to construct more complex queries and we will need to support that. Sorting, counting,
-      # setting limits, skipping records, pagination, converting spaces, phrase matching, grouping, and using dates and
-      # ranges are examples of more complex queries that can be built.
-      @search
+      {
+        api_key: @api_key,
+        search: @search,
+        sort: @sort,
+        count: @count,
+        skip: @skip,
+        limit: @limit
+      }.compact.reject { |_k, v| v.to_s.empty? }
     end
 
     private
 
-    def validate_arguments!(valid_search_fields, search:, sort:, count:, skip:)
+    def validate_arguments!(valid_search_fields, query_input:)
       # `search` keys must exist in adverse_events_fields.yml
-      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: search)
+      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: query_input.search)
       raise InvalidQueryArgument, "'search' has invalid fields: #{invalid_fields}" if invalid_fields.any?
 
       # `sort` keys must exist in adverse_events_fields.yml
-      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: sort)
+      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: query_input.sort)
       raise InvalidQueryArgument, "'sort' has invalid fields: #{invalid_fields}" if invalid_fields.any?
 
       # `count` keys must exist in adverse_events_fields.yml
-      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: count)
+      invalid_fields = get_invalid_fields(valid_search_fields: valid_search_fields, fields: query_input.count)
       raise InvalidQueryArgument, "'count' has invalid fields: #{invalid_fields}" if invalid_fields.any?
 
       # `count` and `skip` cannot be set at the same time
-      return unless count_and_skip_set?(count, skip)
+      return unless count_and_skip_set?(query_input.count, query_input.skip)
 
       raise InvalidQueryArgument, "'count' and 'skip' cannot both be set at the same time!"
     end
 
-    def build_search_string(search)
-      return "" if search.empty?
+    def build_query_string(query_fields:)
+      return "" if query_fields.empty?
 
-      value = search.map do |and_args|
+      build_groupings(query_fields).to_s
+    end
+
+    def build_skip_string(skip)
+      skip.positive? ? skip.to_s : ""
+    end
+
+    def build_groupings(fields)
+      fields.map do |and_args|
         "(#{and_args.map { |k, v| "#{k}:#{v.gsub(" ", "+")}" }.join("+AND+")})"
       end.join("+")
-
-      "search=#{value}"
     end
 
     def get_invalid_fields(valid_search_fields:, fields:)
+      # TODO: valid_search_fields define types and we need to check against those
       fields.map(&:keys).flatten.select do |field|
         if field.include?(".") # nested field (e.g. patient.patientagegroup)
           dig_values = field.split(".").join(",properties,").split(",")

data/lib/open_fda_api/query_inputs.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module OpenFdaApi
+  # Group of inputs to build the query against the API with
+  class QueryInputs
+    attr_reader :search, :sort, :count, :skip, :limit, :api_key
+
+    def initialize(**params)
+      @search  = params[:search]  || []
+      @sort    = params[:sort]    || []
+      @count   = params[:count]   || []
+      @skip    = params[:skip]    || 0
+      @limit   = params[:limit]   || nil
+      @api_key = params[:api_key] || nil
+    end
+  end
+end

data/lib/open_fda_api/tobacco.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module OpenFdaApi
+  # Interact with the Tobacco API Endpoint:
+  #  - Problem Reports
+  class Tobacco < Endpoint
+    # @param search [Array<Hash>] Search fields defined in https://open.fda.gov/apis/tobacco/problem/searchable-fields/
+    # @param sort   [Array<Hash>] Sort fields defined in https://open.fda.gov/apis/tobacco/problem/searchable-fields/
+    # @param count  [Array<Hash>] Count fields defined https://open.fda.gov/apis/tobacco/problem/searchable-fields/
+    # @param skip   [Integer]     Number of results to skip
+    # @param limit  [Integer]     Number of results to return
+    # @return Response from the API parsed as JSON
+    def problem_reports(search: [], sort: [], count: [], skip: 0, limit: 1)
+      endpoint = "problem.json"
+      inputs   = build_inputs(search: search, sort: sort, count: count, skip: skip, limit: limit)
+      query    = build_query(inputs, {}) # TODO: Upload valid fields
+      make_request(endpoint, query)
+    end
+
+    private
+
+    def endpoint_path
+      "/tobacco"
+    end
+  end
+end

data/lib/open_fda_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenFdaApi
-  VERSION = "0.0.5"
+  VERSION = "0.0.13"
 end

data/lib/open_fda_api.rb

@@ -1,13 +1,19 @@
 # frozen_string_literal: true
 
 require_relative "open_fda_api/version"
-require_relative "open_fda_api/client"
 
 # A Ruby wrapper for the openFDA API: https://open.fda.gov/apis/
 module OpenFdaApi
   class Error < StandardError; end
 
-  def self.client(api_key: nil)
-    OpenFdaApi::Client.new(api_key: api_key)
-  end
+  autoload :Client, "open_fda_api/client"
+  autoload :Endpoint, "open_fda_api/endpoint"
+  autoload :AnimalAndVeterinary, "open_fda_api/animal_and_veterinary"
+  autoload :Drugs, "open_fda_api/drugs"
+  autoload :Device, "open_fda_api/device"
+  autoload :Food, "open_fda_api/food"
+  autoload :Other, "open_fda_api/other"
+  autoload :Tobacco, "open_fda_api/tobacco"
+  autoload :QueryInputs, "open_fda_api/query_inputs"
+  autoload :QueryBuilder, "open_fda_api/query_builder"
 end

data/open_fda_api.gemspec

@@ -27,7 +27,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency "faraday", "~> 1.9"
+  spec.add_dependency "faraday_middleware", "~> 1.2"
+
   spec.add_development_dependency "pry"
 
   # For more information and examples about making a new gem, checkout our

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: open_fda_api
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.13
 platform: ruby
 authors:
 - Hebron George
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-20 00:00:00.000000000 Z
+date: 2022-01-27 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -46,9 +74,16 @@ files:
 - bin/setup
 - lib/open_fda_api.rb
 - lib/open_fda_api/adverse_events_fields.yml
+- lib/open_fda_api/animal_and_veterinary.rb
 - lib/open_fda_api/client.rb
+- lib/open_fda_api/device.rb
 - lib/open_fda_api/drugs.rb
+- lib/open_fda_api/endpoint.rb
+- lib/open_fda_api/food.rb
+- lib/open_fda_api/other.rb
 - lib/open_fda_api/query_builder.rb
+- lib/open_fda_api/query_inputs.rb
+- lib/open_fda_api/tobacco.rb
 - lib/open_fda_api/version.rb
 - open_fda_api.gemspec
 homepage: https://github.com/hebron-george/open_fda_api