command_tower 0.3.0

data/app/helpers/command_tower/schema_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module SchemaHelper
+    def schema_succesful!(schema:, status:)
+      render(json: schema.to_h, status:)
+    end
+
+    def invalid_arguments!(message:, argument_object:, schema:, status:)
+      bad_arguments = argument_object.map do |key, metadata|
+        CommandTower::Schema::Error::InvalidArgument.new(
+          schema:,
+          argument: key,
+          argument_type: metadata[:type],
+          reason: metadata[:msg],
+        )
+      end
+
+      result = CommandTower::Schema::Error::InvalidArgumentResponse.new(
+        invalid_arguments: bad_arguments,
+        invalid_argument_keys: argument_object.keys,
+        status:,
+        message:,
+      )
+
+      render(json: result.to_h, status:)
+    end
+  end
+end

data/app/jobs/command_tower/application_job.rb

@@ -0,0 +1,4 @@
+module CommandTower
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/command_tower/application_mailer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module CommandTower
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/mailers/command_tower/email_verification_mailer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module CommandTower
+  class EmailVerificationMailer < ApplicationMailer
+    def verify_email(email, user, code)
+      subject = "Welcome to #{}"
+      @user = user
+      @code = code
+      mail(to: email, subject:)
+    end
+  end
+end

data/app/models/command_tower/application_record.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module CommandTower
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    def self.attribute_to_type_mapping
+      @attribute_to_type_mapping ||= begin
+        mapping = ActiveSupport::HashWithIndifferentAccess.new
+        columns_hash.each do |attribute_name, metadata|
+          base = nil
+          ruby_type = nil
+          allowed_types = nil
+          serialized_type = nil
+          case metadata.type
+          when :string, :text
+            base = ruby_type = String
+          when :integer, :bigint
+            base = ruby_type = Integer
+          when :datetime, :time, :date
+            base = String
+            ruby_type = [DateTime, Time]
+          when :float, :decimal
+            base = ruby_type = Float
+          when :boolean
+            base = "Boolean"
+            ruby_type = [TrueClass, FalseClass]
+            allowed_types = [true, false]
+          else
+            # All else fails convert to String and continue
+            base = ruby_type = String
+          end
+
+          attribute_type = attribute_types[attribute_name]
+          if attribute_type.is_a?(ActiveRecord::Type::Serialized)
+            serialized_type = attribute_type.coder.object_class
+          end
+          mapping[attribute_name] = { serialized_type:, base:, ruby_type:, allowed_types: }.compact
+        end
+
+        mapping
+      end
+    end
+  end
+end

data/app/models/message.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: messages
+#
+#  id               :bigint           not null, primary key
+#  pushed           :boolean          default(FALSE)
+#  text             :text(65535)
+#  title            :string(255)
+#  viewed           :boolean          default(FALSE)
+#  created_at       :datetime         not null
+#  updated_at       :datetime         not null
+#  message_blast_id :bigint
+#  user_id          :bigint           not null
+#
+# Indexes
+#
+#  index_messages_on_message_blast_id  (message_blast_id)
+#  index_messages_on_user_id           (user_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (message_blast_id => message_blasts.id)
+#  fk_rails_...  (user_id => users.id)
+#
+class Message < ApplicationRecord
+  belongs_to :user
+  belongs_to :message_blast, optional: true
+end

data/app/models/message_blast.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: message_blasts
+#
+#  id             :bigint           not null, primary key
+#  existing_users :boolean          default(FALSE)
+#  new_users      :boolean          default(FALSE)
+#  text           :text(65535)
+#  title          :string(255)
+#  created_at     :datetime         not null
+#  updated_at     :datetime         not null
+#  user_id        :bigint           not null
+#
+# Indexes
+#
+#  index_message_blasts_on_user_id  (user_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (user_id => users.id)
+#
+class MessageBlast < ApplicationRecord
+  has_many :messages
+  belongs_to :user
+end

