command_tower 0.3.1 → 0.10.0

data/app/models/command_tower/messaging/endpoint.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Messaging
+    class Endpoint < CommandTower::ApplicationRecord
+      self.table_name = "messaging_endpoints"
+
+      SINGLE_ACTIVE_CHANNELS = %w[pushover].freeze
+      LIFECYCLE_STATES = %w[active revoked invalid retired].freeze
+      VERIFICATION_STATES = %w[unverified pending verified failed].freeze
+      TERMINAL_LIFECYCLES = %w[revoked invalid retired].freeze
+
+      TYPED_CREDENTIAL_CHANNELS = %w[pushover].freeze
+
+      belongs_to :user
+      has_one :pushover_credential,
+              class_name: "CommandTower::Messaging::EndpointPushoverCredential",
+              foreign_key: :messaging_endpoint_id,
+              dependent: :destroy,
+              inverse_of: :endpoint
+
+      validates :channel_key, presence: true
+      validates :lifecycle_state, inclusion: { in: LIFECYCLE_STATES }
+      validates :verification_state, inclusion: { in: VERIFICATION_STATES }
+      validates :address_fingerprint, presence: true
+      validates :masked_display_value, presence: true
+      validates :address_ciphertext, presence: true, unless: :typed_credentials_channel?
+      validates :address_ciphertext, absence: true, if: :typed_credentials_channel?
+      validates :encryption_key_version, presence: true
+      validate :channel_must_support_endpoint_records
+      validate :timestamps_consistent_with_state
+
+      before_validation :derive_uniqueness_columns!
+
+      scope :for_owner, ->(owner_user_id) { where(user_id: owner_user_id) }
+      scope :active, -> { where(lifecycle_state: "active") }
+      scope :for_channel, ->(channel_key) { where(channel_key: channel_key.to_s) }
+
+      def self.single_active_channel?(channel_key)
+        SINGLE_ACTIVE_CHANNELS.include?(channel_key.to_s)
+      end
+
+      def self.typed_credentials_channel?(channel_key)
+        TYPED_CREDENTIAL_CHANNELS.include?(channel_key.to_s)
+      end
+
+      def typed_credentials_channel?
+        self.class.typed_credentials_channel?(channel_key)
+      end
+
+      def active?
+        lifecycle_state == "active"
+      end
+
+      def terminal?
+        TERMINAL_LIFECYCLES.include?(lifecycle_state)
+      end
+
+      # Centralized uniqueness derivation — must run whenever lifecycle, owner,
+      # channel, or fingerprint change. Terminal rows clear both slots.
+      def derive_uniqueness_columns!
+        if active?
+          self.active_fingerprint = address_fingerprint
+          self.single_active_slot =
+            if self.class.single_active_channel?(channel_key)
+              "#{user_id}:#{channel_key}"
+            end
+        else
+          self.active_fingerprint = nil
+          self.single_active_slot = nil
+        end
+      end
+
+      private
+
+      def channel_must_support_endpoint_records
+        return if channel_key.blank?
+
+        definition = Channels.fetch(channel_key)
+        if definition.nil? || !definition.supports_endpoint_records
+          errors.add(:channel_key, "must be a catalog channel that supports endpoint records")
+        end
+      end
+
+      def timestamps_consistent_with_state
+        if verification_state == "verified" && verified_at.nil?
+          errors.add(:verified_at, "must be set when verification_state is verified")
+        end
+        if verification_state != "verified" && verified_at.present? && verification_state_changed?
+          # reset_verification clears verified_at; allow historical verified_at only when verified
+        end
+        if %w[revoked].include?(lifecycle_state) && revoked_at.nil?
+          errors.add(:revoked_at, "must be set when lifecycle_state is revoked")
+        end
+      end
+    end
+  end
+end

data/app/models/command_tower/messaging/endpoint_pushover_credential.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Messaging
+    class EndpointPushoverCredential < CommandTower::ApplicationRecord
+      self.table_name = "messaging_endpoint_pushover_credentials"
+
+      belongs_to :endpoint,
+                 class_name: "CommandTower::Messaging::Endpoint",
+                 foreign_key: :messaging_endpoint_id,
+                 inverse_of: :pushover_credential
+
+      validates :user_key_ciphertext, presence: true
+      validates :application_token_ciphertext, presence: true
+      validates :encryption_key_version, presence: true
+    end
+  end
+end

