deferred_request 0.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a9e96cf574be720de97ae91ae7f06d09b082d56ffc2aef3eae449653dbce7b9
-  data.tar.gz: f604991997404bf38fad4cae5fd40b5b00088d952f0f3d15bd1a64b4f9d4a078
+  metadata.gz: 4a12d759682c3ca5d2e1171cc6da944e80ce6a9b0f3ccfb65dcaca5d10b2a0c9
+  data.tar.gz: 6ef803175b32093e08d330caebb28d06fbd31e0c3db33f34304ec3163b31e63a
 SHA512:
-  metadata.gz: ffa3d29e8e24b1c6dc48200cb6463f4facef2ded394cd820b0a5083dee8948f779b2f0e439779a8276a786dffbfc6790b20679a98d1481861a2b8bd9410677a3
-  data.tar.gz: 5bffe0fe31acd967710261f6a23925ccf48db5b9e1b573df520eec7d6d42c97df13cf92ac1d7853007d945fd3ac4ae2fb2ecee0cff8bef62eaf70dc380d08673
+  metadata.gz: d2efcff67bba0f0d7fcd75ae8e08e8cb120412753cc1a1e5439ea37b13bae5323095a866e9d7671be31c13701e8c85aeeb060592537d9b1e087a658884a08cb7
+  data.tar.gz: 5004f590c976b08777e42753b19bb53588dfe54386e6470818ab366f60b363748f0c87728c963a499eba0cd6fafcbba0b422430c35353f784ff3d10921ff5399

data/README.md

@@ -45,10 +45,7 @@ def status_callback
   head :ok
 
   # Then queue the request to run later
-  deferred_request = DeferredRequest::DeferredRequest.from_request(request, params)
-  deferred_request.save!
-
-  deferred_request.peform_later
+  deferred_request = DeferredRequest::DeferredRequest.perform_later_from_request!(request)
 end
 
 # Your deferred request method will be called later (via a job)
@@ -65,6 +62,27 @@ end
 # ...
 ```
 
+### Class Methods
+- `DeferredRequest::DeferredRequest.from_request(request)` - returns a DeferredRequest::DeferredRequest object (unsaved). Returns the DeferredRequest::DeferredRequest instance.
+- `DeferredRequest::DeferredRequest.perform_later_from_request!(request)` - creates a deferred request (saved) and enqueues job to process the request. Returns the DeferredRequest::DeferredRequest instance.
+
+### Instance Methods
+- `deferred_request.perform_later` - Enqueues a job to `perform!` the deferred request later. Returns the job id.
+- `deferred_request.perform!` - Calls the `#{controller}_deferred(deferred_request)` method to be processed. Returns the deferred_request instance or raises an exception.
+
+## Configuration
+
+- `DeferredRequest.model_parent_class` - Set the parent class
+- `DeferredRequest.deferred_request_instance_class` - Set the instance class that is created (in-case you sub-class)
+- `DeferredRequest.job_queue` - Set the job queue for the deferred request job
+
+```ruby
+# config/initializers/deferred_request.rb
+DeferredRequest.model_parent_class = "MyParentClass"
+DeferredRequest.job_queue = "low"
+```
+
+
 ## 🙏 Contributing
 
 If you have an issue you'd like to submit, please do so using the issue tracker in GitHub. In order for us to help you in the best way possible, please be as detailed as you can.

data/app/controllers/deferred_request/test_controller.rb

@@ -1,26 +1,19 @@
 module DeferredRequest
   class TestController < ApplicationController
-    skip_before_action :verify_authenticity_token
-    
     def status_callback
-      # We can go ahead and give a :ok response (fast and snappy)
       head :ok
-
-      # Then queue the request to run later
-      deferred_request = DeferredRequest::DeferredRequest.from_request(request, params)
-      deferred_request.save!
-
-      deferred_request.peform_later
+      DeferredRequest.perform_later_from_request!(request)
     end
 
     def status_callback_deferred(deferred_request)
-      # do some actual processing
-      if deferred_request.params["SmsStatus"] == "delivered"
-        # mark message as delivered
-      end
-    
-      # return a status and it will be saved to the database
-      true
+      # Do something with the deferred request
+      deferred_request.params.dig("answer")
+    end
+
+    def status_error
+      # don't add the "_deferred" method (used for testing)
+      head :ok
+      DeferredRequest.perform_later_from_request!(request)
     end
   end
 end

