active_denormalize 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 148b91bf184914f2ed121d72c24e47e6128d9de79bf79b0d6e89aee87b846071
+  data.tar.gz: 5156b8a2066c0767fb2ae3f75f1b86f17435e7247d16683c81750c1a72613b14
+SHA512:
+  metadata.gz: 860141aa31a24db2981ada37c98f6ac806e9ee4ad22c71f4f4ed59c82f7b02c24efa69d33661f7e16544738d8071348f918101fe5fa032f10d6acff4ca005ee6
+  data.tar.gz: 61f6c010ced24e1e17783f34bfa11d713f2207a3b16ff35769b35500c3e802768b65185293612e5f7dc048e195a089f52d858b90c106ae318195a185aa1e07c0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2023 Garrett Bjerkhoel
+
+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,109 @@
+# ActiveDenormalize
+
+ActiveDenormalize is a gem that allows you to denormalize data across your ActiveRecord models. It currently supports `belongs_to` relationships.
+
+Below is a simple example which you can use to get started (and mostly until further documentation is added in this README).
+
+```ruby
+class Product < ApplicationRecord
+  has_many :inventory_checks
+end
+
+class InventoryCheck < ApplicationRecord
+  belongs_to :product, denormalize: true
+end
+```
+
+ActiveDenormalize works by adding create, update, and destroy `after_*_commit` callbacks to the host model, in this case InventoryCheck, which will update the denormalized attributes on the Product model.
+
+To know which attributes to denormalize on to the Product model, ActiveDenormalize will look for `inventory_check` prefixed columns on the Product model. For example, if you have a `inventory_check_id` column on the Product model, ActiveDenormalize will update that column with the ID of most recent InventoryCheck record that belong to the Product.
+
+```ruby
+# No InventoryCheck has been created yet
+> product = Product.create(name: "Product 1")
+> product.inventory_check_id
+=> nil
+> product.inventory_check_created_at
+=> nil
+> product.inventory_check_status
+=> nil
+> product.inventory_check_denormalized_at
+=> nil
+
+# Updates the Product record to know about the newest InventoryCheck
+> first_inventory_check = InventoryCheck.create(product: product, status: "backordered")
+> first_inventory_check.id
+=> 1
+> product.reload.inventory_check_id
+=> 1
+> product.inventory_check_created_at
+=> Sun, 17 Sep 2023 17:28:13.674818427 UTC +00:00
+> product.inventory_check_status
+=> "backordered"
+> product.inventory_check_denormalized_at
+=> Sun, 17 Sep 2023 17:28:13.674818427 UTC +00:00
+
+# Updates the Product record to know about the newest InventoryCheck
+> second_inventory_check = InventoryCheck.create(product: product, status: "available")
+> second_inventory_check.id
+=> 2
+> product.reload.inventory_check_id
+=> 2
+> product.inventory_check_created_at
+=> Sun, 17 Sep 2023 17:28:53.903842001 UTC +00:00
+> product.inventory_check_status
+=> "available"
+> product.inventory_check_denormalized_at
+=> Sun, 17 Sep 2023 17:28:53.903842001 UTC +00:00
+> second_inventory_check.destroy
+
+# Reverts to the previous InventoryCheck record
+> product.reload.inventory_check_id
+=> 1
+> product.inventory_check_created_at
+=> Sun, 17 Sep 2023 17:28:13.674818427 UTC +00:00
+> product.inventory_check_status
+=> "backordered"
+> product.inventory_check_denormalized_at
+=> Sun, 17 Sep 2023 17:28:13.674818427 UTC +00:00
+
+# Updates the denormalized representation of the InventoryCheck on Product
+> first_inventory_check.update!(status: "available")
+> product.reload.inventory_check_id
+=> 1
+> product.inventory_check_created_at
+=> Sun, 17 Sep 2023 17:28:13.674818427 UTC +00:00
+> product.inventory_check_status
+=> "available"
+> product.inventory_check_denormalized_at # This timestamp will be updated
+=> Sun, 17 Sep 2023 17:31:16.388224345 UTC +00:00
+```
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "active_denormalize"
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install active_denormalize
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/active_denormalize. 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]/active_denormalize/blob/main/CODE_OF_CONDUCT.md).
+
+## 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/active_denormalize/associations/extension.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ActiveDenormalize
+  module Associations
+    module Extension
+      OPTIONS = [:denormalize].freeze
+
+      def self.build(model, reflection)
+        return unless reflection.options[:denormalize]
+
+        define_accessors(model, reflection)
+        add_after_commit_callback(model, reflection)
+      end
+
+      def self.valid_options
+        OPTIONS
+      end
+
+      def self.define_accessors(model, reflection)
+        denormalized_column_prefix = model.model_name.singular
+        target_mixin = reflection.klass.generated_association_methods
+
+        target_mixin.class_eval do
+          define_method("clear_denormalized_#{denormalized_column_prefix}") do
+            denormalized_columns = model.denormalized_column_mapping.keys & self.class.column_names
+            cleared_denormalized_attributes = denormalized_columns.index_with { |_column| nil }
+            update!(cleared_denormalized_attributes)
+          end
+        end
+
+        model.class_eval do
+          # Needed to lookup the next valid record to denormalize when destroying the latest record.
+          scope :denormalize, -> {}
+
+          def denormalize?
+            true
+          end
+
+          def denormalize(target)
+            denormalized_columns = self.class.denormalized_column_mapping.keys & target.class.column_names
+            attributes = denormalized_columns.to_h do |denormalized_column|
+              column = self.class.denormalized_column_mapping[denormalized_column]
+
+              if column == "denormalized_at"
+                [denormalized_column, Time.zone.now]
+              else
+                value = send(column)
+                if (enum_mapping = defined_enums[column])
+                  value = enum_mapping.fetch(value)
+                end
+
+                [denormalized_column, value]
+              end
+            end
+
+            if attributes.empty?
+              Rails.logger.debug { "No denormalized columns found for #{target.class}" }
+            else
+              Rails.logger.debug { "Denormalizing #{target.class} #{target.id} with #{attributes}" }
+              target.update!(attributes)
+            end
+          end
+
+          def self.denormalized_column_mapping
+            @denormalized_column_mapping ||= begin
+              prefix = model_name.singular
+
+              mapping = column_names.index_by do |column_name|
+                "#{prefix}_#{column_name}"
+              end
+              mapping["#{prefix}_denormalized_at"] = "denormalized_at"
+              mapping
+            end
+          end
+        end
+      end
+
+      def self.add_after_commit_callback(model, reflection)
+        denormalized_column_prefix = model.model_name.singular
+        denormalized_primary_key = "#{denormalized_column_prefix}_#{model.primary_key}"
+
+        model.before_destroy do
+          if (target = public_send(reflection.name))
+            primary_key = public_send(self.class.primary_key)
+            denormalized_primary_key_id = target.public_send(denormalized_primary_key)
+
+            # The record being destroyed is currently denormalized on its association and needs to be replaced
+            if denormalized_primary_key_id == primary_key
+              replacement = target.association(model.model_name.collection).scope.denormalize.where.not(id: primary_key).order(created_at: :desc).first
+              if replacement.present?
+                replacement.denormalize(target)
+              else
+                target.public_send("clear_denormalized_#{denormalized_column_prefix}")
+              end
+            end
+          end
+        end
+
+        model.after_create_commit do
+          if denormalize? && (target = public_send(reflection.name))
+            denormalize(target)
+          end
+        end
+
+        model.after_update_commit do
+          if (target = public_send(reflection.name))
+            primary_key = public_send(self.class.primary_key)
+            denormalized_primary_key_id = target.public_send(denormalized_primary_key)
+
+            # After an update of a denormalized record, check the association to see if it is still the current denormalized record or if it has changed.
+            denormalize(target) if denormalized_primary_key_id == primary_key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_denormalize/version.rb

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

data/lib/active_denormalize.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "active_denormalize/version"
+require "active_denormalize/associations/extension"
+
+ActiveRecord::Associations::Builder::Association.extensions << ActiveDenormalize::Associations::Extension

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: active_denormalize
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Garrett Bjerkhoel
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-09-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.6
+description: Description of ActiveDenormalize.
+email:
+- me@garrettbjerkhoel.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/active_denormalize.rb
+- lib/active_denormalize/associations/extension.rb
+- lib/active_denormalize/version.rb
+homepage: https://github.com/dewski/active_denormalize
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/dewski/active_denormalize
+  source_code_uri: https://github.com/dewski/active_denormalize
+  changelog_uri: https://github.com/dewski/active_denormalize/blob/main/CODE_OF_CONDUCT.md
+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.3.7
+signing_key:
+specification_version: 4
+summary: Summary of ActiveDenormalize.
+test_files: []