data/app/models/command_tower/messaging/inbox_item.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Messaging
+    class InboxItem < CommandTower::ApplicationRecord
+      self.table_name = "messaging_inbox_items"
+
+      STATUS_CREATED = "created"
+      STATUS_VIEWED = "viewed"
+      STATUS_ARCHIVED = "archived"
+      STATUS_DELETED = "deleted"
+
+      belongs_to :communication,
+                 class_name: "CommandTower::Messaging::Communication",
+                 inverse_of: :inbox_item
+
+      validates :communication_id, uniqueness: true
+
+      scope :not_deleted, -> { where(deleted_at: nil) }
+      scope :not_archived, -> { where(archived_at: nil) }
+      scope :archived, -> { where.not(archived_at: nil) }
+      scope :default_list, -> { not_deleted.not_archived }
+      scope :archived_list, -> { not_deleted.archived }
+      scope :unread, -> { default_list.where(viewed_at: nil) }
+
+      def viewed?
+        viewed_at.present?
+      end
+
+      def archived?
+        archived_at.present?
+      end
+
+      def deleted?
+        deleted_at.present?
+      end
+
+      def unread?
+        !viewed? && !archived? && !deleted?
+      end
+
+      # Denormalized label helper — timestamps remain authoritative for filters.
+      def lifecycle_label
+        return STATUS_DELETED if deleted?
+        return STATUS_ARCHIVED if archived?
+        return STATUS_VIEWED if viewed?
+
+        STATUS_CREATED
+      end
+    end
+  end
+end

data/app/models/command_tower/messaging/notification_preference.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Messaging
+    class NotificationPreference < CommandTower::ApplicationRecord
+      self.table_name = "messaging_notification_preferences"
+
+      belongs_to :user
+
+      serialize :state, coder: JSON, type: Hash
+
+      validates :notification_type_key, presence: true
+      validates :state, presence: true
+      validates :notification_type_key, uniqueness: { scope: :user_id }
+
+      def self.find_for(recipient_id:, notification_type_key:)
+        find_by(user_id: recipient_id, notification_type_key: notification_type_key.to_s)
+      end
+    end
+  end
+end

data/app/models/user.rb

@@ -40,7 +40,10 @@ class User < CommandTower::ApplicationRecord
   # Serialize the roles column to check for inclusion easily
   serialize :roles, coder: JSON, type: Array
 
-  has_many :messages
+  has_many :messaging_communications,
+           class_name: "CommandTower::Messaging::Communication",
+           inverse_of: :user,
+           foreign_key: :user_id
 
   def full_name
     "#{first_name} #{last_name}"

