sqlite_backups 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5befa74d4c48692314c28f8ca62ba631a87faaff37c3ee83ee792267127bad8b
+  data.tar.gz: 04e12d29cc5c7285487fd63374d598d5d2e687c113f2dd560a556701d4a80d40
+SHA512:
+  metadata.gz: 6f610817967e118afb908977f1d14c06cacf0400ed9cb202792914181326430f6a8f219f4f8eb74990d04430c3d09d29035ca66ca9c03ce1972564dbbcd0a9b1
+  data.tar.gz: 6bd671346cc80c2a21a160d32e74b2d09a20a2b91645416edbeea89490979edd1b72e9177d36631b006d39d999e1054c43078e551b18f77b6c8d861851a5f207

data/README.md

@@ -0,0 +1,50 @@
+# SqliteBackups
+
+A dead simple Rails engine to backup your Sqlite databases utilizing Active
+Storage.
+
+## Usage
+
+To backup a database:
+```bash
+$ bin/rails backup:[database_name]
+```
+
+Alternatively, you can use a job:
+```ruby
+Backups::DatabaseJob.perform_later(database_name)
+Backups::AllJob.perform_later
+```
+
+To restore a database:
+```bash
+$ bin/rails restore:[database_name]
+```
+
+## Installation
+Add this line to your Gemfile:
+
+```ruby
+gem "sqlite_backups"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Then run the installer to copy over the migration and mount a route we use for
+restoring:
+```bash
+$ bin/rails backups:install
+```
+
+These are the available configuration options:
+
+```ruby
+config.backups.storage_service = :backups
+config.backups.retention = 1.day
+```
+
+## 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,8 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/app/controllers/backups/backups_controller.rb

@@ -0,0 +1,19 @@
+module Backups
+  class BackupsController < ActionController::Base
+    before_action :verify_token
+
+    def show
+      files = Backup.where(database: params[:name]).map do
+        { date: it.created_at, key: it.file.key }
+      end
+
+      render json: { name: params[:name], files: }
+    end
+
+    private
+
+    def verify_token
+      raise(ActiveRecord::RecordNotFound) unless Backups.valid_token?(params[:token])
+    end
+  end
+end

data/app/jobs/backups/all_job.rb

@@ -0,0 +1,9 @@
+module Backups
+  class AllJob < ApplicationJob
+    def perform
+      Backups.databases.each_key do |name|
+        DatabaseJob.perform_later(name)
+      end
+    end
+  end
+end

data/app/jobs/backups/application_job.rb

@@ -0,0 +1,4 @@
+module Backups
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/backups/database_job.rb

@@ -0,0 +1,7 @@
+module Backups
+  class DatabaseJob < ApplicationJob
+    def perform(name)
+      Create.new(name).run
+    end
+  end
+end

data/app/models/backups/application_record.rb

@@ -0,0 +1,5 @@
+module Backups
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/backups/backup.rb

@@ -0,0 +1,16 @@
+module Backups
+  class Backup < ApplicationRecord
+    self.table_name = "backups"
+
+    validates :database, inclusion: { in: Backups.databases.keys }
+
+    has_one_attached :file, service: Backups.storage_service, dependent: :purge_later
+
+    scope :expired,
+      -> { where(created_at: ..(Backups.retention || 1.day).ago) }
+
+    def formated_date
+      created_at.strftime("%Y-%m-%d_%H:%M")
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+Backups::Engine.routes.draw do
+  get "rails/backups/:name", to: "backups#show", as: :backup
+end

data/db/migrate/20250430005926_create_sqlite_backup_backups.rb

@@ -0,0 +1,9 @@
+class CreateSqliteBackupBackups < ActiveRecord::Migration[8.0]
+  def change
+    create_table :backups do |t|
+      t.string :database
+
+      t.timestamps
+    end
+  end
+end

data/lib/backups/create.rb

@@ -0,0 +1,50 @@
+module Backups
+  class Create
+    def initialize(name)
+      @name = name
+      @path = Backups.databases[name.to_s]
+      @key = SecureRandom.hex(16)
+    end
+
+    def run
+      execute_backup
+
+      Backup.create(database: name).tap do
+        it.file.attach(io: compressed_data, filename: key)
+        File.delete(backup_path)
+        File.delete("#{backup_path}.gz")
+      end
+
+      expire_old_backups
+    end
+
+    private
+
+    attr_reader :name, :path, :key
+
+    def execute_backup
+      `sqlite3 #{path} '.backup #{backup_path}'`
+    end
+
+    def compressed_data
+      gzip_path = "#{backup_path}.gz"
+      Zlib::GzipWriter.open(gzip_path) do |gz|
+        File.open(backup_path, "rb") do |f|
+          IO.copy_stream(f, gz)
+        end
+      end
+      File.open(gzip_path, "rb")
+    end
+
+    def backup_path
+      Rails.root.join("tmp/#{name}_backup_#{key}")
+    end
+
+    def expire_old_backups
+      Backup.where(database: name).expired.each do
+        it.file.purge
+        it.destroy
+      end
+    end
+  end
+end

data/lib/backups/engine.rb

@@ -0,0 +1,13 @@
+module Backups
+  class Engine < ::Rails::Engine
+    isolate_namespace Backups
+
+    config.backups = ActiveSupport::OrderedOptions.new
+
+    initializer "backups.config" do
+      config.backups.each do |name, value|
+        Backups.public_send(:"#{name}=", value)
+      end
+    end
+  end
+end

