shogun 6.2.1 → 6.2.2

data/scaffold/new/project/lib/namespace/accounts/create/normalizer.rb

@@ -0,0 +1,42 @@
+module {{namespace_module}}
+  module Accounts
+    module Create
+      class Normalizer
+        include Shogun::Normalizer
+        include Accounts
+
+        ATTRIBUTES = %w|signature username name email password|
+
+        def initialize(raw:)
+          if raw[namespace]
+            @signature = raw[namespace]["signature"]
+            @name = raw[namespace]["name"]
+            @email = raw[namespace]["email"]
+            @username = raw[namespace]["username"]
+            @password = raw[namespace]["password"]
+          end
+        end
+
+        def signature
+          @signature.strip if @signature.is_a?(String)
+        end
+
+        def name
+          @name.strip if @name.is_a?(String)
+        end
+
+        def email
+          @email.strip if @email.is_a?(String)
+        end
+
+        def username
+          @username.strip if @username.is_a?(String)
+        end
+
+        def password
+          @password
+        end
+      end
+    end
+  end
+end

data/scaffold/new/project/lib/namespace/accounts/create/validator.rb

@@ -0,0 +1,34 @@
+module {{namespace_module}}
+  module Accounts
+    module Create
+      class Validator
+        include Shogun::Validator
+        include Accounts
+
+        EMAIL_MATCH = /^[^@\s]+@([^@\s]+\.)+[^@\s]+$/
+        PASSWORD_RANGE = 8..1024
+        SIGNATURE_RANGE = 2..64
+        USERNAME_MATCH = /^\S*$/
+        USERNAME_RANGE = 2..64
+
+        def initialize(data:)
+          @verifiers = [
+            Shogun::Verifier::Presence.new(data: data.email, name: "email"),
+            Shogun::Verifier::Match.new(data: data.email, name: "email", comparison: EMAIL_MATCH),
+            Shogun::Verifier::Uniqueness.new(data: data.email, name: "email", list: Model.pluck(:email)),
+            Shogun::Verifier::Presence.new(data: data.name, name: "name"),
+            Shogun::Verifier::Presence.new(data: data.password, name: "password"),
+            Shogun::Verifier::Range.new(data: data.password, name: "password", range: PASSWORD_RANGE),
+            Shogun::Verifier::Presence.new(data: data.signature, name: "signature"),
+            Shogun::Verifier::Range.new(data: data.signature, name: "signature", range: SIGNATURE_RANGE),
+            Shogun::Verifier::Uniqueness.new(data: data.signature, name: "signature", list: Model.pluck(:signature)),
+            Shogun::Verifier::Match.new(data: data.username, name: "username", comparison: USERNAME_MATCH),
+            Shogun::Verifier::Range.new(data: data.username, name: "username", range: USERNAME_RANGE),
+            Shogun::Verifier::Presence.new(data: data.username, name: "username"),
+            Shogun::Verifier::Uniqueness.new(data: data.username, name: "username", list: Model.pluck(:username))
+          ]
+        end
+      end
+    end
+  end
+end

data/scaffold/new/project/lib/namespace/accounts/destroy.rb

@@ -0,0 +1,11 @@
+module {{namespace_module}}
+  module Accounts
+    module Destroy
+      require_relative "destroy/control"
+      require_relative "destroy/authorizer"
+      require_relative "destroy/denormalizer"
+      require_relative "destroy/normalizer"
+      require_relative "destroy/validator"
+    end
+  end
+end

data/scaffold/new/project/lib/namespace/accounts/destroy/authorizer.rb

@@ -0,0 +1,21 @@
+module {{namespace_module}}
+  module Accounts
+    module Destroy
+      class Authorizer
+        include Shogun::Authorizer
+        include Accounts
+
+        def initialize(requester:, resource:)
+          if requester
+            @requester = requester.account
+          end
+          @resource = resource
+        end
+
+        def allowed?
+          @requester == @resource
+        end
+      end
+    end
+  end
+end

data/scaffold/new/project/lib/namespace/accounts/destroy/control.rb

@@ -0,0 +1,37 @@
+module {{namespace_module}}
+  module Accounts
+    module Destroy
+      class Control
+        include Shogun::Control
+        include Accounts
+
+        def initialize(payload:)
+          @normalizer = Normalizer.new(raw: payload.to_hash)
+          @validator = Validator.new(data: @normalizer)
+
+          if @validator.valid?
+            @session = Sessions::Model.find_by(id: @normalizer.session)
+            @model = Model.find_by(id: @normalizer.id)
+            @authorizer = Authorizer.new(requester: @session, resource: @model)
+
+            case
+            when @model && @authorizer.allowed?
+              @model.destroy
+              @presenter = Presenter.new(resource: @model, meta: @normalizer.as_meta)
+              @denormalizer = Denormalizer.new(object: @presenter)
+              @status = OK
+            when @model && @authorizer.denied?
+              @status = UNAUTHORIZED
+            else
+              @status = NOT_FOUND
+            end
+          else
+            @presenters = Shogun::Presenters.new(resources: @validator.invalids, cast: Errors::Presenter)
+            @denormalizer = Errors::Denormalizer.new(object: @presenters)
+            @status = UNPROCESSABLE_ENTITY
+          end
+        end
+      end
+    end
+  end
+end

