fulfil_api 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb30711ccea7942e991ecf77dcc3c25290752c09d83674c822c018d4d8c7fcde
-  data.tar.gz: 82e58d3494b0b0a8d73d7ff3c4bd2d96fb79b599f3588bda3b1c4035fd22fcf0
+  metadata.gz: dc3d42e014ce01e2bca045883fcbe4b43a2f701fafd6c4252c7b06c1a9314acf
+  data.tar.gz: e6e79edf8b831515f3a706358c5884384b1f925b150443b1627ae33905ead5c6
 SHA512:
-  metadata.gz: 4f2ac1b0f4d06d7d55cbf0a2f69cf5fd566ad514439a983270d0f14e1235c38a2c258b3f97dccd4589c81d4f1942309fa4eae5ce9e5c719b29ee104555e2692a
-  data.tar.gz: ca9fd568544fb12b16d8a656667c7ca09d8c1583d8e29324fa8d9ed924a5d380fee2ff7fd7a435b987f744c561a278bea657f5f538331a461c8288265c7f4430
+  metadata.gz: 8694733643edbf5caa327f42fb5121b4557869358afaf916c4cdfe30e2a7854ba70b189b24d8f1886b41054f1eb36aa6ffc1bafbc4c378e0b2276fa4513aaebc
+  data.tar.gz: ef3818c50ac4a8e09660a690a7d3a97e0775111ccbd1f35825969ab66ee1cb4003e5c2aec2f2b26ef5902a0e1ad07a5fb90bda99ad4b6c94b7bff4a8b57dbcc3

data/lib/fulfil_api/relation/batchable.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module FulfilApi
+  class Relation
+    # The {FulfilApi::Relation::Batchable} module includes a set of
+    #   helper/query methods that queries resources in Fulfil in batches.
+    module Batchable
+      # The {#find_each} is a shorthand for iterating over individual API resources
+      #   in a memory effective way.
+      #
+      # Under the hood, it uses the {#in_batches} to find API resources in batches
+      #   and process them efficiently.
+      #
+      # @example find all resources
+      #
+      #   FulfilApi::Resource.set(model_name: "sale.sale").find_each do |sales_order|
+      #     process_sales_order(sales_order)
+      #   end
+      #
+      # @param batch_size [Integer] The default batch forwarded to the {#in_batches} method.
+      # @yield [FulfilApi::Resource] An individual API resource.
+      # @return [FulfilApi::Relation]
+      def find_each(batch_size: 500, &block)
+        in_batches(of: batch_size) do |batch|
+          batch.each(&block)
+        end
+      end
+
+      # Finds API resources in batches. Defaults to the maximum number of resources
+      #   Fulfil's API endpoints will return (500 resources).
+      #
+      # @example find resources in batches of 10.
+      #
+      #   FulfilApi::Resource.set(model_name: "sale.sale").in_batches(of: 10) do |batch|
+      #     batch.each do |sales_order|
+      #       process_sales_order(sales_order)
+      #     end
+      #   end
+      #
+      # @note the {#in_batches} automatically retries when it encounters a 429
+      #   (TooManyRequests) HTTP error to ensure the lookup can be completed.
+      #
+      # @param of [Integer] The maximum number of resources in a batch.
+      # @yield [FulfilApi::Relation] Yields FulfilApi::Relation
+      #   objects to work with a batch of records.
+      # @return [FulfilApi::Relation]
+      def in_batches(of: 500) # rubocop:disable Metrics/MethodLength
+        current_offset = request_offset.presence || 0
+        batch_size = of
+
+        loop do
+          batch_relation = dup.offset(current_offset * batch_size).limit(batch_size)
+          batch_relation.load
+
+          yield(batch_relation)
+
+          break unless batch_relation.size == batch_size
+
+          current_offset += 1
+        rescue FulfilApi::Error => e
+          retry if e.details[:response_status] == 429
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/fulfil_api/relation/countable.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module FulfilApi
+  class Relation
+    # The {FulfilApi::Relation::Countable} extends the relation by
+    #   adding a method to count the records within a given context.
+    module Countable
+      # Finds the exact number of API resources in Fulfil.
+      #
+      # @note It takes into account the query conditions and can be used to find
+      #   the count of a subset of resources.
+      #
+      # @note The {#count} directly triggers an HTTP request to Fulfil but the
+      #   return value is cached. When you want to recount, use {#recount}.
+      #
+      # @return [Integer]
+      def count
+        raise FulfilApi::Resource::ModelNameMissing if model_name.nil?
+
+        @count ||= FulfilApi.client.put(
+          "/model/#{model_name}/search_count",
+          body: { filters: conditions }.compact_blank
+        )
+      end
+
+      # Checks if the relation has already been counted.
+      #
+      # @return [true, false]
+      def counted?
+        @count
+      end
+
+      # Recounts the exact number of API resources in Fulfil.
+      #
+      # @note Under the hood, it uses the {#count} method by resetting the cached
+      #   value and calling {#count} again.
+      #
+      # @return [Integer]
+      def recount
+        @count = nil
+        count
+      end
+    end
+  end
+end

