nulogy_message_bus_producer 2.1.1 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4cc826f5c2b4bf8ebf1e9e97b3dee97cbd923c1d954d73100755f3497837e28
-  data.tar.gz: a59dae8e534e69b9b0aba0b5e572a6d98c75510e77b5d6b763bc8a80ca1e3e56
+  metadata.gz: 3f7851fbbe2f63a88307bc6f8c735b78d998a576e8c0beeb3feb2497171a341f
+  data.tar.gz: 8fb164dd469b34498f4b205277811527507930d24ae56202451ab31758a87c58
 SHA512:
-  metadata.gz: a72e3b5e4147f8d7db19830bb09ccc97ddb07e5e659c6c1fb34c64edf867fd3c3ae6a3aa2b8942bc312bb8633831cf13d5d9b19fd5559d808330998c3d96e079
-  data.tar.gz: 7ea5411883b1bc0acbb92f6625928c94118d73c613bf763a8898d4d2db6c6fa4662fb00ea5cca11c9da88120a201c0cc38ee0e98bd9d3a2d22d4e55f93b6b5dc
+  metadata.gz: c42247256982eff8fbf1a93900fa24deb61094e33d46387737e44380d29b36bba66ab61c2df2d7cbcd46610fdf7e3a76494e395b7ecca1aba8170c43a2baeca6
+  data.tar.gz: 14235e2f752cf55ee5a1499d9f1aedde3267124a40c662a08bee80abcc42ed1373a5539f2607c127fbf80aa976b6171575c51283b57f37d974680a6b5eef4186

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,10 +19,12 @@ 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
 
@@ -30,13 +32,20 @@ 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.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.
@@ -58,17 +67,24 @@ NulogyMessageBusProducer.configure do |config|
 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::PostgresPublicSubscriptions` 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.
+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::PostgresPublicSubscriptions
+    use NulogyMessageBusProducer::Subscriptions::PostgresTransport
+    
+    # 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.
+    use GraphQL::Analysis::AST
+    query_analyzer NulogyMessageBusProducer::Subscriptions::RiskySubscriptionBlocker
 
     query Types::QueryType
     subscription Types::SubscriptionType
@@ -111,7 +127,7 @@ end
 
 module ExampleDomainPublicApi
   module Subscriptions
-    class SkuCreated < NulogyMessageBusProducer::BasePublicSubscription
+    class SkuCreated < NulogyMessageBusProducer::BaseSubscription
       field :sku, Types::SkuType, null: false
     end
   end
@@ -119,7 +135,7 @@ end
 
 module ExampleDomainPublicApi
   module Subscriptions
-    class SkuUpdated < NulogyMessageBusProducer::BasePublicSubscription
+    class SkuUpdated < NulogyMessageBusProducer::BaseSubscription
       field :sku, Types::SkuType, null: false
     end
   end
@@ -160,11 +176,11 @@ class CreateSku
   def trigger_subscription(event, entity)
     object = {
       uuid: entity.id,
-      tenant_id: entity.company_id,
+      company_uuid: entity.company_id,
       context: {}
     }
-  
-    ExampleDomainPublicApi::Schema.subscriptions.trigger(event, {}, object)
+
+    NulogyMessageBusProducer.trigger_event(ExampleDomainPublicApi::Schema, event, object)
   end
 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

@@ -14,24 +14,50 @@ 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.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)
-    config.registered_schemas.fetch(schema_key) do
-      raise KeyError, <<~MESSAGE unless block_given?
+    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)`
@@ -39,9 +65,7 @@ module NulogyMessageBusProducer
         Schemas Registered:
         #{config.registered_schemas.pretty_inspect}
       MESSAGE
-
-      yield
-    end.constantize
+    end
   end
 
   def self.resolve_schema_key(schema)
@@ -67,7 +91,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).
 
@@ -106,7 +130,7 @@ module NulogyMessageBusProducer
           FROM pg_tables
           WHERE tablename = '#{NulogyMessageBusProducer.subscriptions_table_name}'
             AND schemaname = 'public';
-        SQL
+      SQL
     rescue # rubocop:disable Style/RescueStandardError
       false
     end
@@ -115,9 +139,10 @@ 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/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

@@ -1,8 +1,8 @@
 module NulogyMessageBusProducer
   module RepopulateReplicationSlots
     def self.repopulate
-      table_name = NulogyMessageBusProducer::PublicSubscriptionEvent.table_name
-      temp_table_name = "#{NulogyMessageBusProducer::PublicSubscriptionEvent.table_name}_tmp_event_repopulation"
+      table_name = NulogyMessageBusProducer::SubscriptionEvent.table_name
+      temp_table_name = "#{NulogyMessageBusProducer::SubscriptionEvent.table_name}_tmp_event_repopulation"
 
       ActiveRecord::Base.connection.execute(<<~SQL)
         BEGIN;

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

data/lib/nulogy_message_bus_producer/{public_subscription.rb → subscription.rb}

@@ -1,7 +1,7 @@
 module NulogyMessageBusProducer
   # This model saves all subscriptions to external systems.
   # An external system can subscribe to events and specify the shape of data it would like to receive for the event.
-  class PublicSubscription < ApplicationRecord
+  class Subscription < ApplicationRecord
     self.table_name = :message_bus_subscriptions
 
     # Run our validator with familar syntax in this model
