upload_d_n_d 0.9.1

data/lib/upload_d_n_d/orphan_blobs.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module UploadDND
+  # Blobs sans rattachement qu'on peut supprimer : envois DirectUpload ratés ou
+  # abandonnés (refus, coupure réseau, onglet fermé, image retirée d'un éditeur).
+  # Le service ne supprime jamais : il LISTE, chaque blob accompagné de ses
+  # citations. C'est l'appelant (job, tâche rake) qui décide de purger.
+  #
+  # Un blob est supprimable seulement si, cumulativement :
+  # - aucun ActiveStorage::Attachment (record, variante, Action Text) ;
+  # - créé depuis plus de min_age ;
+  # - non gardé par un UploadDND::TemporaryAttachment (son blob est rattaché au
+  #   temporaire, donc déjà exclu par where.missing(:attachments)) ;
+  # - non cité dans un texte de la base (colonnes texte ET JSON) : par la clé du
+  #   bucket, par le signed_id (brut et échappé), ou par sgid (fichier inséré
+  #   avec l'éditeur dans un HTML stocké hors Action Text). Jamais par le nom.
+  #
+  # Le scan des citations ne lit que les textes contenant une adresse de
+  # stockage ou un sgid (filtre SQL LIKE), une seule fois pour tous les
+  # candidats. PostgreSQL requis (CAST AS text + ILIKE).
+  class OrphanBlobs
+    Result = Data.define(:blob, :citations) do
+      def purgeable? = citations.empty?
+    end
+
+    # Tables sans texte de contenu, ou dont les adresses ne comptent pas.
+    DEFAULT_EXCLUDED_TABLES = %w[
+      active_storage_blobs active_storage_attachments active_storage_variant_records
+      upload_d_n_d_temporary_attachments
+      schema_migrations ar_internal_metadata
+    ].freeze
+
+    # Seuls les textes contenant une adresse Active Storage ou un fichier inséré
+    # (sgid) sont lus. L'app ajoute l'hôte de son bucket via orphan_scan_patterns
+    # pour couvrir les citations par URL directe (image collée).
+    DEFAULT_PATTERNS = %w[%active_storage% %sgid%].freeze
+
+    TEXT_TYPES = %i[string text json jsonb].freeze
+
+    def self.call(**) = new(**).call
+
+    def initialize(now: Time.current, min_age: nil)
+      @now = now
+      @min_age = min_age || UploadDND.configuration.orphan_blob_min_age
+    end
+
+    def call
+      ensure_postgresql!
+      candidates.map { |blob| Result.new(blob: blob, citations: citations_for(blob)) }
+    end
+
+    private
+
+    def ensure_postgresql!
+      adapter = connection.adapter_name.to_s.downcase
+      return if adapter.include?("postgresql") || adapter.include?("postgis")
+
+      raise UploadDND::Error,
+            "UploadDND::OrphanBlobs : le scan des citations nécessite PostgreSQL " \
+            "(adaptateur courant : #{connection.adapter_name}). " \
+            "Sans ce scan, un blob cité dans un texte serait supprimé à tort."
+    end
+
+    def candidates
+      ActiveStorage::Blob
+        .where.missing(:attachments)
+        .where(created_at: ...(@now - @min_age))
+        .order(:id)
+    end
+
+    # Une adresse de fichier contient la clé (bucket) ou le signed_id
+    # (Active Storage, stable par défaut).
+    def citations_for(blob)
+      tokens = [ blob.key, blob.signed_id, CGI.escape(blob.signed_id) ].uniq
+      by_url = texts_citing_storage.filter_map do |source, text|
+        source if tokens.any? { |token| text.include?(token) }
+      end
+      (by_url + embedded_blob_sources.fetch(blob.id, [])).uniq
+    end
+
+    # { blob_id => ["table.colonne#id", ...] } pour les fichiers insérés (sgid).
+    def embedded_blob_sources
+      @embedded_blob_sources ||= compute_embedded_blob_sources
+    end
+
+    def compute_embedded_blob_sources
+      return {} unless defined?(ActionText)
+
+      texts_citing_storage.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |(source, text), sources|
+        next unless text.include?("sgid")
+
+        ActionText::Content.new(text).attachables.grep(ActiveStorage::Blob).each do |blob|
+          sources[blob.id] << source
+        end
+      end
+    end
+
+    # [["table.colonne#id", texte], ...], lus une seule fois.
+    def texts_citing_storage
+      @texts_citing_storage ||= scanned_columns.flat_map do |table_name, column, has_id|
+        table = Arel::Table.new(table_name)
+        as_text = Arel::Nodes::NamedFunction.new("CAST", [ table[column].as("text") ])
+        query = table.project(has_id ? table[:id] : Arel.sql("NULL"), as_text)
+                     .where(patterns.map { |pattern| as_text.matches(pattern) }.reduce(:or))
+        connection.select_rows(query.to_sql).map do |id, text|
+          [ "#{table_name}.#{column}#{"##{id}" if id}", text.to_s ]
+        end
+      end
+    end
+
+    # Colonnes à scanner : la liste blanche de l'app si elle est renseignée,
+    # sinon toutes les colonnes texte/JSON des tables non exclues.
+    def scanned_columns
+      whitelist = UploadDND.configuration.orphan_scan_columns
+      whitelist.present? ? whitelisted_columns(whitelist) : schema_columns
+    end
+
+    def whitelisted_columns(entries)
+      Array(entries).filter_map do |entry|
+        table, column = entry.to_s.split(".", 2)
+        next if table.blank? || column.blank?
+        next unless connection.data_source_exists?(table)
+
+        [ table, column, has_id_column?(table) ]
+      end
+    end
+
+    def schema_columns
+      (connection.tables - excluded_tables).flat_map do |table|
+        columns = connection.columns(table)
+        has_id = columns.any? { |column| column.name == "id" }
+        columns.select { |column| TEXT_TYPES.include?(column.type) }
+               .map { |column| [ table, column.name, has_id ] }
+      end
+    end
+
+    def has_id_column?(table)
+      connection.columns(table).any? { |column| column.name == "id" }
+    end
+
+    def excluded_tables
+      DEFAULT_EXCLUDED_TABLES + Array(UploadDND.configuration.orphan_scan_excluded_tables).map(&:to_s)
+    end
+
+    def patterns
+      (DEFAULT_PATTERNS + Array(UploadDND.configuration.orphan_scan_patterns)).uniq
+    end
+
+    def connection = ActiveRecord::Base.connection
+  end
+end

data/lib/upload_d_n_d/rejected_blob.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module UploadDND
+  # Blob envoyé par DirectUpload puis refusé par le serveur (contraintes,
+  # validation du modèle, erreur à l'enregistrement).
+  #
+  # Avec l'envoi direct, le fichier est déjà dans le bucket quand le serveur
+  # le contrôle : sans purge, chaque refus (et chaque nouvel essai) laisse un
+  # blob orphelin.
+  #
+  # Règle : on ne supprime jamais un fichier qui appartient à quelqu'un. Le
+  # signed_id vient du navigateur, il peut désigner un blob existant :
+  # - un blob qui a un attachment (record, ou TemporaryAttachment) est intact ;
+  # - un blob ancien est intact, même sans attachment : il peut être cité dans
+  #   un HTML stocké (sgid, URL) — seul un envoi récent est purgé.
+  module RejectedBlob
+    # Programme la purge du blob s'il est purgeable. La purge effective
+    # revérifie l'absence d'attachment (cf. PurgeRejectedBlobJob).
+    def self.discard(blob)
+      return unless discardable?(blob)
+
+      Rails.logger.info "UploadDND: rejected blob #{blob.id} scheduled for purge"
+      UploadDND::PurgeRejectedBlobJob.perform_later(blob.id)
+    end
+
+    def self.discardable?(blob)
+      blob.is_a?(ActiveStorage::Blob) &&
+        blob.persisted? &&
+        recent?(blob) &&
+        unattached?(blob)
+    end
+
+    def self.unattached?(blob)
+      !blob.attachments.exists?
+    end
+
+    def self.recent?(blob)
+      window = UploadDND.configuration.rejected_blob_purge_window
+      window.present? && blob.created_at >= window.ago
+    end
+  end
+end

data/lib/upload_d_n_d/session_id.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module UploadDND
+  # Identifiant de session utilisé pour scoper les fichiers temporaires.
+  #
+  # Sur une session vierge (aucun cookie), `session.id` est nil tant que rien
+  # n'a été écrit en session : le premier upload échouerait (session_id vide)
+  # et l'id lu au rendu du formulaire ne correspondrait pas à celui des uploads.
+  #
+  # `SessionId.for` amorce la session en y écrivant une clé neutre, ce qui force
+  # l'émission d'un id et du cookie dès la réponse courante, quel que soit le store.
+  # L'id est ainsi stable entre le rendu du composant et les requêtes suivantes.
+  module SessionId
+    KEY = "upload_d_n_d.session"
+
+    def self.for(session)
+      return "" if session.nil?
+
+      session[KEY] ||= true if session.respond_to?(:[]=)
+
+      sid = session.respond_to?(:id) ? session.id : (session[:id] || session["id"])
+      sid.to_s
+    end
+  end
+end

data/lib/upload_d_n_d/uploadable.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module UploadDND
+  # Concern modèle pour déclarer des attachments "uploadables" et transférer
+  # automatiquement les fichiers temporaires lors de la création d'un record.
+  #
+  # Remarque: ce module existait historiquement comme template de générateur.
+  # Il est maintenant livré par la gem pour éviter un prérequis implicite
+  # (et coller au README).
+  module Uploadable
+    extend ActiveSupport::Concern
+
+    included do
+      # Callbacks pour attacher les fichiers temporaires après création
+      after_create :attach_temporary_uploads
+    end
+
+    # Stocke temporairement le session_id pour l'upload
+    # Utilise une variable d'instance privée plutôt qu'attr_accessor
+    def temp_upload_session_id=(value)
+      @_temp_upload_session_id = value
+    end
+
+    def temp_upload_session_id
+      @_temp_upload_session_id
+    end
+
+    class_methods do
+      # Déclare un champ uploadable avec validation
+      #
+      # @param attribute_name [Symbol] le nom de l'attribut (ex: :avatar, :documents)
+      # @param options [Hash] les options de validation
+      # @option options [Array<String>] :content_type les types MIME autorisés
+      # @option options [Integer] :max_size la taille max en bytes
+      # @option options [Integer] :max_files le nombre max de fichiers (pour has_many)
+      # @option options [Boolean] :multiple autoriser plusieurs fichiers (auto-détecté depuis has_one/has_many par défaut)
+      # @option options [String] :message message d'erreur personnalisé
+      # @option options [Boolean] :strict_mime_check active la détection MIME côté serveur (anti-spoofing, plus coûteux)
+      # @option options [String] :spoofing_message message d'erreur personnalisé pour les erreurs de spoofing
+      def uploadable(attribute_name, **options)
+        # Résoudre accept: en content_type: (symboles → MIME strings)
+        if options[:accept]
+          options[:content_type] = UploadDND::MimeTypes.resolve(options.delete(:accept))
+        end
+
+        # Auto-déclarer has_one_attached / has_many_attached si pas déjà fait
+        unless reflect_on_attachment(attribute_name)
+          if options[:multiple]
+            has_many_attached attribute_name
+          else
+            has_one_attached attribute_name
+          end
+        end
+
+        validates attribute_name,
+                  file: options.slice(:content_type, :max_size, :max_files, :message, :strict_mime_check, :spoofing_message)
+
+        # Stocke les options pour usage ultérieur (ViewComponent, helpers, etc.)
+        (@uploadable_attributes ||= {})[attribute_name] = options
+      end
+
+      def uploadable_attributes
+        @uploadable_attributes || {}
+      end
+    end
+
+    private
+
+    def attach_temporary_uploads
+      return unless temp_upload_session_id.present?
+      return unless UploadDND::TemporaryAttachment.exists?(session_id: temp_upload_session_id)
+
+      UploadDND::TemporaryAttachment.where(session_id: temp_upload_session_id).find_each do |temp_attachment|
+        attribute_name = temp_attachment.attribute_name
+
+        # SÉCURITÉ : attribute_name vient du client — seul un attachment déclaré
+        # sur le modèle est résolu. Détection serveur du type (has_one vs has_many).
+        attachment = UploadDND::AttachmentLookup.find(self, attribute_name)
+        unless attachment
+          # Si l'attribut n'est pas un attachment du record, on nettoie quand même
+          # pour éviter de laisser des fichiers orphelins en base.
+          temp_attachment.destroy
+          next
+        end
+
+        blob_attachment = temp_attachment.blob_attachment
+        if blob_attachment.nil? || temp_attachment.violates_constraints_of?(self, attribute_name)
+          temp_attachment.destroy
+          next
+        end
+
+        if attachment.is_a?(ActiveStorage::Attached::Many)
+          # has_many_attached: on "déplace" l'attachment (pas de purge du blob)
+          blob_attachment.update!(record: self, name: attribute_name)
+        elsif attachment.is_a?(ActiveStorage::Attached::One)
+          # has_one_attached: utiliser = (remplace automatiquement)
+          # Ne transférer que le PREMIER fichier temporaire si plusieurs existent
+          if attachment.attached?
+            # Le record a déjà un fichier: on purgera le temporaire.
+            temp_attachment.destroy
+            next
+          end
+
+          blob_attachment.update!(record: self, name: attribute_name)
+        end
+
+        # Après déplacement, temp_attachment n'a plus d'attachment ActiveStorage.
+        # On reload pour éviter les caches d'association avant destroy.
+        temp_attachment.reload
+        temp_attachment.destroy
+      end
+
+      # Nettoie le session_id après utilisation
+      @_temp_upload_session_id = nil
+    end
+  end
+end

data/lib/upload_d_n_d/version.rb

@@ -0,0 +1,3 @@
+module UploadDND
+  VERSION = "0.9.1"
+end

data/lib/upload_d_n_d.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "upload_d_n_d/version"
+require "upload_d_n_d/engine"
+require "upload_d_n_d/configuration"
+require "upload_d_n_d/session_id"
+require "upload_d_n_d/attachment_lookup"
+require "upload_d_n_d/rejected_blob"
+require "upload_d_n_d/orphan_blobs"
+require "upload_d_n_d/file_validator"
+require "upload_d_n_d/mime_types"
+require "upload_d_n_d/uploadable"
+require "upload_d_n_d/controllers/uploadable"
+
+module UploadDND
+  class Error < StandardError; end
+
+  # Levée quand un record affiché dans la liste de fichiers n'a pas de route
+  # polymorphique (resource imbriquée, singulière, ou non routée).
+  # Remède côté app : resolve() dans config/routes.rb, ou surcharge du helper
+  # udnd_remove_file_url. Voir README, section "Records imbriqués".
+  class UnroutableRecordError < Error; end
+end
+
+require "upload_d_n_d/authorization"
+require "upload_d_n_d/field_constraints"
+require "upload_d_n_d/field_reference"
+
+module UploadDND
+  # Autoload des concerns, helpers et autres composants
+  # Ces fichiers seront chargés automatiquement par le moteur Rails
+
+  # Helpers publics pour les routes de la gem
+  class << self
+    # Retourne le path pour créer un attachement
+    # @return [String] le chemin vers la création d'attachement
+    def attachments_path
+      Engine.routes.url_helpers.attachments_path
+    end
+
+    # Retourne le path pour un attachement spécifique
+    # @param id [Integer, String] l'ID de l'attachement
+    # @param options [Hash] options supplémentaires (ex: record_gid)
+    # @return [String] le chemin vers l'attachement
+    def attachment_path(id, **options)
+      Engine.routes.url_helpers.attachment_path(id, **options)
+    end
+
+    # Retourne le path pour créer un attachement temporaire
+    # @return [String] le chemin vers la création d'attachement temporaire
+    def temporary_attachments_path
+      Engine.routes.url_helpers.temporary_attachments_path
+    end
+
+    # Retourne le path pour un attachement temporaire spécifique
+    # @param id [Integer, String] l'ID de l'attachement temporaire
+    # @return [String] le chemin vers l'attachement temporaire
+    def temporary_attachment_path(id)
+      Engine.routes.url_helpers.temporary_attachment_path(id)
+    end
+  end
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: upload_d_n_d
+version: !ruby/object:Gem::Version
+  version: 0.9.1
+platform: ruby
+authors:
+- Pierre Cherbero
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+- !ruby/object:Gem::Dependency
+  name: view_component
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: UploadDND provides a drag & drop upload interface for Rails apps, built
+  on ActiveStorage, Stimulus and ViewComponent. It validates files server-side (MIME
+  sniffing, size, count), supports temporary uploads for new records, and authorizes
+  every request fail-closed through Pundit or CanCanCan.
+email:
+- cameleon24@outlook.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/upload_d_n_d_manifest.js
+- app/assets/stylesheets/upload_d_n_d/application.css
+- app/components/upload_d_n_d/upload_component.html.erb
+- app/components/upload_d_n_d/upload_component.rb
+- app/controllers/concerns/upload_d_n_d/rate_limiting.rb
+- app/controllers/upload_d_n_d/attachments_controller.rb
+- app/controllers/upload_d_n_d/base_attachments_controller.rb
+- app/controllers/upload_d_n_d/temporary_attachments_controller.rb
+- app/helpers/upload_d_n_d/application_helper.rb
+- app/helpers/upload_d_n_d/controllers/helpers.rb
+- app/javascript/upload_d_n_d/controllers/preview_controller.js
+- app/javascript/upload_d_n_d/controllers/uploads_controller.js
+- app/javascript/upload_d_n_d/index.js
+- app/jobs/upload_d_n_d/application_job.rb
+- app/jobs/upload_d_n_d/cleanup_temporary_attachments_job.rb
+- app/jobs/upload_d_n_d/purge_orphan_blobs_job.rb
+- app/jobs/upload_d_n_d/purge_rejected_blob_job.rb
+- app/models/upload_d_n_d/application_record.rb
+- app/models/upload_d_n_d/temporary_attachment.rb
+- app/views/upload_d_n_d/shared/_file_icon.html.erb
+- app/views/upload_d_n_d/shared/_files_list.html.erb
+- app/views/upload_d_n_d/shared/_temp_files_list.html.erb
+- config/importmap.rb
+- config/initializers/inflections.rb
+- config/locales/upload_d_n_d.en.yml
+- config/locales/upload_d_n_d.fr.yml
+- config/routes.rb
+- docs/CHANGELOG.md
+- lib/generators/upload_d_n_d/POLICY_README
+- lib/generators/upload_d_n_d/USAGE
+- lib/generators/upload_d_n_d/install_generator.rb
+- lib/generators/upload_d_n_d/mime_type_helper.rb
+- lib/generators/upload_d_n_d/model_generator.rb
+- lib/generators/upload_d_n_d/policy_generator.rb
+- lib/generators/upload_d_n_d/templates/POST_INSTALL
+- lib/generators/upload_d_n_d/templates/concerns/controllers_uploadable.rb
+- lib/generators/upload_d_n_d/templates/concerns/upload_authorization.rb
+- lib/generators/upload_d_n_d/templates/concerns/uploadable.rb
+- lib/generators/upload_d_n_d/templates/controller.rb.tt
+- lib/generators/upload_d_n_d/templates/helpers/upload_helper.rb
+- lib/generators/upload_d_n_d/templates/initializers/upload_d_n_d.rb
+- lib/generators/upload_d_n_d/templates/migrations/create_upload_d_n_d_temporary_attachments.rb
+- lib/generators/upload_d_n_d/templates/policies/upload_d_n_d_attachment_policy.rb
+- lib/generators/upload_d_n_d/templates/policies/upload_d_n_d_temporary_attachment_policy.rb
+- lib/generators/upload_d_n_d/templates/validators/file_validator.rb
+- lib/tasks/upload_d_n_d_storage.rake
+- lib/tasks/upload_d_n_d_tasks.rake
+- lib/upload_d_n_d.rb
+- lib/upload_d_n_d/attachment_lookup.rb
+- lib/upload_d_n_d/authorization.rb
+- lib/upload_d_n_d/authorization/can_can_can_adapter.rb
+- lib/upload_d_n_d/authorization/no_authorization.rb
+- lib/upload_d_n_d/authorization/pundit_adapter.rb
+- lib/upload_d_n_d/authorization/unconfigured.rb
+- lib/upload_d_n_d/configuration.rb
+- lib/upload_d_n_d/controllers/uploadable.rb
+- lib/upload_d_n_d/engine.rb
+- lib/upload_d_n_d/field_constraints.rb
+- lib/upload_d_n_d/field_reference.rb
+- lib/upload_d_n_d/file_validator.rb
+- lib/upload_d_n_d/mime_types.rb
+- lib/upload_d_n_d/orphan_blobs.rb
+- lib/upload_d_n_d/rejected_blob.rb
+- lib/upload_d_n_d/session_id.rb
+- lib/upload_d_n_d/uploadable.rb
+- lib/upload_d_n_d/version.rb
+homepage: https://github.com/Peyochanchan/upload_d_n_d
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/Peyochanchan/upload_d_n_d
+  changelog_uri: https://github.com/Peyochanchan/upload_d_n_d/blob/main/docs/CHANGELOG.md
+  bug_tracker_uri: https://github.com/Peyochanchan/upload_d_n_d/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.5
+specification_version: 4
+summary: Secure drag & drop file uploads for Rails, built on ActiveStorage
+test_files: []