nulogy_message_bus_producer 2.0.0 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 270f095b931c9560de5dc65248349f1efe633f2bfd9a6771691d861feff8b09d
-  data.tar.gz: 0b8b4786d163434c1cdb5821544ff5f07cd9f4ee1149dd5da75099b411b939ed
+  metadata.gz: b81166f96e6dc18fa79dcd9a3d5fd56785e929866c9f6c2bf1571c3b7ca3965d
+  data.tar.gz: e0d7c148e751180d9f336146a17cb56b343d9459af5f436a452a4af4649904d3
 SHA512:
-  metadata.gz: 05004d9c4bd4741eb554836d0e5e29fb7456ac9842c62f9627ebde63d7c7aa28d3b00a0b5fc693b182d6e9a4810b56018410f16d834c717a8bed2060bfbb87b4
-  data.tar.gz: 41f41b4cc5c111c67ca7d23c0a4487843bca9aa024eded62293ea62eda533dc077299b1ca247ab477ee0359338d397bd18f6463f39da209b57b3548aca11e04d
+  metadata.gz: 9aaf43cc6e873323874a31baa272fcb00ac8b4792b9bead305510ea3f52ec236e5654c3bdcbf5630a3af1466530e434e20958d4134cf75df5cbaf8c16d8a4416
+  data.tar.gz: 33e75bf74472c78810a433036a9658736e9f4b6cb8d506092ffb631bd3a9092ed914be9bb5196783e83d95dcfbabb34b8d45cbdb964154121f95f5caa8f75f14

data/README.md

@@ -11,7 +11,7 @@ Nulogy's code for producing to to the Message Bus
 
 This engine contains the classes and validations for producing messages to the Message Bus.
 
-In general, as long as a subscription inherits from `NulogyMessageBusProducer::BasePublicSubscription`, everything
+In general, as long as a subscription inherits from `NulogyMessageBusProducer::BaseSubscription`, everything
 should be set up.
 
 Subscriptions will be written to the `NulogyMessageBusProducer.subscriptions_table_name` while events generated from the subscriptions will be written to
@@ -19,34 +19,207 @@ Subscriptions will be written to the `NulogyMessageBusProducer.subscriptions_tab
 
 ## Configuration
 
-| Configuration                  | Default                         | Description                                                  |
-|--------------------------------|---------------------------------|--------------------------------------------------------------|
-| subscriptions_table_name       | message_bus_subscriptions       | The name of the table for the PublicSubscription model       |
-| subscription_events_table_name | message_bus_subscription_events | The name of the table for the PublicSubscriptionEvents model |
+| Configuration                  | Default                         | Description                                                                                 |
+|--------------------------------|---------------------------------|---------------------------------------------------------------------------------------------|
+| context_for_subscription       | `->(_subscription) { {} }`        | A lambda used to inject any GraphQL Context to be used when producing subscription events |
+| producing_events_fails_with    | :raise                            | How the producer should handle errors when producing subscription events                  |
+| subscriptions_table_name       | "message_bus_subscriptions"       | The name of the table for the Subscription model                                          |
+| subscription_events_table_name | "message_bus_subscription_events" | The name of the table for the SubscriptionEvents model                                    |
 
 ## Setup
 
 You should configure the gem with an initializer. A recommended setup:
 
-```
+```ruby
 # Table names are configurable (optional)
-NulogyMessageBusProducer.subscriptions_table_name = :public_subscriptions
-NulogyMessageBusProducer.subscription_events_table_name = :public_subscription_events
+NulogyMessageBusProducer.subscriptions_table_name = :message_bus_subscriptions
+NulogyMessageBusProducer.subscription_events_table_name = :message_bus_subscription_events
 
 # Register known schemas
-NulogyMessageBusProducer.register_schema("example_domain", "ExampleDomain::Schema")
+NulogyMessageBusProducer.configure do |config|
+  config.register_schema(schema: "ExampleDomain::Schema", key: "exampleDomain")
+
+  config.context_for_subscription = lambda do |_subscription|
+    {
+      current_user: Current.user,
+      current_company: Current.company
+    }
+  end
+
+  # Can fail with either :soft_fail or :raise
+  # :raise will cause the application to halt when event generation fails.
+  # :soft_fail will allow the application to continue, even if generating events fails.
+  # Be very careful when deciding on the behaviour.
+  # Using :raise can result in the application being unusable if a subscription cannot be fulfilled.
+  # Using :soft_fail can result in missing messages, and a lack of consistency between applications.
+  config.producing_events_fails_with(:soft_fail) do |subscription_id:, context:, variables:, result:|
+    # Log in Airbrake / Honeybadger
+    ExceptionNotifier.tagged_message(
+      message: "Generating an event failed!",
+      context: {
+        subscription_id: subscription_id,
+        context: context,
+        variables: variables,
+        result: result
+      }
+    )
+  end
+end
 
 # It is *strongly* recommended to run this validation
-# It ensures the query in a subscription is valid agains the current schema
+# It ensures the query in a subscription is valid against the current schema
 # If you do not run this, a change to the schema could break the app
 # Note: ensure to register schemas before running this
 NulogyMessageBusProducer.validate_existing!
 ```
 