data/lib/fulfil_api/relation/loadable.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module FulfilApi
+  class Relation
+    # The {FulfilApi::Relation::Loadable} extends the relation by
+    #   adding methods to load, reload and identify loaded resources from Fulfil's
+    #   API endpoints.
+    #
+    # By default, all HTTP requests to Fulfil are delayed until they're directly
+    #   or indirectly requested by the user of the gem. This way, we ensure that
+    #   we only request data when we need to.
+    module Loadable
+      # Loads resources from Fulfil's API based on the current filters, fields,
+      #   offset, and limits if they haven't been loaded yet.
+      #
+      # Requires that {#model_name} is set; raises an exception if it's not.
+      #
+      # @return [true, false] True if the resources were loaded successfully.
+      def load # rubocop:disable Metrics/MethodLength
+        return true if loaded?
+        raise FulfilApi::Resource::ModelNameMissing if model_name.nil?
+
+        response = FulfilApi.client.put(
+          "/model/#{model_name}/search_read",
+          body: {
+            filters: conditions,
+            fields: fields,
+            limit: request_limit,
+            offset: request_offset
+          }.compact_blank
+        )
+
+        # NOTE: The /search_read endpoint will always be an array. Therefore, we're
+        #   always looping over the response values.
+        @resources = response.map do |attributes|
+          @resource_klass.new(attributes.merge(model_name: model_name))
+        end
+
+        @loaded = true
+      end
+
+      # Checks whether the resources have been loaded to avoid repeated API calls when
+      #   using enumerable methods.
+      #
+      # @return [true, false] True if the resources are already loaded.
+      def loaded?
+        @loaded
+      end
+
+      # Reloads the resources from Fulfil's API by resetting the {@loaded} flag.
+      #
+      # @return [true, false] True if the resources were successfully reloaded.
+      def reload
+        @loaded = false
+        load
+      end
+    end
+  end
+end

data/lib/fulfil_api/relation/naming.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module FulfilApi
+  class Relation
+    # The {FulfilApi::Relation::Naming} extends the relation by
+    #   adding methods to it that allow us to identify the type of resource that
+    #   is being requested.
+    module Naming
+      extend ActiveSupport::Concern
+
+      # Sets the name of the resource model to be queried.
+      #
+      # @todo In the future, derive the {#name} from the @resource_klass automatically.
+      #
+      # @param model_name [String] The name of the resource model in Fulfil.
+      # @return [FulfilApi::Relation] A new {Relation} instance with the model name set.
+      def set(model_name:)
+        clone.tap do |relation|
+          relation.model_name = model_name
+        end
+      end
+    end
+  end
+end

