isomorfeus-operation 2.2.10 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7219d159c43e8ff7c984f03884de967389af8d49491b65525c309f01276bca7
-  data.tar.gz: 07fffbdea0e4bbbadf1027a2781eb9a697c9c53264be251c7be13f30915b6d77
+  metadata.gz: b18d527260f0587a538b217ef2bf48de482ab1d5b0ebf4254ab144a30c269994
+  data.tar.gz: 296e6ae448f9a1da77ea1a4a69f9cf575a04f350c4eee40ae93b483e252c1e10
 SHA512:
-  metadata.gz: 1bb1c92cf61fa2d0a268258f506758d12b0be8b1934e7bdd130b5d83370d188d25cf48be769b53dbf562c91ac6c361db0e6d14d6071eadd9e19659e1e28926f3
-  data.tar.gz: c3d54ff814a242496a9bf1100b8078460602377f28dd49736876957c97727f792006feda6138d5f576b3f83000e748d112851d97c88840af7f9ce8a2f9ef6735
+  metadata.gz: 98b94dbff5c94a2c4f8e108cb9edc6b34f3587247ff728ab92a434d1c5c48e3dd7d51803cdf3f50effcd6c5953e77c6258a90889132ab710d6fe2e15902478d7
+  data.tar.gz: 0275e6b05df139a96ea614c9f1b039e828086353c1b4f7f27a9448dcf6bcb4e87e2e313bb6aad90634ae2384cbdc7343aa9b163dd6d473b02991570dfee39335

data/README.md

