erp_integration 0.2.0 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b73b17b72afec2d03e59213c35db31b1260f304907a9686af94a6bc0123b19c2
-  data.tar.gz: e2f42a3b2c313c6aa91efdcd5663b3c070a04221416799f0b4ee8753fc29df43
+  metadata.gz: 373cc92b70776b3ab2547879840468b0b5e2c9269aaf4991a1e3c283435609c4
+  data.tar.gz: cd372fe6aed0b7f88ddcf0007ad895386a75ca593a0bfff4ce978cad8de84cce
 SHA512:
-  metadata.gz: e951c654c3293e5e169b212c5b0dc5ecc1b742750155520edb68302b2452e7f5637caa2e36ec75e37363e76626efe667186bd45e58e38cfe0c08c92709cd9f9a
-  data.tar.gz: ff1d1e69793589517db55c30ad56be8e7a484d77ef5cba846d00805aad46e3123d90343b38854a6b2323eb7607835fe9ab4a6d491d769d6d78a66b2657e1c4c0
+  metadata.gz: e711394078bb8e517436cd9b10f4231248cbef3bf6bb744834270e305e6329e0672611761b091d98a53fcd5d00f7f781ef2309b76c4db64cbe2bbd8b2ad3a519
+  data.tar.gz: 5490ad8f93dfabc1e77d8ef326ab34ee29d62b416f061cf83780f49fcb7d42882aab46e29e16e36f730ba7555a1d1482b55a2f45255fb71b252b5758a9cdf58b

data/.reek.yml

@@ -49,7 +49,7 @@ detectors:
       # Acceptable code smell as we don't know the full extend of our configuration
       # interface for the gem yet.
       - ErpIntegration::Configuration
-      - ErpIntegration::Resource#initialize
+      - ErpIntegration::Resource
   MissingSafeMethod:
     enabled: true
     exclude: []

data/README.md