data/app/jobs/deferred_request/deferred_request_job.rb

@@ -1,6 +1,6 @@
 module DeferredRequest
   class DeferredRequestJob < ApplicationJob
-    queue_as :default
+    queue_as ::DeferredRequest.job_queue
 
     def perform(*args)
       id = args[0]

data/app/models/deferred_request/deferred_request.rb

@@ -1,7 +1,8 @@
 module DeferredRequest
-  class DeferredRequest < ApplicationRecord
-    serialize :routing, JSON, default: {}
-    serialize :request, JSON, default: {}
+  class DeferredRequest < DeferredRequest.model_parent_class.constantize
+    serialize :routing
+    serialize :request
+    serialize :result
 
     store_accessor :routing, "controller", "action"
     store_accessor :request, "url", "method", "headers", "params", "remote_ip"
@@ -11,12 +12,11 @@ module DeferredRequest
     # request: ActionDispatch::Request
     # create a deferred request from a ActionDispatch::Request
     def self.from_request(request)
-      deferred_request = DeferredRequest.new
+      deferred_request = ::DeferredRequest.deferred_request_instance_class.constantize.new
 
-      debugger
-      deferred_request.controller = request.controller_class
+      deferred_request.controller = request.controller_class.name
       deferred_request.action = request.params["action"]
-      
+
       deferred_request.url = request.url
       deferred_request.method = request.method
       deferred_request.headers = get_headers(request)
@@ -26,37 +26,44 @@ module DeferredRequest
       deferred_request
     end
 
+    def self.perform_later_from_request!(request)
+      deferred_request = DeferredRequest.from_request(request)
+      deferred_request.save!
+
+      deferred_request.perform_later
+
+      deferred_request
+    end
+
     def perform_later
-      DeferredRequestJob.perform_later(self.id)
+      DeferredRequestJob.perform_later(id)
     end
 
     def perform!
       begin
         self.status = :processing
-        self.save!
+        save!
 
-        klass = self.controller.constantize.new
+        klass = controller.constantize.new
 
-        self.result = klass.try("#{self.action}_deferred".to_sym, self)
+        self.result = klass.send("#{action}_deferred".to_sym, self)
         self.status = :complete
       rescue => e
         Rails.logger.error("DeferredRequest::DeferredRequestJob: #{e.message}")
         self.result = e.message
         self.status = :error
       end
-      
-      self.save!
-    end
 
-    private
+      save!
+    end
 
-      def self.get_headers(request)
-        # Get the request headers from the request
-        {}.tap do |t|
-          request.headers.each do |key, value|
-            t[key] = value if key.downcase.starts_with?("http")
-          end
+    def self.get_headers(request)
+      # Get the request headers from the request
+      {}.tap do |t|
+        request.headers.each do |key, value|
+          t[key] = value if key.downcase.starts_with?("http")
         end
       end
+    end
   end
 end

data/config/routes.rb

@@ -1,3 +1,4 @@
 DeferredRequest::Engine.routes.draw do
-  post 'status_callback' => 'deferred_request/test#status_callback'
+  post "status_callback" => "test#status_callback"
+  post "status_error" => "test#status_error"
 end

data/lib/deferred_request/version.rb

@@ -1,3 +1,3 @@
 module DeferredRequest
-  VERSION = "0.0.1"
+  VERSION = "1.0.2"
 end

data/lib/deferred_request.rb

@@ -3,4 +3,12 @@ require "deferred_request/engine"
 
 module DeferredRequest
   # Your code goes here...
+  mattr_accessor :model_parent_class
+  @@model_parent_class = "ApplicationRecord"
+
+  mattr_accessor :deferred_request_instance_class
+  @@deferred_request_instance_class = "DeferredRequest::DeferredRequest"
+
+  mattr_accessor :job_queue
+  @@job_queue = "default"
 end

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: deferred_request
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Austin Miller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-06 00:00:00.000000000 Z
+date: 2022-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: 6.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: standardrb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A simple library to defer http requests until you can actually process
   them. (Think webhooks. Stripe webhooks, Twilio status callbacks, ect.)
 email:
@@ -75,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: Deferred Request