data/lib/backups/railtie.rb

@@ -0,0 +1,7 @@
+module Backups
+  class Railtie < Rails::Railtie # :nodoc:
+    rake_tasks do
+      load "backups/tasks.rake"
+    end
+  end
+end

data/lib/backups/restore.rb

@@ -0,0 +1,63 @@
+require "cli/ui"
+
+module Backups
+  class Restore
+    def initialize(name)
+      @name = name
+    end
+
+    def run
+      raise StandardError, "No backups found" if backups["files"].blank?
+      raise StandardError, "File not found" unless service.exist?(key)
+
+      File.open(path, "wb") do |file|
+        file.write(ActiveSupport::Gzip.decompress(service.download(key)))
+      end
+    end
+
+    private
+
+    attr_reader :name
+
+    def path
+      Backups.databases(env_name: Rails.env)[name.to_s]
+    end
+
+    def service
+      ActiveStorage::Blob.services.fetch(Backups.storage_service)
+    end
+
+    def token
+      Backups.generate_token
+    end
+
+    def key
+      @key ||=
+        if backups["files"].count == 1
+          backups["files"].first["key"]
+        else
+          CLI::UI.ask("Pick a backup to restore", options:).then do |date|
+            backups["files"].find { it["date"].to_s == date }["key"]
+          end
+        end
+    end
+
+    def options
+      backups[:files].pluck("date").map(&:to_s)
+    end
+
+    def uri
+      host = `RAILS_ENV=production bin/rails runner 'puts Rails.application.config.x.url'`
+      URI("#{host.strip}/rails/backups/#{name}").
+        tap { it.query = URI.encode_www_form(token:) }
+    end
+
+    def backups
+      @backups ||= begin
+        ActiveSupport.parse_json_times = true
+        ActiveSupport::JSON.
+          decode(Net::HTTP.get_response(uri).body).with_indifferent_access
+      end
+    end
+  end
+end

data/lib/backups/tasks.rake

@@ -0,0 +1,15 @@
+namespace :backup do
+  Rails.application.config_for(:database).keys.each do |name|
+    task name => :environment do
+      Backups::DatabaseJob.perform_later(name)
+    end
+  end
+end
+
+namespace :restore do
+  Rails.application.config_for(:database).keys.each do |name|
+    task name => :environment do
+      Backups::Restore.new(name).run
+    end
+  end
+end

data/lib/backups/version.rb

@@ -0,0 +1,3 @@
+module Backups
+  VERSION = "0.1.0"
+end

data/lib/backups.rb

@@ -0,0 +1,36 @@
+require "backups/version"
+require "backups/engine"
+require "backups/railtie"
+require "backups/create"
+require "backups/restore"
+
+module Backups
+  mattr_accessor :retention, :storage_service
+
+  class << self
+    def databases(env_name: "production")
+      ActiveRecord::Base.
+        configurations.
+        configs_for(env_name: env_name).
+        to_h { [ it.name, it.database ] }
+    end
+
+    def generate_token
+      verifier.generate(
+        SecureRandom.hex(16), expires_in: 5.minutes, purpose: :fetch_backups
+      )
+    end
+
+    def valid_token?(token)
+      verifier.verify(token, purpose: :fetch_backups).present?
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      false
+    end
+
+    private
+
+    def verifier
+      Backup.generated_token_verifier
+    end
+  end
+end

data/lib/generators/backups/install/USAGE

@@ -0,0 +1,5 @@
+Description:
+    Installs migration and route
+
+Example:
+    bin/rails generate backups:install

data/lib/generators/backups/install/install_generator.rb

@@ -0,0 +1,9 @@
+class Backups::InstallGenerator < Rails::Generators::Base
+  def add_route
+    route "mount Backups::Engine => \"/\""
+  end
+
+  def create_migrations
+    rails_command "backups:install:migrations", inline: true
+  end
+end

data/lib/sqlite_backups.rb

@@ -0,0 +1 @@
+require "backups"

data/lib/tasks/backups_tasks.rake

@@ -0,0 +1,6 @@
+desc "Copy over the migrations and mount route for backups"
+namespace :backups do
+  task install: :environment do
+    Rails::Command.invoke :generate, [ "backups:install" ]
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: sqlite_backups
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nick Pezza
+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: 8.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.2
+- !ruby/object:Gem::Dependency
+  name: cli-ui
+  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'
+email:
+- pezza@hey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- app/controllers/backups/backups_controller.rb
+- app/jobs/backups/all_job.rb
+- app/jobs/backups/application_job.rb
+- app/jobs/backups/database_job.rb
+- app/models/backups/application_record.rb
+- app/models/backups/backup.rb
+- config/routes.rb
+- db/migrate/20250430005926_create_sqlite_backup_backups.rb
+- lib/backups.rb
+- lib/backups/create.rb
+- lib/backups/engine.rb
+- lib/backups/railtie.rb
+- lib/backups/restore.rb
+- lib/backups/tasks.rake
+- lib/backups/version.rb
+- lib/generators/backups/install/USAGE
+- lib/generators/backups/install/install_generator.rb
+- lib/sqlite_backups.rb
+- lib/tasks/backups_tasks.rake
+homepage: https://github.com/npezza93/sqlite_backup
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.8
+specification_version: 4
+summary: Simple sqlite backup for Rails
+test_files: []