upload_d_n_d 0.9.4 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bc35467ae9c71f396f1168a6c900f8a828e87ad9491b99abd0f07c3ebfe49ab
-  data.tar.gz: 477cb07d1fda946dfccea4181327a4a5c8ce978998c2183a7fd7b38f1fd1ff6d
+  metadata.gz: 7a16cbbec64d738e23701d35ec650f5b9b378b494d470b2611ea7415f3e31d3b
+  data.tar.gz: 32fdff2762b16165eb808a46a1446d99c855c779d9e8e83ee64954260bf42d97
 SHA512:
-  metadata.gz: '09adbe224dd2403b21da5e590e667686dea3c514f9c6c5a11f8cd2b528cf2506883cc283e99b916795afaf9a3278b7ff31c8aa9de41cb8a2ff3b403c5c947d29'
-  data.tar.gz: b5427eda02e120647c435f27df467126cbe24faa060260cd71833b02c57f4aa5adca316db0f6354606b20e632113eb1a48edeba72b8c5928aa94270ee44818fa
+  metadata.gz: 381d1e0884e50cf3fc72109db3e5ae0912ebf0bed0084fc6216ff6a692b49844b4b838f4e40232cd36f895ea10fd7b6721179e4e19e87ad365a6586c420bf483
+  data.tar.gz: 20fa9e3fe22f13ccf6d22cf75b0df2436d3a0f3b4046216d3e27dd8ef1c642ef0d3517e9003c97af44a65905a566edd7645a10c14e77209389280386b37d4630

data/README.md

@@ -57,6 +57,19 @@ Everything else (JS, CSS, components, concerns) is served from the gem: upgradin
 
 With **jsbundling-rails** (bun/esbuild), the `upload_d_n_d:link_js` task copies the gem's JS/CSS into `node_modules/upload_d_n_d` so your bundler can resolve `import "upload_d_n_d"` and `@import "upload_d_n_d/styles"`. It is a real directory (not a symlink), so the gem's own imports of `@hotwired/stimulus` and `@rails/activestorage` resolve against your app's `node_modules`. The task runs automatically on `javascript:build` (so `assets:precompile` at deploy is always up to date). Note: a watch-mode dev server such as `bin/dev` calls the bundler directly and does **not** run the task, so after upgrading the gem run `bin/rails javascript:build` once locally to refresh the copy.
 