@@ -10,7 +10,6 @@ Operations use Props like other parts of the system.
 See [the isomorfeus-preact props documentation](https://github.com/isomorfeus/isomorfeus-preact/blob/master/docs/props.md#prop-declaration).
 
 There are 3 kinds of Operations:
-- [LucidQuickOp](https://github.com/isomorfeus/isomorfeus-project/blob/master/isomorfeus-operation/docs/quick_op.md) - Quick simple operation, always executed on the server.
-- [LucidOperation](https://github.com/isomorfeus/isomorfeus-project/blob/master/isomorfeus-operation/docs/operation.md) - For complex multi-stepped operations, always executed on the server.
+- [LucidSimpleOperation](https://github.com/isomorfeus/isomorfeus-project/blob/master/isomorfeus-operation/docs/simple_operation.md) - Simple operation, always executed on the server, also deferred or daily.
+- [LucidOperation](https://github.com/isomorfeus/isomorfeus-project/blob/master/isomorfeus-operation/docs/operation.md) - For complex multi-stepped operations, always executed on the server, also deferred or daily.
 - [LucidLocalOperation](https://github.com/isomorfeus/isomorfeus-project/blob/master/isomorfeus-operation/docs/operation.md) - For complex multi-stepped operations, always executed locally.
-

data/lib/isomorfeus/operation/config.rb

@@ -11,6 +11,8 @@ module Isomorfeus
     end
 
     if RUBY_ENGINE != 'opal'
+      attr_accessor :operation_timer_tasks
+
       def valid_operation_class_names
         @valid_operation_class_names ||= Set.new
       end
@@ -24,6 +26,27 @@ module Isomorfeus
         class_name = class_name.split('>::').last if class_name.start_with?('#<')
         valid_operation_class_names << class_name
       end
+
+      def pop_failed_tasks
+        failed_tasks = []
+        [Isomorfeus::Operation::DeferredTask, Isomorfeus::Operation::DailyTask].each do |task_class|
+          task_class.search(:state, 'failed').each do |task|
+            failed_tasks << task
+            task.destroy
+          end
+        end
+        failed_tasks
+      end
+
+      def all_tasks
+        all_tasks = []
+        [Isomorfeus::Operation::DeferredTask, Isomorfeus::Operation::DailyTask].each do |task_class|
+          task_class.search(:state, '*').each do |task|
+            all_tasks << task
+          end
+        end
+        all_tasks
+      end
     end
   end
 end

data/lib/isomorfeus/operation/daily_task.rb

@@ -0,0 +1,23 @@
+module Isomorfeus
+  module Operation
+    class DailyTask < LucidObject::Base
+      STATES = %w[ready running failed]
+      # when the task is added to the queue its added as ready
+      # when its running, its running
+      # when it failes, it failed, the exception attribute is filled
+      # when it was successful, its removed from the queue
+      attribute :operation_class_name, class: String, required: true, validate_block: proc { |v| raise 'Invalid Operation class!' unless Isomorfeus.valid_operation_class_name?(v) }
+      attribute :props
+      attribute :user_class_name, class: String, default: 'Anonymous'
+      attribute :user_key, class: String, default: 'anonymous'
+      attribute :state, class: String, required: true, index: :value, ensure: proc { |v| Isomorfeus::Operation::DailyTask::STATES.include?(v) ? v : 'ready' }
+      attribute :exception
+      attribute :rtime
+      attribute :fail, default: true
+
+      def get_exception
+        Marshal.load(exception) if exception
+      end
+    end
+  end
+end

data/lib/isomorfeus/operation/deferred_task.rb

@@ -0,0 +1,22 @@
+module Isomorfeus
+  module Operation
+    class DeferredTask < LucidObject::Base
+      STATES = %w[ready running failed]
+      # when the task is added to the queue its added as ready
+      # when its running, its running
+      # when it failes, it failed, the exception attribute is filled
+      # when it was successful, its removed from the queue
+      attribute :operation_class_name, class: String, required: true, validate_block: proc { |v| raise 'Invalid Operation class!' unless Isomorfeus.valid_operation_class_name?(v) }
+      attribute :props
+      attribute :user_class_name, class: String, default: 'Anonymous'
+      attribute :user_key, class: String, default: 'anonymous'
+      attribute :state, class: String, required: true, index: :value, ensure: proc { |v| Isomorfeus::Operation::DeferredTask::STATES.include?(v) ? v : 'ready' }
+      attribute :exception
+      attribute :rtime
+
+      def get_exception
+        Marshal.load(exception) if exception
+      end
+    end
+  end
+end

data/lib/isomorfeus/operation/generic_class_api.rb

@@ -0,0 +1,94 @@
+module Isomorfeus
+  module Operation
+    module GenericClassApi
+      def current_user
+        Isomorfeus.current_user
+      end
+
+      if RUBY_ENGINE == 'opal'
+        def _process_response(agent)
+          agent.process do |agnt|
+            agnt.response[:result]
+          end
+          if agent.result.key?(:rejected)
+            if agent.result.key?(:error)
+              e = agent.result[:error]
+              exception_class_name = e[:class_name]
+              exception_class = exception_class_name.constantize
+              exception = exception_class.new(e[:message])
+              exception.set_backtrace(e[:backtrace])
+              raise exception
+            else
+              raise agent.result[:rejected]
+            end
+          else
+            agent.result[:resolved]
+          end
+        end
+
+        def promise_run(**props_hash)
+          props = validated_props(props_hash)
+          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, :run, props)
+            .then { |agent| _process_response(agent) }
+        end
+
+        def promise_deferred(**props_hash)
+          props = validated_props(props_hash)
+          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, :deferred, props)
+            .then { |agent| _process_response(agent) }
+        end
+
+        def promise_daily(**props_hash)
+          key = props_hash.delete(:key)
+          props = validated_props(props_hash)
+          props[:key] = key if key
+          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, :daily, props)
+            .then { |agent| _process_response(agent) }
+        end
+
+        def promise_remove_daily(**props_hash)
+          raise "key: must be given" unless props_hash.key?(:key)
+          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, :remove_daily, props_hash)
+            .then { |agent| _process_response(agent) }
+        end
+
+        def promise_daily_exist?(**props_hash)
+          raise "key: must be given" unless props_hash.key?(:key)
+          Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, :daily_exist, props_hash)
+            .then { |agent| _process_response(agent) }
+        end
+      else
+        def promise_run(**props_hash)
+          self.new(**props_hash).promise_run
+        end
+
+        def promise_deferred(**props_hash)
+          props = validated_props(props_hash)
+          task = Isomorfeus::Operation::DeferredTask.create(attributes: { operation_class_name: self.name, props: props, user_class_name: current_user.class.name, user_key: current_user.key, state: 'ready' })
+          Promise.new.resolve(task.key)
+        end
+
+        def promise_daily(**props_hash)
+          key = props_hash.delete(:key)
+          props = validated_props(props_hash)
+          task = Isomorfeus::Operation::DailyTask.create(key: key, attributes: { operation_class_name: self.name, props: props, user_class_name: current_user.class.name, user_key: current_user.key, state: 'ready' })
+          Promise.new.resolve(task.key)
+        end
+
+        def promise_remove_daily(**props_hash)
+          raise "key: must be given" unless props_hash.key?(:key)
+          key = props_hash.delete(:key)
+          Isomorfeus::Operation::DailyTask.destroy(key: key)
+          Promise.new.resolve(true)
+        end
+
+        def promise_daily_exist?(**props_hash)
+          raise "key: must be given" unless props_hash.key?(:key)
+          key = props_hash.delete(:key)
+          have_task = !!Isomorfeus::Operation::DailyTask.load(key: key)
+          Promise.new.resolve(have_task)
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/operation/handler/operation_handler.rb

@@ -10,32 +10,15 @@ module Isomorfeus
             if Isomorfeus.valid_operation_class_name?(operation_class_name)
               operation_class = Isomorfeus.cached_operation_class(operation_class_name)
               if operation_class
-                props = response_agent.request[operation_class_name]
-                props.transform_keys!(&:to_sym)
-                begin
-                  if Isomorfeus.current_user.authorized?(operation_class, :promise_run, props)
-                    operation_promise = operation_class.promise_run(**props)
-                    if operation_promise.realized?
-                      state = operation_promise.resolved? ? :resolved : :rejected
-                      result_hash = { state => operation_promise.value }
-                      if operation_promise.error
-                        e = operation_promise.error
-                        result_hash[:error] = { message: e.message, class_name: e.class.to_s, back_trace: e.backtrace }
-                      end
-                      response_agent.agent_result = { success: 'ok' , result: result_hash }
-                    else
-                      start = Time.now
-                      timeout = false
-                      while !operation_promise.realized?
-                        if (Time.now - start) > 20
-                          timeout = true
-                          break
-                        end
-                        sleep 0.01
-                      end
-                      if timeout
-                        response_agent.error = { error: 'Timeout' }
-                      else
+                response_agent.request[operation_class_name].each_key do |method|
+                  props = response_agent.request[operation_class_name][method]
+                  props.transform_keys!(&:to_sym)
+                  begin
+                    case method
+                    when 'run'
+                      raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_run, props)
+                      operation_promise = operation_class.promise_run(**props)
+                      if operation_promise.realized?
                         state = operation_promise.resolved? ? :resolved : :rejected
                         result_hash = { state => operation_promise.value }
                         if operation_promise.error
