pg_cron 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f0af5c531c4a322d7ebb5e47372655ec43255307332bf0c7598e06da1aa4f071
+  data.tar.gz: c088b6bde067d9a7b1cb374def26313cef93b0d4429dcbea26835b1f355ae49b
+SHA512:
+  metadata.gz: 06a0c5a1d04197d4230759ddcc2cd952bcfb0095a057dc5495cd3a6c4781466e0e9e4ee664a524a540987251782853c36e5225d280a894877cf8775e70886827
+  data.tar.gz: 33fcf9a7ea6754a710476e04c542b37d58b177484a58781b09589c86e64070df7e2f4279c9a89ddfd3ad4c0b73a819b0b08244388842904959c52398ef31c4b5

data/.rubocop.yml

@@ -0,0 +1,25 @@
+AllCops:
+  TargetRubyVersion: 2.7
+  Exclude:
+    - 'spec/**/*'
+
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/Documentation:
+  Enabled: false
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,56 @@
+## [Unreleased]
+
+## [2.0.0] - 2026-08-04
+
+Restructured on F(x)'s model. Every change below is breaking; there is no
+upgrade path that does not touch existing job definitions.
+
+### Changed
+
+- **Definitions are versioned SQL, not YAML.** `db/pg_cron_jobs/<name>.yml`
+  becomes `db/cron/<name>_v<NN>.sql`, holding the `cron.schedule()` call
+  verbatim. A job's body was always SQL; YAML meant a SQL string inside a YAML
+  scalar, so nothing could syntax-check it, dollar-quoting had to survive two
+  levels of escaping, and it could not be dumped back out.
+- **Migration methods renamed and reshaped.** `schedule_pg_cron_job` /
+  `unschedule_pg_cron_job` / `update_pg_cron_job` become `create_cron_job` /
+  `drop_cron_job` / `update_cron_job`, taking F(x)'s arguments: `version:`,
+  `sql_definition:` (mutually exclusive) and `revert_to_version:`.
+- **The module is `PgCron` and the gem is `pg_cron`** (was `PgCronRails` /
+  `pg_cron_rails`).
+- **The adapter is split** into `Adapters::Postgres` plus `Connection`, `Jobs`
+  and `QueryExecutor`, matching F(x)'s layout.
+- **The generator is namespaced and versioned**: `rails g pg_cron:job NAME`.
+  Running it again for an existing job copies the current definition to the next
+  version and writes an update migration carrying `revert_to_version`.
+- `pg_cron:schedule_all_jobs` reads `db/cron/*_v*.sql` and schedules the HIGHEST
+  version of each job. Globbing filenames the old way scheduled every historical
+  version in turn and left whichever sorted last in place.
+
+### Added
+
+- **A schema dumper.** Scheduled jobs are written into `db/schema.rb` as
+  `create_cron_job` lines. Without this the schema was wrong rather than merely
+  incomplete: a `db:schema:load` database came up with every table and none of
+  the schedules, silently.
+- Reversibility. `CommandRecorder` inverts all three statements, and raises
+  `ActiveRecord::IrreversibleMigration` when a drop or update has no
+  `revert_to_version` instead of deleting the job.
+
+### Fixed
+
+- Definitions are executed as given rather than assembled by interpolating
+  values into a heredoc, where a job name or command containing a quote produced
+  broken SQL.
+- `update_cron_job` verifies the job exists first. `cron.schedule()` would
+  otherwise silently create one that was expected to be there, hiding a
+  migration applied out of order.
+
+## [1.0.1] - 2021-10-26
+
+- Fix PgCron manual configuration
+
+
+## [1.0.0] - 2021-10-19
+
+- Initial release

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in pg_cron.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,121 @@
+PATH
+  remote: .
+  specs:
+    pg_cron_rails (1.0.1)
+      activerecord (>= 6.0.0)
+      activesupport (>= 6.0.0)
+      railties (>= 6.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (6.1.4.1)
+      actionview (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+      rack (~> 2.0, >= 2.0.9)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actionview (6.1.4.1)
+      activesupport (= 6.1.4.1)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activemodel (6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activerecord (6.1.4.1)
+      activemodel (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activesupport (6.1.4.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    ast (2.4.2)
+    builder (3.2.4)
+    concurrent-ruby (1.1.9)
+    crass (1.0.6)
+    diff-lcs (1.4.4)
+    erubi (1.10.0)
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
+    loofah (2.12.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    method_source (1.0.0)
+    minitest (5.14.4)
+    nokogiri (1.12.5-arm64-darwin)
+      racc (~> 1.4)
+    parallel (1.21.0)
+    parser (3.0.2.0)
+      ast (~> 2.4.1)
+    pg (1.2.3)
+    racc (1.6.0)
+    rack (2.2.3)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.4.2)
+      loofah (~> 2.3)
+    railties (6.1.4.1)
+      actionpack (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+      method_source
+      rake (>= 0.13)
+      thor (~> 1.0)
+    rainbow (3.0.0)
+    rake (13.0.6)
+    regexp_parser (2.1.1)
+    rexml (3.2.5)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-rails (5.0.2)
+      actionpack (>= 5.2)
+      activesupport (>= 5.2)
+      railties (>= 5.2)
+      rspec-core (~> 3.10)
+      rspec-expectations (~> 3.10)
+      rspec-mocks (~> 3.10)
+      rspec-support (~> 3.10)
+    rspec-support (3.10.2)
+    rubocop (1.22.1)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.12.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.12.0)
+      parser (>= 3.0.1.1)
+    ruby-progressbar (1.11.0)
+    thor (1.1.0)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.1.0)
+    zeitwerk (2.5.1)
+
+PLATFORMS
+  arm64-darwin-20
+
+DEPENDENCIES
+  bundler
+  pg
+  pg_cron_rails!
+  rake (~> 13.0)
+  rspec-rails
+  rubocop (~> 1.7)
+
+BUNDLED WITH
+   2.2.29

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Agendrix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+# pg_cron Rails
+[pg_cron](https://github.com/citusdata/pg_cron) jobs scheduling for Rails applications
+
+
+## Configuration
+
+By default, no configuration is needed to use this gem. 
+
+PgCron schedules your pg_cron jobs in the default PSQL database using your current database connection user.
+
+You can also customize PgCron database connection configuration by creating an initializer:
+```ruby
+PgCron.configure do |config|
+    config.connection_config =  {
+        username: username
+        password: password
+        database: database
+    }
+end
+```
+
+## Usage
+
+**Create pg_cron job**
+1. Generate a job:
+```bash
+rails generate pg_cron_job daily_vacuum
+      create  db/pg_cron_jobs/daily_vacuum.yml
+      create  db/migrate/[TIMESTAMP]_add_daily_vacuum_pg_cron_job.rb
+```
+
+2. Define `db/pg_cron_jobs/daily_vacuum.yml` job params. 
+```yml
+daily_vacuum:
+    cron: "3 5 * * *"
+    statement: "VACUUM VERBOSE ANALYZE"
+    database: <%= ActiveRecord::Base.connection.current_database %> # This parameter is optional
+```
+
+3. Run the migration
+
+```bash
+rails db:migrate
+```
+
+
+## Methods
+
+The methods added to `ActiveRecord::Migration` are defined in [PgCron::Statements](https://github.com/agendrix/pg-cron-rails/blob/main/lib/pg_cron/statements.rb)
+
+
+## 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,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "test"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/increment-version

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "erb"
+require_relative "../lib/pg_cron/version"
+
+USAGE = "Usage: bin/increment-version <major|minor|patch>"
+
+segment = ARGV[0]
+unless %w[major minor patch].include?(segment)
+  warn USAGE
+  exit 1
+end
+
+current = PgCron::VERSION
+major, minor, patch = current.split(".").map(&:to_i)
+
+case segment
+when "major" then major += 1; minor = 0; patch = 0
+when "minor" then minor += 1; patch = 0
+when "patch" then patch += 1
+end
+
+version = "#{major}.#{minor}.#{patch}"
+
+template_path = File.expand_path("../lib/pg_cron/version.rb.erb", __dir__)
+output_path   = File.expand_path("../lib/pg_cron/version.rb", __dir__)
+
+template = ERB.new(File.read(template_path))
+result = template.result(binding)
+
+
+File.write(output_path, result)
+
+`bundle install`
+
+puts "#{current} -> #{version}"

data/bin/release-gem

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/pg_cron/version"
+
+local_version = PgCron::VERSION
+gem_name = "pg_cron"
+gemspec = "pg_cron.gemspec"
+
+puts "Local version: #{local_version}"
+
+remote_output = `gem specification #{gem_name} version --remote 2>&1`
+
+if $?.success?
+  remote_version = remote_output[/version: (.+)/, 1]&.strip
+  puts "Remote version: #{remote_version}"
+
+  if Gem::Version.new(local_version) <= Gem::Version.new(remote_version)
+    abort "ERROR: Local version (#{local_version}) has not been incremented past remote (#{remote_version})"
+  end
+else
+  puts "Gem not yet published remotely, proceeding with first release"
+end
+
+puts "Building #{gemspec}..."
+system("gem build #{gemspec}") || abort("ERROR: gem build failed")
+
+gem_file = "#{gem_name}-#{local_version}.gem"
+puts "Pushing #{gem_file}..."
+system("gem push #{gem_file}") || abort("ERROR: gem push failed")
+
+puts "Released #{gem_name} #{local_version}"

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/generators/pg_cron/job/USAGE

@@ -0,0 +1,19 @@
+Description:
+    Create a new pg_cron job for your application. This will create a new job
+    definition file and the accompanying migration.
+
+    Run it again for an existing job to start the next version from the current
+    definition; the migration it writes is an update with revert_to_version set.
+
+    When --no-migration is passed, skips generating a migration.
+
+Examples:
+    rails generate pg_cron:job drain_juicefs_events
+
+      create: db/cron/drain_juicefs_events_v01.sql
+      create: db/migrate/[TIMESTAMP]_create_cron_job_drain_juicefs_events.rb
+
+    rails generate pg_cron:job drain_juicefs_events   # a second time
+
+      create: db/cron/drain_juicefs_events_v02.sql
+      create: db/migrate/[TIMESTAMP]_update_cron_job_drain_juicefs_events_to_version_2.rb

data/lib/generators/pg_cron/job/job_generator.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+require "generators/pg_cron/version_helper"
+require "generators/pg_cron/migration_helper"
+require "generators/pg_cron/name_helper"
+
+module PgCron
+  module Generators
+    # Generates a cron job definition and its migration.
+    #
+    #   rails generate pg_cron:job drain_juicefs_events
+    #
+    # Structured exactly as Fx::Generators::FunctionGenerator: the same
+    # class_option, the same three phases (directory, definition, migration),
+    # and the same versioning behaviour — running it again for an existing job
+    # COPIES the previous definition to the next version rather than creating an
+    # empty file, so an edit starts from what is currently deployed and the
+    # migration it writes is an update with revert_to_version set.
+    #
+    # @api private
+    class JobGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      DEFINITION_PATH = %w[db cron].freeze
+
+      class_option :migration, type: :boolean
+
+      def create_cron_directory
+        return if job_definition_path.exist?
+
+        empty_directory(job_definition_path)
+      end
+
+      def create_job_definition
+        if version_helper.creating_new?
+          create_file(definition.path)
+        else
+          copy_file(previous_definition.full_path, definition.full_path)
+        end
+      end
+
+      def create_migration_file
+        return if migration_helper.skip_creation?
+
+        template_info = migration_helper.migration_template_info(
+          file_name: file_name,
+          updating_existing: version_helper.updating_existing?,
+          version: version_helper.current_version
+        )
+
+        migration_template(
+          template_info.fetch(:template),
+          template_info.fetch(:filename)
+        )
+      end
+
+      def self.next_migration_number(dir)
+        ::ActiveRecord::Generators::Base.next_migration_number(dir)
+      end
+
+      no_tasks do
+        def previous_version
+          version_helper.previous_version
+        end
+
+        def version
+          version_helper.current_version
+        end
+
+        def migration_class_name
+          if version_helper.updating_existing?
+            migration_helper.update_migration_class_name(
+              class_name: class_name,
+              version: version
+            )
+          else
+            super
+          end
+        end
+
+        def formatted_name
+          PgCron::Generators::NameHelper.format_for_migration(singular_name)
+        end
+      end
+
+      private
+
+      def job_definition_path
+        @_job_definition_path ||= Rails.root.join(*DEFINITION_PATH)
+      end
+
+      def version_helper
+        @_version_helper ||= PgCron::Generators::VersionHelper.new(
+          file_name: file_name,
+          definition_path: job_definition_path
+        )
+      end
+
+      def migration_helper
+        @_migration_helper ||= PgCron::Generators::MigrationHelper.new(options)
+      end
+
+      def definition
+        version_helper.definition_for_version(version: version)
+      end
+
+      def previous_definition
+        version_helper.definition_for_version(version: previous_version)
+      end
+    end
+  end
+end

data/lib/generators/pg_cron/job/templates/db/migrate/create_job.erb

@@ -0,0 +1,5 @@
+class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_cron_job <%= formatted_name %>
+  end
+end

data/lib/generators/pg_cron/job/templates/db/migrate/update_job.erb

@@ -0,0 +1,5 @@
+class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    update_cron_job <%= formatted_name %>, version: <%= version %>, revert_to_version: <%= previous_version %>
+  end
+end

data/lib/generators/pg_cron/migration_helper.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PgCron
+  module Generators
+    # Chooses the migration template and filename.
+    #
+    # Copied from Fx::Generators::MigrationHelper, minus the object_type
+    # argument: this gem has one kind of object, so the templates are named
+    # create_job / update_job rather than being interpolated per type.
+    #
+    # @api private
+    class MigrationHelper
+      def initialize(options)
+        @options = options
+      end
+
+      def skip_creation?
+        !should_create_migration?
+      end
+
+      def update_migration_class_name(class_name:, version:)
+        "UpdateCronJob#{class_name}ToVersion#{version}"
+      end
+
+      def migration_template_info(file_name:, updating_existing:, version:)
+        if updating_existing
+          {
+            template: "db/migrate/update_job.erb",
+            filename: "db/migrate/update_cron_job_#{file_name}_to_version_#{version}.rb"
+          }
+        else
+          {
+            template: "db/migrate/create_job.erb",
+            filename: "db/migrate/create_cron_job_#{file_name}.rb"
+          }
+        end
+      end
+
+      private
+
+      attr_reader :options
+
+      def should_create_migration?
+        options.fetch(:migration, true)
+      end
+    end
+  end
+end

data/lib/generators/pg_cron/name_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module PgCron
+  module Generators
+    # Formats a job name for use in a generated migration.
+    #
+    # Copied from Fx::Generators::NameHelper. F(x) quotes names containing a dot
+    # because a function or trigger can be schema-qualified; a pg_cron jobname
+    # is a plain string in cron.job and never is, but the same rule is kept so a
+    # name with a dot still produces valid Ruby rather than a stray constant.
+    #
+    # @api private
+    class NameHelper
+      def self.format_for_migration(name)
+        if name.include?(".")
+          "\"#{name}\""
+        else
+          ":#{name}"
+        end
+      end
+
+      def self.validate_and_format(name)
+        raise ArgumentError, "Name cannot be blank" if name.blank?
+
+        format_for_migration(name)
+      end
+    end
+  end
+end