data/lib/fulfil_api/relation/query_methods.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module FulfilApi
+  class Relation
+    # The {FulfilApi::Relation::QueryMethods} extends the relation by
+    #   adding query methods to it.
+    module QueryMethods
+      # Finds the first resource that matches the given conditions.
+      #
+      # It constructs a query using the `where` method, limits the result to one record,
+      #   and then returns the first result.
+      #
+      # @note Unlike the other methods in this module, `#find_by` will immediately trigger an
+      #   HTTP request to retrieve the resource, rather than allowing for lazy evaluation.
+      #
+      # @param conditions [Array<String, String, String>] The filter conditions as required by Fulfil.
+      # @return [FulfilApi::Resource, nil] The first resource that matches the conditions,
+      #   or nil if no match is found.
+      def find_by(conditions)
+        where(conditions).limit(1).first
+      end
+
+      # Finds the first resource that matches the given conditions and raises
+      #   when no resource is found.
+      #
+      # @see .find_by
+      #
+      # @param conditions [Array<String, String, String>] The filter conditions as required by Fulfil.
+      # @return [FulfilApi::Resource] The first resource that matches the conditions
+      # @raise [FulfilApi::Resource::NotFound]
+      def find_by!(conditions)
+        find_by(conditions) || raise(FulfilApi::Resource::NotFound, "Unable to find #{model_name} where #{conditions}")
+      end
+
+      # Limits the number of resources returned by Fulfil's API. This is useful when only
+      #   a specific number of resources are needed.
+      #
+      # @note If not specified, Fulfil will assume a request limit of 500.
+      #
+      # @param value [Integer] The maximum number of resources to return.
+      # @return [FulfilApi::Relation] A new {Relation} instance with the limit applied.
+      def limit(value)
+        clone.tap do |relation|
+          relation.request_limit = value
+        end
+      end
+
+      # Applies an offset to the API resources returned by Fulfil's API.
+      #   This is useful when paginating over larger lists of API resources.
+      #
+      # @note If not specified, Fulfil will assume a request offset of 0.
+      #
+      # @param value [Integer] The page offset for the API request.
+      # @return [FulfilApi::Relation] A new {Relation} instance with the offset applied.
+      def offset(value)
+        clone.tap do |relation|
+          relation.request_offset = value
+        end
+      end
+
+      # Specifies the fields to include in the response from Fulfil's API. By default, only
+      #   the ID is returned.
+      #
+      # Supports dot notation for nested data fields, though not all nested data may be available
+      #   depending on the API's limitations.
+      #
+      # @example Requesting nested data fields
+      #   FulfilApi::Resource.set(model_name: "sale.line").select("sale.reference").find_by(["id", "=", 10])
+      #
+      # @example Requesting additional fields
+      #   FulfilApi::Resource.set(model_name: "sale.sale").select(:reference).find_by(["id", "=", 10])
+      #
+      # @param fields [Array<Symbol, String>] The fields to include in the response.
+      # @return [FulfilApi::Relation] A new {Relation} instance with the selected fields.
+      def select(*fields)
+        clone.tap do |relation|
+          relation.fields.concat(fields.map(&:to_s))
+          relation.fields.uniq!
+        end
+      end
+
+      # Adds filter conditions for querying Fulfil's API. Conditions should be formatted
+      #   as arrays according to the Fulfil API documentation.
+      #
+      # @example Simple querying with conditions
+      #   FulfilApi::Resource.set(model_name: "sale.line").where(["sale.reference", "=", "ORDER-123"])
+      #
+      # @todo Enhance the {#where} method to allow more natural and flexible queries.
+      #
+      # @param conditions [Array<String, String, String>] The filter conditions as required by Fulfil.
+      # @return [FulfilApi::Relation] A new {Relation} instance with the conditions applied.
+      def where(conditions)
+        clone.tap do |relation|
+          relation.conditions << conditions
+          relation.conditions.uniq!
+        end
+      end
+    end
+  end
+end

