fx-aggregate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e151a7544a00f2a530deac87732962dd53a23de1cede96e75ef638356bda8179
+  data.tar.gz: 3997927b6b491bbada4786486a96f83832be7e5dc6bd7f7a3d0ec69166507466
+SHA512:
+  metadata.gz: 041fa0fff61293ec4ed61020c3c5e6fe36b1300c3ce0ff885ae6679acb791b83b4c3ebb77139c7b06041bd5fea42db0236e786c32adb090007db65c6d11cb5ee
+  data.tar.gz: b53284c7853da505f78621622bd43e24043b273b07fca485244079e8675e1eb2cd36dc0658f1d8da3c90895b38b6a53bcdbdbd2291498a2dc9ee4e0f2ec3fc9e

data/.github/workflows/ci.yml

@@ -0,0 +1,53 @@
+name: CI
+
+on:
+  push:
+    branches: main
+  pull_request:
+    branches: "*"
+
+jobs:
+  tests:
+    name: Ruby ${{ matrix.ruby }}, Rails ${{ matrix.rails }}
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ["3.0", "3.1", "3.2", "3.3", "3.4"]
+        rails: ["7.0", "7.1", "7.2", "8.0.0"]
+        continue-on-error: [false]
+
+    services:
+      postgres:
+        image: postgres:13
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_HOST_AUTH_METHOD: trust
+        ports:
+          - 5432:5432
+        # Set health checks to wait until postgres has started
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    env:
+      POSTGRES_USER: postgres
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+          rubygems: latest
+
+      - name: Setup environment
+        run: bin/setup
+
+      - name: Run tests
+        run: bundle exec rake

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+/Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.standard.yml

@@ -0,0 +1,3 @@
+ignore:
+  - 'spec/dummy/db/schema.rb'
+  - '**/tmp/*'

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.3.1

data/Gemfile