@@ -12,7 +12,6 @@ module NulogyMessageBusProducer
         validator = NulogyMessageBusProducer::SubscriberGraphqlSchemaValidator.new
 
         validator.validate(record)
-
         validator.errors.each { |e| record.errors.add(attribute, e) }
       end
     end

data/lib/nulogy_message_bus_producer/{public_subscription_event.rb → subscription_event.rb}

@@ -1,7 +1,7 @@
 module NulogyMessageBusProducer
   # A model that contains the event data for a particular subscription
   # It is simply saved in the database and shipped to Kafka by Debezium
-  class PublicSubscriptionEvent < ApplicationRecord
+  class SubscriptionEvent < ApplicationRecord
     self.table_name = :message_bus_subscription_events
 
     def self.create_or_update(attrs)

data/lib/nulogy_message_bus_producer/subscriptions/postgres_transport.rb

@@ -0,0 +1,83 @@
+module NulogyMessageBusProducer
+  module Subscriptions
+    # Subscription class to `use` when developing Message Bus-backed subscriptions
+    # For example,
+    #
+    #  class SomeSchema < GraphQL::Schema
+    #    ...
+    #    use NulogyMessageBusProducer::PostgresPublicSubscriptions
+    #  end
+    #
+    # It expects that schema to already be registered, or will raise an error.
+    #
+    # NulogyMessageBusProducer.register_schema("some_schema", "SomeSchema")
+    class PostgresTransport < GraphQL::Subscriptions
+      def initialize(options = {})
+        super
+        @schema_key = NulogyMessageBusProducer.resolve_schema_key(options.fetch(:schema))
+      end
+
+      def each_subscription_id(event)
+        yield event.arguments["subscriptionId"]
+      end
+
+      def read_subscription(subscription_id)
+        subscription = Subscription.find(subscription_id)
+        context = NulogyMessageBusProducer.context_for_subscription(subscription)
+
+        {
+          context: context,
+          operation_name: nil,
+          query_string: subscription.query,
+          variables: {},
+        }
+      end
+
+      def deliver(subscription_id, result)
+        if result["errors"]&.any?
+          NulogyMessageBusProducer.config.handle_event_generation_error(
+            subscription_id: subscription_id,
+            context: result.query.context.object,
+            variables: result.query.provided_variables,
+            result: result
+          )
+        else
+          create_event(subscription_id, result)
+        end
+      end
+
+      def write_subscription(query, events)
+        events.each do |event|
+          Subscription.create_or_update(
+            id: event.arguments["subscriptionId"],
+            subscription_group_id: event.arguments["subscriptionGroupId"],
+            event_type: event.name,
+            schema_key: @schema_key,
+            query: query.query_string,
+            topic_name: event.arguments["topicName"]
+          )
+        end
+      end
+
+      def delete_subscription(subscription_id)
+        Subscription.find_by(id: subscription_id).destroy
+      end
+
+      private
+
+      def create_event(subscription_id, result)
+        company_uuid = result.query.context.object[:company_uuid]
+        subscription = Subscription.find_by(id: subscription_id)
+
+        SubscriptionEvent.create_or_update(
+          id: SecureRandom.uuid,
+          subscription_id: subscription_id,
+          partition_key: "#{subscription.subscription_group_id},#{company_uuid}",
+          company_uuid: company_uuid,
+          event_json: result.to_h["data"],
+          topic_name: subscription.topic_name
+        )
+      end
+    end
+  end
+end

data/lib/nulogy_message_bus_producer/subscriptions/risky_subscription_blocker.rb

@@ -0,0 +1,58 @@
+module NulogyMessageBusProducer
+  module Subscriptions
+    class RiskySubscriptionBlocker < GraphQL::Analysis::AST::Analyzer
+      def initialize(query_or_multiplex)
+        super
+        @nodes_using_arguments = Set.new
+        @nodes_are_lists = Set.new
+      end
+
+      PERMITTED_ARGUMENTS = Set.new(%w[subscriptionId subscriptionGroupId topicName])
+
+      def analyze?
+        subject.subscription?
+      end
+
+      def on_enter_argument(argument, parent, _visitor)
+        @nodes_using_arguments << parent unless PERMITTED_ARGUMENTS.include?(argument.name)
+      end
+
+      def on_enter_field(node, _parent, visitor)
+        @nodes_are_lists << node if list?(node, visitor)
+      end
+
+      def result
+        error_messages = []
+
+        if @nodes_using_arguments.any?
+          node_names = @nodes_using_arguments.map(&:name).join("\n")
+          error_messages << "Arguments may not be used:\n#{node_names}"
+        end
+
+        if @nodes_are_lists.any?
+          node_names = @nodes_are_lists.map(&:name).join("\n")
+          error_messages << "Lists may not be queried:\n#{node_names}"
+        end
+
+        GraphQL::AnalysisError.new(error_messages.join("\n\n")) if error_messages.any?
+      end
+
+      private
+
+      def list?(node, visitor)
+        field_definition = visitor.field_definition
+        nested_type = field_definition.type_class.type
+
+        loop do
+          @nodes_are_lists << node if nested_type.is_a?(GraphQL::Schema::List)
+
+          if nested_type.respond_to?(:of_type)
+            nested_type = nested_type.of_type
+          else
+            break
+          end
+        end
+      end
+    end
+  end
+end