nulogy_message_bus_producer 2.0.0 → 3.2.1

data/lib/nulogy_message_bus_producer/postgres_public_subscriptions.rb

@@ -1,117 +0,0 @@
-module NulogyMessageBusProducer
-  # 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 PostgresPublicSubscriptions < GraphQL::Subscriptions
-    def initialize(options = {})
-      super
-
-      @schema_key = NulogyMessageBusProducer.resolve_schema_key(options.fetch(:schema))
-    end
-
-    # This method is copied from GraphQL::Subscriptions and customized.
-    # Check for changes in the superclass when upgrading the graphql gem.
-    def execute(subscription_id, event, object) # rubocop:disable Metrics/MethodLength
-      query_data = read_subscription(subscription_id)
-      query_string = query_data.fetch(:query_string)
-      variables = { id: object[:uuid] }
-      context = object[:context]
-      operation_name = query_data.fetch(:operation_name)
-      result = @schema.execute(
-        query: query_string,
-        context: context,
-        subscription_topic: event.topic,
-        operation_name: operation_name,
-        variables: variables,
-        root_value: object
-      )
-      deliver(subscription_id, result)
-    rescue GraphQL::Schema::Subscription::NoUpdateError
-      # This update was skipped in user code; do nothing.
-    rescue GraphQL::Schema::Subscription::UnsubscribedError
-      delete_subscription(subscription_id)
-    end
-
-    def each_subscription_id(event)
-      PublicSubscription
-        .where(event_type: event.name, schema_key: @schema_key)
-        .ids
-        .each { |id| yield id }
-    end
-
-    def read_subscription(subscription_id)
-      query_string = PublicSubscription.find_by(id: subscription_id).query
-
-      {
-        query_string: query_string,
-        operation_name: nil
-      }
-    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|
-        PublicSubscription.create_or_update(
-          id: event.arguments[:subscription_id],
-          subscription_group_id: event.arguments[:subscription_group_id],
-          event_type: event.name,
-          schema_key: @schema_key,
-          query: convert_subscription_result_query_to_regular_query(query, event),
-          topic_name: event.arguments[:topic_name]
-        )
-      end
-    end
-
-    def delete_subscription(subscription_id)
-      PublicSubscription.find_by(id: subscription_id).destroy
-    end
-
-    private
-
-    def create_event(subscription_id, result)
-      tenant_id = result.query.context.object[:tenant_id]
-      subscription = PublicSubscription.find_by(id: subscription_id)
-
-      PublicSubscriptionEvent.create_or_update(
-        id: SecureRandom.uuid,
-        public_subscription_id: subscription_id,
-        partition_key: "#{subscription.subscription_group_id},#{tenant_id}",
-        tenant_id: tenant_id,
-        event_json: result.to_h["data"],
-        topic_name: subscription.topic_name
-      )
-    end
-
-    def convert_subscription_result_query_to_regular_query(query, event)
-      selections = query.document.definitions.first.selections
-
-      event_selection = selections.find { |e| e.name == event.name }
-
-      # TODO: This assumes the query_type.rb takes an argument called 'id'.
-      # This should check the query to lookup the argument name
-      # TODO: Can we do this by manipulating GQL objects?
-      inner_query = event_selection.selections.first.to_query_string.sub("{", "(id: $id) {")
-      "query ($id: UUID!) { #{inner_query} }"
-    end
-  end
-end

data/spec/integration/lib/graphql_api/postgres_public_subscriptions_spec.rb