@@ -32,6 +32,29 @@ ErpIntegration.configure do |config|
 end
 ```
 
+### Querying third-party vendors
+
+After configuring the gem, one can easily query all the available ERP resources from the connected third-parties.
+
+```ruby
+$ ErpIntegration::Order.where(reference: 'MT1000SKX')
+=> #<ErpIntegration::Fulfil::Collection @items=[<ErpIntegration::Order @id=100 />] />
+```
+
+By default, only the `id` will be added to the found ERP resources. However, one can use the `select` method to include more fields.
+
+```ruby
+$ ErpIntegration::Order.select(:id, :reference).where(reference: 'MT1000SKX')
+=> #<ErpIntegration::Fulfil::Collection @items=[<ErpIntegration::Order @id=100 @reference=MT1000SKX />] />
+```
+
+There are also other type of `where` queries available:
+- `where_like` for case sensitive queries.
+- `where_ilike` for case insensitive queries.
+- `where_not` for non-equality queries.
+- `where_in` for inclusion queries.
+- `where_not_in` for exclusion queries.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/bin/prerelease

@@ -9,7 +9,7 @@ bundle
 rake
 
 # Update the gem version.
-printf "module ErpIntegration\n  VERSION = \"$VERSION\".freeze\nend\n" > ./lib/erp_integration/version.rb
+printf "# frozen_string_literal: true\n\nmodule ErpIntegration\n  VERSION = '$VERSION'\nend\n" > ./lib/erp_integration/version.rb
 git add lib/erp_integration/version.rb
 git checkout -b "release_v.$VERSION"
 git commit -m "[RELEASE] Bump version for v$VERSION"
@@ -17,4 +17,4 @@ git push origin "release_v.$VERSION"
 
 # Tag the new gem version.
 git tag v$VERSION
-git push --tags
+git push origin v$VERSION

data/erp_integration.gemspec

@@ -32,7 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'activesupport', '>= 0.12'
 
   # Faraday is a HTTP/REST API client library to interact with third-party API vendors
-  spec.add_dependency 'faraday', '>= 0.17.3', '< 1.8.0'
+  spec.add_dependency 'faraday', '>= 0.17.3', '< 1.9.0'
   spec.add_dependency 'faraday_middleware', '~> 0.14.0'
 
   # Development dependencies

data/lib/erp_integration/configuration.rb

@@ -27,6 +27,26 @@ module ErpIntegration
     # @return [Symbol] The configured adapter for the orders
     attr_writer :order_adapter
 
+    # Allows configuring an adapter for the `OrderLine` resource. When none is
+    # configured, it will default to Fulfil.
+    # @return [Symbol] The configured adapter for the order lines.
+    attr_writer :order_line_adapter
+
+    # Allows configuring an adapter for the `PurchaseOrder` resource. When none is
+    # configured, it will default to Fulfil.
+    # @return [Symbol] The configured adapter for the purchase orders.
+    attr_writer :purchase_order_adapter
+
+    # Allows configuring an adapter for the `PurchaseOrderLine` resource. When
+    # none is configured, it will default to Fulfil.
+    # @return [Symbol] The configured adapter for the purchase order lines.
+    attr_writer :purchase_order_line_adapter
+
+    # Allows configuring an adapter for the `PurchaseRequest` resource. When
+    # none is configured, it will default to Fulfil.
+    # @return [Symbol] The configured adapter for the purchase request.
+    attr_writer :purchase_request_adapter
+
     def initialize(**options)
       options.each_pair do |key, value|
         public_send("#{key}=", value) if respond_to?("#{key}=")
@@ -36,6 +56,22 @@ module ErpIntegration
     def order_adapter
       @order_adapter || :fulfil
     end
+
+    def order_line_adapter
+      @order_line_adapter || :fulfil
+    end
+
+    def purchase_order_adapter
+      @purchase_order_adapter || :fulfil
+    end
+
+    def purchase_order_line_adapter
+      @purchase_order_line_adapter || :fulfil
+    end
+
+    def purchase_request_adapter
+      @purchase_request_adapter || :fulfil
+    end
   end
 
   # Returns ERP Integration's configuration.

data/lib/erp_integration/fulfil/api_resource.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'query_methods'
+
+module ErpIntegration
+  module Fulfil
+    class ApiResource
+      include Enumerable
+      include QueryMethods
+
+      cattr_accessor :resource_klass, instance_accessor: false
+      delegate :client, :model_name, :resource_klass, to: 'self.class'
+
+      def initialize(resource_klass)
+        self.class.resource_klass = resource_klass
+      end
+
+      # The `where` and `includes` methods lazyly build a search/read query
+      # for Fulfil. By calling `all`, the prepared search/read query will actually
+      # be executed and the results will be fetched.
+      # @return [Array] An enumerable collection object with all API results.
+      def all
+        return @results if defined?(@results)
+
+        @results =
+          client.put(
+            "model/#{model_name}/search_read",
+            Query.new(selected_fields, where_clauses)
+          ).map { |item| resource_klass.new(item) }
+      end
+
+      # The `each` method turns the `ApiResource` instance into an enumerable object.
+      # For more information, see https://ruby-doc.org/core-3.0.2/Enumerable.html
+      def each(&block)
+        all.each(&block)
+      end
+
+      # The `client` exposes the `ErpIntegration::Fulfil::Client` to the class.
+      # @return [ErpIntegration::Fulfil::Client] The HTTP client for Fulfil.
+      def self.client
+        Client.new(
+          api_key: config.fulfil_api_key,
+          merchant_id: config.fulfil_merchant_id
+        )
+      end
+
+      # The `config` exposes the gem's configuration to the `ApiResource`.
+      # @return [ErpIntegration::Configuration] The gem's configuration object.
+      def self.config
+        ErpIntegration.config
+      end
+
+      # Fulfil doesn't use logical naming conventions. However, we do need
+      # the name of a model to build the resource URI.
+      #
+      # By manually setting the model name, we allow the `Fulfil::Connection`
+      # module to connect to the correct API endpoint.
+      #
+      # @param name [String] The logical path name in Fulfil.
+      # @return [String] The model name
+      def self.model_name=(name)
+        instance_variable_set(:@model_name, name)
+      end
+
+      def self.model_name
+        instance_variable_get(:@model_name)
+      end
+    end
+  end
+end

data/lib/erp_integration/{clients/fulfil_client.rb → fulfil/client.rb}

@@ -1,12 +1,8 @@
 # frozen_string_literal: true
 
-require 'faraday_middleware'
-
 module ErpIntegration
-  module Clients
-    # The `FulfilClient` is a simple HTTP client configured to be used for API
-    # requests to the Fulfil endpoints.
-    class FulfilClient
+  module Fulfil
+    class Client
       attr_reader :api_key, :merchant_id
       attr_writer :connection, :faraday_adapter
 
@@ -49,6 +45,10 @@ module ErpIntegration
 
       %i[delete get patch put post].each do |action_name|
         define_method(action_name) do |path, options = {}|
+          if api_key.nil? || merchant_id.nil?
+            raise ErpIntegration::Error, 'The Fulfil API key and/or Merchant ID are missing.'
+          end
+
           connection.public_send(action_name, "api/#{version}/#{path}", options).body
         end
       end

data/lib/erp_integration/fulfil/query.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ErpIntegration
+  module Fulfil
+    # The `Query` class transforms where clauses and included fields into a
+    # queryable object that Fulfil understands.
+    #
+    # @example
+    #   $ Query.new([:id, 'product.id'], [['id', '=', '100']]).to_json
+    #   # => {"fields":["id","product.id"],"filters":[["id","=","100"]]}
+    #
+    # The instance of the `Query` class is meant to be passed to `Faraday` or
+    # a third-party vendor client (e.g. `Fulfil::Client`) that uses `Faraday`.
+    #
+    # `Faraday` will call the `.to_json` method before sending the data to Fulfil.
+    # So, there is no need to explicitly call `.to_json` on the `Query` instance.
+    #
+    # @example
+    #   Faraday.post("/api-endpoint", Query.new([:id, 'product.id'], [WhereClause.new(key: :id, value: 100)]))
+    class Query
+      attr_reader :fields, :filters
+      DEFAULT_FIELDS = %w[id].freeze
+
+      # @param fields [Array<String|Symbol>] A list of fields for Fulfil.
+      # @param filters [Array<WhereClause>] A list of where clauses for Fulfil.
+      def initialize(fields, filters)
+        @fields = (fields || DEFAULT_FIELDS).map(&:to_s).uniq
+        @filters = (filters || []).map(&:to_filter).uniq
+      end
+
+      def to_json(*_object)
+        {
+          fields: @fields,
+          filters: @filters
+        }.to_json
+      end
+    end
+  end
+end

data/lib/erp_integration/fulfil/query_methods.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative 'query'
+require_relative 'where_clause'
+
+module ErpIntegration
+  module Fulfil
+    module QueryMethods
+      attr_accessor :selected_fields, :where_clauses
+
+      # Fulfil only returns an ID by default when one would query their API. However,
+      # the ID is seldom the only value one will need. The `select` method allows
+      # selecting multiple fields at once.
+      #
+      # @example
+      #   $ ErpIntegration::Order.select(:id, :name, 'product.name')
+      #   # => <ErpIntegration::Fulfil::Resources::Order @selected_fields=[:id, :name, "product.name"] />
+      #
+      # When one calls the `all` method, it will fetch all the resources from Fulfil
+      # and it will return all the given fields (if available).
+      #
+      # @example
+      #   $ ErpIntegration::Order.select(:id, :name, 'product.name').all
+      #   # => <ErpIntegration::Fulfil::Collection @items=[...] />
+      #
+      # Both a list of Strings, Symbols or a combination of these can be passed
+      # to the `select` method.
+      def select(*fields)
+        clone.select!(*fields)
+      end
+
+      def select!(*fields)
+        self.selected_fields = (selected_fields || []).concat(fields)
+        self
+      end
+
+      # Fulfil has a very powerful query syntax. However, that query syntax is rather
+      # complicated and it's really specific to Fulfil.
+      #
+      # The `where` method introduces a well-known interface (e.g. ActiveRecord::Relation)
+      # to query resources in Fulfil.
+      #
+      # @example
+      #   $ ErpIntegration::Order.where(id: 100).all
+      #   # => <ErpIntegration::Fulfil::Collection @items=[<ErpIntegration::Order @id=100 />] />
+      #
+      # If one adds the `comparison_operator` key to the arguments, it will use
+      # that comparison operator to build the query to Fulfil.
+      #
+      # All the other `where_` methods use this technique to provide logic for all
+      # the different comparison operators.
+      def where(*args)
+        clone.where!(*args)
+      end
+
+      def where!(args)
+        comparison_operator = args.delete(:comparison_operator)
+
+        args.each_pair do |key, value|
+          self.where_clauses =
+            (where_clauses || []) << WhereClause.new(
+              key: key, value: value, comparison_operator: comparison_operator
+            )
+        end
+
+        self
+      end
+
+      def where_ilike(args)
+        where(args.merge(comparison_operator: 'ilike'))
+      end
+
+      def where_in(args)
+        where(args.merge(comparison_operator: 'in'))
+      end
+
+      def where_like(args)
+        where(args.merge(comparison_operator: 'like'))
+      end
+
+      def where_not(args)
+        where(args.merge(comparison_operator: '!='))
+      end
+
+      def where_not_in(args)
+        where(args.merge(comparison_operator: 'not in'))
+      end
+    end
+  end
+end

data/lib/erp_integration/fulfil/resources/order.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../api_resource'
+
+module ErpIntegration
+  module Fulfil
+    module Resources
+      class Order < ApiResource
+        self.model_name = 'sale.sale'
+
+        # Allows cancelling the entire sales order in Fulfil.
+        # @param id [Integer|String] The ID of the to be cancelled order.
+        # @return [boolean] Whether the sales order was cancelled successfully or not.
+        def cancel(id)
+          begin
+            client.put("model/sale.sale/#{id}/cancel")
+          rescue Faraday::Error::ParsingError
+            # Workaround: Fulfil api does not return a json when status code is 200 (a.k.a. "Ok")
+            # and faraday is having an error when trying to parse it. Let's skip the parse error
+            # and move on.
+          end
+          true
+
+        # Fulfil will return an 400 (a.k.a. "Bad Request") status code when a sales order couldn't
+        # be cancelled. If a sales order isn't cancellable by design, no exception should be raised.
+        #
+        # See the Fulfil's documentation for more information:
+        # https://developers.fulfil.io/rest_api/model/sale.sale/#cancel-a-sales-order
+        rescue ErpIntegration::HttpError::BadRequest
+          false
+        end
+      end
+    end
+  end
+end

data/lib/erp_integration/fulfil/resources/order_line.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../api_resource'
+
+module ErpIntegration
+  module Fulfil
+    module Resources
+      class OrderLine < ApiResource
+        self.model_name = 'sale.line'
+      end
+    end
+  end
+end

data/lib/erp_integration/fulfil/resources/purchase_order.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../api_resource'
+
+module ErpIntegration
+  module Fulfil
+    module Resources
+      class PurchaseOrder < ApiResource
+        self.model_name = 'purchase.purchase'
+      end
+    end
+  end
+end

data/lib/erp_integration/fulfil/resources/purchase_order_line.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../api_resource'
+
+module ErpIntegration
+  module Fulfil
+    module Resources
+      class PurchaseOrderLine < ApiResource
+        self.model_name = 'purchase.line'
+      end
+    end
+  end
+end

data/lib/erp_integration/fulfil/resources/purchase_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../api_resource'
+
+module ErpIntegration
+  module Fulfil
+    module Resources
+      class PurchaseRequest < ApiResource
+        self.model_name = 'purchase.request'
+      end
+    end
+  end
+end

data/lib/erp_integration/fulfil/where_clause.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ErpIntegration
+  module Fulfil
+    # The `WhereClause` model encapsulates the logic for the filter options for Fulfil.
+    # It transforms the attributes passed to any of the where lookup methods into
+    # a format that Fulfil can actually understand.
+    #
+    # For more information, see their documentation.
+    # https://developers.fulfil.io/guides/searching-filtering/#field-filter-expressions
+    #
+    # @example
+    #   WhereClause.new({ key: :id, value: 100, comparison_operator: 'ilike' })
+    #   # => <WhereClause @key="id" value="100" comparison_operator="ilike" />
+    #
+    # @example
+    #   $ WhereClause.new({ key: :id, value: 100 })
+    #   # => <WhereClause @key="id" value="100" comparison_operator="=" />
+    class WhereClause
+      COMPARISON_OPERATORS = [
+        '=', '!=', '<', '<=', '=>', '>', 'like', 'ilike', 'in', 'not in'
+      ].freeze
+
+      DEFAULT_COMPARISON_OPERATOR = '='
+
+      def initialize(key:, value:, comparison_operator: DEFAULT_COMPARISON_OPERATOR)
+        @comparison_operator = verify_comparison_operator(comparison_operator)
+        @key = key.to_s
+        @value = value.to_s
+      end
+
+      # Transforms the `WhereClause` into a filter object for Fulfil.
+      # @return [Array<String>] The formatted filter for Fulfil.
+      def to_filter
+        [@key, @comparison_operator, @value]
+      end
+
+      # The `===` allows comparing different WhereClause objects. Under the hood,
+      # this is used by `.uniq` to determine whether objects are equal to each other.
+      #
+      # Note: `.uniq` also depends on `.hash` on the `WhereClause` instance. See
+      # the `.hash` method to see how the two objects are compared.
+      #
+      # @example
+      #   $ WhereClause.new(id: 100) == WhereClause.new(id: 100)
+      #   # => true
+      #
+      #   $ WhereClause.new(id: 100) == WhereClause.new(id: 101)
+      #   # => false
+      #
+      #   $ WhereClause.new(id: 100) == WhereClause.new(name: "PT100")
+      #   # => false
+      #
+      # @param other [WhereClause] Another `WhereClause` instance.
+      # @return [Boolean] Whether or not the `WhereClause`s are equal.
+      def ==(other)
+        to_filter == other.to_filter
+      end
+      alias eql? ==
+
+      # The `.hash` allows comparing two `WhereClause` instances for uniqueness.
+      # See https://rubyapi.org/2.3/o/object#method-i-hash
+      # @return [Fixnum] A Fixnum that identifies the `WhereClause`.
+      def hash
+        to_filter.hash
+      end
+
+      private
+
+      def verify_comparison_operator(comparison_operator)
+        return comparison_operator if COMPARISON_OPERATORS.include?(comparison_operator)
+
+        DEFAULT_COMPARISON_OPERATOR
+      end
+    end
+  end
+end

data/lib/erp_integration/order.rb

@@ -1,16 +1,23 @@
 # frozen_string_literal: true
 
 module ErpIntegration
-  # The `Order` class exposes available ERP Order operations
-  # assigning them to the proper adapter
+  # The `ErpIntegration::Order` exposes an uniformed API for interaction with
+  # third-party ERP vendors.
   class Order < Resource
-    attr_accessor :id, :number
+    attr_accessor :id, :channel, :number, :party, :sale_date, :shipment_address,
+                  :amount_invoiced, :attachments, :carrier, :carrier_service,
+                  :channel_identifier, :comment, :company, :confirmation_time,
+                  :create_date, :currency, :description, :gateway_transaction,
+                  :invoice_address, :invoice_method, :invoice_state, :invoices,
+                  :lines, :metadata, :payment_term, :payment_total, :price_list,
+                  :reference, :sales_person, :shipment_amount, :shipment_method,
+                  :shipment_state, :shipments, :shipping_start_date, :state,
+                  :tax_amount, :total_amount, :total_quantity, :total_shipment_cost,
+                  :untaxed_amount, :warehouse, :weight, :weight_uom, :write_date,
+                  :write_uid
 
-    # Allows cancelling the entire sales order.
-    # @param id [Integer|String] The ID of the to be cancelled order.
-    # @return [boolean] Whether the sales order was cancelled successfully or not.
-    def self.cancel(id)
-      adapter.new.cancel(id)
+    def cancel
+      self.class.adapter.cancel(id)
     end
   end
 end

data/lib/erp_integration/order_line.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ErpIntegration
+  # The `ErpIntegration::OrderLine` exposes an uniformed API for interaction with
+  # third-party ERP vendors.
+  class OrderLine < Resource
+    attr_accessor :id, :product, :quantity, :unit, :unit_price, :amount, :attachments,
+                  :channel_identifier, :create_date, :create_uid, :delivery_address,
+                  :delivery_date, :delivery_mode, :description, :discount, :gift_message,
+                  :gross_profit_cpny_cc, :is_gift_card, :list_price, :listing_sku,
+                  :metadata, :note, :options, :purhcase_request, :quantity_canceled,
+                  :quantity_reserved, :quantity_shipped, :return_reason, :sale,
+                  :sequence, :shipping_date, :taxes, :type, :warehouse, :write_date,
+                  :write_uid
+  end
+end

data/lib/erp_integration/purchase_order.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ErpIntegration
+  # The `ErpIntegration::PurchaseOrder` exposes an uniformed API for interaction with
+  # third-party ERP vendors.
+  class PurchaseOrder < Resource
+    attr_accessor :id, :lines, :number, :party, :purchase_date, :warehouse,
+                  :approval_status, :attachments, :company, :create_date, :create_uid,
+                  :currency, :customer, :delivery_address, :description, :invoice_address,
+                  :invoice_method, :invoice_state, :invoices, :metadata, :payment_term,
+                  :purchase_person, :reference, :shipment_method, :shipments, :state,
+                  :tax_amount, :total_amount, :total_quantity, :untaxed_amount, :write_date,
+                  :write_uid
+  end
+end

data/lib/erp_integration/purchase_order_line.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ErpIntegration
+  # The `ErpIntegration::PurchaseOrderLine` exposes an uniformed API for
+  # interaction with third-party ERP vendors.
+  class PurchaseOrderLine < Resource
+    attr_accessor :id, :amount, :delivery_date, :product, :quantity, :unit_price,
+                  :attachments, :create_date, :create_uid, :description, :invoice_lines,
+                  :metadata, :note, :purchase, :quantity_canceled, :quantity_invoiced,
+                  :quantity_received, :sequence, :taxes, :type, :unit, :write_date, :write_uid
+  end
+end

data/lib/erp_integration/purchase_request.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ErpIntegration
+  # The `ErpIntegration::PurchaseRequest` exposes an uniformed API for interaction with
+  # third-party ERP vendors.
+  class PurchaseRequest < Resource
+    attr_accessor :id, :party, :product, :quantity, :attachments, :company,
+                  :create_date, :create_uid, :customer, :delivery_address,
+                  :metadata, :purchase, :purchase_date, :purchase_line, :state,
+                  :uom, :warehouse, :write_date, :write_uid
+  end
+end

data/lib/erp_integration/resource.rb

@@ -46,8 +46,8 @@ module ErpIntegration
       def adapter
         return @adapter if defined?(@adapter)
 
-        require_relative File.join(File.dirname(__FILE__), '..', "#{adapter_path}.rb")
-        @adapter = adapter_klass.constantize
+        require_relative File.join(File.dirname(__FILE__), "#{adapter_path}.rb")
+        @adapter = adapter_klass.constantize.new(self)
       end
 
       # Dynamically exposes the adapter class to the resource.
@@ -56,16 +56,37 @@ module ErpIntegration
         "ErpIntegration::#{adapter_path.classify}"
       end
 
+      # Provides a relative path to the adapter for the resource.
+      # @return [String] the path to the adapter
+      def adapter_path
+        "#{adapter_type}/resources/#{resource_name}"
+      end
+
       # Retrieves the adapter type for the resource from the global configuration.
       # @return [String] the adapter type for the resource
       def adapter_type
         ErpIntegration.config.send("#{resource_name}_adapter").to_s
       end
 
-      # Provides a relative path to the adapter for the resource.
-      # @return [String] the path to the adapter
-      def adapter_path
-        "#{resource_name.pluralize}/#{adapter_type}_#{resource_name}"
+      # Due to `method_missing` we're able to delegate all the work automatically
+      # to the adapter. However, if the method doesn't exist on the adapter, the
+      # `NoMethodError` is still being raised.
+      # @param method_name [Symbol] The name of the missing method.
+      # @param args [Array] The list of arguments for the missing method.
+      # @param block [Proc] Any block given to the missing method.
+      def method_missing(method_name, *args, &block)
+        if adapter.respond_to?(method_name)
+          adapter.send(method_name, *args, &block)
+        else
+          super
+        end
+      end
+
+      # The `respond_to_missing?` complements the `method_missing` method.
+      # @param method_name [Symbol] The name of the missing method.
+      # @param include_private [Boolean] Whether private methods should be checked too (defaults to false).
+      def respond_to_missing?(method_name, include_private = false)
+        adapter.respond_to?(method_name) || super
       end
 
       # Derives the name of the resource from the class name.

data/lib/erp_integration/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ErpIntegration
-  VERSION = "0.2.0".freeze
+  VERSION = '0.3.3'
 end

data/lib/erp_integration.rb

@@ -2,7 +2,9 @@
 
 require 'active_support'
 require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/module/delegation' # Allows using `delegate`
 require 'faraday'
+require 'faraday_middleware'
 require 'json'
 
 require_relative 'erp_integration/version'
@@ -12,13 +14,16 @@ require_relative 'erp_integration/configuration'
 # Middleware
 require_relative 'erp_integration/middleware/error_handling'
 
-# Resources
-require_relative 'erp_integration/resource'
-require_relative 'erp_integration/order'
-
 # HTTP clients
-require_relative 'erp_integration/clients/fulfil_client'
+require_relative 'erp_integration/fulfil/client'
 
 # The `ErpIntegration` integrates Mejuri with third-party ERP vendors.
 module ErpIntegration
+  # Resources
+  autoload :Resource, 'erp_integration/resource'
+  autoload :Order, 'erp_integration/order'
+  autoload :OrderLine, 'erp_integration/order_line'
+  autoload :PurchaseOrder, 'erp_integration/purchase_order'
+  autoload :PurchaseOrderLine, 'erp_integration/purchase_order_line'
+  autoload :PurchaseRequest, 'erp_integration/purchase_request'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: erp_integration
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.3
 platform: ruby
 authors:
 - Stefan Vermaas
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-09-23 00:00:00.000000000 Z
+date: 2021-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -33,7 +33,7 @@ dependencies:
         version: 0.17.3
     - - "<"
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: 1.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -43,7 +43,7 @@ dependencies:
         version: 0.17.3
     - - "<"
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: 1.9.0
 - !ruby/object:Gem::Dependency
   name: faraday_middleware
   requirement: !ruby/object:Gem::Requirement
@@ -253,12 +253,24 @@ files:
 - bin/setup
 - erp_integration.gemspec
 - lib/erp_integration.rb
-- lib/erp_integration/clients/fulfil_client.rb
 - lib/erp_integration/configuration.rb
 - lib/erp_integration/errors.rb
+- lib/erp_integration/fulfil/api_resource.rb
+- lib/erp_integration/fulfil/client.rb
+- lib/erp_integration/fulfil/query.rb
+- lib/erp_integration/fulfil/query_methods.rb
+- lib/erp_integration/fulfil/resources/order.rb
+- lib/erp_integration/fulfil/resources/order_line.rb
+- lib/erp_integration/fulfil/resources/purchase_order.rb
+- lib/erp_integration/fulfil/resources/purchase_order_line.rb
+- lib/erp_integration/fulfil/resources/purchase_request.rb
+- lib/erp_integration/fulfil/where_clause.rb
 - lib/erp_integration/middleware/error_handling.rb
 - lib/erp_integration/order.rb
-- lib/erp_integration/orders/fulfil_order.rb
+- lib/erp_integration/order_line.rb
+- lib/erp_integration/purchase_order.rb
+- lib/erp_integration/purchase_order_line.rb
+- lib/erp_integration/purchase_request.rb
 - lib/erp_integration/resource.rb
 - lib/erp_integration/version.rb
 homepage: https://www.github.com/mejuri-inc/erp-integration

data/lib/erp_integration/orders/fulfil_order.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module ErpIntegration
-  module Orders
-    # The `FulfilOrder` handles all interaction with sales orders in Fulfil.
-    class FulfilOrder
-      extend Forwardable
-      def_delegator 'ErpIntegration', :config
-
-      # Allows cancelling the entire sales order in Fulfil.
-      # @param id [Integer|String] The ID of the to be cancelled order.
-      # @return [boolean] Whether the sales order was cancelled successfully or not.
-      def cancel(id)
-        client.put("model/sale.sale/#{id}/cancel")
-        true
-
-      # Fulfil will return an 400 (a.k.a. "Bad Request") status code when a sales order couldn't
-      # be cancelled. If a sales order isn't cancellable by design, no exception should be raised.
-      #
-      # See the Fulfil's documentation for more information:
-      # https://developers.fulfil.io/rest_api/model/sale.sale/#cancel-a-sales-order
-      rescue ErpIntegration::HttpError::BadRequest
-        false
-      end
-
-      private
-
-      def client
-        @client ||= Clients::FulfilClient.new(
-          api_key: config.fulfil_api_key,
-          merchant_id: config.fulfil_merchant_id
-        )
-      end
-    end
-  end
-end