api_engine_base 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 237d043d261233c9e45d4b7466dcacbfb4792636246fa2e211e765ee21b75141
+  data.tar.gz: 55d598e1abaf7a12a253fbc9ea8d010c9a11ac9ca5ea293e2a30f6cb42ffc759
+SHA512:
+  metadata.gz: 53180702bea719474e8f9922858da3c1af7b6c44ce3ad1db78bb5c633c039b9b5bb7a524984a637e41dd16499478f896731f033a8c8beece0441eff76ac40fa9
+  data.tar.gz: '03397ea3efb5e7a68554ae600d4eda0d0f467d2990a14dbb4e1bf2ea2cd13a96e82abd679894e2943c51e097eab095c10434116303c1004404626d84d2805c5a'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 
+
+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/README.md

@@ -0,0 +1,28 @@
+# ApiEngineBase
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "api_engine_base"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install api_engine_base
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ApiEngineBase'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("rails_app/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/controllers/api_engine_base/application_controller.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ApiEngineBase
+  class ApplicationController < ActionController::API
+    AUTHORIZATION_HEADER = "AUTHORIZATION"
+
+    ###
+    # AUTHORIZATION_HEADER="Bearer: {token value}"
+    def authenticate_user!(bypass_email_validation: false)
+      raw_token = request.headers[AUTHORIZATION_HEADER]
+      if raw_token.nil?
+        status = 401
+        schema = ApiEngineBase::Schema::Error::Base.new(status:, message: "Bearer token missing")
+        render(json: schema.to_h, status:)
+        return false
+      end
+
+      token = raw_token.split("Bearer:")[1].strip
+      result = ApiEngineBase::Jwt::AuthenticateUser.(token:, bypass_email_validation:)
+      if result.success?
+        @current_user = result.user
+        true
+      else
+        status = 401
+        schema = ApiEngineBase::Schema::Error::Base.new(status:, message: result.msg)
+        render(json: schema.to_h, status:)
+        # Must return false so callbacks know to halt propagation
+        false
+      end
+    end
+
+    def authenticate_user_without_email_verification!
+      authenticate_user!(bypass_email_validation: true)
+    end
+
+    def current_user
+      @current_user ||= nil
+    end
+
+    def add_to_body
+      # {
+      #   token_valid_till:,
+      #   needs_email_verification:,
+      # }
+    end
+  end
+end

data/app/controllers/api_engine_base/auth/plain_text_controller.rb

@@ -0,0 +1,132 @@
+module ApiEngineBase
+  module Auth
+    class PlainTextController < ::ApiEngineBase::ApplicationController
+      include ApiEngineBase::SchemaHelper
+
+      before_action :authenticate_user_without_email_verification!, only: [:email_verify_post, :email_verify_resend_post]
+
+      # POST /auth/login
+      # Login to the application and create/set the JWT token
+      def login_post
+        result = ApiEngineBase::LoginStrategy::PlainText::Login.(**login_params)
+        if result.success?
+          schema = ApiEngineBase::Schema::PlainText::LoginResponse.new(
+            token: result.token,
+            header_name: AUTHORIZATION_HEADER,
+            message: "Successfully logged user in"
+          )
+          status = 201
+          schema_succesful!(status:, schema:)
+        else
+          if result.invalid_arguments
+            invalid_arguments!(
+              status: 401,
+              message: result.msg,
+              argument_object: result.invalid_argument_hash,
+              schema: ApiEngineBase::Schema::PlainText::LoginRequest
+            )
+          else
+            json_result = { msg: result.msg }
+            status = 400
+            render(json: schema.to_h, status:)
+          end
+        end
+      end
+
+      # POST /auth/create
+      # New PlainText user creation
+      def create_post
+        result = ApiEngineBase::LoginStrategy::PlainText::Create.(**create_params)
+        if result.success?
+          schema = ApiEngineBase::Schema::PlainText::CreateUserResponse.new(
+            full_name: result.user.full_name,
+            first_name: result.first_name,
+            last_name: result.last_name,
+            username: result.username,
+            email: result.email,
+            msg: "Successfully created new User",
+          )
+          status = 201
+          schema_succesful!(status:, schema:)
+        else
+          if result.invalid_arguments
+            invalid_arguments!(
+              status: 400,
+              message: result.msg,
+              argument_object: result.invalid_argument_hash,
+              schema: ApiEngineBase::Schema::PlainText::CreateUserRequest
+            )
+          end
+        end
+      end
+
+      # POST /auth/email/verify
+      # Verifies a logged in users email verification code when enabled
+      def email_verify_post
+        if current_user.email_validated
+          schema = ApiEngineBase::Schema::PlainText::EmailVerifyResponse.new(message: "Email is already verified.")
+          status = 200
+          schema_succesful!(status:, schema:)
+        else
+          result = ApiEngineBase::LoginStrategy::PlainText::EmailVerification::Verify.(user: current_user, code: params[:code])
+          if result.success?
+            schema = ApiEngineBase::Schema::PlainText::EmailVerifyResponse.new(message: "Successfully verified email")
+            status = 201
+            schema_succesful!(status:, schema:)
+          else
+            if result.invalid_arguments
+              invalid_arguments!(
+                status: result.status || 403,
+                message: result.msg,
+                argument_object: result.invalid_argument_hash,
+                schema: ApiEngineBase::Schema::PlainText::EmailVerifyRequest
+              )
+            end
+          end
+        end
+      end
+
+      # POST /auth/email/send
+      # Sends a logged in users email verification code
+      def email_verify_resend_post
+        if current_user.email_validated
+          schema = ApiEngineBase::Schema::PlainText::EmailVerifyResponse.new(message: "Email is already verified. No code required")
+          status = 200
+          schema_succesful!(status:, schema:)
+        else
+          result = ApiEngineBase::LoginStrategy::PlainText::EmailVerification::Send.(user: current_user)
+          if result.success?
+            schema = ApiEngineBase::Schema::PlainText::EmailVerifyResponse.new(message: "Successfully sent Email verification code")
+            status = 201
+            schema_succesful!(status:, schema:)
+          else
+            schema = ApiEngineBase::Schema::Error::Base.new(status:, message: result.msg)
+            status = result.status || 401
+            render(json: schema.to_h, status:)
+          end
+        end
+      end
+
+      private
+
+      def login_params
+        {
+          username: params[:username],
+          email: params[:email],
+          password: params[:password],
+        }
+      end
+
+      def create_params
+        {
+          first_name: params[:first_name],
+          last_name: params[:last_name],
+          username: params[:username],
+          email: params[:email],
+          password: params[:password],
+          password_confirmation: params[:password_confirmation],
+        }
+      end
+    end
+  end
+end