+Additionally, your GraphQL Schema will need to use `NulogyMessageBusProducer::Subscriptions::PostgresTransport`, `NulogyMessageBusProducer::Subscriptions::RiskySubscriptionBlocker` and expose subscriptions and queries for the objects to be integrated. Below is an example of how to expose `:sku_created` and `:sku_updated` events.
+```ruby
+module ExampleDomainPublicApi
+  class Schema < GraphQL::Schema
+    use NulogyMessageBusProducer::Subscriptions::PostgresTransport
+
+    # You must use the Interpreter, as it will be the new default.
+    # See more here: https://graphql-ruby.org/queries/interpreter
+    use GraphQL::Analysis::AST
+    use GraphQL::Execution::Interpreter
+
+    # This prevents subscriptions which contain arguments or expand lists form being registered.
+    # Expanding unbounded lists inside of an event may severely impact the performance of the system.
+    # Arguments are a source of variation that may not be appropriately tested.
+    # For now, these are banned until we have a use-case which would require them.
+    query_analyzer NulogyMessageBusProducer::Subscriptions::RiskySubscriptionBlocker
+
+    # This prevents creating subscriptions with variables.
+    # Since variables are not saved with the query,
+    # the Subscription would always fail when generating events.
+    query_analyzer NulogyMessageBusProducer::Subscriptions::NoVariables
+
+    query Types::QueryType
+    subscription Types::SubscriptionType
+  end
+end
+
+module ExampleDomainPublicApi
+  module Types
+    class QueryType < BaseObject
+      description "The query root for this schema"
+
+      field :sku, Types::SkuType, null: false do
+        argument :id, NulogyGraphqlApi::Types::UUID, required: true
+      end
+
+      def sku(id:)
+        Sku.find(id)
+      end
+    end
+  end
+end
+
+module ExampleDomainPublicApi
+  module Types
+    class SubscriptionType < Types::BaseObject
+      extend GraphQL::Subscriptions::SubscriptionRoot
+
+      description "The subscription root for this schema"
+
+      field :sku_created,
+        subscription: Subscriptions::SkuCreated,
+        description: "Event from creating a SKU. Tenancy is company.uuid"
+
+      field :sku_updated,
+        subscription: Subscriptions::SkuUpdated,
+        description: "Event from updating a SKU. Tenancy is company.uuid"
+    end
+  end
+end
+
+module ExampleDomainPublicApi
+  module Subscriptions
+    class SkuCreated < NulogyMessageBusProducer::BaseSubscription
+      field :sku, Types::SkuType, null: false
+    end
+  end
+end
+
+module ExampleDomainPublicApi
+  module Subscriptions
+    class SkuUpdated < NulogyMessageBusProducer::BaseSubscription
+      field :sku, Types::SkuType, null: false
+    end
+  end
+end
+
+module ExampleDomainPublicApi
+  module Types
+    class SkuType < Types::BaseType
+      field :code, GraphQL::Types::String, null: false
+
+      field :description, GraphQL::Types::String, null: true
+      field :setup_time, GraphQL::Types::Float, null: true
+      field :teardown_time, GraphQL::Types::Float, null: true
+    end
+  end
+end
+```
+
+Events would need to be triggered. Ideally, the underlying domain would be emitting domain events and the events would then be routed in the application layer to the GraphQL API. Where the domain is enemic, this could be done soley in the application layer. In either case, it needs to be invoked in the same transaction as the underlying service.
+```ruby
+class CreateSku
+  def initialize(company)
+    @company = company
+  end
+
+  def create(attrs)
+    sku = Sku.new(attrs.merge(company: company))
+
+    if sku.save
+      # This needs to be invoked within the same transaction as Sku.save
+      # Otherwise, the sku could be saved without the event being triggered
+      trigger_subscription("skuCreated", sku)
+    end
+  end
+
+  private
+
+  def trigger_subscription(event, entity)
+    object = {
+      uuid: entity.id,
+      company_uuid: entity.company_id,
+      context: {}
+    }
+
+    NulogyMessageBusProducer.trigger_event(ExampleDomainPublicApi::Schema, event, object)
+  end
+end
+```
+
+## Resending All Events to the Message Bus
+
+There is a rake task for resending all events that are currently in the producer's event tables to the message bus.
+It works by locking the table, deleting all of the events and re-inserting them. This ensures that order is preserved
+for both existing and newly created events. Unfortunately, the lock will halt most activity on the application server.
+
+```shell script
+# WARNING: THIS WILL LOCK THE EVENTS TABLE, AND BY EXTENSION ANY DOMAIN LOGIC WHICH EMITS EVENTS.
+# THIS IS INTENDED TO BE USED FOR DISASTER RECOVERY ONLY.
+
+rails message_bus_producer:repopulate_replication_slots
+```
+
 ## Rake Tasks
 