@@ -43,13 +26,50 @@ module Isomorfeus
                           result_hash[:error] = { message: e.message, class_name: e.class.to_s, back_trace: e.backtrace }
                         end
                         response_agent.agent_result = { success: 'ok' , result: result_hash }
+                      else
+                        start = Time.now
+                        timeout = false
+                        while !operation_promise.realized?
+                          if (Time.now - start) > 20
+                            timeout = true
+                            break
+                          end
+                          sleep 0.01
+                        end
+                        if timeout
+                          response_agent.error = { error: 'Timeout' }
+                        else
+                          state = operation_promise.resolved? ? :resolved : :rejected
+                          result_hash = { state => operation_promise.value }
+                          if operation_promise.error
+                            e = operation_promise.error
+                            result_hash[:error] = { message: e.message, class_name: e.class.to_s, back_trace: e.backtrace }
+                          end
+                          response_agent.agent_result = { success: 'ok' , result: result_hash }
+                        end
                       end
+                    when 'deferred'
+                      raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_deferred, props)
+                      operation_promise = operation_class.promise_deferred(**props)
+                      response_agent.agent_result = { success: 'ok' , result: { :resolved => operation_promise.value }}
+                    when 'daily'
+                      raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_daily, props)
+                      operation_promise = operation_class.promise_daily(**props)
+                      response_agent.agent_result = { success: 'ok' , result: { :resolved => operation_promise.value }}
+                    when 'remove_daily'
+                      raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_daily, props)
+                      operation_promise = operation_class.promise_remove_daily(**props)
+                      response_agent.agent_result = { success: 'ok' , result: { :resolved => operation_promise.value }}
+                    when 'daily_exist'
+                      raise 'Access denied!' unless Isomorfeus.current_user.authorized?(operation_class, :promise_daily, props)
+                      operation_promise = operation_class.promise_daily(**props)
+                      response_agent.agent_result = { success: 'ok' , result: { :resolved => operation_promise.value }}
+                    else
+                      response_agent.error = { error: 'No such method!' }
                     end