data/scaffold/new/project/lib/namespace/accounts/destroy/denormalizer.rb

@@ -0,0 +1,35 @@
+module {{namespace_module}}
+  module Accounts
+    module Destroy
+      class Denormalizer
+        include Shogun::Denormalizer
+        include Accounts
+
+        MAPPING = {
+          "id" => "id",
+          "signature" => "signature",
+          "username" => "username",
+          "email" => "email",
+          "name" => "name",
+          "created_at" => "created_at",
+          "destroyed_at" => "destroyed_at",
+          "updated_at" => "updated_at",
+          "href" => "href"
+        }
+
+        def initialize(object:)
+          @object = object
+          @meta = object.meta
+          @links = object.links
+          @linked = object.linked
+        end
+
+        private def document
+          mapping.inject({}) do |hash, (field, name)|
+            hash.merge(field => @object.public_send(name))
+          end
+        end
+      end
+    end
+  end
+end

data/scaffold/new/project/lib/namespace/accounts/destroy/normalizer.rb

@@ -0,0 +1,28 @@
+module {{namespace_module}}
+  module Accounts
+    module Destroy
+      class Normalizer
+        include Shogun::Normalizer
+        include Accounts
+
+        METADATA = %w|id|
+
+        def initialize(raw:)
+          @id = raw["id"]
+
+          if raw["rack.authentication"] && raw["rack.authentication"]["sessions"]
+            @session = raw["rack.authentication"]["sessions"]["id"]
+          end
+        end
+
+        def id
+          @id
+        end
+
+        def session
+          @session
+        end
+      end
+    end
+  end
+end

data/scaffold/new/project/lib/namespace/accounts/destroy/validator.rb

@@ -0,0 +1,20 @@
+module {{namespace_module}}
+  module Accounts
+    module Destroy
+      class Validator
+        include Shogun::Validator
+        include Accounts
+
+        ID_MATCH = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+
+        def initialize(data:)
+          @verifiers = [
+            Shogun::Verifier::Presence.new(data: data.id, name: "id"),
+            Shogun::Verifier::Match.new(data: data.id, name: "id", comparison: ID_MATCH),
+            Shogun::Verifier::Presence.new(data: data.session, name: "session")
+          ]
+        end
+      end
+    end
+  end
+end

data/scaffold/new/project/lib/namespace/accounts/endpoint.rb

@@ -0,0 +1,16 @@
+module {{namespace_module}}
+  module Accounts
+    class Endpoint
+      include Accounts
+      include Shogun::Endpoint
+
+      def initialize(router:)
+        router.push route: route(verb: :get, control: List::Control)
+        router.push route: route(verb: :post, control: Create::Control)
+        router.push route: route(verb: :get, matcher: /(?<id>.+)/, control: Show::Control)
+        router.push route: route(verb: :patch, matcher: /(?<id>.+)/, control: Update::Control)
+        router.push route: route(verb: :delete, matcher: /(?<id>.+)/, control: Destroy::Control)
+      end
+    end
+  end
+end

data/scaffold/new/project/lib/namespace/accounts/list.rb

@@ -0,0 +1,10 @@
+module {{namespace_module}}
+  module Accounts
+    module List
+      require_relative "list/control"
+      require_relative "list/denormalizer"
+      require_relative "list/normalizer"
+      require_relative "list/validator"
+    end
+  end
+end

data/scaffold/new/project/lib/namespace/accounts/list/control.rb

@@ -0,0 +1,26 @@
+module {{namespace_module}}
+  module Accounts
+    module List
+      class Control
+        include Shogun::Control
+        include Accounts
+
+        def initialize(payload:)
+          @normalizer = Normalizer.new(raw: payload.to_hash)
+          @validator = Validator.new(data: @normalizer)
+
+          if @validator.valid?
+            @models = Model.limit(@normalizer.limit).where(@normalizer.filters).includes(@normalizer.includes)
+            @presenters = Shogun::Presenters.new(resources: @models, cast: Presenter, includes: @normalizer.includes, meta: @normalizer.as_meta)
+            @denormalizer = Denormalizer.new(object: @presenters, fields: @normalizer.fields)
+            @status = OK
+          else
+            @presenters = Shogun::Presenters.new(resources: @validator.invalids, cast: Errors::Presenter)
+            @denormalizer = Errors::Denormalizer.new(object: @presenters)
+            @status = UNPROCESSABLE_ENTITY
+          end
+        end
+      end
+    end
+  end
+end