-| Rake command | Description    |
-|--------------|----------------|
-| (default)    | RSpec +RuboCop |
-| `spec`       | RSpec          |
-| `rubocop`    | RuboCop        |
+| Rake command | Description     |
+|--------------|-----------------|
+| (default)    | RSpec + RuboCop |
+| `spec`       | RSpec           |
+| `rubocop`    | RuboCop         |
+
+# Gem Development Setup
+
+If you are doing work on this gem you will want to:
+```shell script
+docker-compose up
+rake db:setup
+rake
+```

data/Rakefile

@@ -8,8 +8,6 @@ end
 APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
 load "rails/tasks/engine.rake"
 
-Bundler::GemHelper.install_tasks
-
 require "rspec/core"
 require "rspec/core/rake_task"
 
@@ -20,3 +18,9 @@ require "rubocop/rake_task"
 RuboCop::RakeTask.new
 
 task default: [:spec, :rubocop]
+
+require "rake/release"
+
+Rake::Release::Task.load_all do |spec|
+  spec.version_tag = "nulogy_message_bus_producer-v#{spec.version}"
+end

data/db/migrate/20201005150212_rename_tenant_id_and_public.rb

@@ -0,0 +1,6 @@
+class RenameTenantIdAndPublic < ActiveRecord::Migration[5.2]
+  def change
+    rename_column NulogyMessageBusProducer.subscription_events_table_name, :tenant_id, :company_uuid
+    rename_column NulogyMessageBusProducer.subscription_events_table_name, :public_subscription_id, :subscription_id
+  end
+end

data/lib/nulogy_message_bus_producer.rb

@@ -1,5 +1,4 @@
 require "graphql"
