bemi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 98fa40708b6bfd92280161b572fc052aa2f8aefb6f9676976c02f1c270547228
+  data.tar.gz: 745f8075714453a0e72aca4d82910c9c847be3b12f9d961b1a353c5c0616b30f
+SHA512:
+  metadata.gz: 12dd253ff5038f98970cd08a3c55dba31e289049b6761d12a3eb90d47dff5eb14957d1c6428f612f17eac95573b81ba639812f0b9609b726aea59af9d069f98a
+  data.tar.gz: b61d9ae6a853a9cb290ac4b637635cfb23ee4bcbc6d89596c9b7dd1781862bfc4f1a3c1cb2daddb0a8cc3272e72f23a40035c74914e534fbecc7cb708228fd25

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.0.1] - 2023-05-17
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at exaspark@gmail.com. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in bemi.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 exAspArk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Makefile

@@ -0,0 +1,8 @@
+install:
+	bundle install
+
+test:
+	bundle exec rspec
+
+release:
+	bundle exec rake release

data/README.md

@@ -0,0 +1,489 @@
+# Bemi
+
+A Ruby framework for managing code workflows. Bemi allows to describe and chain multiple actions similarly to function pipelines, have the execution reliability of a background job framework, unlock full visibility into business and infrastructure processes, distribute workload and implementation across multiple services as simply as running everything in the monolith.
+
+Bemi stands for "beginner mindset" and is pronounced as [ˈbɛmɪ].
+
+## Contents
+
+* [Overview](#overview)
+* [Code example](#code-example)
+* [Architecture](#architecture)
+* [Usage](#usage)
+  * [Workflows](#workflows)
+    * [Workflow definition](#workflow-definition)
+    * [Workflow validation](#workflow-validation)
+    * [Workflow concurrency](#workflow-concurrency)
+    * [Workflow querying](#workflow-querying)
+  * [Actions](#actions)
+    * [Action validation](#action-validation)
+    * [Action error handling](#action-error-handling)
+    * [Action rollback](#action-rollback)
+    * [Action querying](#action-querying)
+    * [Action concurrency](#action-concurrency)
+* [Installation](#installation)
+* [Alternatives](#alternatives)
+* [License](#license)
+* [Code of Conduct](#code-of-conduct)
+
+## Overview
+
+* Explicitly defined and orchestrated workflows instead of implicit execution sequences and spaghetti code
+* Synchronous, scheduled, and background execution of workflows
+* Improved reliability with transactions, queues, retries, timeouts, rate limiting, and priorities
+* Implemented patterns like sagas, distributed tracing, transactional outbox, and railway-oriented programming
+* Full visibility into the system, event logging for debugging and auditing, and monitoring with the web UI
+* Simple distributed workflow execution across services, applications, and programming languages (soon)
+
+## Code example
+
+Here is an example of a multi-step workflow:
+
+```ruby
+# app/workflows/order_workflow.rb
+class OrderWorkflow < Bemi::Workflow
+  name :order
+
+  def perform
+    action :process_payment, sync: true
+    action :send_confirmation, wait_for: [:process_payment], async: true
+    action :ship_package, wait_for: [:process_payment], async: { queue: 'warehouse' }
+    action :request_feedback, wait_for: [:ship_package], async: { delay: 7.days.to_i }
+  end
+end
+```
+
+To run an instance of this workflow:
+
+```ruby
+# Init a workflow, it will stop at the first action and wait until it is executed synchronously
+workflow = Bemi.perform_workflow(:order, context: { order_id: params[:order_id], user_id: current_user.id })
+
+# Process payment by running the first workflow action synchronously
+Bemi.perform_action(:process_payment, workflow_id: workflow.id, input: { payment_token: params[:payment_token] })
+
+# Once the payment is processed, the next actions in the workflow
+# will be executed automatically through background workers
+```
+
+Each action can be implemented in a separate class that can be called "action", "service", "use case", "interactor", "mutation"...  you name it:
+
+```ruby
+# app/actions/order/process_payment_action.rb
+class Order::ProcessPaymentAction < Bemi::Action
+  name :process_payment
+
+  def perform
+    payment = PaymentProcessor.pay_for!(workflow.context[:order_id], input[:payment_token])
+    { payment_id: payment.id }
+  end
+end
+```
+
+```ruby
+# app/actions/order/send_confirmation_action.rb
+class Order::SendConfirmationAction < Bemi::Action
+  name :send_confirmation
+
+  def perform
+    payment_output = wait_for(:process_payment).output
+    mail = OrderMailer.send_confirmation(payment_output[:payment_id])
+    { delivered: mail.delivered? }
+  end
+end
+```
+
+```ruby
+# ../warehouse/app/actions/order/ship_package_action.rb
+class Order::ShipPackageAction < Bemi::Action
+  name :ship_package
+
+  def perform
+    # Run a separate "shipment" workflow
+    shipment_workflow = Bemi.perform_workflow(:shipment, context: { order_id: workflow.context[:order_id] })
+    { shipment_workflow_id: shipment_workflow.id }
+  end
+end
+```
+
+```ruby
+# app/actions/order/request_feedback_action.rb
+class Order::RequestFeedbackAction < Bemi::Action
+  name :request_feedback
+
+  def perform
+    mail = OrderMailer.request_feedback(workflow.context[:user_id])
+    { delivered: mail.delivered? }
+  end
+end
+```
+
+## Architecture
+
+Bemi is designed to be lightweight and simple to use by default. As a system dependency, all you need is PostgreSQL.
+
+```
+         /‾‾‾\
+         \___/
+       __/   \__
+      /   User  \
+           │
+ - - - - - │ - - - - - - - - - - - - - - - -
+╵          │  Start "order" workflow         ╵
+╵          ∨                                 ╵
+╵  ________________                          ╵  [‾‾‾‾‾‾‾‾‾‾‾‾]
+╵ ┆ [Rails Server] ┆  Run "process_payment"  ╵  [------------]
+╵ ┆      with      ┆⸺⸺⸺⸺⸺⸺⸺⸺⸺> [ PostgreSQL ]
+╵ ┆    Bemi gem    ┆  action synchronously   ╵  [------------]
+╵  ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾                          ╵  [____________]
+╵                                            ╵        │
+╵                                            ╵        │
+╵   _______________                          ╵        │
+╵  | [Bemi Worker] | Run "send_confirmation" ╵        │
+╵  |   "default"   | <⸺⸺⸺⸺⸺⸺⸺⸺⸺⸺⸺│
+╵  |     queue     |      action async       ╵        │        - - - - - - - - - - - - - - - - - - -
+╵   ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾                          ╵        │       ╵                     _______________  ╵
+╵                                            ╵        │       ╵ Run "ship_package" | [Bemi Worker] | ╵
+╵                                            ╵        │⸺⸺⸺⸺⸺⸺⸺⸺⸺> |  "warehouse"  | ╵
+╵                                            ╵        │       ╵    action async    |     queue     | ╵
+╵   _______________                          ╵        │       ╵                     ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾  ╵
+╵  | [Bemi Worker] |  Run "request_feedback" ╵        │       ╵                                      ╵
+╵  |   "default"   | <⸺⸺⸺⸺⸺⸺⸺⸺⸺⸺⸺╵       ╵                                      ╵
+╵  |     queue     |    action by schedule   ╵                ╵                                      ╵
+╵   ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾                          ╵                ╵                                      ╵
+╵                                            ╵                ╵                                      ╵
+╵              Store service                 ╵                ╵          Warehouse service           ╵
+ - - - - - - - - - - - - - - - - - - - - - -                   - - - - - - - - - - - - - - - - - - - -
+```
+
+* Workflows
+
+Bemi orchestrates workflows by persisting their execution state into PostgreSQL. When connecting to PostgreSQL, Bemi first scans the codebase and registers all workflows uniquely identified by `name`. Workflows describe a sequence of actions by using the DSL written in Ruby that can be run synchronously in the same process or asynchronously and by schedule in workers.
+
+* Actions
+
+Actions are also uniquely identified by `name`. They can receive data from an input if ran synchronously, previously executed actions if they depend on them, and the shared workflow execution context. They can be implemented and executed in any service or application as long as it is connected to the same PostgreSQL instance. So, there is no need to deal with message passing by implementing APIs, callbacks, message buses, data serialization, etc.
+
+* Workers
+
+Bemi workers allow running actions that are executed asynchronously or by schedule. One worker represents a process with multiple threads to enable concurrency. Workers can process one or more `queues` and execute different actions across different workflows simultaneously if they are assigned to the same workers' queues.
+
+See the [Alternatives](#alternatives) section that describes how Bemi is different from other tools you might be familiar with.
+
+## Usage
+
+### Workflows
+
+#### Workflow definition
+
+Workflows declaratively describe actions that can be executed
+
+* Synchronously
+
+```ruby
+class RegistrationWorkflow < Bemi::Workflow
+  name :registration
+
+  def perform
+    action :create_user, sync: true
+    action :send_confirmation_email, sync: true
+    action :confirm_email_address, sync: true
+  end
+end
+
+workflow = Bemi.perform_workflow(:registration, context: { email: params[:email] })
+Bemi.perform_action(:create_user, workflow_id: workflow.id, input: { password: params[:password] })
+Bemi.perform_action(:send_confirmation_email, workflow_id: workflow.id)
+Bemi.perform_action(:confirm_email_address, workflow_id: workflow.id, input: { token: params[:token] })
+```
+
+* Asynchronously
+
+```ruby
+class RegistrationWorkflow < Bemi::Workflow
+  name :registration
+
+  def perform
+    action :create_user, async: true
+    action :send_welcome_email, wait_for: [:create_user], async: true
+    action :run_background_check, wait_for: [:send_welcome_email], async: { queue: 'kyc' }
+  end
+end
+
+Bemi.perform_workflow(:registration, context: { email: params[:email] })
+```
+
+* By schedule
+
+```ruby
+class RegistrationWorkflow < Bemi::Workflow
+  name :registration
+
+  def perform
+    action :create_user, async: { cron: '0 2 * * *' } # daily at 2am
+    action :send_welcome_email, async: { cron: '0 3 * * *', queue: 'emails', priority: 10 }
+    action :run_background_check, async: { delay: 24.hours.to_i },
+  end
+end
+
+Bemi.perform_workflow(:registration, context: { email: params[:email] })
+```
+
+#### Workflow validation
+
+Workflow can define the shape of the `context` and validate it against a JSON Schema
+
+```ruby
+class RegistrationWorkflow < Bemi::Workflow
+  name :registration
+  context_schema {
+    type: :object,
+    properties: { email: { type: :string } },
+    required: [:email],
+  }
+end
+```
+
+#### Workflow concurrency
+
+It is possible to set workflow concurrency options if you want to guarantee uniqueness
+
+```ruby
+class RegistrationWorkflow < Bemi::Workflow
+  name :registration
+  concurrency limit: 1, on_conflict: :raise # or :reject
+end
+
+Bemi.perform_workflow(:registration, context: { email: 'email@example.com' })
+Bemi.perform_workflow(:registration, context: { email: 'email@example.com' })
+# => Bemi::ConcurrencyError: cannot run more than 1 'registration' workflow at the same time
+```
+
+#### Workflow querying
+
+You can query workflows if, for example, one of the actions in the middle of the workflow execution needs to be triggered manually
+
+```ruby
+workflow = Bemi.find_workflow(:registration, context: { email: 'email@example.com' })
+
+workflow.canceled?
+workflow.completed?
+workflow.failed?
+workflow.running?
+workflow.timed_out?
+
+# Persisted and deserialized from JSON
+workflow.context
+
+Bemi.perform_action(:confirm_email_address, workflow_id: workflow.id)
+```
+
+### Actions
+
+#### Action validation
+
+Bemi allows to define the shape of actions' inputs and outputs and validate it against a JSON Schema
+
+```ruby
+class RegistrationWorkflow < Bemi::Workflow
+  name :registration
+
+  def perform
+    action :create_user,
+      sync: true,
+      input_schema: {
+        type: :object, properties: { password: { type: :string } }, required: [:password],
+      },
+      output_schema: {
+        type: :object, properties: { user_id: { type: :integer } }, required: [:user_id],
+      }
+  end
+end
+```
+
+#### Action error handling
+
+Custom `retry` count
+
+```ruby
+class RegistrationWorkflow < Bemi::Workflow
+  name :registration
+
+  def perform
+    action :create_user, async: true, on_error: { retry: :exponential_backoff } # default retry option
+    action :send_welcome_email, async: true, on_error: { retry: 1 }
+  end
+end
+```
+
+Custom error handler with `around_perform`
+
+```ruby
+class Registration::SendWelcomeEmailAction < Bemi::Action
+  name :send_welcome_email
+  around_perform :error_handler
+
+  def perform
+    user = User.find(workflow.context[:user_id])
+    context[:email] = user.email
+    mail = UserMailer.welcome(user.id)
+    { delivered: mail.delivered? }
+  end
+
+  private
+
+  def error_handler(&block)
+    block.call
+  rescue User::InvalidEmail => e
+    add_error!(:email, "Invalid email: #{context[:email]}")
+    fail! # don't retry if there is an application-level error
+  rescue Errno::ECONNRESET => e
+    raise e # retry by raising an exception if there is a temporary system-level error
+  end
+end
+```
+
+#### Action rollback
+
+If one of the actions in a workflow fails, all previously executed actions can be rolled back by defining a method called `rollback`
+
+```ruby
+class Order::ProcessPaymentAction < Bemi::Action
+  name :process_payment
+  around_rollback :rollback_notifier
+
+  def perform
+    payment = PaymentProcessor.pay_for!(workflow.context[:order_id], input[:payment_token])
+    { payment_id: payment.id }
+  end
+
+  def rollback
+    refund = PaymentProcessor.issue_refund!(output[:payment_id], input[:payment_token])
+    { refund_id: refund.id }
+  end
+
+  def rollback_notifier(&block)
+    OrderMailer.notify_cancelation(output[:payment_id])
+    block.call
+  end
+end
+```
+
+#### Action querying
+
+```ruby
+workflow = Bemi.find_workflow(:registration, context: { email: 'email@example.com' })
+action = Bemi.find_action(:create_user, workflow_id: workflow.id)
+
+action.canceled?
+action.completed?
+action.failed?
+action.running?
+action.timed_out?
+
+action.workflow
+action.options
+
+# Persisted and deserialized from JSON
+action.input
+action.output
+action.errors
+action.rollback_output
+action.context
+```
+
+#### Action concurrency
+
+Custom concurrency `limit`
+
+```ruby
+class RegistrationWorkflow < Bemi::Workflow
+  name :registration
+
+  def perform
+    action :create_user, async: true, concurrency: { limit: 1, on_conflict: :reschedule } # or :raise
+  end
+end
+```
+
+Custom uniqueness key defined in `concurrency_key`
+
+```ruby
+class Registration::SendWelcomeEmailAction < Bemi::Action
+  name :send_welcome_email
+
+  def perform
+    mail = UserMailer.welcome(workflow.context[:user_id])
+    { delivered: mail.delivered? }
+  end
+
+  def concurrency_key
+    "#{options[:async][:queue]}-#{input[:user_id]}"
+  end
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```
+gem 'bemi'
+```
+
+And then execute:
+
+```
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install bemi
+```
+
+## Alternatives
+
+#### Background jobs with persistent state
+
+Tools like Sidekiq, Que, and GoodJob are similar since they execute jobs in background, persist the execution state, retry, etc. These tools, however, focus on executing a single job as a unit of work. Bemi can be used in a similar way to perform single actions. But it shines when it comes to managing chains of actions defined in workflows without a need to use complex callbacks.
+
+Bemi orchestrates workflows instead of trying to choreograph them. This makes it easy to implement and maintain the code, reduce coordination overhead by having a central coordinator, improve observability, and simplify troubleshooting issues.
+
+<details>
+<summary>Orchestration</summary>
+
+![Orchestration](images/orchestration.jpg)
+</details>
+
+<details>
+<summary>Choreography</summary>
+
+![Choreography](images/choreography.jpg)
+</details>
+
+#### Workflow orchestration tools and services
+
+Tools like Temporal, AWS Step Functions, Argo Workflows, and Airflow allow orchestrating workflows, although they use quite different approaches.
+
+Temporal was born based on challenges faced by big-tech and enterprise companies. As a result, it has a complex architecture with deployed clusters, different databases like Cassandra and optional Elasticsearch, and multiple services for frontend, matching, history, etc. It was initially designed for programming languages like Java and Go. Some would argue that the development and user experience are quite rough. Plus, at the time of this writing, it doesn't have an official stable SDK for our favorite programming language (Ruby).
+
+AWS Step Functions rely on using AWS Lambda to execute each action in a workflow. For various reasons, not everyone can use AWS and their serverless solution. Additionally, workflows should be defined in JSON by using Amazon States Language instead of using a regular programming language.
+
+Argo Workflows relies on using Kubernetes. It is closer to infrastructure-level workflows since it relies on running a container for each workflow action and doesn't provide code-level features. Additionally, it requires defining workflows in YAML.
+
+Airflow is a popular tool for data engineering pipelines. Unfortunately, it can work only with Python.
+
+#### Ruby frameworks for writing better code
+
+There are many libraries that also implement useful patterns and allow better organize the code. For example, Interactor, ActiveInteraction, Mutations, Dry-Rb, and Trailblazer. They, however, don't help with asynchronous and distributed execution with better reliability guarantees that many of us rely on to execute code "out-of-band" to avoid running long-running workflows in a request/response lifecycle. For example, when sending emails, sending requests to other services, running multiple actions in parallel, etc.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Bemi project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/exAspArk/bemi/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bemi.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "lib/bemi/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "bemi"
+  spec.version = Bemi::VERSION
+  spec.authors = ["exAspArk"]
+  spec.email = ["exaspark@gmail.com"]
+
+  spec.summary = "Ruby framework for managing code workflows."
+  spec.description = "Bemi allows to describe and chain multiple actions similarly to function pipelines, have the execution reliability of a background job framework, unlock full visibility into business and infrastructure processes, distribute workload and implementation across multiple services as simply as running everything in the monolith."
+  spec.homepage = "https://github.com/exAspArk/bemi"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/exAspArk/bemi"
+  spec.metadata["changelog_uri"] = "https://github.com/exAspArk/bemi/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(bin|images|\.git|\.github)\/|(\.rspec|\.gitignore)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/bemi/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Bemi
+  VERSION = "0.0.1"
+end

data/lib/bemi.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "bemi/version"
+
+class Bemi
+end

data/sig/bemi.rbs

@@ -0,0 +1,4 @@
+class Bemi
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/spec/bemi_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe Bemi do
+  it "has a version number" do
+    expect(Bemi::VERSION).not_to be nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "bemi"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: bemi
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- exAspArk
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-05-17 00:00:00.000000000 Z
+dependencies: []
+description: Bemi allows to describe and chain multiple actions similarly to function
+  pipelines, have the execution reliability of a background job framework, unlock
+  full visibility into business and infrastructure processes, distribute workload
+  and implementation across multiple services as simply as running everything in the
+  monolith.
+email:
+- exaspark@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- Makefile
+- README.md
+- Rakefile
+- bemi.gemspec
+- lib/bemi.rb
+- lib/bemi/version.rb
+- sig/bemi.rbs
+- spec/bemi_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/exAspArk/bemi
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/exAspArk/bemi
+  source_code_uri: https://github.com/exAspArk/bemi
+  changelog_uri: https://github.com/exAspArk/bemi/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.6
+signing_key:
+specification_version: 4
+summary: Ruby framework for managing code workflows.
+test_files: []