+CSS — one line, whichever bundler:
+
+```css
+/* Tailwind 3 (postcss-import), esbuild or bun */
+@import "upload_d_n_d/styles";
+```
+
+With **Sprockets** (asset pipeline) instead of a JS bundler, use the stylesheet tag:
+
+```erb
+<%= stylesheet_link_tag "upload_d_n_d/application", media: "all" %>
+```
+
 ActiveStorage must be installed (`bin/rails active_storage:install`). With an external S3-like bucket and a strict CSP, serve files same-origin:
 
 ```ruby

data/app/components/upload_d_n_d/upload_component.html.erb

@@ -1,14 +1,12 @@
 <div class="udnd-container"
      style="--udnd-accent-color: <%= main_color %>; --udnd-accent-rgb: <%= main_color_rgb %>;"
      data-controller="upload-d-n-d--uploads"
-     data-upload-d-n-d--uploads-record-id-value="<%= record&.id %>"
-     data-upload-d-n-d--uploads-record-gid-value="<%= record_gid %>"
      data-upload-d-n-d--uploads-attribute-name-value="<%= attribute_name %>"
      data-upload-d-n-d--uploads-attach-url-value="<%= attach_path %>"
      data-upload-d-n-d--uploads-max-size-value="<%= max_size %>"
      data-upload-d-n-d--uploads-accepted-types-value="<%= accepted_types %>"
      data-upload-d-n-d--uploads-mime-types-value="<%= accepted_mime_types %>"
-     data-upload-d-n-d--uploads-field-ref-value="<%= field_ref %>"
+     data-upload-d-n-d--uploads-target-value="<%= signed_target %>"
      data-upload-d-n-d--uploads-multiple-value="<%= multiple %>"
      data-upload-d-n-d--uploads-i18n-value="<%= i18n_messages.to_json %>">
 
@@ -46,7 +44,7 @@
   <%# Record persisté : ses attachments. Sinon : les fichiers temporaires de la session,
       pour que la zone reste remplie après un rechargement de page. %>
   <% if record&.persisted? %>
-    <%= render "upload_d_n_d/shared/files_list", record: record, attribute_name: attribute_name %>
+    <%= render "upload_d_n_d/shared/files_list", record: record, attribute_name: attribute_name, namespace: namespace %>
   <% else %>
     <%= render "upload_d_n_d/shared/temp_files_list", files: files, attribute_name: attribute_name %>
   <% end %>

data/app/components/upload_d_n_d/upload_component.rb

@@ -42,13 +42,26 @@ module UploadDND
       UploadDND::MimeTypes.from_accepted_types(@accepted_types).join(",")
     end
 
-    # Référence signée du champ, renvoyée au dépôt : le serveur en déduit les
-    # limites du modèle. nil sans record (limites globales).
-    def field_ref
-      return unless record && record.class.respond_to?(:reflect_on_attachment)
-      return unless record.class.reflect_on_attachment(attribute_name)
+    # Cible signée renvoyée au dépôt et à la suppression : le serveur en déduit
+    # modèle, attribut, record et namespace, sans faire confiance au client.
+    #
+    # Exige un `record:` (même non persisté) pour pouvoir signer le couple
+    # modèle/attribut, et que l'attribut soit déclaré `uploadable` sur le modèle.
+    def signed_target
+      unless record
+        raise ArgumentError,
+              "upload_field(#{attribute_name.inspect}) exige record: (même une instance neuve) " \
+              "pour signer la cible d'upload."
+      end
+
+      model_class = record.class
+      unless model_class.respond_to?(:uploadable_attributes) && model_class.uploadable_attributes.key?(attribute_name.to_sym)
+        raise ArgumentError,
+              "#{attribute_name.inspect} n'est pas déclaré `uploadable` sur #{model_class} : " \
+              "déclarez-le avec `uploadable :#{attribute_name}, ...`."
+      end
 
-      UploadDND::FieldReference.generate(record.class, attribute_name)
+      UploadDND::SignedTarget.for(record, attribute_name, namespace: namespace)
     end
 
     def model_name
@@ -58,14 +71,6 @@ module UploadDND
       record.class.name.underscore.tr("/", "_")
     end
 
-    # Génère le GlobalID pour le record (fonctionne avec tous les namespaces)
-    def record_gid
-      # Un record non persisté n'a pas d'ID => GlobalID impossible (MissingModelIdError).
-      return nil unless record&.persisted?
-
-      record.to_global_id.to_s
-    end
-
     # Détermine l'URL d'attachement : soit vers le moteur de la gem, soit vers une route spécifique
     def attach_path
       action_path = record&.persisted? ? :attachments_path : :temporary_attachments_path

data/app/controllers/upload_d_n_d/attachments_controller.rb

@@ -1,94 +1,52 @@
 # frozen_string_literal: true
 
 module UploadDND
-  # Contrôleur dédié à la gestion des attachments permanents (sur records existants).
+  # Contrôleur des attachments permanents (sur records existants).
   #
-  # Responsabilités:
-  # - Attacher des fichiers à des records ActiveRecord déjà persistés
-  # - Valider que le record existe via GlobalID
-  # - Gérer has_one vs has_many attachments
-  # - Renvoyer la liste des fichiers pour mise à jour UI
+  # La cible (modèle, attribut, record, namespace de policy) provient d'un jeton
+  # signé (`UploadDND::SignedTarget`) émis par le composant : le client ne
+  # désigne plus le record ni l'attribut en clair. L'autorisation porte sur le
+  # record (`:update`), avec le namespace du jeton, en fail-closed.
   #