-require "strong_migrations"
 
 require "nulogy_message_bus_producer/config"
 require "nulogy_message_bus_producer/version"
@@ -15,39 +14,65 @@ module NulogyMessageBusProducer
   end
 
   def self.subscriptions_table_name=(table_name)
-    NulogyMessageBusProducer::PublicSubscription.table_name = table_name
+    NulogyMessageBusProducer::Subscription.table_name = table_name
   end
 
   def self.subscriptions_table_name
-    NulogyMessageBusProducer::PublicSubscription.table_name
+    NulogyMessageBusProducer::Subscription.table_name
   end
 
   def self.subscription_events_table_name=(table_name)
-    NulogyMessageBusProducer::PublicSubscriptionEvent.table_name = table_name
+    NulogyMessageBusProducer::SubscriptionEvent.table_name = table_name
   end
 
   def self.subscription_events_table_name
-    NulogyMessageBusProducer::PublicSubscriptionEvent.table_name
+    NulogyMessageBusProducer::SubscriptionEvent.table_name
   end
 
-  def self.resolve_schema(schema_key)
-    config.registered_schemas.fetch(schema_key) do
-      raise KeyError, <<~MESSAGE unless block_given?
+  def self.context_for_subscription(subscription)
+    config.context_for_subscription(subscription)
+  end
+
+  def self.trigger_event(schema, event_type, root_object)
+    schema_key = NulogyMessageBusProducer.resolve_schema_key(schema)
+    subscriptions = Subscription.where(event_type: event_type, schema_key: schema_key)
+
+    subscriptions.each do |subscription|
+      args = {
+        subscriptionId: subscription.id,
+        subscriptionGroupId: subscription.subscription_group_id,
+        topicName: subscription.topic_name
+      }
+      schema.subscriptions.trigger(event_type, args, root_object)
+    end
+  end
+
+  def self.resolve_schema(schema_key) # rubocop:disable Metrics/MethodLength
+    if config.registered_schemas.key?(schema_key)
+      config.registered_schemas[schema_key].constantize
+    elsif block_given?
+      yield
+    else
+      raise KeyError, <<~MESSAGE
         The schema registry did not contain an entry for the schema key '#{schema_key}'.
 
         Please register the schema first with `NulogyMessageBusProducer.schemas.register(schema_key, schema)`
-      MESSAGE
 
-      yield
-    end.constantize
+        Schemas Registered:
+        #{config.registered_schemas.pretty_inspect}
+      MESSAGE
+    end
   end
 
   def self.resolve_schema_key(schema)
-    config.registered_schemas.invert.fetch(schema.class.name) do
+    config.registered_schemas.invert.fetch(schema.name) do
       raise KeyError, <<~MESSAGE
-        The schema registry did not contain an entry for the schema '#{schema.class.name}'.
+        The schema registry did not contain an entry for the schema '#{schema.name}'.
 
         Please register the schema first with `NulogyMessageBusProducer.schemas.register(schema_key, schema)`
+
+        Schemas Registered:
+        #{config.registered_schemas.pretty_inspect}
       MESSAGE
     end
   end
@@ -62,7 +87,7 @@ module NulogyMessageBusProducer
     raise <<~MESSAGE
       #{"#" * 80}
 
-      The GraphQL queries stored in public_subscriptions.query must always remain valid against the current schema.
+      The GraphQL queries stored in subscriptions.query must always remain valid against the current schema.
       If one is not valid, a domain event firing could fail and users would not be able to perform critical duties
       (e.g. adding production).
 
@@ -101,7 +126,7 @@ module NulogyMessageBusProducer
           FROM pg_tables
           WHERE tablename = '#{NulogyMessageBusProducer.subscriptions_table_name}'
             AND schemaname = 'public';
-        SQL
+      SQL
     rescue # rubocop:disable Style/RescueStandardError
       false
     end