-                  else
-                    response_agent.error = { error: 'Access denied!' }
+                  rescue Exception => e
+                    response_agent.error = { error: { operation_class_name => "Isomorfeus::Operation::Handler::OperationHandler: #{e.message}" }}
                   end
-                rescue Exception => e
-                  response_agent.error = { error: { operation_class_name => "Isomorfeus::Operation::Handler::OperationHandler: #{e.message}" }}
                 end
               else
                 response_agent.error = { error: { operation_class_name => 'Could not get operation class!' }}

data/lib/isomorfeus/operation/init_timer_tasks.rb

@@ -0,0 +1,13 @@
+Isomorfeus.operation_timer_tasks = {}
+
+Isomorfeus.operation_timer_tasks[:deferred] = Concurrent::TimerTask.new(execution_interval: Isomorfeus.production? ? 120 : 10, timeout_interval: 115) do |timer_task|
+  Isomorfeus::Operation::RunTask.new(Isomorfeus::Operation::DeferredTask, timer_task: timer_task, interval: Isomorfeus.production? ? 120 : 10).run
+end
+
+Isomorfeus.operation_timer_tasks[:daily] = Concurrent::TimerTask.new(execution_interval: 86400, timeout_interval: 3600) do |timer_task|
+  Isomorfeus::Operation::RunTask.new(Isomorfeus::Operation::DailyTask, timer_task: timer_task, interval: 86400, recurring: true).run
+end
+
+Isomorfeus.operation_timer_tasks.each do |k, t|
+  t.execute
+end

data/lib/isomorfeus/operation/run_task.rb

@@ -0,0 +1,97 @@
+module Isomorfeus
+  module Operation
+    class RunTask
+      def initialize(task_class, timer_task:, interval:, recurring: false)
+        @task_class = task_class
+        @recurring = recurring
+        @timer_task = timer_task
+        @interval = interval
+      end
+
+      def run
+        @rtime = Time.now
+        tasks = get_tasks
+        tasks.each do |task|
+          marked = mark_as_running(task)
+          if marked
+            begin
+              operation_class = task.operation_class_name.constantize
+              user_class_name = task.user_class_name
+              Thread.current[:isomorfeus_user] = if user_class_name == 'LocalSystem'
+                                                   LocalSystem.new
+                                                 elsif Isomorfeus.valid_user_class_name?(user_class_name)
+                                                   user_class = user_class_name.constantize
+                                                   user_class.load(key: task.user_key) || Anonymous.new
+                                                 else
+                                                   Anonymous.new
+                                                 end
+              raise 'Access denied!' unless Thread.current[:isomorfeus_user].authorized?(operation_class, :promise_run, task.props)
+              if @recurring
+                operation_class.promise_run(**task.props)
+                  .then { mark_as_ready(task) }
+                  .fail { |e| task.fail ? mark_as_failed(task, e) : save_exception(task, e) }
+              else
+                operation_class.promise_run(**task.props)
+                .then { remove_task(task) }
+                .fail { |e| mark_as_failed(task, e) }
+              end
+            rescue => e
+              mark_as_failed(task, e)
+            ensure
+              Thread.current[:isomorfeus_user] = nil
+            end
+          end
+        end
+        cleanup
+        @timer_task.execution_interval = @interval - (Time.now - @rtime)
+      end
+
+      def get_tasks
+        @task_class.search(:state, 'ready').sort_by! { |task| task.rtime.to_i }
+      end
+
+      def mark_as_running(task)
+        result = false
+        @task_class.object_expander.environment.transaction do
+          task = @task_class.load(key: task.key)
+          if task.rtime.nil? || (task.rtime - @rtime) >= @timer_task.execution_interval
+            if task.state == 'ready'
+              task.state = 'running'
+              task.rtime = @rtime
+              task.save
+              result = true
+            end
+          end
+        end
+        result
+      end
+
+      def mark_as_ready(task)
+        task.state = 'ready'
+        task.save
+      end
+
+      def mark_as_failed(task, exception)
+        task.state = 'failed'
+        save_exception(task, exception)
+      end
+
+      def save_exception(taks, exception)
+        task.exception = Marshal.dump(exception)
+        task.save
+      end
+
+      def remove_task(task)
+        @task_class.destroy(key: task.key)
+      end
+
+      def cleanup
+        running_tasks = @task_class.search(:state, 'running').sort_by! { |task| task.rtime.to_i }
+        running_tasks.each do |task|
+          # previous task run has timed out most probably
+          mark_as_failed(task, RuntimeError.new('Operation execution timed out, giving up.')) if (@rtime - task.rtime) > @interval
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/operation/version.rb