-  # Utilisé par:
-  # - POST /upload_d_n_d/attachments (lors de l'upload sur record existant)
-  #
-  # Workflow:
-  # 1. User uploads file on edit form → record_gid present in params
-  # 2. Controller locates record via GlobalID
-  # 3. Attaches blob directly to record.attribute_name
-  # 4. Saves record with validations
-  # 5. Returns updated file list
-  #
-  # Note: Pour les formulaires SANS record (ex: new User), utilisez TemporaryAttachmentsController.
+  # Routes :
+  # - POST /upload_d_n_d/attachments
+  # - DELETE /upload_d_n_d/attachments/:id
   class AttachmentsController < BaseAttachmentsController
-    # Autorisation (UploadDND::Authorization, fail-closed)
-    before_action :authorize_upload!, only: [ :create ]
+    before_action :find_target, only: [ :create, :destroy ]
+    before_action :authorize_target!, only: [ :create, :destroy ]
     before_action :reject_attached_blob, only: [ :create ]
 
-    before_action :validate_record_gid_presence, only: [ :create ]
-    before_action :validate_destroy_params, only: [ :destroy ]
-
     # POST /upload_d_n_d/attachments
     #
-    # Params:
-    # - signed_blob_id: String (ActiveStorage signed blob ID)
-    # - attribute_name: String (ex: "avatar", "documents")
-    # - record_gid: String (GlobalID du record, ex: "gid://app/User/123")
-    # - multiple: String ("true" ou "false", optionnel)
-    #
-    # Returns:
-    # - Turbo Stream pour remplacer la liste de fichiers
-    # - JSON {status: 'ok'} en mode API
+    # Params : signed_blob_id, target (jeton signé).
     def create
-      attribute_name = params[:attribute_name]
-
-      begin
-        record = GlobalID::Locator.locate(params[:record_gid])
-      rescue ActiveRecord::RecordNotFound
-        render_error(I18n.t("upload_d_n_d.errors.blob_not_found"), :not_found)
-        return
-      end
-
-      unless record
-        render_error(I18n.t("upload_d_n_d.errors.blob_not_found"), :not_found)
-        return
-      end
+      record = @target_record
+      attribute_name = @target.attribute
 
-      authorize_record_upload!(record)
-      return if performed?
-
-      # SÉCURITÉ : l'attribut doit être un attachment déclaré sur le modèle.
-      # Détection SERVEUR du type d'attachment (has_one vs has_many) :
-      # NE JAMAIS faire confiance au paramètre client params[:multiple]
+      # L'attribut du jeton est déjà vérifié `uploadable` ; on résout l'objet
+      # d'association (has_one vs has_many) par réflexion, jamais par le client.
       attachment = UploadDND::AttachmentLookup.find(record, attribute_name)
       unless attachment
         render_error(I18n.t("upload_d_n_d.errors.invalid_attribute", attribute: attribute_name), :unprocessable_entity)
         return
       end
 
-      # Limites du champ, lues sur le modèle du record (vérifiées avant toute
-      # écriture ; le blob refusé est purgé).
-      constraints = UploadDND::FieldConstraints.for(record.class, attribute_name)
-      if (violation = constraints.violation(@blob))
-        render_error(constraints.error_message(violation), :unprocessable_entity)
+      if (violation = @target.constraints.violation(@blob))
+        render_error(@target.constraints.error_message(violation), :unprocessable_entity)
         return
       end
 
-      # Sanitize filename avant l'attachement
       @blob.update(filename: sanitize_filename(@blob.filename.to_s))
 
       if attachment.is_a?(ActiveStorage::Attached::Many)
-        # has_many_attached: ajouter à la collection
         attachment.attach(@blob)
       elsif attachment.is_a?(ActiveStorage::Attached::One)