data/app/models/user.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: users
+#
+#  id                         :bigint           not null, primary key
+#  email                      :string(255)      default(""), not null
+#  email_validated            :boolean          default(FALSE)
+#  first_name                 :string(255)      default(""), not null
+#  last_known_timezone        :string(255)
+#  last_known_timezone_update :datetime
+#  last_login                 :datetime
+#  last_login_strategy        :string(255)
+#  last_name                  :string(255)      default(""), not null
+#  password_consecutive_fail  :integer          default(0)
+#  password_digest            :string(255)      default(""), not null
+#  recovery_password_digest   :string(255)      default(""), not null
+#  roles                      :string(255)      default([])
+#  successful_login           :integer          default(0)
+#  username                   :string(255)
+#  verifier_token             :string(255)
+#  verifier_token_last_reset  :datetime
+#  created_at                 :datetime         not null
+#  updated_at                 :datetime         not null
+#
+# Indexes
+#
+#  index_users_on_username  (username) UNIQUE
+#
+require "securerandom"
+
+class User < CommandTower::ApplicationRecord
+  has_secure_password
+
+  validates :username, uniqueness: true
+  validates :email, uniqueness: true
+
+  ###
+  # Serialize the roles column to check for inclusion easily
+  serialize :roles, coder: JSON, type: Array
+
+  has_many :messages
+
+  def full_name
+    "#{first_name} #{last_name}"
+  end
+
+  def reset_verifier_token!
+    value = SecureRandom.alphanumeric(32)
+    update!(verifier_token: value, verifier_token_last_reset: Time.now)
+
+    value
+  end
+
+  def retreive_verifier_token!
+    return verifier_token if verifier_token
+
+    reset_verifier_token!
+  end
+end

data/app/models/user_secret.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: user_secrets
+#
+#  id            :bigint           not null, primary key
+#  death_time    :datetime
+#  extra         :string(255)
+#  reason        :string(255)
+#  secret        :string(255)
+#  use_count     :integer          default(0)
+#  use_count_max :integer
+#  created_at    :datetime         not null
+#  updated_at    :datetime         not null
+#  user_id       :bigint           not null
+#
+# Indexes
+#
+#  index_user_secrets_on_secret   (secret) UNIQUE
+#  index_user_secrets_on_user_id  (user_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (user_id => users.id)
+#
+class UserSecret < ApplicationRecord
+  belongs_to :user
+
+  def self.find_record(secret:, reason: nil, access_count: true)
+    params = { secret:, reason: }.compact
+    record = where(**params).first
+    return { found: false } if record.nil?
+
+    record.access_count! if access_count
+
+    {
+      found: true,
+      valid: record.is_valid?,
+      record: record,
+      user: record.user,
+    }
+  end
+
+  def invalid_reason
+    arr = []
+    arr << "Expired secret." if !still_alive?
+    arr << "Secret used too many times." if !valid_use_count?
+
+    arr
+  end
+
+  def access_count!
+    update(use_count: use_count + 1)
+  end
+
+  def is_valid?
+    valid_use_count? && still_alive?
+  end
+
+  def valid_use_count?
+    return true if use_count_max.nil?
+
+    use_count <= use_count_max
+  end
+
+  def still_alive?
+    return true if death_time.nil?
+
+    death_time > Time.now
+  end
+end

data/app/services/command_tower/README.md

@@ -0,0 +1,49 @@
+# CommandTower Service
+
+`CommandTower::ServiceBase` an abstraction around the Ruby Gem Interactor. It dds custom functionality to the base Service and is intended to be an inherited Class to create Application logic code. All Services in `CommandTower` utilize this base Service class for convenience and DRYness.
+
+## What does ServiceBase offer
+
+### Logging
+`ServiceBase` offers a convenient way to tag logs. It keeps track of:
+- The start of the the Logic call
+- The time it took to complete the logic
+- The status of the logic
+
+Additionally, it provides some convenience methods for logging
+- `log_debug`
+- `log_info`
+- `log_warn`
+- `log_error`
+
+### Argument Validation
+Argument Validation is the powerhouse behind ServiceBase
+
+Customized argument validation can be created by adding the method `validate!`
+```ruby
+class MyServiceClass < CommandTower::ServiceBase
+
+  def call
+  end
+
+  def validate!
+    # run custom validations before executing call
+  end
+end
+```
+
+Other more complex Argument validation includes:
+- Validating Presence of Argument
+- Validating Type of argument
+- Validating a composition of argument values (At least, At Most, Exactly)
+- Delegate context variable to the class for simplicity
+- Validating Argument length or size is `<` `≤` `==` `>` `≥`
+
+For More information, Check out the [ArgumentValidation ReadMe](argument_validation/README.md)
+
+
+## Basic Examples:
+Check out the examples used in this directory!
+
+
+