data/lib/fulfil_api/relation.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module FulfilApi
+  # The {FulfilApi::Relation} class provides an abstraction for chaining multiple API operations.
+  #
+  # It allows handling a set of API resources in a uniform way, similar to
+  #   ActiveRecord's query interface, enabling the user to build complex queries
+  #   in a clean and reusable manner.
+  class Relation
+    include Enumerable
+
+    # Insert the {FulfilApi::Relation} modules after the inclusion of
+    #   standard Ruby module extensions. This ensures our modules win when there
+    #   is any conflicting method. An example of this is the {#count} method.
+    include Batchable
+    include Countable
+    include Loadable
+    include Naming
+    include QueryMethods
+
+    attr_accessor :conditions, :fields, :model_name, :request_limit, :request_offset
+
+    delegate_missing_to :all
+
+    # @param resource_klass [FulfilApi::Resource] The resource data model class.
+    def initialize(resource_klass)
+      @resource_klass = resource_klass
+
+      @loaded = false
+      @resources = []
+
+      reset
+    end
+
+    # Loads and returns all resources from Fulfil's API. This method functions as a proxy,
+    #   deferring the loading of resources until they are required, thus avoiding unnecessary
+    #   HTTP requests.
+    #
+    # @return [Array<FulfilApi::Resource>] An array of loaded resource objects.
+    def all
+      load
+      @resources
+    end
+
+    # The {#each} method allows iteration over the resources. If no block is given,
+    #   it returns an Enumerator, enabling lazy evaluation and allowing for chaining
+    #   without immediately triggering an API request.
+    #
+    # @yield [resource] Yields each resource object to the given block.
+    # @return [Enumerator, self] Returns an Enumerator if no block is given; otherwise, returns self.
+    def each(&block)
+      all.each(&block)
+    end
+
+    # Resets any of the previously provided query conditions.
+    #
+    # @return [FulfilApi::Relation] The relation with cleared query conditions.
+    def reset
+      @conditions = []
+      @fields = %w[id]
+      @request_limit = nil
+      @request_offset = nil
+
+      self
+    end
+  end
+end

data/lib/fulfil_api/resource.rb

@@ -7,15 +7,21 @@ module FulfilApi
     include AttributeAssignable
     include Persistable
 
-    class ModelNameMissing < Error; end
+    # The model name is required to be able to build the API endpoint to
+    #   perform the search/read/count HTTP requests.
+    class ModelNameMissing < Error
+      def initialize
+        super("The model name is missing. Use #set to define it.")
+      end
+    end
+
     class NotFound < Error; end
 
     def initialize(attributes = {})
       attributes.deep_stringify_keys!
 
       @attributes = {}.with_indifferent_access
-      @model_name = attributes.delete("model_name").presence ||
-                    raise(ModelNameMissing, "The model name is missing. Use the :model_name attribute to define it.")
+      @model_name = attributes.delete("model_name").presence || raise(ModelNameMissing)
 
       assign_attributes(attributes)
     end
@@ -34,7 +40,7 @@ module FulfilApi
       # @example forwarding of the .where class method
       #   FulfilApi::Resource.set(model_name: "sale.sale").find_by(["id", "=", 100])
       #
-      # @return [FulfilApi::Resource::Relation]
+      # @return [FulfilApi::Relation]
       def relation
         Relation.new(self)
       end

data/lib/fulfil_api/test_helper.rb

@@ -59,6 +59,8 @@ module FulfilApi
     #   stubbed_request_for(:get, model: "product.product", id: "123")
     def stubbed_request_for(method, **options)
       case options.transform_keys(&:to_sym)