@@ -0,0 +1,16 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in fx-aggregate.gemspec
+gemspec
+
+gem "ammeter", ">= 1.1.3"
+gem "bundler", ">= 1.5"
+gem "database_cleaner"
+gem "pg"
+gem "pry"
+gem "rake"
+gem "redcarpet"
+gem "rspec", ">= 3.3"
+gem "standardrb"
+gem "yard"
+gem "warning"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Agustin
+
+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,44 @@
+# Fx::Aggregate
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/fx/aggregate`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fx-aggregate'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install fx-aggregate
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/fx-aggregate. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/fx-aggregate/blob/master/CODE_OF_CONDUCT.md).
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Fx::Aggregate project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/fx-aggregate/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,24 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "standard/rake"
+
+namespace :dummy do
+  require_relative "spec/dummy/config/application"
+  Dummy::Application.load_tasks
+end
+
+task(:spec).clear
+desc "Run specs other than spec/acceptance"
+RSpec::Core::RakeTask.new("spec") do |task|
+  task.exclude_pattern = "spec/acceptance/**/*_spec.rb"
+  task.verbose = false
+end
+
+desc "Run acceptance specs in spec/acceptance"
+RSpec::Core::RakeTask.new("spec:acceptance") do |task|
+  task.pattern = "spec/acceptance/**/*_spec.rb"
+  task.verbose = false
+end
+
+desc "Run the specs and acceptance tests"
+task default: %w[spec spec:acceptance standard]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "fx-aggregate"
+
+# 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/rake

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/rspec

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/bin/setup

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+set -e
+
+gem install bundler --conservative
+bundle check || bundle install
+
+bundle exec rake dummy:db:drop
+bundle exec rake dummy:db:create

data/bin/standardrb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'standardrb' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("standard", "standardrb")

data/fx-aggregate.gemspec

@@ -0,0 +1,34 @@
+require_relative "lib/fx-aggregate/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "fx-aggregate"
+  spec.version = FxAggregate::VERSION
+  spec.authors = ["Agustin"]
+  spec.email = ["agustin@mailbutler.io"]
+
+  spec.summary = "An extension for the fx gem to manage PostgreSQL aggregate functions in Rails migrations."
+  spec.description = <<~DESCRIPTION
+    Adds methods to ActiveRecord::Migration to create and manage database aggregates
+    functions in Rails
+  DESCRIPTION
+  spec.homepage = "https://github.com/agustin/fx-aggregate"
+  spec.license = "MIT"
+
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+
+  spec.metadata = {
+    "bug_tracker_uri" => "#{spec.homepage}/issues",
+    "changelog_uri" => "#{spec.homepage}/blob/v#{spec.version}/CHANGELOG.md",
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage
+  }
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "fx", ">= 0.9"
+end

data/lib/fx-aggregate/adapters/postgres/aggregates.rb

@@ -0,0 +1,61 @@
+require "fx-aggregate/aggregate"
+
+module Fx
+  module Adapters
+    class Postgres
+      # Fetches defined aggregates from the postgres connection.
+      # @api private
+      class Aggregates
+        # The SQL query used by F(x) to retrieve the aggregates considered
+        # dumpable into `db/schema.rb`.
+        AGGREGATES_WITH_DEFINITIONS_QUERY = <<-EOS.freeze
+          SELECT
+              pp.proname AS name,
+              pg_get_function_identity_arguments(pp.oid) AS arguments,
+              pa.*,
+              format_type(pa.aggtranstype, null) AS aggtranstype,
+              format_type(pa.aggmtranstype, null) AS aggmtranstype
+          FROM pg_proc pp
+          JOIN pg_aggregate pa
+              ON pa.aggfnoid = pp.oid
+          JOIN pg_namespace pn
+              ON pn.oid = pp.pronamespace
+          LEFT JOIN pg_depend pd
+              ON pd.objid = pp.oid AND pd.deptype = 'e'
+          WHERE pn.nspname = 'public' AND pd.objid IS NULL
+          ORDER BY pp.oid;
+        EOS
+
+        # Wraps #all as a static facade.
+        #
+        # @return [Array<Fx::Aggregate>]
+        def self.all(*args)
+          new(*args).all
+        end
+
+        def initialize(connection)
+          @connection = connection
+        end
+
+        # All of the aggregates that this connection has defined.
+        #
+        # @return [Array<Fx::Aggregate>]
+        def all
+          aggregates_from_postgres.map { |aggregate| to_fx_aggregate(aggregate) }
+        end
+
+        private
+
+        attr_reader :connection
+
+        def aggregates_from_postgres
+          connection.execute(AGGREGATES_WITH_DEFINITIONS_QUERY)
+        end
+
+        def to_fx_aggregate(result)
+          Fx::Aggregate.new(result)
+        end
+      end
+    end
+  end
+end

data/lib/fx-aggregate/adapters/postgres.rb

@@ -0,0 +1,60 @@
+require "fx-aggregate/adapters/postgres/aggregates"
+
+module FxAggregate
+  module Adapters
+    module Postgres
+      # Returns an array of aggregates in the database.
+      #
+      # This collection of aggregates is used by the [Fx::SchemaDumper] to
+      # populate the `schema.rb` file.
+      #
+      # @return [Array<Fx::Aggregate>]
+      def aggregates
+        ::Fx::Adapters::Postgres::Aggregates.all(connection)
+      end
+
+      # Creates an aggregate in the database.
+      #
+      # This is typically called in a migration via
+      # {Fx::Statements::Aggregate#create_aggregate}.
+      #
+      # @param sql_definition The SQL schema for the aggregate.
+      #
+      # @return [void]
+      def create_aggregate(sql_definition)
+        execute(sql_definition)
+      end
+
+      # # Updates an aggregate in the database.
+      #
+      # This is typically called in a migration via
+      # {Fx::Statements::Aggregate#update_aggregate}.
+      #
+      # @param name The name of the aggregate.
+      # @param sql_definition The SQL schema for the aggregate.
+      #
+      # @return [void]
+      def update_aggregate(name, sql_definition)
+        drop_aggregate(name)
+        create_aggregate(sql_definition)
+      end
+
+      # Drops the aggregate from the database
+      #
+      # This is typically called in a migration via
+      # {Fx::Statements::Aggregate#drop_aggregate}.
+      #
+      # @param name The name of the aggregate to drop
+      #
+      # @return [void]
+      def drop_aggregate(name)
+        defs = aggregates.select { |aggregate| aggregate.name == name.to_s }
+
+        defs.each do |aggregate|
+          execute "DROP AGGREGATE #{name}(#{aggregate.arguments});"
+        end
+        # execute "DROP AGGREGATE #{name}();"
+      end
+    end
+  end
+end

data/lib/fx-aggregate/aggregate.rb

@@ -0,0 +1,75 @@
+module Fx
+  class Aggregate
+    include Comparable
+
+    attr_reader :name, :arguments, :definition
+    delegate :<=>, to: :name
+
+    def initialize(aggregate_row)
+      @name = aggregate_row.fetch("name")
+      @arguments = aggregate_row.fetch("arguments", "")
+      @definition = aggregate_row.except("name", "arguments")
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        name == other.name &&
+        arguments == other.arguments &&
+        definition == other.definition
+    end
+
+    def to_schema
+      <<-SCHEMA
+  create_aggregate :#{name}, sql_definition: <<-\SQL
+    CREATE AGGREGATE #{name}(#{arguments})(
+      #{options_for_create_statement.join(",\n").indent(6).lstrip}
+    );
+  SQL
+      SCHEMA
+    end
+
+    private
+
+    Field = Struct.new(:option, :type)
+    private_constant :Field
+
+    # Maps pg_aggregate columns to their definition field and type.
+    FIELDS = {
+      "aggtransfn" => Field.new("SFUNC", "raw"),
+      "aggtranstype" => Field.new("STYPE", "raw"),
+      "aggtransspace" => Field.new("SSPACE", "int"),
+      "aggfinalfn" => Field.new("FINALFUNC", "raw"),
+      "aggfinalextra" => Field.new("FINALFUNC_EXTRA", "bool"),
+      "agginitval" => Field.new("INITCOND", "string")
+    }.freeze
+
+    def options_for_create_statement
+      FIELDS.map do |key, field|
+        value = format_value(field.type, @definition[key])
+        next if !value
+
+        if value == true
+          field.option
+        else
+          "#{field.option} = #{value}"
+        end
+      end.compact
+    end
+
+    def format_value(type, value)
+      return if value.nil?
+      return if value == "-"
+
+      case type
+      when "bool"
+        return value == "t"
+      when "int"
+        return if value.to_i == 0
+      when "string"
+        return "'#{value}'"
+      end
+
+      value
+    end
+  end
+end

data/lib/fx-aggregate/command_recorder.rb

@@ -0,0 +1,27 @@
+module FxAggregate
+  module CommandRecorder
+    def create_aggregate(*args)
+      record(:create_aggregate, args)
+    end
+
+    def drop_aggregate(*args)
+      record(:drop_aggregate, args)
+    end
+
+    def update_aggregate(*args)
+      record(:update_aggregate, args)
+    end
+
+    def invert_create_aggregate(args)
+      [:drop_aggregate, args]
+    end
+
+    def invert_drop_aggregate(args)
+      perform_inversion(:create_aggregate, args)
+    end
+
+    def invert_update_aggregate(args)
+      perform_inversion(:update_aggregate, args)
+    end
+  end
+end

data/lib/fx-aggregate/definition.rb

@@ -0,0 +1,15 @@
+module FxAggregate
+  module Definition
+    AGGREGATE = "aggregate".freeze
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def aggregate(name:, version:)
+        new(name: name, version: version, type: AGGREGATE)
+      end
+    end
+  end
+end

data/lib/fx-aggregate/railtie.rb

@@ -0,0 +1,15 @@
+require "rails/railtie"
+
+module FxAggregate
+  # Automatically initializes Fx in the context of a Rails application when
+  # ActiveRecord is loaded.
+  #
+  # @see Fx.load
+  class Railtie < Rails::Railtie
+    initializer "fx-aggregate.load", after: "fx.load" do
+      ActiveSupport.on_load :active_record do
+        FxAggregate.load
+      end
+    end
+  end
+end

data/lib/fx-aggregate/schema_dumper.rb

@@ -0,0 +1,24 @@
+module FxAggregate
+  module SchemaDumper
+    def tables(stream)
+      super
+      aggregates(stream)
+    end
+
+    private
+
+    def aggregates(stream)
+      if dumpable_aggregates_in_database.any?
+        stream.puts
+      end
+
+      dumpable_aggregates_in_database.each do |aggregate|
+        stream.puts(aggregate.to_schema)
+      end
+    end
+
+    def dumpable_aggregates_in_database
+      @_dumpable_aggregates_in_database ||= Fx.database.aggregates
+    end
+  end
+end

data/lib/fx-aggregate/statements.rb

@@ -0,0 +1,104 @@
+module FxAggregate
+  module Statements
+    # Create a new database aggregate.
+    #
+    # @param name [String, Symbol] The name of the database aggregate.
+    # @param version [Fixnum] The version number of the aggregate, used to
+    #   find the definition file in `db/aggregates`. This defaults to `1` if
+    #   not provided.
+    # @param sql_definition [String] The SQL query for the aggregate schema.
+    #   If both `sql_definition` and `version` are provided,
+    #   `sql_definition` takes prescedence.
+    # @return The database response from executing the create statement.
+    #
+    # @example Create from `db/aggregates/median_v2.sql`
+    #   create_aggregate(:median, version: 2)
+    #
+    # @example Create from provided SQL string
+    #   create_aggregate(:median, sql_definition: <<-SQL)
+    #     CREATE AGGREGATE median(NUMERIC)(
+    #       SFUNC = array_append,
+    #       STYPE = NUMERIC[],
+    #       FINALFUNC = array_median,
+    #       INITCOND = '{}'
+    #     )
+    #   SQL
+    #
+    def create_aggregate(name, options = {})
+      version = options.fetch(:version, 1)
+      sql_definition = options[:sql_definition]
+
+      if version.nil? && sql_definition.nil?
+        raise(
+          ArgumentError,
+          "version or sql_definition must be specified"
+        )
+      end
+
+      sql_definition = sql_definition.strip_heredoc if sql_definition
+      sql_definition ||= Fx::Definition.aggregate(name: name, version: version).to_sql
+
+      Fx.database.create_aggregate(sql_definition)
+    end
+
+    # Drop a database aggregate by name.
+    #
+    # @param name [String, Symbol] The name of the database aggregate.
+    # @param revert_to_version [Fixnum] Used to reverse the `drop_aggregate`
+    #   command on `rake db:rollback`. The provided version will be passed as
+    #   the `version` argument to {#create_aggregate}.
+    # @return The database response from executing the drop statement.
+    #
+    # @example Drop a aggregate, rolling back to version 2 on rollback
+    #   drop_aggregate(:median, revert_to_version: 2)
+    #
+    def drop_aggregate(name, options = {})
+      Fx.database.drop_aggregate(name)
+    end
+
+    # Update a database aggregate.
+    #
+    # @param name [String, Symbol] The name of the database aggregate.
+    # @param version [Fixnum] The version number of the aggregate, used to
+    #   find the definition file in `db/aggregates`. This defaults to `1` if
+    #   not provided.
+    # @param sql_definition [String] The SQL query for the aggregate schema.
+    #   If both `sql_definition` and `version` are provided,
+    #   `sql_definition` takes prescedence.
+    # @return The database response from executing the create statement.
+    #
+    # @example Update aggregate to a given version
+    #   update_aggregate(
+    #     :median,
+    #     version: 3,
+    #     revert_to_version: 2,
+    #   )
+    #
+    # @example Update aggregate from provided SQL string
+    #   update_aggregate(:median, sql_definition: <<-SQL)
+    #     CREATE AGGREGATE median(NUMERIC)(
+    #       SFUNC = array_append,
+    #       STYPE = NUMERIC[],
+    #       FINALFUNC = array_median,
+    #       INITCOND = '{}'
+    #     )
+    #   SQL
+    #
+    def update_aggregate(name, options = {})
+      version = options[:version]
+      sql_definition = options[:sql_definition]
+
+      if version.nil? && sql_definition.nil?
+        raise(
+          ArgumentError,
+          "version or sql_definition must be specified"
+        )
+      end
+
+      sql_definition = sql_definition.strip_heredoc if sql_definition
+      sql_definition ||= Fx::Definition.aggregate(name: name, version: version).to_sql
+
+      Fx.database.update_aggregate(name, sql_definition)
+    end
+  end
+end

data/lib/fx-aggregate/version.rb

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

data/lib/fx-aggregate.rb

@@ -0,0 +1,22 @@
+require "fx"
+
+require "fx-aggregate/version"
+require "fx-aggregate/adapters/postgres"
+require "fx-aggregate/aggregate"
+require "fx-aggregate/command_recorder"
+require "fx-aggregate/definition"
+require "fx-aggregate/statements"
+require "fx-aggregate/schema_dumper"
+require "fx-aggregate/railtie"
+
+module FxAggregate
+  def self.load
+    Fx::Adapters::Postgres.include(FxAggregate::Adapters::Postgres)
+    Fx::CommandRecorder.include(FxAggregate::CommandRecorder)
+    Fx::Definition.include(FxAggregate::Definition)
+    Fx::SchemaDumper.include(FxAggregate::SchemaDumper)
+    Fx::Statements.include(FxAggregate::Statements)
+
+    true
+  end
+end

data/lib/generators/fx/aggregate/USAGE

@@ -0,0 +1,10 @@
+Description:
+  Create a new database aggregate for your application. This will create a new aggregate definition file and the accompanying migration.
+
+  When --no-migration is passed, skips generating a migration.
+
+Examples:
+    rails generate fx:aggregate test
+
+      create: db/aggregates/test_v01.sql
+      create: db/migrate/[TIMESTAMP]_create_test_aggregate.rb

data/lib/generators/fx/aggregate/aggregate_generator.rb

@@ -0,0 +1,120 @@
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Fx
+  module Generators
+    # @api private
+    class AggregateGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::Migration
+      source_root File.expand_path("../templates", __FILE__)
+
+      class_option :migration, type: :boolean
+
+      def create_aggregates_directory
+        unless aggregate_definition_path.exist?
+          empty_directory(aggregate_definition_path)
+        end
+      end
+
+      def create_aggregate_definition
+        if creating_new_aggregate?
+          create_file definition.path
+        else
+          copy_file previous_definition.full_path, definition.full_path
+        end
+      end
+
+      def create_migration_file
+        return if skip_migration_creation?
+        if updating_existing_aggregate?
+          migration_template(
+            "db/migrate/update_aggregate.erb",
+            "db/migrate/update_aggregate_#{file_name}_to_version_#{version}.rb"
+          )
+        else
+          migration_template(
+            "db/migrate/create_aggregate.erb",
+            "db/migrate/create_aggregate_#{file_name}.rb"
+          )
+        end
+      end
+
+      def self.next_migration_number(dir)
+        ::ActiveRecord::Generators::Base.next_migration_number(dir)
+      end
+
+      no_tasks do
+        def previous_version
+          @_previous_version ||= Dir.entries(aggregate_definition_path)
+            .map { |name| version_regex.match(name).try(:[], "version").to_i }
+            .max
+        end
+
+        def version
+          @_version ||= previous_version.next
+        end
+
+        def migration_class_name
+          if updating_existing_aggregate?
+            "UpdateAggregate#{class_name}ToVersion#{version}"
+          else
+            super
+          end
+        end
+
+        def activerecord_migration_class
+          if ActiveRecord::Migration.respond_to?(:current_version)
+            "ActiveRecord::Migration[#{ActiveRecord::Migration.current_version}]"
+          else
+            "ActiveRecord::Migration"
+          end
+        end
+
+        def formatted_name
+          if singular_name.include?(".")
+            "\"#{singular_name}\""
+          else
+            ":#{singular_name}"
+          end
+        end
+      end
+
+      private
+
+      def aggregate_definition_path
+        @_aggregate_definition_path ||= Rails.root.join(*%w[db aggregates])
+      end
+
+      def version_regex
+        /\A#{file_name}_v(?<version>\d+)\.sql\z/
+      end
+
+      def updating_existing_aggregate?
+        previous_version > 0
+      end
+
+      def creating_new_aggregate?
+        previous_version == 0
+      end
+
+      def definition
+        Fx::Definition.new(name: file_name, version: version, type: "aggregate")
+      end
+
+      def previous_definition
+        Fx::Definition.new(name: file_name, version: previous_version, type: "aggregate")
+      end
+
+      # Skip creating migration file if:
+      #   - migrations option is nil or false
+      def skip_migration_creation?
+        !migration
+      end
+
+      # True unless explicitly false
+      def migration
+        options[:migration] != false
+      end
+    end
+  end
+end

data/lib/generators/fx/aggregate/templates/db/migrate/create_aggregate.erb

@@ -0,0 +1,5 @@
+class <%= migration_class_name %> < <%= activerecord_migration_class %>
+  def change
+    create_aggregate <%= formatted_name %>
+  end
+end

data/lib/generators/fx/aggregate/templates/db/migrate/update_aggregate.erb

@@ -0,0 +1,5 @@
+class <%= migration_class_name %> < <%= activerecord_migration_class %>
+  def change
+    update_aggregate <%= formatted_name %>, version: <%= version %>, revert_to_version: <%= previous_version %>
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: fx-aggregate
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Agustin
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-01-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: |
+  Adds methods to ActiveRecord::Migration to create and manage database aggregates
+  functions in Rails
+email:
+- agustin@mailbutler.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".standard.yml"
+- ".tool-versions"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/rake
+- bin/rspec
+- bin/setup
+- bin/standardrb
+- fx-aggregate.gemspec
+- lib/fx-aggregate.rb
+- lib/fx-aggregate/adapters/postgres.rb
+- lib/fx-aggregate/adapters/postgres/aggregates.rb
+- lib/fx-aggregate/aggregate.rb
+- lib/fx-aggregate/command_recorder.rb
+- lib/fx-aggregate/definition.rb
+- lib/fx-aggregate/railtie.rb
+- lib/fx-aggregate/schema_dumper.rb
+- lib/fx-aggregate/statements.rb
+- lib/fx-aggregate/version.rb
+- lib/generators/fx/aggregate/USAGE
+- lib/generators/fx/aggregate/aggregate_generator.rb
+- lib/generators/fx/aggregate/templates/db/migrate/create_aggregate.erb
+- lib/generators/fx/aggregate/templates/db/migrate/update_aggregate.erb
+homepage: https://github.com/agustin/fx-aggregate
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/agustin/fx-aggregate/issues
+  changelog_uri: https://github.com/agustin/fx-aggregate/blob/v0.1.0/CHANGELOG.md
+  homepage_uri: https://github.com/agustin/fx-aggregate
+  source_code_uri: https://github.com/agustin/fx-aggregate
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: An extension for the fx gem to manage PostgreSQL aggregate functions in Rails
+  migrations.
+test_files: []