data/scaffold/new/project/lib/namespace/accounts/list/denormalizer.rb

@@ -0,0 +1,37 @@
+module {{namespace_module}}
+  module Accounts
+    module List
+      class Denormalizer
+        include Shogun::Denormalizer
+        include Accounts
+
+        MAPPING = {
+          "id" => "id",
+          "signature" => "signature",
+          "username" => "username",
+          "email" => "email",
+          "name" => "name",
+          "created_at" => "created_at",
+          "destroyed_at" => "destroyed_at",
+          "updated_at" => "updated_at",
+          "href" => "href",
+          LINKS_KEY => "links",
+          META_KEY => "meta",
+          LINKED_KEY => "linked"
+        }
+
+        private def document
+          @object.map do |object|
+            if @fields.one?
+              object.public_send(@fields.first)
+            else
+              @fields.inject({}) do |hash, field|
+                hash.merge(field => object.public_send(mapping[field]))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/scaffold/new/project/lib/namespace/accounts/list/normalizer.rb

@@ -0,0 +1,58 @@
+module {{namespace_module}}
+  module Accounts
+    module List
+      class Normalizer
+        include Shogun::Normalizer
+        include Accounts
+
+        METADATA = %w|limit filters includes fields|
+        LIST_DELIMITER = /\s*,\s*/
+        DEFAULT_FIELD = "id"
+        AUTOMATIC_FIELDS = %w|id href meta links linked|
+
+        def initialize(raw:)
+          @limit = raw["limit"]
+          @filters = raw["filter"]
+          @includes = raw["include"]
+          @fields = raw["fields"]
+        end
+
+        def limit
+          Integer(@limit) rescue 10
+        end
+
+        def filters
+          if @filters.is_a?(Hash)
+            @filters
+          else
+            Hash.new
+          end
+        end
+
+        def includes
+          case @includes
+          when String
+            @includes.split(LIST_DELIMITER)
+          when Array
+            @includes
+          else
+            Array.new
+          end
+        end
+
+        def fields
+          case
+          when @fields.is_a?(Array)
+            @fields + AUTOMATIC_FIELDS
+          when @fields.is_a?(String) && @fields.match(LIST_DELIMITER)
+            @fields.split(LIST_DELIMITER) + AUTOMATIC_FIELDS
+          when @fields.is_a?(String)
+            [@fields.strip] + AUTOMATIC_FIELDS
+          else
+            [DEFAULT_FIELD]
+          end.uniq
+        end
+      end
+    end
+  end
+end

data/scaffold/new/project/lib/namespace/accounts/list/validator.rb

@@ -0,0 +1,24 @@
+module {{namespace_module}}
+  module Accounts
+    module List
+      class Validator
+        include Shogun::Validator
+        include Accounts
+
+        INCLUDES_ALLOWED = %w||
+        FIELDS_ALLOWED = %w|updated_at destroyed_at href created_at name email username signature id meta links linked|
+        FILTERS_ALLOWED = %w|username signature created_at name|
+        LIMIT_RANGE = 1..100
+
+        def initialize(data:)
+          @verifiers = [
+            Shogun::Verifier::Range.new(data: data.limit, name: "limit", range: LIMIT_RANGE),
+            Shogun::Verifier::Allowed.new(data: data.filters.keys, name: "filters", list: FILTERS_ALLOWED),
+            Shogun::Verifier::Allowed.new(data: data.includes, name: "includes", list: INCLUDES_ALLOWED),
+            Shogun::Verifier::Allowed.new(data: data.fields, name: "fields", list: FIELDS_ALLOWED)
+          ]
+        end
+      end
+    end
+  end
+end

data/scaffold/new/project/lib/namespace/accounts/model.rb

@@ -0,0 +1,49 @@
+module {{namespace_module}}
+  module Accounts
+    class Model < ActiveRecord::Base
+      include BCrypt
+      include Accounts
+
+      self.table_name = NAMESPACE
+
+      has_many :sessions, class_name: "{{namespace_module}}::Sessions::Model", foreign_key: "account_id", dependent: :destroy
+
+      def self.setup!
+        ActiveRecord::Migration.create_table table_name, force: true, id: :uuid do |table|
+          table.string :name, null: false
+          table.index :name, unique: true
+
+          table.string :username, null: false
+          table.index :username, unique: true
+
+          table.string :email, null: false
+          table.index :email, unique: true
+
+          table.string :signature, null: false
+          table.index :signature, unique: true
+
+          table.text :bio, default: "", null: false
+
+          table.string :password, null: false
+
+          table.datetime :created_at, null: false
+          table.index :created_at
+
+          table.datetime :destroyed_at
+          table.index :destroyed_at
+
+          table.datetime :updated_at
+          table.index :updated_at
+        end
+      end
+
+      def password
+        Password.new(super)
+      end
+
+      def password=(value)
+        super(Password.create(value))
+      end
+    end
+  end
+end