activestorage-delayed 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d45bf7babcb289d33cb76078e9e944be721fd42ebd7b28f4bd1ca60fee81c148
+  data.tar.gz: 933186d50d21a26346941e7253f5fdc2b15c194b049411054a2f10d825d52bf2
+SHA512:
+  metadata.gz: 766911783743811c91ac4b7aeb7161783d17128a3ad626321d8220b53862e2182ec5b278fb7f1c3827a2dc3ec9acf30eddc58a05dc1d32280edfd03404b8b82a
+  data.tar.gz: aa629632c162e3f9b4910242ab89422ee95aca3c6ddc67b190b215b966028eadb1876e4ea9d7463e88fbf94a433683532b6c96d7d8f4ec98cbb8bfb7ae5ffbd6

data/README.md

@@ -0,0 +1,140 @@
+# Activestorage Delayed
+
+ActiveStorage for Rails 6 and 7 does not support to upload files in background which in most cases delays the submit process and then making the visitor get bored or receive a timeout error.    
+This is a Ruby on Rails gem to upload activestorage files in background by saving them as base64 encoded in the database and be processed later.
+
+## Installation
+- Add this line to your application's Gemfile:
+  ```ruby
+    gem 'activestorage-delayed'
+  ```
+- And then execute: `bundle install`
+- Generate the migration: `rails g migration add_activestorage_delayed`
+- Add the following content to the migration file:
+    ```ruby
+      create_table :activestorage_delayed_uploads do |t|
+        t.references :uploadable, polymorphic: true, null: false
+        t.string :attr_name, null: false
+        t.string :deleted_ids, default: ''
+        t.boolean :clean_before, default: false
+        t.text :files
+        t.timestamps
+      end
+    ```
+- Run the migration: `rails db:migrate`
+
+
+## Usage
+- Include `ActivestorageDelayed::DelayedConcern`
+- Add `delayed_attach` to the files you want to upload in background
+
+```ruby
+  class User < ApplicationRecord
+  include ActivestorageDelayed::DelayedConcern
+
+  has_one_attached :photo, require: true, use_filename: true
+  delayed_attach :photo
+
+  has_many_attached :certificates
+  delayed_attach :certificates
+end
+
+```
+### `delayed_attach` accepts an optional hash with the following options:
+- `require`: If set to `true`, the `photo` or the `photo_tmp` will be required before saving.
+- `use_filename`: If set to `true`, the image filename will be used as the name of uploaded file instead of the hash-key used by `activestorage`
+
+### Examples to upload files in background 
+- Upload a single file
+  ```ruby
+    User.create(photo_tmp: File.open('my_file.png')) # uploads the file in background
+    User.create(photo: File.open('my_file.png')) # uploads the file directly
+  ```
+  **HTML**:
+  ```haml
+  f.file_field :photo_tmp
+  ```
+
+- Upload multiple files
+  ```ruby
+    User.create(certificates_tmp: [File.open('my_file.png'), File.open('my_file.png')])
+  ```    
+   **HTML**:
+  ```haml
+  = f.file_field :certificates_tmp, multiple: true
+  ```
+
+- Deletes first 2 certificates and uploads a new one
+  ```ruby
+    file_ids = User.first.certificates.limit(2).pluck(:id)
+    User.first.update(certificates_tmp: { deleted_ids: file_ids, files: [File.open('my_file.png')] })
+  ```
+   **HTML**
+  ```haml
+  = file_field_tag 'user[certificates_tmp][files][]', multiple: true
+  - user.certificates.each do |file|
+    %li
+      = image_tag(file)
+      = check_box_tag 'user[certificates_tmp][deleted_ids][]', value: file.id
+  ```
+    
+- Removes all certificates before uploading a new one
+  ```ruby
+    User.first.update(certificates_tmp: { clean_before: true, files: [File.open('my_file.png')] })
+  ```
+  
+- Upload files with custom names (requires `use_filename: true`)
+  ```ruby
+  class User < ApplicationRecord
+    def photo_filename(filename)
+      "#{id}-#{full_name.parameterize}#{File.extname(filename)}"
+    end
+  end
+  ```
+  When `<attr_name>_filename` is defined, then it is called to fetch the uploaded file name.    
+  Note: Check [this](https://gist.github.com/owen2345/33730a452d73b6b292326bb602b0ee6b) if you want to rename an already uploaded file (remote file)
+
+- Capture event when file upload has failed
+  ```ruby
+    class User < ApplicationRecord
+      def ast_delayed_on_error(attr_name, error)
+        puts "Failed #{attr_name} with #{error}"
+      end
+    end
+  ```
+
+- Capture event when file has been uploaded
+  ```ruby
+    class User < ApplicationRecord
+      after_save_commit do
+        puts 'Photo has been uploaded' if photo.blob.present?
+        puts 'No pending enqueued photo uploads' unless photo_delayed_uploads.any?
+      end
+      
+      before_save do 
+        puts "current assigned tmp photo: #{photo_tmp.inspect}"
+      end
+    end
+  ```
+  `<attr_name>_delayed_uploads` is a `has_many` association that contains the list of scheduled uploads for the corresponding attribute.
+  
+  
+## Preprocessing original files before uploading (Rails 7+)
+```ruby
+class User < ApplicationRecord
+  has_one_attached :photo do |attachable|
+    attachable.variant :default, strip: true, quality: 70, resize_to_fill: [200, 200]
+  end
+end
+```
+`:default` variant will be used to pre-preprocess the original file before uploading (if defined). By this way you have your desired image size and quality as the original image.
+
+
+
+## Contributing
+Bug reports and pull requests are welcome on https://github.com/owen2345/activestorage-delayed. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.    
+
+To ensure your contribution changes, run the tests with: `docker-compose run test`
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+require 'bundler/gem_tasks'

data/lib/activestorage-delayed/delayed_concern.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ActivestorageDelayed
+  module DelayedConcern
+    extend ActiveSupport::Concern
+    included do
+      @ast_delayed_settings = {}
+      def self.delayed_attach(attr_name, required: false, use_filename: false) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        @ast_delayed_settings[attr_name] = { use_filename: use_filename }
+        tmp_attr_name = :"#{attr_name}_tmp"
+        has_many_attr = :"#{attr_name}_delayed_uploads"
+        attr_accessor tmp_attr_name
+
+        has_many has_many_attr, as: :uploadable, dependent: :destroy, class_name: 'ActivestorageDelayed::DelayedUpload'
+        if required
+          validates tmp_attr_name, presence: true, unless: ->(o) { o.send(attr_name).blob }
+          validates attr_name, presence: true, unless: ->(o) { o.send(tmp_attr_name) }
+        end
+
+        # @param delayed_data [Hash<files: Array<File1, File2>, deleted_ids: Array<1, 2>, clean_before: Boolean>]
+        # @param delayed_data [Array<File1, File2>]
+        define_method "#{tmp_attr_name}=" do |delayed_data|
+          instance_variable_set(:"@#{tmp_attr_name}", delayed_data.dup)
+          delayed_data = { files: delayed_data } unless delayed_data.is_a?(Hash)
+          delayed_data[:tmp_files] = delayed_data.delete(:files)
+          delayed_data[:deleted_ids] = (delayed_data.delete(:deleted_ids) || []).join(',')
+          delayed_data[:attr_name] = attr_name
+          send(has_many_attr) << send(has_many_attr).new(delayed_data)
+        end
+      end
+    end
+
+    # @param _attr_name (String)
+    # @param _error (Exception)
+    def ast_delayed_on_error(_attr_name, _error); end
+  end
+end

data/lib/activestorage-delayed/delayed_uploader.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module ActivestorageDelayed
+  class DelayedUploader
+    attr_reader :delayed_upload
+
+    def initialize(delayed_upload_id)
+      @delayed_upload = delayed_upload_id if delayed_upload_id.is_a?(ActiveRecord::Base)
+      @delayed_upload ||= DelayedUpload.find_by(id: delayed_upload_id)
+    end
+
+    def call
+      return unless delayed_upload
+
+      remove_files
+      upload_photos
+      save_changes
+    end
+
+    private
+
+    # TODO: check the ability to delete io with save or upload method
+    # file_data['io'].close
+    def upload_photos # rubocop:disable Metrics/AbcSize
+      tmp_files_data.each do |file_data|
+        model.send(attr_name).attach(file_data.transform_keys(&:to_sym))
+      end
+    rescue => e # rubocop:disable Style/RescueStandardError
+      Rails.logger.error("********* #{self.class.name} -> Failed uploading files: #{e.message}. #{e.backtrace[0..20]}")
+      model.ast_delayed_on_error(attr_name, e)
+    end
+
+    def save_changes
+      model.save!
+      delayed_upload.destroy!
+    end
+
+    # @return [Array<Hash<io: StringIO, filename: String, content_type: String>]
+    def tmp_files_data
+      @tmp_files_data ||= begin
+        files = JSON.parse(delayed_upload.files || '[]')
+        files.each do |file_data|
+          file_data['io'] = base64_to_file(file_data)
+          if attr_settings[:use_filename]
+            file_data['key'] = filename_for(file_data['filename'])
+            file_data['filename'] = file_data['key']
+          end
+        end
+      end
+    end
+
+    def base64_to_file(file_data)
+      tempfile = Tempfile.new(file_data['filename'])
+      tempfile.binmode
+      tempfile.write Base64.decode64(file_data['io'])
+      tempfile.rewind
+      tempfile
+    end
+
+    def model
+      @model ||= delayed_upload.uploadable
+    end
+
+    def filename_for(filename)
+      method_name = "#{attr_name}_filename".to_sym
+      return model.send(method_name, filename) if model.respond_to?(method_name)
+
+      name = File.basename(filename, '.*').parameterize
+      name = "#{SecureRandom.uuid}-#{name}" if support_multiple?
+      "#{model.id}-#{name}#{File.extname(filename)}"
+    end
+
+    def remove_files
+      items = delayed_upload.uploadable.send(attr_name)
+      return unless support_multiple?
+
+      items.where(id: delayed_upload.deleted_ids.split(',')).destroy_all if delayed_upload.deleted_ids.present?
+      items.destroy_all if delayed_upload.clean_before
+    end
+
+    def support_multiple?
+      model.send(attr_name).class.name.include?('Many')
+    end
+
+    def attr_name
+      delayed_upload.attr_name.to_sym
+    end
+
+    def attr_settings
+      model.class.instance_variable_get(:@ast_delayed_settings)[attr_name]
+    end
+  end
+end

data/lib/activestorage-delayed/delayed_uploader_job.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActivestorageDelayed
+  class DelayedUploaderJob < ActiveJob::Base
+    queue_as :default
+
+    def perform(delayed_upload_id)
+      ActivestorageDelayed::DelayedUploader.new(delayed_upload_id).call
+    end
+  end
+end

data/lib/activestorage-delayed/models/delayed_upload.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# t.string :attr_name, null: false
+# t.string :deleted_ids, default: ''
+# t.boolean :clean_before, default: false
+# t.text :files
+
+module ActivestorageDelayed
+  class DelayedUpload < ActiveRecord::Base
+    self.table_name = 'activestorage_delayed_uploads'
+    attr_accessor :tmp_files
+
+    belongs_to :uploadable, polymorphic: true
+
+    before_save :parse_tmp_files
+    after_create_commit do
+      ActivestorageDelayed::DelayedUploaderJob.perform_later(id)
+    end
+
+    private
+
+    def parse_tmp_files
+      self.files = (tmp_files.is_a?(Array) ? tmp_files : [tmp_files]).select(&:present?).map do |file|
+        {
+          'io' => Base64.encode64(file.read),
+          'filename' => file.try(:original_filename) || File.basename(file.path),
+          'content_type' => file.try(:content_type) || Marcel::MimeType.for(file)
+        }
+      end.to_json
+    end
+  end
+end

data/lib/activestorage-delayed/railtie.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rails'
+module ActivestorageDelayed
+  class Railtie < ::Rails::Railtie
+    railtie_name :activestorage_delayed
+
+    config.after_initialize do |_app|
+      require_relative '../../initializers/upload_default_variation'
+    end
+  end
+end

data/lib/activestorage-delayed/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActivestorageDelayed
+  VERSION = '0.1.0'
+end

data/lib/activestorage_delayed.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'active_storage'
+require 'active_job'
+require 'activestorage-delayed/version'
+require 'activestorage-delayed/railtie'
+require 'activestorage-delayed/delayed_concern'
+require 'activestorage-delayed/delayed_uploader'
+require 'activestorage-delayed/delayed_uploader_job'
+require 'activestorage-delayed/models/delayed_upload'
+
+module ActivestorageDelayed
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: activestorage-delayed
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Owen Peredo Diaz
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activestorage
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby on Rails gem to upload activestorage files in background
+email:
+- owenperedo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/activestorage-delayed/delayed_concern.rb
+- lib/activestorage-delayed/delayed_uploader.rb
+- lib/activestorage-delayed/delayed_uploader_job.rb
+- lib/activestorage-delayed/models/delayed_upload.rb
+- lib/activestorage-delayed/railtie.rb
+- lib/activestorage-delayed/version.rb
+- lib/activestorage_delayed.rb
+homepage: https://github.com/owen2345/activestorage-delayed
+licenses: []
+metadata:
+  homepage_uri: https://github.com/owen2345/activestorage-delayed
+  source_code_uri: https://github.com/owen2345/activestorage-delayed
+  changelog_uri: https://github.com/owen2345/activestorage-delayed
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Ruby on Rails gem to upload activestorage files in background
+test_files: []