@@ -1,5 +1,5 @@
 module Isomorfeus
   module Operation
-    VERSION = '2.2.10'
+    VERSION = '2.3.1'
   end
 end

data/lib/isomorfeus-operation.rb

@@ -1,6 +1,8 @@
-require 'isomorfeus-transport'
 require 'isomorfeus-policy'
+require 'isomorfeus-transport'
+
 require 'isomorfeus/operation/config'
+require 'isomorfeus/operation/generic_class_api'
 
 if RUBY_ENGINE == 'opal'
   Isomorfeus.zeitwerk.push_dir('isomorfeus_operation')
@@ -8,22 +10,26 @@ if RUBY_ENGINE == 'opal'
   Isomorfeus.zeitwerk.push_dir('operations')
 else
   require 'oj'
+  require 'concurrent/timer_task'
+  require 'isomorfeus-data'
   require 'isomorfeus/operation/handler/operation_handler'
   require 'isomorfeus_operation/lucid_operation/gherkin'
   require 'isomorfeus_operation/lucid_operation/steps'
   require 'isomorfeus_operation/lucid_operation/promise_run'
   require 'isomorfeus_operation/lucid_local_operation/mixin'
   require 'isomorfeus_operation/lucid_local_operation/base'
-  require 'isomorfeus_operation/lucid_quick_op/mixin'
-  require 'isomorfeus_operation/lucid_quick_op/base'
+  require 'isomorfeus_operation/lucid_simple_operation/mixin'
+  require 'isomorfeus_operation/lucid_simple_operation/base'
   require 'isomorfeus_operation/lucid_operation/mixin'
   require 'isomorfeus_operation/lucid_operation/base'
+  require 'isomorfeus/operation/deferred_task'
+  require 'isomorfeus/operation/daily_task'
+  require 'isomorfeus/operation/run_task'
+  require 'isomorfeus/operation/init_timer_tasks'
 
   require 'iso_opal'
   Opal.append_path(__dir__.untaint) unless IsoOpal.paths.include?(__dir__.untaint)
 
-  # require 'active_support/dependencies'
-
   path = File.expand_path(File.join('app', 'operations'))
 
   Isomorfeus.zeitwerk.push_dir(path)

data/lib/isomorfeus_operation/lucid_operation/mixin.rb

@@ -4,72 +4,42 @@ module LucidOperation
   module Mixin
     def self.included(base)
       base.extend(LucidPropDeclaration::Mixin)
+      base.extend(LucidOperation::Steps)
+      base.extend(Isomorfeus::Operation::GenericClassApi)
 
       if RUBY_ENGINE == 'opal'
-        base.instance_exec do
-          def procedure(gherkin_text)
-          end
-
-          def steps
-          end
-          alias :gherkin :steps
-          alias :ensure_steps :steps
-          alias :failure_steps :steps
-          alias :Given :steps
-          alias :And :steps
-          alias :Then :steps
-          alias :When :steps
-          alias :Ensure :steps
-          alias :Failed :steps
-          alias :If_failing :steps
-          alias :When_failing :steps
-          alias :If_this_failed :steps
-          alias :If_that_failed :steps
-
-          def First(regular_expression, &block)
-            Isomorfeus.raise_error(message: "#{self}: First already defined, can only be defined once!") if @first_defined
-            @first_defined = true
-          end
+        def procedure(gherkin_text)
+        end
 