@@ -1,122 +0,0 @@
-require "integration_spec_helper"
-
-RSpec.describe NulogyMessageBusProducer::PostgresPublicSubscriptions do
-  context "when the class is not registered" do
-    it "raises" do
-      unregistered_schema = Class.new(GraphQL::Schema) do
-        use(NulogyMessageBusProducer::PostgresPublicSubscriptions)
-      end
-
-      expect do
-        # this find triggers the plugin to be loaded
-        unregistered_schema.find("something")
-      end.to raise_error(KeyError, /The schema registry did not contain an entry/)
-    end
-  end
-
-  context "when subscription is triggered" do
-    before do
-      NulogyMessageBusProducer.config.register_schema(
-        schema: "NulogyMessageBusProducer::Specs::TestSchema",
-        key: "test"
-      )
-    end
-
-    it "generates events" do
-      create_subscription(event_type: "testCreated")
-      create_subscription(event_type: "testCreated")
-
-      uuid = SecureRandom.uuid
-
-      expect do
-        NulogyMessageBusProducer::Specs::TestSchema.subscriptions.trigger(
-          "testCreated",
-          {},
-          { uuid: uuid, tenant_id: SecureRandom.uuid }
-        )
-      end.to change(NulogyMessageBusProducer::PublicSubscriptionEvent, :count).by(2)
-
-      event_data = NulogyMessageBusProducer::PublicSubscriptionEvent.pluck(:event_json)
-      expect(event_data).to all(include("foo" => { "id" => uuid }))
-    end
-  end
-
-  context "when a subscription error occurs" do
-    context "when failing with raise" do
-      before do
-        NulogyMessageBusProducer.config.producing_events_fails_with(:raise)
-      end
-
-      it "raises an exception" do
-        expect { trigger_erroneous_subscription }.to raise_error(/A subscription event could not be produced/)
-      end
-    end
-
-    context "when failing with a soft fail" do
-      before do
-        NulogyMessageBusProducer.config.producing_events_fails_with(:soft_fail)
-      end
-
-      it "does not raise an error" do
-        trigger_erroneous_subscription
-      end
-
-      it "calls the provided block" do
-        called = false
-
-        NulogyMessageBusProducer.config.producing_events_fails_with(:soft_fail) do |_|
-          called = true
-        end
-
-        trigger_erroneous_subscription
-
-        expect(called).to be(true)
-      end
-    end
-  end
-
-  def trigger_erroneous_subscription
-    NulogyMessageBusProducer.config.register_schema(schema: "NulogyMessageBusProducer::Specs::TestSchema", key: "test")
-
-    event_type = "testCreated"
-
-    subscription = create_subscription(event_type: event_type)
-    simulate_invalid_query(subscription)
-
-    NulogyMessageBusProducer::Specs::TestSchema.subscriptions.trigger(
-      event_type,
-      {},
-      { uuid: SecureRandom.uuid, tenant_id: SecureRandom.uuid }
-    )
-  end
-
-  def create_subscription(**overrides) # rubocop:disable Metrics/MethodLength
-    args = {
-      id: SecureRandom.uuid,
-      subscription_group_id: SecureRandom.uuid,
-      topic_name: "test_topic",
-      schema_key: "test",
-      event_type: "test_event_type",
-      query: <<~QUERY
-        query ($id: UUID!) {
-          foo (id: $id) {
-            id
-          }
-        }
-      QUERY
-    }.merge(overrides)
-
-    NulogyMessageBusProducer::PublicSubscription.create_or_update(args)
-  end
-
-  def simulate_invalid_query(subscription)
-    subscription.query = <<~QUERY
-      query ($id: UUID!) {
-        foo (id: $id) {
-          a_field_that_does_not_exist
-        }
-      }
-    QUERY
-    subscription.save(validate: false)
-  end
-end

data/spec/integration/lib/graphql_api/validators/subscriber_graphql_schema_validator_spec.rb