data/app/controllers/api_engine_base/username_controller.rb

@@ -0,0 +1,26 @@
+module ApiEngineBase
+  class UsernameController < ::ApiEngineBase::ApplicationController
+
+    # GET /username/available/:username
+    def username_availability
+      result = ApiEngineBase::Username::Available.(username: params[:username])
+
+      if result.success?
+        json_result = {
+          username: {
+            available: result.available,
+            valid: result.valid,
+            description: ApiEngineBase.config.username.username_failure_message
+          }
+        }
+        status = 200
+      else
+        json_result = { msg: result.msg }
+        json_result[:invalid_arguments] = true if result.invalid_arguments
+        status = 401
+      end
+
+      render json: json_result, status: status
+    end
+  end
+end

data/app/controllers/concerns/api_engine_base/schematizable.rb

@@ -0,0 +1,5 @@
+module ApiEngineBase
+  class Schematizable
+  end
+end
+

data/app/helpers/api_engine_base/application_helper.rb

@@ -0,0 +1,4 @@
+module ApiEngineBase
+  module ApplicationHelper
+  end
+end

data/app/helpers/api_engine_base/schema_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ApiEngineBase
+  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|
+        ApiEngineBase::Schema::Error::InvalidArgument.new(
+          schema:,
+          argument: key,
+          argument_type: metadata[:type],
+          reason: metadata[:msg],
+        )
+      end
+
+      result = ApiEngineBase::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/api_engine_base/application_job.rb

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

data/app/mailers/api_engine_base/application_mailer.rb

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

data/app/mailers/api_engine_base/email_verification_mailer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ApiEngineBase
+  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/api_engine_base/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ApiEngineBase
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/user.rb