-          def Finally(regular_expression, &block)
-            Isomorfeus.raise_error(message: "#{self}: Finally already defined, can only be defined once!") if @finally_defined
-            @finally_defined = true
-          end
+        def steps
+        end
+        alias :gherkin :steps
+        alias :ensure_steps :steps
+        alias :failure_steps :steps
+        alias :Given :steps
+        alias :And :steps
+        alias :Then :steps
+        alias :When :steps
+        alias :Ensure :steps
+        alias :Failed :steps
+        alias :If_failing :steps
+        alias :When_failing :steps
+        alias :If_this_failed :steps
+        alias :If_that_failed :steps
+
+        def First(regular_expression, &block)
+          Isomorfeus.raise_error(message: "#{self}: First already defined, can only be defined once!") if @first_defined
+          @first_defined = true
+        end
 
-          def promise_run(**props_hash)
-            props = validated_props(props_hash)
-            Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, props).then do |agent|
-              agent.process do |agnt|
-                agnt.response[:result]
-              end
-              if agent.result.key?(:rejected)
-                if agent.result.key?(:error)
-                  e = agent.result[:error]
-                  exception_class_name = e[:class_name]
-                  exception_class = exception_class_name.constantize
-                  exception = exception_class.new(e[:message])
-                  exception.set_backtrace(e[:backtrace])
-                  raise exception
-                else
-                  raise agent.result[:rejected]
-                end
-              else
-                agent.result[:resolved]
-              end
-            end
-          end
+        def Finally(regular_expression, &block)
+          Isomorfeus.raise_error(message: "#{self}: Finally already defined, can only be defined once!") if @finally_defined
+          @finally_defined = true
         end
       else
         Isomorfeus.add_valid_operation_class(base) unless base == LucidOperation::Base
-        base.extend(LucidOperation::Steps)
         base.include(LucidOperation::PromiseRun)
 
-        base.instance_exec do
-          def promise_run(**props_hash)
-            self.new(**props_hash).promise_run
-          end
-        end
-
         attr_reader :props
         attr_accessor :step_result
 

data/lib/isomorfeus_operation/{lucid_quick_op → lucid_simple_operation}/base.rb

@@ -1,7 +1,7 @@
-module LucidQuickOp
+module LucidSimpleOperation
   class Base
     def self.inherited(base)
-      base.include LucidQuickOp::Mixin
+      base.include LucidSimpleOperation::Mixin
       if RUBY_ENGINE != 'opal'
         Isomorfeus.add_valid_operation_class(base)
       end

data/lib/isomorfeus_operation/lucid_simple_operation/mixin.rb

@@ -0,0 +1,50 @@
+module LucidSimpleOperation
+  module Mixin
+    def self.included(base)
+      base.extend(LucidPropDeclaration::Mixin)
+      base.extend(Isomorfeus::Operation::GenericClassApi)
+
+      if RUBY_ENGINE == 'opal'
+        base.instance_exec do
+          def op
+          end
+        end
+      else
+        Isomorfeus.add_valid_operation_class(base) unless base == LucidSimpleOperation::Base
+
+        base.instance_exec do
+          def op(&block)
+            @op = block
+          end
+        end
+      end
+    end
+
+    attr_reader :props
+
+    def initialize(**props_hash)
+      props_hash = self.class.validated_props(props_hash)
+      @props = LucidProps.new(props_hash)
+    end
+
+    def promise_run
+      original_promise = Promise.new
+
+      operation = self
+      promise = original_promise.then do |_|
+        operation.instance_exec(&operation.class.instance_variable_get(:@op))
+      end
+
+      original_promise.resolve
+      promise
+    end
+
+    def current_user
+      Isomorfeus.current_user
+    end
+
+    def pub_sub_client
+      Isomorfeus.pub_sub_client
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isomorfeus-operation
 version: !ruby/object:Gem::Version