@@ -110,8 +135,11 @@ module NulogyMessageBusProducer
 end
 
 require "nulogy_message_bus_producer/application_record"
-require "nulogy_message_bus_producer/base_public_subscription"
-require "nulogy_message_bus_producer/postgres_public_subscriptions"
-require "nulogy_message_bus_producer/public_subscription"
-require "nulogy_message_bus_producer/public_subscription_event"
+require "nulogy_message_bus_producer/base_subscription"
+require "nulogy_message_bus_producer/subscription"
+require "nulogy_message_bus_producer/subscription_event"
+require "nulogy_message_bus_producer/repopulate_replication_slots"
 require "nulogy_message_bus_producer/subscriber_graphql_schema_validator"
+require "nulogy_message_bus_producer/subscriptions/postgres_transport"
+require "nulogy_message_bus_producer/subscriptions/no_variables"
+require "nulogy_message_bus_producer/subscriptions/risky_subscription_blocker"

data/lib/nulogy_message_bus_producer/{base_public_subscription.rb → base_subscription.rb}

@@ -5,7 +5,7 @@ module NulogyMessageBusProducer
   #  class AggregateRootCreated < NulogyMessageBusProducer::BasePublicSubscription
   #    field :aggregate_root, Domain::Public::Types::AggregateRootType, null: true
   #  end
-  class BasePublicSubscription < GraphQL::Schema::Subscription
+  class BaseSubscription < GraphQL::Schema::Subscription
     argument :subscription_id, ID, required: true
     argument :subscription_group_id, ID, required: true
     argument :topic_name, String, required: true

data/lib/nulogy_message_bus_producer/config.rb

@@ -5,6 +5,7 @@ module NulogyMessageBusProducer
     FAILURE_MODES = [:raise, :soft_fail].freeze
 
     attr_reader :registered_schemas
+    attr_writer :context_for_subscription
 
     def initialize(options = {})
       @registered_schemas = {}
@@ -13,6 +14,11 @@ module NulogyMessageBusProducer
       update(options)
     end
 
+    def context_for_subscription(subscription)
+      @context_for_subscription ||= ->(_) {}
+      @context_for_subscription.call(subscription)
+    end
+
     def register_schema(schema:, key:)
       @registered_schemas[key] = schema
     end

data/lib/nulogy_message_bus_producer/repopulate_replication_slots.rb

@@ -0,0 +1,25 @@
+module NulogyMessageBusProducer
+  # This modules repopulates the replication slot (what debezium uses to populate Kafka)
+  # by re-generating the subscription events
+  module RepopulateReplicationSlots
+    def self.repopulate
+      table_name = NulogyMessageBusProducer::SubscriptionEvent.table_name
+      temp_table_name = "#{NulogyMessageBusProducer::SubscriptionEvent.table_name}_tmp_event_repopulation"
+
+      ActiveRecord::Base.connection.execute(<<~SQL)
+        BEGIN;
+        LOCK TABLE #{table_name} IN SHARE MODE;
+
+        DROP TABLE IF EXISTS #{temp_table_name};
+        CREATE TEMPORARY TABLE #{temp_table_name} AS
+          SELECT * FROM #{table_name} ORDER BY created_at ASC;
+
+        TRUNCATE #{table_name};
+        INSERT INTO #{table_name}
+          (SELECT * FROM #{temp_table_name} ORDER BY created_at ASC);
+
+        COMMIT;
+      SQL
+    end
+  end
+end

data/lib/nulogy_message_bus_producer/subscriber_graphql_schema_validator.rb

@@ -13,7 +13,7 @@ module NulogyMessageBusProducer
       @errors = []
     end
 
-    def validate(subscription_or_subscriptions = NulogyMessageBusProducer::PublicSubscription.all)
+    def validate(subscription_or_subscriptions = NulogyMessageBusProducer::Subscription.all)
       Array(subscription_or_subscriptions).each do |subscription|
         schema = find_schema(subscription)
         next unless schema