@@ -1,76 +0,0 @@
-require "integration_spec_helper"
-
-RSpec.describe NulogyMessageBusProducer::SubscriberGraphqlSchemaValidator do
-  subject(:validator) { NulogyMessageBusProducer::SubscriberGraphqlSchemaValidator.new }
-
-  before do
-    NulogyMessageBusProducer.config.register_schema(schema: "NulogyMessageBusProducer::Specs::TestSchema", key: "test")
-  end
-
-  describe "#validate" do
-    context "when a valid query is present" do
-      it "return true" do
-        create_subscription(<<~QUERY)
-          query ($id: UUID!) {
-            foo (id: $id) {
-              id
-            }
-          }
-        QUERY
-
-        expect(validator.validate).to be(true)
-      end
-    end
-
-    context "when an invalid query is present" do
-      let(:subscription_with_error) do
-        subscription = create_subscription(<<~QUERY)
-          query ($id: UUID!) {
-            foo (id: $id) {
-              id
-            }
-          }
-        QUERY
-
-        subscription.query = <<~BAD_QUERY
-          query ($id: UUID!) {
-            foo (id: $id) {
-              a_field_that_does_not_exist
-            }
-          }
-        BAD_QUERY
-        subscription.save(validate: false)
-        subscription
-      end
-
-      it "returns false" do
-        subscription_with_error
-
-        expect(validator.validate).to be(false)
-      end
-
-      it "has errors" do
-        subscription_with_error
-
-        validator.validate
-
-        expect(validator.errors).to contain_exactly(
-          "Field 'a_field_that_does_not_exist' doesn't exist on type 'testObject' (id: #{subscription_with_error.id})"
-        )
-      end
-    end
-  end
-
-  def create_subscription(query, event_type = "testEvent", schema_key: "test")
-    NulogyMessageBusProducer::PublicSubscription.create_or_update(
-      query: query,
-      event_type: event_type,
-      schema_key: schema_key,
-
-      # not relavant, but needed for DB constraints
-      id: SecureRandom.uuid,
-      subscription_group_id: SecureRandom.uuid,
-      topic_name: SecureRandom.uuid
-    )
-  end
-end

data/spec/unit/lib/graphql_api/models/public_subscription_spec.rb

@@ -1,66 +0,0 @@
-require "unit_spec_helper"
-
-RSpec.describe NulogyMessageBusProducer::PublicSubscription do
-  context "when validating" do
-    before do
-      NulogyMessageBusProducer.config.register_schema schema: "NulogyMessageBusProducer::Specs::TestSchema", key: "test"
-    end
-
-    it "is invalid with a blank query" do
-      model = NulogyMessageBusProducer::PublicSubscription.new(
-        schema_key: "test",
-        query: ""
-      )
-
-      model.validate
-
-      expect(model).to_not be_valid
-      expect(model.errors[:query]).to contain_exactly("can't be blank")
-    end
-
-    it "is invalid with blank schema_key" do
-      model = NulogyMessageBusProducer::PublicSubscription.new(schema_key: "")
-
-      model.validate
-
-      expect(model.errors[:schema_key]).to be_present
-    end
-
-    it "is invalid with an invalid query" do
-      model = NulogyMessageBusProducer::PublicSubscription.new(
-        schema_key: "test",
-        query: <<~QUERY
-          query ($id: UUID!) {
-            foo (id: $id) {
-              a_field_that_does_not_exist
-            }
-          }
-        QUERY
-      )
-
-      model.validate
-
-      expect(model).to_not be_valid
-      expect(model.errors[:query]).to contain_exactly(
-        "Field 'a_field_that_does_not_exist' doesn't exist on type 'testObject' (id: <new_record>)"
-      )
-    end
-
-    it "valid with a valid query" do
-      model = NulogyMessageBusProducer::PublicSubscription.new(
-        schema_key: "test",
-        query: <<~QUERY
-          query ($id: UUID!) {
-            foo (id: $id) {
-              id
-            }
-          }
-        QUERY
-      )
-
-      model.validate
-
-      expect(model.errors).to_not include(:query)
-    end
-  end
-end

data/spec/unit_spec_helper.rb

@@ -1,6 +0,0 @@
-# Make all rspec configuration changes to this file.
-# Leave automatically generated configuration files untouched to facilitate gem upgrades.
-
-require "nulogy_message_bus_producer"
-require "rspec/core"
-require "spec_helper"