data/app/services/command_tower/argument_validation/README.md

@@ -0,0 +1,192 @@
+# Argument Validation
+
+Argument validation provides a robust framework to ensure correctness of arguments before executing any application logic code. This was created because when in use with an API, this can help provide reusable messaging directly back to the API when the parameters are incorrect.
+
+## Argument Validation
+Argument Validation provides service object code assurances on what to expect for inputted arguments.
+
+Available arguments:
+- `default`: Default value to set the argument when not provided by user
+- `is_a`: The allowed types of the passed in argument. Will also check if the type is in the ancestral tree
+- `is_one`: Checks a direct comparison if the input is one of these values. Note: while not disallowed, `is_a` and `is_one` should not be used together
+- `length`: (used with operators exclusively) When set to true, the operators will use the length of value rather than the exact value
+- `lt`: When provided, argument must be less than this value
+- `lte`: When provided, argument must be less than or equal to this value
+- `eq`: When provided, argument must be equal to this value
+- `gte`: When provided, argument must be greater than or equal to this value
+- `gt`: When provided, argument must be greater than this value
+- `delegation`: (Default set to true) - Sets the delegation on the object. This allows you to reference the argument name rather than the context.{argument_name}
+- `sensitive`: This marks the argument as sensitive. It will scrub the value of the argument when returning the context to the caller
+- `required`: When set, this marks the argument as required. If not provided, validations are not run. When provided, validations must pass
+
+## Argument Composition
+Argument Compositions are made up of 1 or more Argument Validations. The intention of compositions are to ensure `at_most`, `at_least`, or `exactly` X argument validations are provided by the user.
+
+### Composition: At Most
+At most composition expects at most X arguments to get passed into the instance.
+
+```ruby
+class ServiceExample < CommandTower::ServiceBase
+  at_most 2, :name_of_composition, required: true do
+    validate :email, is_a: String
+    validate :phone, is_a: String
+    validate :username, is_a: String
+  end
+
+  def call; end
+end
+```
+
+```ruby
+rails-app(dev)> ServiceExample.(email: "email", phone: "phone", username: "username")
+=> # Composite Key failure for name_of_composition [name_of_composition]. Expected at most 2 keys assigned. Provided values for the following keys: [:email, :phone, :username]. Available keys [:email, :phone, :username] (CommandTower::ServiceBase::CompositionValidationError)
+```
+
+### Composition: At Least
+At least composition expects at least X arguments to get passed into the instance.
+
+```ruby
+class ServiceExample < CommandTower::ServiceBase
+  at_least 2, :name_of_composition, required: true do
+    validate :email, is_a: String
+    validate :phone, is_a: String
+    validate :username, is_a: String
+  end
+
+  def call; end
+end
+```
+
+```ruby
+rails-app(dev)> ServiceExample.(email: "email")
+=> # Composite Key failure for name_of_composition [name_of_composition]. Expected at least 2 keys assigned. Available keys. Provided values for the following keys: [:email]. Available keys [:email, :phone, :username] (CommandTower::ServiceBase::CompositionValidationError)
+```
+
+**Noteworthy**: `at_least` can take in any integer for its `count`. However, we found that most people just need one. For that reason, the convenience method of `at_least_one` was created. It can be used without the `count` argument in `at_least`
+
+### Composition: Compose Exact
+Compose Exact composition expects exactly X arguments to get passed into the instance. For this composition to be valid, there must be X or more validations.
+
+```ruby
+class ServiceExample < CommandTower::ServiceBase
+  compose_exact 2, :name_of_composition, required: true do
+    validate :email, is_a: String
+    validate :phone, is_a: String
+    validate :username, is_a: String
+  end
+
+  def call; end
+end
+```
+```ruby
+rails-app(dev)> ServiceExample.(email: "email")
+=> # Composite Key failure for name_of_composition [name_of_composition]. Expected [2] of the keys to have a value assigned. But 1 keys were assigned. Provided values for the following keys: [:email]. Available keys [:email, :phone, :username] (CommandTower::ServiceBase::CompositionValidationError)
+```
+
+**Noteworthy**: `compose_exact` can take any `count` value to dynamically provision the exact component. However, we found that we almost only just needed count == 1. We have provided a convenience method of `one_of` without the `count` variable to simplify. There are quite a few examples of this already created
+
+### Custom Compositions
+All compositions are built on top of the same underlying function. This allows you to build additional compositions to add custom logic for validations and what not.
+Check out the [ClassMethods Source Code](class_methods.rb) on what method arguments are required.
+
+
+## Argument validation Failures
+When an argument validation fails (whether that is a single `validate` or a composition), there are 3 options on what to do:
+
+### Raise an error (Default)
+As you can see in the examples above, the default for argument validation failures is to raise the following error
+```ruby
+CommandTower::ServiceBase::CompositionValidationError
+```
+
+The expected behavior is:
+- Downstream code catches the failure and handles it correctly
+- Service Logic code is not executed
+
+This failure mode can get explicitly set via:
+```ruby
+class ServiceExample < CommandTower::ServiceBase
+  on_argument_validation :raise
+
+  one_of :name_of_composition, required: true do
+    validate :email, is_a: String
+    validate :phone, is_a: String
+    validate :username, is_a: String
+  end
+
+  def call; end
+end
+```
+
+### Fail the context Early (Recommended)
+Failing the context early is we recommend to do for your service objects. This mode provides an exceptionally amount of context into **HOW** the validation failed and what needs to get corrected.
+
+
+The expected behavior is:
+- Downstream code checks for `result.failure?` and continues accordingly
+- Service Logic code is not executed
+- Nothing is raised
+
+```ruby
+class ServiceExample < CommandTower::ServiceBase
+  on_argument_validation :fail_early
+
+  one_of :name_of_composition, required: true do
+    validate :email, is_a: String
+    validate :phone, is_a: String
+    validate :username, is_a: String
+  end
+
+  def call; end
+end
+```
+```ruby
+result = ServiceExample.(email: :not_a_string)
+if result.success?
+else
+  if result.invalid_arguments
+    # context.fail! was called by argument validation
+    puts result.invalid_arguments
+    puts result.invalid_argument_hash
+    puts result.invalid_argument_keys
+  else
+    # context.fail! was called by user
+  end
+end
+=> true
+=> {:email=>{:msg=>"Parameter [email] must be of type String. Given Symbol [not_a_string]", :required=>nil, :is_a=>String}}
+=> [:email]
+
+result = ServiceExample.()
+result.invalid_arguments
+=> true
+result.invalid_argument_hash
+=> {:name_of_composition=>{:msg=>"Composite Key failure for name_of_composition [name_of_composition]. Expected [1] of the keys to have a value assigned. But no key was assigned. Provided values for the following keys: []. Available keys [:email, :phone, :username]", :required=>nil, :is_a=>nil}}
+result.invalid_argument_keys
+=> [:name_of_composition]
+
+result = ServiceExample.(email: 7, username: 8)
+result.invalid_arguments
+=> true
+result.invalid_argument_hash
+=> {:email=>{:msg=>"Parameter [email] must be of type String. Given Integer [7]", :required=>nil, :is_a=>String}, :username=>{:msg=>"Parameter [username] must be of type String. Given Integer [8]", :required=>nil, :is_a=>String}, :name_of_composition=>{:msg=>"Composite Key failure for name_of_composition [name_of_composition]. Expected [1] of the keys to have a value assigned. But 2 keys were assigned. Provided values for the following keys: [:email, :username]. Available keys [:email, :phone, :username]", :required=>nil, :is_a=>nil}}
+=> [:email, :username, :name_of_composition]
+```
+
+### Log and Continue (Not Recommended)
+This mode will allow you to log the validation failure and continue. We do not recommend this
+
+
+```ruby
+class ServiceExample < CommandTower::ServiceBase
+  on_argument_validation :log
+
+  one_of :name_of_composition, required: true do
+    validate :email, is_a: String
+    validate :phone, is_a: String
+    validate :username, is_a: String
+  end
+
+  def call; end
+end
+```