-        # has_one_attached: remplacer (purge l'ancien automatiquement)
         record.send("#{attribute_name}=", @blob)
       else
         render_error(I18n.t("upload_d_n_d.errors.not_active_storage_attachment", attribute: attribute_name), :unprocessable_entity)
         return
       end
 
-      # Sauvegarde avec validation
       if record.save
         render_file_list(record, attribute_name)
         log_upload_success
@@ -101,29 +59,14 @@ module UploadDND
 
     # DELETE /upload_d_n_d/attachments/:id
     #
-    # Détache un fichier d'un record existant, sans dépendre des routes de
-    # l'app hôte (contrairement au flux legacy remove_file du concern
-    # Controllers::Uploadable). Symétrique du POST #create.
-    #
-    # Params:
-    # - id: Integer (ActiveStorage::Attachment id)
-    # - record_gid: String (GlobalID du record)
-    # - attribute_name: String (ex: "avatar", "documents")
+    # Params : id (ActiveStorage::Attachment), target (jeton signé).
     def destroy
-      record = GlobalID::Locator.locate(params[:record_gid])
-
-      unless record
-        render_error(I18n.t("upload_d_n_d.errors.record_not_found"), :not_found)
-        return
-      end
-
-      authorize_destroy!(record)
-      return if performed?
+      record = @target_record
+      attribute_name = @target.attribute
 
       attachment = ActiveStorage::Attachment.find_by(id: params[:id])
-      attribute_name = params[:attribute_name]
 
-      # Sécurité : le fichier doit appartenir au record ET à l'attribut annoncés
+      # Sécurité : le fichier doit appartenir au record ET à l'attribut signés.
       if attachment && attachment.record == record && attachment.name == attribute_name.to_s
         attachment.purge_later
         record.reload
@@ -138,81 +81,43 @@ module UploadDND
 
     private
 
-    def validate_destroy_params
-      unless params[:record_gid].present? && params[:attribute_name].present?
-        render_error(I18n.t("upload_d_n_d.errors.missing_params"), :bad_request)
+    # Autorisation sur le record désigné par le jeton signé : policy `:update`,
+    # avec le namespace du jeton (ex. Admin::RecordPolicy). Fail-closed : sans
+    # policy utilisable (ni namespacée ni top-level), la requête est refusée
+    # (403), avec un avertissement en log nommant la policy manquante.
+    def authorize_target!
+      @target_record = @target.record
+      unless @target_record
+        render_error(I18n.t("upload_d_n_d.errors.record_not_found"), :not_found)
         return
       end
 
-      unless params[:attribute_name].match?(/\A[a-z_][a-z0-9_]*\z/)
-        render_error(I18n.t("upload_d_n_d.errors.invalid_attribute_name"), :bad_request)
-        nil
-      end
-    end
-
-    # Autorisation de la suppression : règle du record (update), avec repli
-    # sur la règle générique de la gem si le modèle n'en a pas (Pundit : pas
-    # de policy). Fail-closed : sans règle du tout, RuleMissing remonte en 500
-    # plutôt que de laisser passer.
-    def authorize_destroy!(record)
-      begin
-        authorize_with_adapter!(record, :update)
-      rescue UploadDND::Authorization::RuleMissing
-        authorize_with_adapter!(:upload_d_n_d_attachment, :destroy)
-      end
-    rescue UploadDND::Authorization::Denied
-      render_forbidden
-    end
-
-    # Autorisation de l'upload sur le record lui-même (policy update?), en plus
-    # de la policy générique vérifiée en before_action : le record_gid vient du
-    # client, sans ce contrôle tout utilisateur autorisé à uploader pouvait
-    # attacher un fichier à n'importe quel record. Si le modèle n'a pas de
-    # règle, la règle générique (create) déjà vérifiée fait foi.
-    def authorize_record_upload!(record)
-      revoke_upload_authorization!
-      begin
-        authorize_with_adapter!(record, :update)
-      rescue UploadDND::Authorization::RuleMissing
-        nil # règle générique déjà vérifiée
-      end
+      authorize_with_adapter!(@target_record, :update, namespace: @target.namespace)
       grant_upload_authorization!
