ruby_slime 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 016751bd1a7ff4786175ba1de34a94c8358c71145f6b24bed359e54a5b2f64d9
+  data.tar.gz: 2a2f73d7f2fd439badd416d433879ef28097aabe1de92a8f92177fc1fe331707
+SHA512:
+  metadata.gz: 484554d5c87bbac120624f97029a35a80937aa05aa3ee70ee186f60431679e368c404d638466022e269696351634dd1327fc9c21bb2b4ed1d7bdce008291f8b2
+  data.tar.gz: 4b3ff146857e90975dd948937f09b1b01b4aca5457b561f4cd23cccb131a398499cbd552b7c770b2c73ba543d08d76dbef29cba4310604c231399cc36fe0b871

data/LICENSE.md

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+====================
+
+_Copyright © `2023`, `Sarun Rattanasiri`_  
+_All rights reserved._
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+* Neither the name of the copyright holder nor the names of its contributors
+  may be used to endorse or promote products derived from this software
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,19 @@
+# RubySlime
+## What is it?
+It is a collection of infrastructure utilities utilized by [Slime Systems](https://slime.systems/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+~~~ruby
+gem 'ruby_slime'
+~~~
+
+And then execute:
+
+    $ bundle install
+
+## License
+Currently, we use the library privately; we don't think it will gain any attention as we never explain anything to anyone. 
+However, RubySlime is released under the [3-clause BSD License](LICENSE.md) anyway.

data/lib/ruby_slime/command.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RubySlime
+  module Command
+    extend ::ActiveSupport::Concern
+    extend ::Forwardable
+    include ::ActiveModel::Model
+    include ::ActiveModel::Attributes
+
+    class_methods do
+      attr_reader :_applied_schema
+
+      private
+
+      def apply_schema(schema)
+        @_applied_schema = schema
+      end
+    end
+
+    def attributes
+      @attributes__immutable_cache ||= begin
+        normalized = super.compact
+        schema = self.class._applied_schema
+        return normalized unless schema
+        result = schema.call(normalized)
+        raise SchemaViolation.new(result.errors) unless result.success?
+        result.to_h
+      end
+    end
+
+    def_delegators :attributes, :[], :values_at
+  end
+end

data/lib/ruby_slime/concurrent_write_detected.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module RubySlime
+  module ConcurrentWriteDetected
+  end
+end

data/lib/ruby_slime/event.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubySlime
+  module Event
+    extend ::ActiveSupport::Concern
+
+    attr_reader :data, :metadata
+
+    def initialize(data: {}, metadata: nil)
+      @data = data
+      @metadata = metadata
+    end
+
+    class_methods do
+      def strict(data: {}, metadata: nil)
+        new(
+          data: _ensure_schema(data),
+          metadata: metadata,
+        )
+      end
+
+      private
+
+      def apply_schema(schema)
+        @_applied_schema = schema
+      end
+
+      def _ensure_schema(data)
+        return data unless @_applied_schema
+        result = @_applied_schema.call(data)
+        raise SchemaViolation.new(result.errors) unless result.success?
+        result.to_h
+      end
+    end
+  end
+end

data/lib/ruby_slime/event_dispatcher.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RubySlime
+  class EventDispatcher
+    include Internals::EventMetadataHandler
+
+    def initialize(*handlers)
+      @handlers = handlers
+      freeze
+    end
+
+    def call(events, **metadata)
+      @handlers.each do |handler|
+        handle_handler_arguments(handler, events, metadata)
+      end
+    end
+  end
+end

data/lib/ruby_slime/event_queue.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RubySlime
+  class EventQueue < EventDispatcher
+    def call(events, **metadata)
+      events.each do |event|
+        super(event, **metadata)
+      end
+    end
+  end
+end

data/lib/ruby_slime/event_router.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RubySlime
+  class EventRouter
+    include Internals::EventMetadataHandler
+
+    def initialize(handlers_map = {})
+      @handlers_map = handlers_map
+      freeze
+    end
+
+    def call(event, **metadata)
+      handler = @handlers_map[event.class]
+      return unless handler
+      handle_handler_arguments(handler, event, metadata)
+    end
+  end
+end

data/lib/ruby_slime/internals/event_metadata_handler.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubySlime
+  module Internals
+    module EventMetadataHandler
+      private
+
+      def handle_handler_arguments(handler, events, metadata)
+        handler.call(events, **metadata)
+      rescue ::ArgumentError => e
+        cache = EventMetadataHandler_SingletonCache.instance
+        should_retry = cache.meta_patterns.any? do |pattern|
+          pattern =~ e.message
+        end
+        raise e unless should_retry
+        handler.call(events)
+      end
+
+      class EventMetadataHandler_SingletonCache
+        include ::Singleton
+        attr_reader :meta_patterns
+
+        def initialize
+          @meta_patterns = [
+            /wrong\s+number\s+of\s+arguments/i,
+            /unknown\s+keywords/i,
+          ]
+          super
+          freeze
+        end
+      end
+
+      private_constant :EventMetadataHandler_SingletonCache
+    end
+  end
+end

data/lib/ruby_slime/internals.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubySlime
+  module Internals
+  end
+  private_constant :Internals
+end

data/lib/ruby_slime/jwt_kit/api_verifier.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RubySlime
+  module JWTKit
+    class APIVerifier
+      extend ::Forwardable
+
+      def initialize(
+        fetch_secret:,
+        handle_result:
+      )
+        @fetch_secret = fetch_secret
+        @handle_result = handle_result
+      end
+
+      def call(token)
+        token_result = token_schema.call({
+          token: token,
+        })
+        raise TokenError.new(token_result.errors) unless token_result.success?
+        ::JWT.decode(token_result[:token], nil, true, {
+          algorithm: 'HS256',
+          required_claims: %w[aud iat sub],
+        }) do |header|
+          header_result = header_schema.call(header)
+          raise TokenError.new(header_result.errors) unless header_result.success?
+          @fetch_secret.call(header_result.to_h)
+        end.then do |sections|
+          payload_section, header_section = sections
+          header_result = header_schema.call(header_section)
+          raise TokenError.new(header_result.errors) unless header_result.success?
+          payload_result = payload_schema.call(payload_section)
+          raise TokenError.new(payload_result.errors) unless payload_result.success?
+          [payload_result, header_result].map(&:to_h)
+        end.then do |sections|
+          @handle_result.call(*sections)
+        end
+      end
+
+      private
+
+      def_delegators :singleton_cache,
+        :token_schema,
+        :header_schema,
+        :payload_schema
+
+      def singleton_cache
+        APIVerifier_SingletonCache.instance
+      end
+
+      class APIVerifier_SingletonCache
+        include ::Singleton
+        attr_reader \
+          :token_schema,
+          :header_schema,
+          :payload_schema
+
+        def initialize
+          @token_schema = ::Dry::Schema.Params do
+            required(:token).filled(:string)
+          end
+          @header_schema = ::Dry::Schema.Params do
+            optional(:typ).filled(:string).value(eql?: 'JWT')
+            required(:alg).filled(:string).value(eql?: 'HS256')
+            required(:kid).filled(:string)
+          end
+          @payload_schema = ::Dry::Schema.Params do
+            required(:aud).filled(:string)
+            required(:iat).value(:integer, gt?: 0)
+            required(:sub).filled(:string)
+            optional(:data).filled(:hash)
+          end
+          super
+          freeze
+        end
+      end
+
+      private_constant :APIVerifier_SingletonCache
+    end
+  end
+end

data/lib/ruby_slime/jwt_kit/handling_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubySlime
+  module JWTKit
+    module HandlingHelper
+      private
+
+      def_delegators :@controller,
+        :params,
+        :redirect_to,
+        :render
+
+      def initialize_helper(controller, payload, header = nil)
+        @controller = controller
+        @payload = payload
+        @header = header
+      end
+
+      def jwt_params(*permit)
+        @payload.fetch(:data, {}).slice(*permit)
+      end
+
+      def render_data(data_hash)
+        render json: {
+          data: data_hash,
+        }
+      end
+
+      def render_exception(code, message = nil, metadata: nil)
+        render json: {
+          exception: {
+            code: code,
+            message: message.presence,
+            **{
+              metadata: metadata,
+            }.compact,
+          }.compact,
+        }, status: :unprocessable_entity
+      end
+    end
+  end
+end

data/lib/ruby_slime/jwt_kit/token_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RubySlime
+  module JWTKit
+    class TokenError < ::StandardError
+      attr_reader :errors
+
+      def initialize(errors)
+        @errors = errors
+        super()
+      end
+    end
+  end
+end

data/lib/ruby_slime/jwt_kit.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'dry-schema'
+require 'jwt'
+
+module RubySlime
+  module JWTKit
+  end
+end

data/lib/ruby_slime/mongoid/interactor.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RubySlime
+  module Mongoid
+    class Interactor
+      def initialize(
+        state_key:,
+        load_process:,
+        event_handler: nil,
+        mongoid_model: State
+      )
+        @state_key = state_key
+        @load_process = load_process
+        @event_handler = event_handler
+        @mongoid_model = mongoid_model
+        freeze
+      end
+
+      def call(*commands)
+        lazy_key = @state_key.respond_to?(:call)
+        state_record = if lazy_key
+          @mongoid_model.new
+        else
+          @mongoid_model.where({
+            _id: @state_key,
+          }).first_or_initialize
+        end
+        process = @load_process.call(
+          state: state_record.state,
+        )
+        metadata_buffer = {
+          next_position: state_record.next_position,
+        }
+        pending_events = commands.each do |command|
+          process.call(command)
+        end.then do
+          process.pending_events
+        end
+        return pending_events unless pending_events.present?
+        state_record.state = process.state
+        state_record.next_position += pending_events.size
+        state_record._id = @state_key.call if lazy_key
+        begin
+          pending_events
+        ensure
+          if state_record.new_record?
+            begin
+              state_record.save!
+            rescue ::Mongo::Error::OperationFailure => e
+              raise e unless e.code == 11000 # E11000 duplicate key error
+              raise StaleRecord
+            end
+          else
+            update_result = @mongoid_model.where({
+              _id: state_record._id,
+              lock_version: state_record.lock_version,
+            }).update_all({
+              '$set': {
+                state: state_record.state,
+                next_position: state_record.next_position,
+              }.compact,
+              '$inc': {
+                lock_version: 1,
+              },
+            })
+            raise StaleRecord unless 0 < update_result.matched_count
+          end
+          metadata_buffer[:state_key] = state_record._id
+          @event_handler&.call(
+            pending_events,
+            **metadata_buffer,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_slime/mongoid/stale_record.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubySlime
+  module Mongoid
+    class StaleRecord < ::StandardError
+      include ConcurrentWriteDetected
+    end
+  end
+end

data/lib/ruby_slime/mongoid/state.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RubySlime
+  module Mongoid
+    class State
+      include ::Mongoid::Document
+      store_in collection: 'process_states'
+
+      field :state, type: ::Hash, default: {}
+      field :next_position, type: ::Integer, default: 1
+      field :lock_version, type: ::Integer, default: 0
+    end
+  end
+end

data/lib/ruby_slime/mongoid.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'mongoid'
+
+module RubySlime
+  module Mongoid
+  end
+end

data/lib/ruby_slime/process_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubySlime
+  module ProcessHelper
+    extend ::ActiveSupport::Concern
+
+    # alias for convenient access
+    class UnknownCommand < ::RubySlime::UnknownCommand
+    end
+
+    def state
+      @state ||= {}
+    end
+
+    def pending_events
+      @pending_events ||= []
+    end
+
+    class_methods do
+      attr_reader :_event_handlers
+
+      private def on(event_class, &block)
+        @_event_handlers ||= {}
+        @_event_handlers[event_class] = block
+      end
+    end
+
+    private def apply(*events)
+      handlers = self.class._event_handlers || {}
+      events.each do |event|
+        handler = handlers[event.class]
+        instance_exec(event, &handler) if handler
+        pending_events << event
+      end
+    end
+  end
+end

data/lib/ruby_slime/schema_violation.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RubySlime
+  class SchemaViolation < ::StandardError
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors
+      super()
+    end
+  end
+end

data/lib/ruby_slime/unknown_command.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RubySlime
+  class UnknownCommand < ::NotImplementedError
+    attr_reader :command
+
+    def initialize(command)
+      @command = command
+      super()
+    end
+  end
+end

data/lib/ruby_slime/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RubySlime
+  VERSION = '0.0.1'
+end

data/lib/ruby_slime.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require 'active_support'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/object/blank'
+require 'forwardable'
+require 'singleton'
+require 'zeitwerk'
+
+loader = ::Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  'api_verifier' => 'APIVerifier',
+  'jwt_kit' => 'JWTKit',
+)
+loader.setup
+
+module RubySlime
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: ruby_slime
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sarun Rattanasiri
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-05-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.3.2
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: midnight_w@gmx.tw
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- lib/ruby_slime.rb
+- lib/ruby_slime/command.rb
+- lib/ruby_slime/concurrent_write_detected.rb
+- lib/ruby_slime/event.rb
+- lib/ruby_slime/event_dispatcher.rb
+- lib/ruby_slime/event_queue.rb
+- lib/ruby_slime/event_router.rb
+- lib/ruby_slime/internals.rb
+- lib/ruby_slime/internals/event_metadata_handler.rb
+- lib/ruby_slime/jwt_kit.rb
+- lib/ruby_slime/jwt_kit/api_verifier.rb
+- lib/ruby_slime/jwt_kit/handling_helper.rb
+- lib/ruby_slime/jwt_kit/token_error.rb
+- lib/ruby_slime/mongoid.rb
+- lib/ruby_slime/mongoid/interactor.rb
+- lib/ruby_slime/mongoid/stale_record.rb
+- lib/ruby_slime/mongoid/state.rb
+- lib/ruby_slime/process_helper.rb
+- lib/ruby_slime/schema_violation.rb
+- lib/ruby_slime/unknown_command.rb
+- lib/ruby_slime/version.rb
+homepage: https://slime.systems/
+licenses:
+- BSD-3-Clause
+metadata:
+  homepage_uri: https://slime.systems/
+  source_code_uri: https://gitlab.com/slime-systems/ruby-slime
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: The ruby-type slime made by Slime Systems.
+test_files: []