+      in { model:, suffix: }
+        stub_request(method.to_sym, %r{fulfil.io/api/v\d+/(?:model/)?#{model}/#{suffix}}i)
       in { model:, id: }
         stub_request(method.to_sym, %r{fulfil.io/api/v\d+/(?:model/)?#{model}/#{id}(.*)}i)
       in { model: }

data/lib/fulfil_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FulfilApi
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fulfil_api
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Stefan Vermaas
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-06 00:00:00.000000000 Z
+date: 2024-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -86,15 +86,17 @@ files:
 - lib/fulfil_api/configuration.rb
 - lib/fulfil_api/customer_shipment.rb
 - lib/fulfil_api/error.rb
+- lib/fulfil_api/relation.rb
+- lib/fulfil_api/relation/batchable.rb
+- lib/fulfil_api/relation/countable.rb
+- lib/fulfil_api/relation/loadable.rb
+- lib/fulfil_api/relation/naming.rb
+- lib/fulfil_api/relation/query_methods.rb
 - lib/fulfil_api/resource.rb
 - lib/fulfil_api/resource/attribute_assignable.rb
 - lib/fulfil_api/resource/attribute_type.rb
 - lib/fulfil_api/resource/errors.rb
 - lib/fulfil_api/resource/persistable.rb
-- lib/fulfil_api/resource/relation.rb
-- lib/fulfil_api/resource/relation/loadable.rb
-- lib/fulfil_api/resource/relation/naming.rb
-- lib/fulfil_api/resource/relation/query_methods.rb
 - lib/fulfil_api/test_helper.rb
 - lib/fulfil_api/version.rb
 - sig/fulfil_api.rbs

data/lib/fulfil_api/resource/relation/loadable.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module FulfilApi
-  class Resource
-    class Relation
-      # The {FulfilApi::Resource::Relation::Loadable} extends the relation by
-      #   adding methods to load, reload and identify loaded resources from Fulfil's
-      #   API endpoints.
-      #
-      # By default, all HTTP requests to Fulfil are delayed until they're directly
-      #   or indirectly requested by the user of the gem. This way, we ensure that
-      #   we only request data when we need to.
-      module Loadable
-        # Loads resources from Fulfil's API based on the current filters, fields, and limits
-        #   if they haven't been loaded yet.
-        #
-        # Requires that {#model_name} is set; raises an exception if it's not.
-        #
-        # @return [true, false] True if the resources were loaded successfully.
-        def load # rubocop:disable Metrics/MethodLength
-          return true if loaded?
-
-          if model_name.nil?
-            raise FulfilApi::Resource::Relation::ModelNameMissing, "The model name is missing. Use #set to define it."
-          end
-
-          response = FulfilApi.client.put(
-            "/model/#{model_name}/search_read",
-            body: { filters: conditions, fields: fields, limit: request_limit }.compact_blank
-          )
-
-          @resources = response.map do |attributes|
-            @resource_klass.new(attributes.merge(model_name: model_name))
-          end
-
-          @loaded = true
-        end
-
-        # Checks whether the resources have been loaded to avoid repeated API calls when
-        #   using enumerable methods.
-        #
-        # @return [true, false] True if the resources are already loaded.
-        def loaded?
-          @loaded
-        end
-
-        # Reloads the resources from Fulfil's API by resetting the {@loaded} flag.
-        #
-        # @return [true, false] True if the resources were successfully reloaded.
-        def reload
-          @loaded = false
-          load
-        end
-      end
-    end
-  end
-end

data/lib/fulfil_api/resource/relation/naming.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module FulfilApi
-  class Resource
-    class Relation
-      # The {FulfilApi::Resource::Relation::Naming} extends the relation by
-      #   adding methods to it that allow us to identify the type of resource that
-      #   is being requested.
-      module Naming
-        extend ActiveSupport::Concern
-
-        included do
-          # Custom error class for missing model name. The model name is required to be
-          #   able to build the API endpoint to perform the search/read HTTP request.
-          class ModelNameMissing < Error; end # rubocop:disable Lint/ConstantDefinitionInBlock
-        end
-
-        # Sets the name of the resource model to be queried.
-        #
-        # @todo In the future, derive the {#name} from the @resource_klass automatically.
-        #
-        # @param model_name [String] The name of the resource model in Fulfil.
-        # @return [FulfilApi::Resource::Relation] A new {Relation} instance with the model name set.
-        def set(model_name:)
-          clone.tap do |relation|
-            relation.model_name = model_name
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fulfil_api/resource/relation/query_methods.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module FulfilApi
-  class Resource
-    class Relation
-      # The {FulfilApi::Resource::Relation::QueryMethods} extends the relation by
-      #   adding query methods to it.
-      module QueryMethods
-        # Finds the first resource that matches the given conditions.
-        #
-        # It constructs a query using the `where` method, limits the result to one record,
-        #   and then returns the first result.
-        #
-        # @note Unlike the other methods in this module, `#find_by` will immediately trigger an
-        #   HTTP request to retrieve the resource, rather than allowing for lazy evaluation.
-        #
-        # @param conditions [Array<String, String, String>] The filter conditions as required by Fulfil.
-        # @return [FulfilApi::Resource, nil] The first resource that matches the conditions,
-        #   or nil if no match is found.
-        def find_by(conditions)
-          where(conditions).limit(1).first
-        end
-
-        # Finds the first resource that matches the given conditions and raises
-        #   when no resource is found.
-        #
-        # @see .find_by
-        #
-        # @param conditions [Array<String, String, String>] The filter conditions as required by Fulfil.
-        # @return [FulfilApi::Resource] The first resource that matches the conditions
-        # @raise [FulfilApi::Resource::NotFound]
-        def find_by!(conditions)
-          find_by(conditions) || raise(NotFound, "Unable to find #{model_name} where #{conditions}")
-        end
-
-        # Limits the number of resources returned by Fulfil's API. This is useful when only
-        #   a specific number of resources are needed.
-        #
-        # @note If not specified, Fulfil's API defaults to returning up to 500 resources per call.
-        #
-        # @param value [Integer] The maximum number of resources to return.
-        # @return [FulfilApi::Resource::Relation] A new {Relation} instance with the limit applied.
-        def limit(value)
-          clone.tap do |relation|
-            relation.request_limit = value
-          end
-        end
-
-        # Specifies the fields to include in the response from Fulfil's API. By default, only
-        #   the ID is returned.
-        #
-        # Supports dot notation for nested data fields, though not all nested data may be available
-        #   depending on the API's limitations.
-        #
-        # @example Requesting nested data fields
-        #   FulfilApi::Resource.set(model_name: "sale.line").select("sale.reference").find_by(["id", "=", 10])
-        #
-        # @example Requesting additional fields
-        #   FulfilApi::Resource.set(model_name: "sale.sale").select(:reference).find_by(["id", "=", 10])
-        #
-        # @param fields [Array<Symbol, String>] The fields to include in the response.
-        # @return [FulfilApi::Resource::Relation] A new {Relation} instance with the selected fields.
-        def select(*fields)
-          clone.tap do |relation|
-            relation.fields.concat(fields.map(&:to_s))
-            relation.fields.uniq!
-          end
-        end
-
-        # Adds filter conditions for querying Fulfil's API. Conditions should be formatted
-        #   as arrays according to the Fulfil API documentation.
-        #
-        # @example Simple querying with conditions
-        #   FulfilApi::Resource.set(model_name: "sale.line").where(["sale.reference", "=", "ORDER-123"])
-        #
-        # @todo Enhance the {#where} method to allow more natural and flexible queries.
-        #
-        # @param conditions [Array<String, String, String>] The filter conditions as required by Fulfil.
-        # @return [FulfilApi::Resource::Relation] A new {Relation} instance with the conditions applied.
-        def where(conditions)
-          clone.tap do |relation|
-            relation.conditions << conditions
-            relation.conditions.uniq!
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fulfil_api/resource/relation.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module FulfilApi
-  class Resource
-    # The {FulfilApi::Resource::Relation} class provides an abstraction for chaining multiple API operations.
-    #
-    # It allows handling a set of API resources in a uniform way, similar to
-    #   ActiveRecord's query interface, enabling the user to build complex queries
-    #   in a clean and reusable manner.
-    class Relation
-      include Enumerable
-      include Loadable
-      include Naming
-      include QueryMethods
-
-      attr_accessor :conditions, :fields, :model_name, :request_limit
-
-      delegate_missing_to :all
-
-      # @param resource_klass [FulfilApi::Resource] The resource data model class.
-      def initialize(resource_klass)
-        @resource_klass = resource_klass
-
-        @loaded = false
-        @resources = []
-
-        reset
-      end
-
-      # Loads and returns all resources from Fulfil's API. This method functions as a proxy,
-      #   deferring the loading of resources until they are required, thus avoiding unnecessary
-      #   HTTP requests.
-      #
-      # @return [Array<FulfilApi::Resource>] An array of loaded resource objects.
-      def all
-        load
-        @resources
-      end
-
-      # The {#each} method allows iteration over the resources. If no block is given,
-      #   it returns an Enumerator, enabling lazy evaluation and allowing for chaining
-      #   without immediately triggering an API request.
-      #
-      # @yield [resource] Yields each resource object to the given block.
-      # @return [Enumerator, self] Returns an Enumerator if no block is given; otherwise, returns self.
-      def each(&block)
-        all.each(&block)
-      end
-
-      # Resets any of the previously provided query conditions.
-      #
-      # @return [FulfilApi::Resource::Relation] The relation with cleared query conditions.
-      def reset
-        @conditions = []
-        @fields = %w[id]
-        @limit = nil
-
-        self
-      end
-    end
-  end
-end