+    rescue ActiveRecord::RecordNotFound
+      render_error(I18n.t("upload_d_n_d.errors.record_not_found"), :not_found)
+    rescue UploadDND::Authorization::RuleMissing
+      Rails.logger.warn "UploadDND: aucune policy d'autorisation pour " \
+                        "#{@target.model_class} (namespace: #{@target.namespace.inspect}) - refus (fail-closed)"
+      render_forbidden
     rescue UploadDND::Authorization::Denied
       render_forbidden
     end
 
-    def validate_record_gid_presence
-      unless params[:record_gid].present?
-        render_error(I18n.t("upload_d_n_d.errors.record_gid_required"), :bad_request)
-        nil
-      end
-    end
-
     def render_file_list(record, attribute_name)
       if turbo_stream_request?
         render_turbo_stream_replace(
           "udnd_files_list_#{attribute_name}",
           partial: "upload_d_n_d/shared/files_list",
-          locals: { record: record, attribute_name: attribute_name }
+          locals: { record: record, attribute_name: attribute_name, namespace: @target.namespace }
         )
       else
         respond_to do |format|
           format.json { render json: { status: "ok", message: I18n.t("upload_d_n_d.success.file_added") }, status: :ok }
-          format.html { redirect_back fallback_location: root_path, notice: I18n.t("upload_d_n_d.success.file_added") }
+          format.html { redirect_back fallback_location: (main_app.respond_to?(:root_path) ? main_app.root_path : "/"), notice: I18n.t("upload_d_n_d.success.file_added") }
           format.any { render json: { status: "ok", message: I18n.t("upload_d_n_d.success.file_added") }, status: :ok }
         end
       end
     end
-
-    # === Autorisation ===
-
-    # Policy générique ; la policy du record est vérifiée ensuite
-    # (authorize_record_upload!), une fois le record localisé.
-    def authorize_upload!
-      authorize_with_adapter!(:upload_d_n_d_attachment, :create)
-      grant_upload_authorization!
-    rescue UploadDND::Authorization::Denied
-      render_forbidden
-    end
   end
 end

data/app/controllers/upload_d_n_d/base_attachments_controller.rb

@@ -11,7 +11,10 @@ module UploadDND
   # - Helpers de rendu (Turbo Streams, JSON, HTML)
   # - Sécurité (CSRF, validation de signature, sanitisation)
   # - Rate limiting (contrôle du taux de requêtes)
-  class BaseAttachmentsController < ActionController::Base
+  # Contrôleur parent configurable (config.parent_controller) : par défaut
+  # ActionController::Base (isolé), ou "ApplicationController" pour hériter des
+  # hooks d'authentification/autorisation/multi-tenant de l'app hôte (F6).
+  class BaseAttachmentsController < UploadDND.configuration.parent_controller.constantize
     # Inclure Pundit si disponible
     include Pundit::Authorization if defined?(Pundit)
 
@@ -27,6 +30,14 @@ module UploadDND
     # Authentification (si disponible dans l'app hôte)
     before_action :authenticate_user_if_available!
 
+    # Le moteur fait sa propre autorisation (port adaptateur), pas via la
+    # convention Pundit de l'app hôte. On marque les vérifications Pundit comme
+    # satisfaites : les after_action verify_* de l'hôte passent alors, quel que
+    # soit leur nom (certaines apps les regroupent dans un callback au nom
+    # custom) — sans masquer d'erreur ni dépendre du nom du callback. Enregistré
+    # inconditionnellement (la présence de Pundit est vérifiée à l'exécution).
+    before_action :satisfy_pundit_verifications
+
     # Gestion des erreurs
     # IMPORTANT: rescue_from utilise le "dernier match" -> on déclare StandardError en premier
     # pour laisser les handlers spécifiques (RecordNotFound, etc.) prendre le dessus.
