upload_d_n_d 0.9.1

data/lib/upload_d_n_d/controllers/uploadable.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+module UploadDND
+  module Controllers
+    module Uploadable
+      extend ActiveSupport::Concern
+
+    included do
+      # Gestion des erreurs ActiveStorage
+      rescue_from ActiveStorage::IntegrityError do |_e|
+        respond_to do |format|
+          format.turbo_stream do
+            flash[:alert] = I18n.t("upload_d_n_d.errors.corrupted")
+            render turbo_stream: turbo_stream.replace("flash_messages", partial: "shared/flashes"),
+                   status: :unprocessable_entity
+          end
+          format.json { render json: { error: I18n.t("upload_d_n_d.errors.corrupted") }, status: :unprocessable_entity }
+        end
+      end
+
+      rescue_from ActiveStorage::UnrepresentableError do |_e|
+        respond_to do |format|
+          format.turbo_stream do
+            flash[:alert] = I18n.t("upload_d_n_d.errors.unrepresentable")
+            render turbo_stream: turbo_stream.replace("flash_messages", partial: "shared/flashes"),
+                   status: :unprocessable_entity
+          end
+          format.json { render json: { error: I18n.t("upload_d_n_d.errors.unrepresentable") }, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # Transfère le session_id d'upload temporaire vers le record,
+    # uniquement si le param correspond à la session courante (sécurité).
+    #
+    # @param record [ApplicationRecord] le record sur lequel wirer le session_id
+    def wire_temporary_uploads(record)
+      sid = params[:temp_upload_session_id]
+      if sid.present? && sid == UploadDND::SessionId.for(session)
+        record.temp_upload_session_id = sid
+      end
+    end
+
+    # Attache un fichier à un record existant
+    # Utilise les fichiers temporaires uploadés via UploadDND
+    #
+    # @param record [ApplicationRecord] le record sur lequel attacher
+    # @param attribute_name [String, Symbol] le nom de l'attribut (ex: :avatar, :documents)
+    def attach_upload_d_n_d_files(record, attribute_name)
+      # Délègue au modèle TemporaryAttachment pour éviter la duplication
+      UploadDND::TemporaryAttachment.attach_to_record(
+        UploadDND::SessionId.for(session),
+        record,
+        { attribute_name.to_s => attribute_name }
+      )
+    end
+
+    # Autorise un record pour update via UploadDND::Authorization
+    # (fail-closed). Avec Pundit, la policy namespacée du controller est
+    # essayée d'abord (Admin::RecordPolicy), puis la policy top-level.
+    #
+    # L'erreur native de la librairie (Pundit::NotAuthorizedError...) est
+    # relancée telle quelle, pour les rescue_from de l'app.
+    #
+    # @param record [ApplicationRecord] le record à autoriser
+    def authorize_record_for_update(record)
+      UploadDND::Authorization.authorize!(self, record, :update, namespace: policy_namespace)
+    rescue UploadDND::Authorization::Denied, UploadDND::Authorization::RuleMissing => e
+      raise e.cause || e
+    end
+
+    # Action pour attacher un fichier à un record existant (appelée via route de l'app)
+    # Route attendue : POST /:model_name/:id/attach_file
+    def attach_file
+      # Utilise l'instance variable définie par before_action (ex: @project)
+      record = instance_variable_get("@#{controller_name.singularize}")
+
+      # Si pas d'instance variable, cherche le record via GlobalID (support namespaces)
+      unless record
+        if params[:record_gid].present?
+          record = GlobalID::Locator.locate(params[:record_gid])
+        else
+          # Fallback pour compatibilité (à déprécier)
+          model_name = params[:model_name] || controller_name.singularize
+          record = find_record_for_upload(model_name, params[:id])
+        end
+      end
+
+      authorize_record_for_update(record)
+      # Posé seulement si l'autorisation a réussi : sans lui, rien n'est purgé.
+      authorized = true
+
+      blob = ActiveStorage::Blob.find_signed(params[:signed_blob_id])
+      attribute_name = params[:attribute_name]
+
+      # SÉCURITÉ : un blob déjà rattaché (signed_id visible dans chaque URL de
+      # fichier) n'est pas rattaché une seconde fois. Pas de purge : il
+      # appartient à un autre record.
+      if blob&.attachments&.exists?
+        render_attach_file_error(I18n.t("upload_d_n_d.errors.blob_already_attached"))
+        return
+      end
+
+      # SÉCURITÉ : attribute_name vient du client — seul un attachment déclaré
+      # sur le modèle est résolu, jamais une méthode quelconque (destroy...).
+      attachment = UploadDND::AttachmentLookup.find(record, attribute_name)
+      unless attachment
+        discard_rejected_upload_blob(blob, authorized)
+        render_attach_file_error(I18n.t("upload_d_n_d.errors.invalid_attribute", attribute: attribute_name))
+        return
+      end
+
+      constraints = UploadDND::FieldConstraints.for(record.class, attribute_name)
+      if blob && (violation = constraints.violation(blob))
+        discard_rejected_upload_blob(blob, authorized)
+        render_attach_file_error(constraints.error_message(violation))
+        return
+      end
+
+      attachment.attach(blob)
+
+      if record.save
+        respond_to do |format|
+          format.turbo_stream do
+            flash.now[:notice] = I18n.t("upload_d_n_d.success.file_added")
+            render turbo_stream: [
+              turbo_stream.replace(
+                "udnd_files_list_#{attribute_name}",
+                partial: "upload_d_n_d/shared/files_list",
+                locals: { record: record.reload, attribute_name: attribute_name }
+              ),
+              turbo_stream.replace("flash_messages", partial: "shared/flashes")
+            ]
+          end
+          format.json { render json: { status: "ok" }, status: :ok }
+        end
+      else
+        discard_rejected_upload_blob(blob, authorized)
+        respond_to do |format|
+          format.turbo_stream do
+            flash.now[:alert] = I18n.t("upload_d_n_d.errors.save_failed", errors: record.errors.full_messages.join(", "))
+            render turbo_stream: turbo_stream.replace("flash_messages", partial: "shared/flashes"),
+                   status: :unprocessable_entity
+          end
+          format.json { render json: { error: record.errors.full_messages }, status: :unprocessable_entity }
+        end
+      end
+    rescue StandardError
+      # Refus de droits ou autorisation non aboutie : authorized est nil,
+      # rien n'est purgé. L'exception est toujours relancée.
+      discard_rejected_upload_blob(blob, authorized)
+      raise
+    end
+
+    # Action pour supprimer un fichier d'un record existant (appelée via route de l'app)
+    # Route attendue : DELETE /:model_name/:id/remove_file
+    def remove_file
+      # Utilise l'instance variable définie par before_action (ex: @project)
+      record = instance_variable_get("@#{controller_name.singularize}")
+
+      # Si pas d'instance variable, cherche le record via GlobalID (support namespaces)
+      unless record
+        if params[:record_gid].present?
+          record = GlobalID::Locator.locate(params[:record_gid])
+        else
+          # Fallback pour compatibilité (à déprécier)
+          model_name = params[:model_name] || controller_name.singularize
+          record = find_record_for_upload(model_name, params[:id])
+        end
+      end
+
+      authorize_record_for_update(record)
+
+      attachment = ActiveStorage::Attachment.find(params[:file_id])
+      attribute_name = params[:attribute_name]
+
+      # Vérification de sécurité : le fichier appartient bien au record
+      if attachment.record == record && attachment.name == attribute_name.to_s
+        attachment.purge_later
+        record.reload
+
+        respond_to do |format|
+          format.turbo_stream do
+            flash.now[:notice] = I18n.t("upload_d_n_d.success.file_removed")
+            render turbo_stream: [
+              turbo_stream.replace(
+                "udnd_files_list_#{attribute_name}",
+                partial: "upload_d_n_d/shared/files_list",
+                locals: { record: record, attribute_name: attribute_name }
+              ),
+              turbo_stream.replace("flash_messages", partial: "shared/flashes")
+            ]
+          end
+          format.json { render json: { status: "ok" }, status: :ok }
+        end
+      else
+        respond_to do |format|
+          format.turbo_stream do
+            flash.now[:alert] = I18n.t("upload_d_n_d.errors.file_not_found_or_denied")
+            render turbo_stream: turbo_stream.replace("flash_messages", partial: "shared/flashes"),
+                   status: :not_found
+          end
+          format.json { render json: { error: I18n.t("upload_d_n_d.errors.blob_not_found") }, status: :not_found }
+        end
+      end
+    end
+
+    private
+
+    def render_attach_file_error(message)
+      respond_to do |format|
+        format.turbo_stream do
+          flash.now[:alert] = message
+          render turbo_stream: turbo_stream.replace("flash_messages", partial: "shared/flashes"), status: :unprocessable_entity
+        end
+        format.json { render json: { error: message }, status: :unprocessable_entity }
+      end
+    end
+
+    # Blob envoyé par DirectUpload puis refusé : purgé sous les garde-fous de
+    # UploadDND::RejectedBlob, et seulement si l'autorisation a réussi. Un échec
+    # de la purge ne masque pas l'erreur d'origine.
+    def discard_rejected_upload_blob(blob, authorized)
+      return unless authorized
+
+      UploadDND::RejectedBlob.discard(blob)
+    rescue StandardError => e
+      Rails.logger.error "UploadDND: rejected blob purge failed - #{e.class}: #{e.message}"
+    end
+
+    # Retourne le namespace du controller si présent
+    # Ex: Admin::ProjectsController => "Admin"
+    # Ex: Admin::Internal::ProjectsController => "Admin::Internal"
+    def controller_namespace
+      controller_class = self.class.name.to_s
+      namespace_parts = controller_class.split("::")
+      if namespace_parts.length > 1
+        namespace_parts[0...-1].join("::")
+      else
+        nil
+      end
+    end
+
+    # Namespace du controller en symboles : Admin::Internal -> [:admin, :internal]
+    def policy_namespace
+      controller_namespace&.underscore&.split("/")&.map(&:to_sym)
+    end
+
+    # @deprecated Utilisez GlobalID à la place (params[:record_gid])
+    # Trouve le record pour l'upload
+    # Supporte les namespaces (ex: "admin_article" -> Admin::Article)
+    def find_record_for_upload(model_name, record_id)
+      # Tente de détecter le namespace depuis le controller
+      if (ns = controller_namespace)
+        # Convertit "article" en "Admin::Article" si on est dans Admin::ArticlesController
+        class_name = "#{ns}::#{model_name.classify}"
+        begin
+          model_class = class_name.constantize
+          return model_class.find(record_id)
+        rescue NameError
+          # Fallback si le namespace ne contient pas ce modèle
+        end
+      end
+
+      # Fallback standard (sans namespace)
+      model_class = model_name.classify.constantize
+      model_class.find(record_id)
+    end
+    end
+  end
+end

data/lib/upload_d_n_d/engine.rb

@@ -0,0 +1,50 @@
+module UploadDND
+  class Engine < ::Rails::Engine
+    isolate_namespace UploadDND
+
+    # Configuration des acronymes pour que Rails reconnaisse DND
+    initializer "upload_d_n_d.inflections" do
+      ActiveSupport::Inflector.inflections(:en) do |inflect|
+        inflect.acronym "DND"
+      end
+
+      ActiveSupport::Inflector.inflections(:fr) do |inflect|
+        inflect.acronym "DND"
+      end
+    end
+
+    # Helpers de la gem disponibles dans les vues de l'app hôte
+    # (les partials de la gem sont rendus depuis les controllers de l'app,
+    # qui n'incluent pas les helpers d'un engine isolé par défaut)
+    initializer "upload_d_n_d.helpers" do
+      ActiveSupport.on_load(:action_controller_base) do
+        helper UploadDND::Engine.helpers
+      end
+    end
+
+    # Uploads non protégés par une librairie d'autorisation : signalé au
+    # démarrage, une fois les initializers de l'app passés.
+    config.after_initialize do
+      UploadDND::Authorization.report
+    end
+
+    # Assets : JS (importmap) + CSS (asset pipeline)
+    initializer "upload_d_n_d.assets" do |app|
+      # JS : rend les fichiers disponibles pour importmap
+      app.config.assets.paths << root.join("app/javascript")
+
+      # CSS : rend upload_d_n_d/application.css disponible via stylesheet_link_tag
+      app.config.assets.paths << root.join("app/assets/stylesheets")
+    end
+
+    # Importmap : pins de la gem (upload_d_n_d, controllers Stimulus), lus par
+    # importmap-rails avec ceux de l'app. Avant son initializer, qui dessine
+    # config.importmap.paths.
+    initializer "upload_d_n_d.importmap", before: "importmap" do |app|
+      if app.config.respond_to?(:importmap)
+        app.config.importmap.paths << root.join("config/importmap.rb")
+        app.config.importmap.cache_sweepers << root.join("app/javascript")
+      end
+    end
+  end
+end

data/lib/upload_d_n_d/field_constraints.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module UploadDND
+  # Limites d'un champ d'upload : taille maximale, types MIME acceptés,
+  # contrôle MIME strict. Source unique pour le composant, les contrôleurs et
+  # le transfert des fichiers temporaires.
+  #
+  # Value object (Data) : immuable, deux instances aux mêmes valeurs sont
+  # égales. Construit depuis `uploadable` du modèle ; chaque limite que le
+  # modèle ne déclare pas retombe sur la configuration globale.
+  FieldConstraints = Data.define(:max_size, :content_types, :strict_mime_check) do
+    class << self
+      def for(model_class, attribute_name)
+        options = uploadable_options(model_class, attribute_name)
+        return global unless options
+
+        config = UploadDND.configuration
+        new(
+          max_size: options[:max_size] || config.max_size,
+          content_types: options[:content_type] || MimeTypes.from_accepted_types(config.accepted_types),
+          strict_mime_check: options.key?(:strict_mime_check) ? options[:strict_mime_check] : config.strict_mime_check
+        )
+      end
+
+      def global
+        config = UploadDND.configuration
+        new(
+          max_size: config.max_size,
+          content_types: MimeTypes.from_accepted_types(config.accepted_types),
+          strict_mime_check: config.strict_mime_check
+        )
+      end
+
+      private
+
+      def uploadable_options(model_class, attribute_name)
+        return unless model_class.respond_to?(:uploadable_attributes)
+
+        model_class.uploadable_attributes[attribute_name.to_sym]
+      end
+    end
+
+    def initialize(max_size:, content_types:, strict_mime_check:)
+      super(
+        max_size: max_size,
+        content_types: Array(content_types).map(&:to_s).uniq.freeze,
+        strict_mime_check: strict_mime_check == true
+      )
+    end
+
+    # Extensions pour l'attribut `accept` et les messages : ".jpg,.jpeg,.png"
+    def accepted_extensions
+      MimeTypes.to_extensions(content_types)
+    end
+
+    # @return [Symbol, nil] :too_large, :invalid_type, :suspicious_type ou
+    #   :mime_detection_failed ; nil si le blob respecte les limites
+    def violation(blob)
+      return :too_large if max_size.present? && blob.byte_size > max_size
+      return if content_types.empty?
+      return :invalid_type unless content_types.include?(blob.content_type)
+
+      detected_type_violation(blob) if strict_mime_check
+    end
+
+    def error_message(violation)
+      case violation
+      when :too_large
+        I18n.t("upload_d_n_d.errors.too_large", max_size: ActiveSupport::NumberHelper.number_to_human_size(max_size))
+      when :invalid_type
+        I18n.t("upload_d_n_d.errors.invalid_type", types: accepted_extensions)
+      else
+        I18n.t("upload_d_n_d.errors.#{violation}")
+      end
+    end
+
+    private
+
+    # Anti-spoofing : type réel lu dans le contenu. Le détail d'un échec reste
+    # dans les logs, jamais dans la réponse.
+    def detected_type_violation(blob)
+      detected = Marcel::MimeType.for(blob.download, name: blob.filename.to_s)
+      return if detected.blank?
+      return :invalid_type unless content_types.include?(detected)
+
+      :suspicious_type unless detected == blob.content_type
+    rescue StandardError => e
+      Rails.logger.warn "UploadDND: MIME detection failed - #{e.class}: #{e.message}"
+      :mime_detection_failed
+    end
+  end
+end

data/lib/upload_d_n_d/field_reference.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module UploadDND
+  # Référence signée d'un champ (modèle + attribut), émise par le composant et
+  # renvoyée au dépôt : le serveur retrouve les limites du champ sans faire
+  # confiance au client. Elle ne porte pas les limites elles-mêmes : le modèle
+  # reste la seule autorité.
+  module FieldReference
+    PURPOSE = :upload_d_n_d_field
+
+    class Invalid < UploadDND::Error; end
+
+    class << self
+      def generate(model_class, attribute_name)
+        verifier.generate([ model_class.name, attribute_name.to_s ], purpose: PURPOSE)
+      end
+
+      # @raise [Invalid] signature fausse, autre attribut, modèle ou attachment inconnu
+      # @return [UploadDND::FieldConstraints]
+      def constraints(token, attribute_name)
+        model_name, attribute = verified(token)
+        raise Invalid unless attribute.present? && attribute == attribute_name.to_s
+
+        model_class = model_name.to_s.safe_constantize
+        raise Invalid unless model_class.respond_to?(:reflect_on_attachment) && model_class.reflect_on_attachment(attribute)
+
+        FieldConstraints.for(model_class, attribute)
+      end
+
+      private
+
+      def verified(token)
+        payload = verifier.verified(token.to_s, purpose: PURPOSE)
+        payload.is_a?(Array) && payload.size == 2 ? payload : raise(Invalid)
+      rescue ActiveSupport::MessageVerifier::InvalidSignature, ArgumentError
+        raise Invalid
+      end
+
+      def verifier
+        Rails.application.message_verifier("upload_d_n_d/field_reference")
+      end
+    end
+  end
+end

data/lib/upload_d_n_d/file_validator.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+# Validateur de fichiers pour ActiveStorage.
+#
+# Rails associe `validates :avatar, file: {...}` à une constante `FileValidator`.
+# Pour garder l'API ergonomique, on expose `UploadDND::FileValidator` ET on
+# fournit un alias top-level `::FileValidator` si absent.
+module UploadDND
+  class FileValidator < ActiveModel::EachValidator
+    def validate_each(record, attribute, value)
+      return unless value.attached?
+
+      Array(value).each do |file|
+        validate_content_type(record, attribute, file)
+        validate_size(record, attribute, file)
+        validate_mime_type(record, attribute, file) if options[:strict_mime_check]
+      end
+
+      validate_file_count(record, attribute, value) if value.respond_to?(:count)
+    end
+
+    private
+
+    def validate_content_type(record, attribute, file)
+      return unless options[:content_type].present?
+
+      unless file.content_type.in?(Array(options[:content_type]))
+        record.errors.add(
+          attribute,
+          :content_type,
+          message: options[:message] || "n'est pas un type de fichier valide"
+        )
+      end
+    end
+
+    def validate_size(record, attribute, file)
+      return unless options[:max_size].present?
+
+      if file.byte_size > options[:max_size]
+        max_size_in_mb = options[:max_size] / 1.megabyte
+        record.errors.add(
+          attribute,
+          :max_size,
+          message: options[:message] || "doit être inférieur à #{max_size_in_mb}MB"
+        )
+      end
+    end
+
+    def validate_file_count(record, attribute, value)
+      return unless options[:max_files].present?
+
+      if value.count > options[:max_files]
+        record.errors.add(
+          attribute,
+          :max_files,
+          message: options[:message] || "ne peut pas avoir plus de #{options[:max_files]} fichiers"
+        )
+      end
+    end
+
+    # Détecte le vrai type MIME en analysant le contenu du fichier (anti-spoofing).
+    def validate_mime_type(record, attribute, file)
+      return unless options[:content_type].present?
+
+      detected_content_type = detect_content_type(record, attribute, file)
+      declared_content_type = file.content_type
+
+      unless detected_content_type.in?(Array(options[:content_type]))
+        record.errors.add(
+          attribute,
+          :spoofed_content_type,
+          message: options[:spoofing_message] ||
+                  "Le type de fichier détecté (#{detected_content_type}) ne correspond pas aux types autorisés"
+        )
+      end
+
+      if detected_content_type != declared_content_type
+        record.errors.add(
+          attribute,
+          :mime_type_mismatch,
+          message: options[:spoofing_message] ||
+                  "Le type de fichier détecté (#{detected_content_type}) " \
+                  "ne correspond pas au type déclaré (#{declared_content_type})"
+        )
+      end
+    rescue StandardError => e
+      # Le détail reste dans les logs : le message d'erreur est affiché.
+      Rails.logger.warn "UploadDND: MIME detection failed - #{e.class}: #{e.message}"
+      record.errors.add(
+        attribute,
+        :mime_type_detection_failed,
+        message: I18n.t("upload_d_n_d.errors.mime_detection_failed")
+      )
+    end
+
+    # Marcel a besoin des octets du fichier. Avec la zone de dépôt, le blob est
+    # déjà sur le stockage et `file.download` suffit. Avec un champ fichier
+    # classique, le fichier part avec le formulaire et n'est envoyé au stockage
+    # qu'après le `save` : à la validation, `file.download` lèverait
+    # `ActiveStorage::FileNotFoundError`. On lit alors la source encore en
+    # attente (`attachment_changes`), sans la consommer pour l'envoi au stockage.
+    def detect_content_type(record, attribute, file)
+      io = pending_upload_io(record, attribute, file)
+      return Marcel::MimeType.for(file.download, name: file.filename.to_s) unless io
+
+      io.rewind if io.respond_to?(:rewind)
+      Marcel::MimeType.for(io, name: file.filename.to_s)
+    ensure
+      io.rewind if io.respond_to?(:rewind)
+    end
+
+    # IO de la source non encore stockée pour ce fichier, ou nil si le blob est
+    # déjà sur le stockage (zone de dépôt, signed_id, blob existant).
+    def pending_upload_io(record, attribute, file)
+      return unless record.respond_to?(:attachment_changes)
+
+      change = record.attachment_changes[attribute.to_s]
+      return unless change
+
+      blob = file.respond_to?(:blob) ? file.blob : file
+      attachable = pending_attachables_by_key(change)[blob&.key]
+      attachable && readable_io(attachable)
+    end
+
+    # { blob.key => attachable } des sources non encore stockées. La `key` est
+    # fiable même avant le save (l'id du blob est encore nil, donc pas de
+    # comparaison par id). has_one : CreateOne (blob + attachable). has_many :
+    # CreateMany (blobs + attachables, même ordre). Une suppression ne crée rien.
+    def pending_attachables_by_key(change)
+      if change.respond_to?(:blobs) && change.respond_to?(:attachables)
+        change.blobs.map(&:key).zip(change.attachables).to_h
+      elsif change.respond_to?(:blob) && change.respond_to?(:attachable)
+        { change.blob&.key => change.attachable }
+      else
+        {}
+      end
+    end
+
+    # Extrait un IO des sources d'upload gérées. Les autres (signed_id, blob
+    # déjà stocké) renvoient nil pour retomber sur `file.download`. Duck typing
+    # volontaire : `Rack::Test::UploadedFile` n'est pas chargé en production, on
+    # ne référence donc pas la constante.
+    def readable_io(attachable)
+      if attachable.respond_to?(:tempfile) # UploadedFile (ActionDispatch / Rack::Test)
+        attachable.tempfile
+      elsif attachable.is_a?(Hash)
+        attachable[:io]
+      elsif attachable.respond_to?(:read) # IO, File, StringIO...
+        attachable
+      end
+    end
+  end
+end
+
+# Alias top-level pour l'API `validates ..., file: ...`
+::FileValidator = UploadDND::FileValidator unless defined?(::FileValidator)

data/lib/upload_d_n_d/mime_types.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module UploadDND
+  module MimeTypes
+    EXTENSION_TO_MIME = {
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      png: "image/png",
+      gif: "image/gif",
+      webp: "image/webp",
+      svg: "image/svg+xml",
+      pdf: "application/pdf",
+      doc: "application/msword",
+      docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      xls: "application/vnd.ms-excel",
+      xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      ppt: "application/vnd.ms-powerpoint",
+      pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      odt: "application/vnd.oasis.opendocument.text",
+      txt: "text/plain",
+      csv: "text/csv",
+      zip: "application/zip"
+    }.freeze
+
+    MIME_TO_EXTENSION = EXTENSION_TO_MIME.each_with_object({}) do |(ext, mime), hash|
+      hash[mime] ||= ".#{ext}"
+    end.freeze
+
+    # Toutes les extensions d'un type : image/jpeg -> [".jpg", ".jpeg"]
+    MIME_TO_EXTENSIONS = EXTENSION_TO_MIME.each_with_object({}) do |(ext, mime), hash|
+      (hash[mime] ||= []) << ".#{ext}"
+    end.transform_values(&:freeze).freeze
+
+    # Converts an array of symbols (extensions) and/or MIME strings into MIME strings.
+    #
+    # @param types [Array<Symbol, String>] e.g. [:jpg, :png, "application/pdf"]
+    # @return [Array<String>] e.g. ["image/jpeg", "image/png", "application/pdf"]
+    def self.resolve(types)
+      Array(types).map do |type|
+        case type
+        when Symbol
+          EXTENSION_TO_MIME.fetch(type) { raise ArgumentError, "Unknown extension: #{type.inspect}" }
+        else
+          type.to_s
+        end
+      end
+    end
+
+    # Converts an array of MIME strings into a comma-separated extensions string
+    # suitable for the HTML `accept` attribute. Every known extension of a type
+    # is listed: the browser checks the extension, a ".jpeg" file must pass.
+    #
+    # @param mime_types [Array<String>] e.g. ["image/jpeg", "image/png"]
+    # @return [String] e.g. ".jpg,.jpeg,.png"
+    def self.to_extensions(mime_types)
+      Array(mime_types).flat_map { |mime| MIME_TO_EXTENSIONS.fetch(mime) { [ mime ] } }.uniq.join(",")
+    end
+
+    # Converts the global `accepted_types` setting (extensions and/or MIME
+    # types, comma-separated) into MIME strings.
+    #
+    # @param value [String, Array<String>] e.g. ".pdf,.png" or "image/png"
+    # @return [Array<String>] e.g. ["application/pdf", "image/png"]
+    def self.from_accepted_types(value)
+      types = Array(value).flat_map { |item| item.to_s.split(",") }.map(&:strip).reject(&:blank?)
+
+      types.filter_map do |type|
+        next type if type.include?("/")
+
+        ext = type.start_with?(".") ? type : ".#{type}"
+        Marcel::MimeType.for(name: "file#{ext}")
+      end.uniq
+    end
+  end
+end