@@ -0,0 +1,50 @@
+# 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
+#  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 < ApiEngineBase::ApplicationRecord
+  has_secure_password
+
+  validates :username, uniqueness: true
+  validates :email, uniqueness: true
+
+  def full_name
+    "#{first_name} #{last_name}"
+  end
+
+  def retreive_verifier_token!
+    return verifier_token if verifier_token
+
+    value = SecureRandom.alphanumeric(32)
+    update!(verifier_token: value)
+
+    value
+  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/api_engine_base/argument_validation/class_methods.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module ApiEngineBase::ArgumentValidation
+  module ClassMethods
+    ON_ARGUMENT_VALIDATION = [
+      DEFAULT_VALIDATION = :raise,
+      :fail_early,
+      :log,
+    ]
+
+    def on_argument_validation_assigned
+      @on_argument_validation ||= DEFAULT_VALIDATION
+    end
+
+    def on_argument_validation(set)
+      raise "Must be one of #{ON_ARGUMENT_VALIDATION}" unless ON_ARGUMENT_VALIDATION.include?(set)
+
+      @on_argument_validation = set
+    end
+
+    def compose_exact(count, name, required:, delegation: false, &block)
+      raise ApiEngineBase::ServiceBase::CompositionValidationError, "Count must be greater than 0" if count < 1
+
+      validation_proc = Proc.new do |input_count, keys|
+
+        language = (input_count > 1) ? "But more than #{count} did" : "But no key had a value"
+        {
+          message: "Expected [#{count}] of the keys to have a value assigned. #{language}",
+          is_valid: (input_count == count),
+          requirement: "Exactly #{count} key(s) of #{keys} must be provided.",
+        }
+      end
+
+      composition_validation_proc = Proc.new do
+        keys = compositions[__stacked_type.last[:name]][:keys]
+        if keys.length < count
+          raise ApiEngineBase::ServiceBase::CompositionValidationError, "Composition configuration error. Key [#{name}] expects EXACTLY #{count} keys to create an instance. Only #{keys.length} is provided for the composition. Please add more keys or reduce the expectation"
+        end
+      end
+      composition(name:, type: :compose_exact, required:, delegation:, composition_validation_proc:, validation_proc:, &block)
+    end
+
+    def at_most(count, name, required:, &block)
+      raise ApiEngineBase::ServiceBase::CompositionValidationError, "Count must be greater than 0" if count < 1
+
+      validation_proc = Proc.new do |input_count, keys|
+        {
+          message: "Expected at most #{count} keys assigned",
+          is_valid: (input_count <= count),
+          requirement: "Validation Error: At most #{count} key(s) of #{keys} can be provided.",
+        }
+      end
+
+      composition(name:, type: :at_most, required:, delegation: false, validation_proc:, &block)
+    end
+
+    def at_least(count, name, required:, &block)
+      raise ApiEngineBase::ServiceBase::CompositionValidationError, "Count must be greater than 0" if count < 1
+
+      validation_proc = Proc.new do |input_count, keys|
+        {
+          message: "Expected at least #{count} keys assigned. Available keys",
+          is_valid: (input_count >= count),
+          requirement: "Validation Error: At least #{count} key(s) of #{keys} must be provided.",
+        }
+      end
+
+      composition_validation_proc = Proc.new do
+        keys = compositions[__stacked_type.last[:name]][:keys]
+        if keys.length < count
+          raise ApiEngineBase::ServiceBase::CompositionValidationError, "Composition configuration error. Key [#{name}] expects AT LEAST #{count} keys to create an instance. Only #{keys.length} is provided for the composition. Please add more keys or reduce the expectation"
+        end
+      end
+      composition(name:, type: :at_least, required:, delegation: false, composition_validation_proc:, validation_proc:, &block)
+    end
+
+    def at_least_one(name, required:, &block)
+      at_least(1, name, required:, &block)
+    end
+
+    def one_of(name, required:, delegation: true, &block)
+      compose_exact(1, name, required:, delegation:, &block)
+    end
+
+    def composition(name:, type:, required:, delegation:, validation_proc:, composition_validation_proc: nil, &block)
+      compositions[name] ||= { type:, name:, keys: [], required:, delegation:, validation_proc: }
+      if __stacked_type.map { _1[:type] }.include?(type)
+        raise ApiEngineBase::ServiceBase::NestedDuplicateTypeError, "Duplicate Nested type's are not allowed. #{type} composition was included more than once"
+      end
+
+      __stacked_type << { type:, name: }
+
+      yield
+
+      if composition_validation_proc
+        composition_validation_proc.()
+      end
+
+      if __existing_names.include?(name)
+        raise ApiEngineBase::ServiceBase::NameConflictError, "Name conflict for #{name}. Duplicated as a key"
+      end
+
+      __existing_names << name
+      # returning from the yield...pop it from the stack.
+      # This allows us to know the current depth of where we are in the nested stack
+      __stacked_type.pop
+
+      if delegation
+        delegate name, to: :context
+        delegate :"#{name}_key", to: :context
+      end
+    end
+
+    def validate(name, default: nil, length: false, matches: nil, is_a: nil, is_one: nil, lt: nil, lte: nil, eq: nil, gt: nil, gte: nil, delegation: true, sensitive: false, required: false)
+      if __existing_names.include?(name)
+        raise ApiEngineBase::ServiceBase::NameConflictError, "Duplicate key name found. [#{name}] can only be defined once"
+      end
+
+      __existing_names << name
+
+      if default
+        if is_a
+          if Array(is_a).none? { _1 === default }
+            raise ApiEngineBase::ServiceBase::DefaultValueError, "Default value provided [#{default}] does not match any `is_a` value(s) of #{is_a}."
+          end
+        end
+
+        if is_one
+          if Array(is_one).none? { _1 == default }
+            raise ApiEngineBase::ServiceBase::DefaultValueError, "Default value provided [#{default}] does not match any `is_one` value(s) of #{is_one}."
+          end
+        end
+      end
+
+      if __stacked_type.length > 0
+        compositions[__stacked_type.last[:name]][:keys] << name
+      end
+
+      validate_params << {
+        name:,
+        is_a:,
+        lt:,
+        lte:,
+        eq:,
+        gt:,
+        gte:,
+        length:,
+        required:,
+        is_one:,
+        default:,
+      }
+      sensitive_params << name if sensitive
+
+      if delegation
+        delegate name, to: :context
+      end
+    end
+
+    def sensitive_params
+      @sensitive_params ||= []
+    end
+
+    def validate_params
+      @validate_params ||= []
+    end
+
+    def compositions
+      @compositions ||= {}
+    end
+
+    def __stacked_type
+      @__stacked_type ||= []
+    end
+
+    def __existing_names
+      @__existing_names ||= []
+    end
+  end
+end