@@ -38,6 +49,8 @@ module UploadDND
     before_action :validate_params, only: [ :create ]
     before_action :validate_signed_blob_id_format, only: [ :create ]
     before_action :find_blob, only: [ :create ]
+    # find_target est enregistré par chaque sous-classe (actions distinctes) :
+    # le re-déclarer ici puis dans une sous-classe écraserait ses conditions.
 
     # Déclaré après find_blob (@blob connu) et avant les before_action des
     # sous-classes (autorisation, contraintes), qu'il englobe.
@@ -99,25 +112,34 @@ module UploadDND
     end
 
     def validate_params
-      unless params[:signed_blob_id].present? && params[:attribute_name].present?
-        render_error(I18n.t("upload_d_n_d.errors.missing_params"), :bad_request)
-        return
-      end
+      return if params[:signed_blob_id].present? && params[:target].present?
 
-      # Validation du nom d'attribut (alphanumeric + underscore uniquement)
-      unless params[:attribute_name].match?(ATTRIBUTE_NAME_FORMAT)
-        render_error(I18n.t("upload_d_n_d.errors.invalid_attribute_name"), :bad_request)
-        nil
-      end
+      render_error(I18n.t("upload_d_n_d.errors.missing_params"), :bad_request)
+      nil
     end
 
     def find_blob
       @blob = ActiveStorage::Blob.find_signed(params[:signed_blob_id])
+      return if @blob
+
+      # find_signed renvoie nil (sans lever) sur signature invalide ou blob
+      # supprimé : sans cette garde, @blob nil provoquait un 500 plus bas.
+      render_error(I18n.t("upload_d_n_d.errors.invalid_blob_signature"), :unauthorized)
+      nil
     rescue ActiveSupport::MessageVerifier::InvalidSignature
       render_error(I18n.t("upload_d_n_d.errors.invalid_blob_signature"), :unauthorized)
       nil
     end
 
+    # Vérifie et décode la cible signée (remplace les record_gid/attribute_name
+    # bruts du client). Toute cible absente ou invalide est refusée.
+    def find_target
+      @target = UploadDND::SignedTarget.verify(params[:target])
+    rescue UploadDND::SignedTarget::Invalid
+      render_error(I18n.t("upload_d_n_d.errors.invalid_field_reference"), :bad_request)
+      nil
+    end
+
     # === Helpers de rendu ===
 
     def render_error(message, status = :unprocessable_entity)
@@ -145,6 +167,10 @@ module UploadDND
       Rails.logger.error "UploadDND Error: #{exception.class} - #{exception.message}"
       Rails.logger.error exception.backtrace.join("\n")
 
+      # Si la réponse est déjà rendue (ex. un after_action qui lève après coup),
+      # ne pas re-rendre : cela provoquerait un DoubleRenderError.
+      return if performed?
+
       render_error(I18n.t("upload_d_n_d.errors.upload_error"), :internal_server_error)
     end
 
@@ -164,16 +190,17 @@ module UploadDND
 
     # === Helpers d'authentification ===
 
-    def current_user
-      # Tente de récupérer current_user depuis l'application hôte
-      # En utilisant warden (Devise)
-      if defined?(Warden) && request.env["warden"]
-        request.env["warden"].user
-      elsif respond_to?(:super, true)
-        super
-      else
-        nil
-      end
+    # Public : l'app hôte vérifie souvent `respond_to?(:current_user)` (sans
+    # include_all) dans ses before_action / pour alimenter Current.user ; une
+    # méthode protected y répondrait faux. Priorité au `current_user` fourni par
+    # le parent (parent_controller = "ApplicationController"), repli Warden sinon.
+    # NB : `defined?(super)` teste la présence d'une méthode parente (et non
+    # `respond_to?(:super)`, qui cherchait à tort une méthode nommée :super).
+    public def current_user
+      return super if defined?(super)
+      return request.env["warden"].user if defined?(Warden) && request.env["warden"]
+
+      nil
     end
 
     def authenticate_user_if_available!