data/app/serializers/command_tower/serializers/admin/messaging/announcement_response_serializer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Admin
+      module Messaging
+        module AnnouncementResponseSerializer
+          module_function
+
+          def serialize(data)
+            mode = data[:mode]
+            base = {
+              "mode" => mode.to_s,
+              "requested" => data[:requested],
+              "campaignIdentity" => data[:campaign_identity],
+            }
+
+            if mode == :async
+              base.merge(
+                "enqueued" => data[:enqueued],
+                "enqueueFailed" => data[:enqueue_failed],
+              )
+            else
+              base.merge(
+                "accepted" => data[:accepted],
+                "failed" => data[:failed],
+                "skipped" => data[:skipped],
+                "failures" => Array(data[:failures]).map do |failure|
+                  {
+                    "userId" => failure[:user_id],
+                    "errorCode" => failure[:error_code],
+                  }
+                end
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/application/envelope_serializer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Application
+      class EnvelopeSerializer
+        def self.success(data:, meta: {})
+          {
+            data: data,
+            meta: meta,
+            errors: []
+          }
+        end
+
+        def self.failure(errors:, meta: {})
+          {
+            data: nil,
+            meta: meta,
+            errors: errors
+          }
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/application/error_entry_serializer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Application
+      class ErrorEntrySerializer
+        def self.serialize(error)
+          entry = {
+            code: error.code,
+            message: error.message
+          }
+          entry[:details] = error.details if error.details.present?
+          entry
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/application_serializer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    class ApplicationSerializer
+      def self.serialize(*)
+        raise NotImplementedError
+      end
+
+      def self.map_serialize(collection, serializer = nil, &block)
+        items = collection.nil? ? [] : Array(collection)
+        if block
+          items.map(&block)
+        else
+          items.map { |item| serializer.serialize(item) }
+        end
+      end
+
+      def self.iso8601(time)
+        return nil if time.nil?
+
+        time.iso8601
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/auth/email_availability_serializer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Auth
+      class EmailAvailabilitySerializer
+        def self.serialize(valid:, available:, message:)
+          {
+            valid: valid,
+            available: available,
+            message: message
+          }
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/auth/email_verification/message_response_serializer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Auth
+      module EmailVerification
+        class MessageResponseSerializer
+          def self.serialize(message:)
+            { message: message }
+          end
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/auth/identity_policy_serializer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Auth
+      class IdentityPolicySerializer
+        def self.serialize(policy:)
+          {
+            password: {
+              minLength: policy[:password][:min_length],
+              maxLength: policy[:password][:max_length]
+            },
+            email: {
+              minLength: policy[:email][:min_length],
+              maxLength: policy[:email][:max_length]
+            },
+            username: {
+              minLength: policy[:username][:min_length],
+              maxLength: policy[:username][:max_length],
+              pattern: policy[:username][:pattern],
+              patternDescription: policy[:username][:pattern_description]
+            },
+            verificationCode: {
+              length: policy[:verification_code][:length],
+              characterSet: policy[:verification_code][:character_set]
+            },
+            phoneVerificationCode: {
+              length: policy[:phone_verification_code][:length],
+              characterSet: policy[:phone_verification_code][:character_set]
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/auth/login_response_serializer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Auth
+      class LoginResponseSerializer
+        def self.serialize(user:, token:, token_expires_at:)
+          {
+            user: UserSerializer.serialize(user),
+            token: token,
+            tokenExpiresAt: token_expires_at
+          }
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/auth/logout_response_serializer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Auth
+      class LogoutResponseSerializer
+        def self.serialize
+          { message: "logged_out" }
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/auth/password_recovery_session_response_serializer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Auth
+      class PasswordRecoverySessionResponseSerializer
+        def self.serialize(token:, expires_at:)
+          {
+            recoverySessionToken: token,
+            expiresAt: expires_at.iso8601
+          }
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/auth/password_reset/message_response_serializer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Auth
+      module PasswordReset
+        class MessageResponseSerializer
+          def self.serialize(message:)
+            { message: message }
+          end
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/auth/password_reset/validate_response_serializer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Auth
+      module PasswordReset
+        class ValidateResponseSerializer
+          def self.serialize(valid:, expires_at:)
+            payload = { valid: valid }
+
+            if expires_at.present?
+              expires_at_value = expires_at.is_a?(Time) || expires_at.is_a?(DateTime) ? expires_at.iso8601 : expires_at.to_s
+              payload[:expiresAt] = expires_at_value
+            end
+
+            payload
+          end
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/auth/register_response_serializer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Auth
+      class RegisterResponseSerializer
+        def self.serialize(user:)
+          {
+            user: UserSerializer.serialize(user),
+            message: "Account created successfully"
+          }
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/auth/session_response_serializer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Auth
+      class SessionResponseSerializer
+        def self.serialize(user:, token_expires_at:)
+          {
+            user: CommandTower::Serializers::Auth::UserSerializer.serialize(user),
+            tokenExpiresAt: token_expires_at
+          }
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/auth/signup_session_response_serializer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Auth
+      class SignupSessionResponseSerializer
+        def self.serialize(token:, expires_at:)
+          {
+            signupSessionToken: token,
+            expiresAt: expires_at.iso8601
+          }
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/auth/user_serializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Auth
+      class UserSerializer
+        def self.serialize(user)
+          {
+            id: user.id,
+            email: user.email,
+            username: user.username,
+            firstName: user.first_name,
+            lastName: user.last_name,
+            emailValidated: user.email_validated,
+            roles: user.roles
+          }
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/auth/username_availability_serializer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Auth
+      class UsernameAvailabilitySerializer
+        def self.serialize(valid:, available:, message:)
+          {
+            valid: valid,
+            available: available,
+            message: message
+          }
+        end
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/me/account_serializer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Me
+      class AccountSerializer
+        def self.serialize(user, capabilities:)
+          first_name = user.first_name.to_s
+          last_name = user.last_name.to_s
+          full_name = [first_name, last_name].map(&:strip).reject(&:empty?).join(" ")
+          full_name = user.full_name.strip if full_name.empty? && user.respond_to?(:full_name)
+
+          {
+            id: user.id,
+            firstName: first_name,
+            lastName: last_name,
+            fullName: full_name,
+            username: user.username,
+            email: user.email,
+            emailValidated: user.email_validated,
+            phoneNumber: phone_number_for(user),
+            phoneNumberValidated: phone_number_validated_for(user),
+            roles: user.roles,
+            createdAt: user.created_at&.iso8601,
+            capabilities: capabilities
+          }
+        end
+
+        def self.phone_number_for(user)
+          return nil unless user.respond_to?(:phone_number)
+
+          user.phone_number.presence
+        end
+        private_class_method :phone_number_for
+
+        def self.phone_number_validated_for(user)
+          return false unless user.respond_to?(:phone_number_validated)
+
+          !!user.phone_number_validated
+        end
+        private_class_method :phone_number_validated_for
+      end
+    end
+  end
+end

data/app/serializers/command_tower/serializers/me/change_password_response_serializer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Serializers
+    module Me
+      class ChangePasswordResponseSerializer
+        def self.serialize(message: "Password updated successfully.")
+          { message: message }
+        end
+      end
+    end
+  end
+end