-  version: 2.2.10
+  version: 2.3.1
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-26 00:00:00.000000000 Z
+date: 2022-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 7.0.2
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.9
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
@@ -72,42 +86,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.17
+        version: 0.14.21
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.17
+        version: 0.14.21
+- !ruby/object:Gem::Dependency
+  name: isomorfeus-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.3.1
 - !ruby/object:Gem::Dependency
   name: isomorfeus-policy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.2.10
+        version: 2.3.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.2.10
+        version: 2.3.1
 - !ruby/object:Gem::Dependency
   name: isomorfeus-preact
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.6.54
+        version: 10.6.61
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.6.54
+        version: 10.6.61
 - !ruby/object:Gem::Dependency
   name: isomorfeus-redux
   requirement: !ruby/object:Gem::Requirement
@@ -128,28 +156,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.2.10
+        version: 2.3.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.2.10
+        version: 2.3.1
 - !ruby/object:Gem::Dependency
   name: isomorfeus
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.2.10
+        version: 2.3.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.2.10
+        version: 2.3.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -188,7 +216,12 @@ files:
 - README.md
 - lib/isomorfeus-operation.rb
 - lib/isomorfeus/operation/config.rb
+- lib/isomorfeus/operation/daily_task.rb
+- lib/isomorfeus/operation/deferred_task.rb
+- lib/isomorfeus/operation/generic_class_api.rb
 - lib/isomorfeus/operation/handler/operation_handler.rb
+- lib/isomorfeus/operation/init_timer_tasks.rb
+- lib/isomorfeus/operation/run_task.rb
 - lib/isomorfeus/operation/version.rb
 - lib/isomorfeus_operation/lucid_local_operation/base.rb
 - lib/isomorfeus_operation/lucid_local_operation/mixin.rb
@@ -197,8 +230,8 @@ files:
 - lib/isomorfeus_operation/lucid_operation/mixin.rb
 - lib/isomorfeus_operation/lucid_operation/promise_run.rb
 - lib/isomorfeus_operation/lucid_operation/steps.rb
-- lib/isomorfeus_operation/lucid_quick_op/base.rb
-- lib/isomorfeus_operation/lucid_quick_op/mixin.rb
+- lib/isomorfeus_operation/lucid_simple_operation/base.rb
+- lib/isomorfeus_operation/lucid_simple_operation/mixin.rb
 homepage: https://isomorfeus.com
 licenses:
 - MIT

data/lib/isomorfeus_operation/lucid_quick_op/mixin.rb

@@ -1,76 +0,0 @@
-module LucidQuickOp
-  module Mixin
-    def self.included(base)
-      base.extend(LucidPropDeclaration::Mixin)
-
-      if RUBY_ENGINE == 'opal'
-        base.instance_exec do
-          def op
-          end
-
-          def promise_run(**props_hash)
-            props = validated_props(props_hash)
-            Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, props).then do |agent|
-              agent.process do
-                agent.response[:result]
-              end
-              if agent.result.key?(:rejected)
-                if agent.result.key?(:error)
-                  e = agent.result[:error]
-                  exception_class_name = e[:class_name]
-                  exception_class = exception_class_name.constantize
-                  exception = exception_class.new(e[:message])
-                  exception.set_backtrace(e[:backtrace])
-                  raise exception
-                else
-                  raise agent.result[:rejected]
-                end
-              else
-                agent.result[:resolved]
-              end
-            end
-          end
-        end
-      else
-        Isomorfeus.add_valid_operation_class(base) unless base == LucidQuickOp::Base
-
-        base.instance_exec do
-          def op(&block)
-            @op = block
-          end
-
-          def promise_run(**props_hash)
-            self.new(**props_hash).promise_run
-          end
-        end
-      end
-    end
-
-    attr_reader :props
-
-    def initialize(**props_hash)
-      props_hash = self.class.validated_props(props_hash)
-      @props = LucidProps.new(props_hash)
-    end
-
-    def promise_run
-      original_promise = Promise.new
-
-      operation = self
-      promise = original_promise.then do |_|
-        operation.instance_exec(&operation.class.instance_variable_get(:@op))
-      end
-
-      original_promise.resolve
-      promise
-    end
-
-    def current_user
-      Isomorfeus.current_user
-    end
-
-    def pub_sub_client
-      Isomorfeus.pub_sub_client
-    end
-  end
-end