@@ -193,8 +220,21 @@ module UploadDND
 
     # Délègue au port d'autorisation (UploadDND::Authorization) : lève
     # Denied, RuleMissing ou ConfigurationError. Fail-closed sans adaptateur.
-    def authorize_with_adapter!(subject, action)
-      UploadDND::Authorization.authorize!(self, subject, action)
+    def authorize_with_adapter!(subject, action, namespace: nil)
+      UploadDND::Authorization.authorize!(self, subject, action, namespace: namespace)
+    end
+
+    # Marque la requête comme « vérifiée » côté Pundit (API officielle), pour que
+    # les after_action verify_authorized / verify_policy_scoped de l'app hôte
+    # passent, indépendamment du nom du callback qui les appelle. Le moteur
+    # applique sa propre autorisation (adaptateur) : ces marqueurs n'affaiblissent
+    # rien, ils neutralisent seulement l'assertion de dev de l'hôte.
+    def satisfy_pundit_verifications
+      # skip_policy_scope / skip_authorization sont PROTECTED dans Pundit : le
+      # second argument (include_all) est indispensable, sinon respond_to? renvoie
+      # false et les marqueurs ne sont jamais posés.
+      skip_policy_scope if respond_to?(:skip_policy_scope, true)
+      skip_authorization if respond_to?(:skip_authorization, true)
     end
 
     def render_forbidden

data/app/controllers/upload_d_n_d/temporary_attachments_controller.rb

@@ -20,6 +20,7 @@ module UploadDND
   # 3. Helper transfers temp files to real record and destroys TemporaryAttachment
   class TemporaryAttachmentsController < BaseAttachmentsController
     # Autorisation (UploadDND::Authorization, fail-closed)
+    before_action :find_target, only: [ :create ]
     before_action :authorize_upload!, only: [ :create ]
     before_action :authorize_delete!, only: [ :destroy, :purge ]
 
@@ -60,7 +61,7 @@ module UploadDND
     # - Turbo Stream pour remplacer la liste de fichiers
     # - JSON {status: 'ok'} en mode API
     def create
-      attribute_name = params[:attribute_name]
+      attribute_name = @target.attribute
 
       # Sanitize filename avant de créer l'attachment
       @blob.update(filename: sanitize_filename(@blob.filename.to_s))
@@ -149,7 +150,7 @@ module UploadDND
       else
         respond_to do |format|
           format.json { render json: { status: "ok", message: I18n.t("upload_d_n_d.success.file_uploaded") }, status: :ok }
-          format.html { redirect_back fallback_location: root_path, notice: I18n.t("upload_d_n_d.success.file_added") }
+          format.html { redirect_back fallback_location: (main_app.respond_to?(:root_path) ? main_app.root_path : "/"), notice: I18n.t("upload_d_n_d.success.file_added") }
           format.any { render json: { status: "ok", message: I18n.t("upload_d_n_d.success.file_uploaded") }, status: :ok }
         end
       end
@@ -159,27 +160,13 @@ module UploadDND
       Rails.logger.info "UploadDND: Temporary file deleted - #{@temp_attachment.attribute_name} by #{current_user&.id || 'anonymous'}"
     end
 
-    # Limites du champ visé : celles du modèle si le composant a fourni sa
-    # référence signée (field_ref), sinon la configuration globale (ancien
-    # client, appel direct).
+    # Limites du champ visé, lues sur le modèle via la cible signée (obligatoire
+    # au dépôt temporaire : plus de repli silencieux sur la configuration globale).
     def validate_blob_constraints
       return unless @blob
 
-      constraints = field_constraints
-      return if performed?
-
-      violation = constraints.violation(@blob)
-      render_error(constraints.error_message(violation), :unprocessable_entity) if violation
-    end
-
-    def field_constraints
-      return UploadDND::FieldConstraints.global if params[:field_ref].blank?
-
-      UploadDND::FieldReference.constraints(params[:field_ref], params[:attribute_name])
-    rescue UploadDND::FieldReference::Invalid
-      Rails.logger.warn "UploadDND: invalid field reference for #{params[:attribute_name]}"
-      render_error(I18n.t("upload_d_n_d.errors.invalid_field_reference"), :bad_request)
-      nil
+      violation = @target.constraints.violation(@blob)
+      render_error(@target.constraints.error_message(violation), :unprocessable_entity) if violation
     end
 
     # === Autorisation ===
@@ -187,12 +174,18 @@ module UploadDND
     def authorize_upload!
       authorize_with_adapter!(:upload_d_n_d_temporary_attachment, :create)
       grant_upload_authorization!
+    rescue UploadDND::Authorization::RuleMissing
+      Rails.logger.warn "UploadDND: aucune policy UploadDNDTemporaryAttachmentPolicy (create?) - refus (fail-closed)"
+      render_forbidden
     rescue UploadDND::Authorization::Denied
       render_forbidden
     end
 
     def authorize_delete!
       authorize_with_adapter!(:upload_d_n_d_temporary_attachment, :destroy)
+    rescue UploadDND::Authorization::RuleMissing
+      Rails.logger.warn "UploadDND: aucune policy UploadDNDTemporaryAttachmentPolicy (destroy?) - refus (fail-closed)"
+      render_forbidden
     rescue UploadDND::Authorization::Denied
       render_forbidden
     end

data/app/helpers/upload_d_n_d/application_helper.rb

@@ -13,16 +13,15 @@ module UploadDND
     # remove_file). Nécessite une route polymorphique — voir README,
     # section "Records imbriqués". Point d'extension : redéfinissez cette
     # méthode dans le ApplicationHelper de votre app.
-    def udnd_remove_file_url(record, attachment, attribute_name)
+    def udnd_remove_file_url(record, attachment, attribute_name, namespace: nil)
       if UploadDND.configuration.delete_route == :host
         query = { file_id: attachment.id, attribute_name: attribute_name }.to_query
         "#{udnd_record_path(record)}/remove_file?#{query}"
       else
-        UploadDND::Engine.routes.url_helpers.attachment_path(
-          attachment.id,
-          record_gid: record.to_global_id.to_s,
-          attribute_name: attribute_name
-        )
+        # Jeton régénéré côté serveur : il survit aux re-rendus Turbo Stream du
+        # partial (les boutons de suppression portent toujours une cible valide).
+        token = UploadDND::SignedTarget.for(record, attribute_name, namespace: namespace)
+        UploadDND::Engine.routes.url_helpers.attachment_path(attachment.id, target: token)
       end
     end
 

data/app/javascript/upload_d_n_d/controllers/uploads_controller.js

@@ -6,13 +6,11 @@ export default class extends Controller {
   static values = {
     attachUrl: String,
     attributeName: String,
-    recordId: String,
-    recordGid: String,
     multiple: Boolean,
     maxSize: Number,
     acceptedTypes: String,
     mimeTypes: String,
-    fieldRef: String,
+    target: String,
     i18n: Object
   }
 
@@ -152,20 +150,11 @@ export default class extends Controller {
   }
 
   attachBlob(blob) {
+    // Cible signée (modèle, attribut, record, namespace) : le serveur ne fait
+    // pas confiance au client pour désigner la cible ni le namespace de policy.
     const payload = {
       signed_blob_id: blob.signed_id,
-      attribute_name: this.attributeNameValue,
-      multiple: this.multipleValue
-    }
-
-    // Référence signée du champ : le serveur applique les limites du modèle
-    if (this.fieldRefValue) {
-      payload.field_ref = this.fieldRefValue
-    }
-
-    // Si on a un record existant, on passe son GlobalID
-    if (this.hasRecordGidValue && this.recordGidValue) {
-      payload.record_gid = this.recordGidValue
+      target: this.targetValue
     }
 
     fetch(this.attachUrlValue, {