webhookdb 0.1.0

data/lib/webhookdb/spec_helpers/whdb.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "webhookdb/spec_helpers"
+
+# Set :whdbisolation metadatabase. Use the isolation mode, or :reset to just reset config
+# before and after the spec.
+module Webhookdb::SpecHelpers::Whdb
+  def self.included(context)
+    context.before(:each) do |example|
+      if (isomode = example.metadata[:whdbisolation])
+        Webhookdb::Organization::DbBuilder.isolation_mode = isomode if isomode.is_a?(String)
+        Webhookdb::Organization::DbBuilder.reset_configuration if isomode == :reset
+      end
+      if (regress = example.metadata[:regression_mode])
+        Webhookdb.regression_mode = regress
+      end
+    end
+
+    context.after(:each) do |example|
+      if (mode = example.metadata[:whdbisolation])
+        Webhookdb::Organization.dataset.each(&:remove_related_database) if mode != :reset
+        Webhookdb::Organization::DbBuilder.reset_configuration
+      end
+      Webhookdb.regression_mode = false if example.metadata[:regression_mode]
+    end
+
+    context.around(:each) do |example|
+      if example.metadata[:fake_replicator]
+        Webhookdb::Replicator::Fake.reset
+        begin
+          example.run
+        ensure
+          Webhookdb::Replicator::Fake.reset
+        end
+      else
+        example.run
+      end
+    end
+
+    super
+  end
+
+  module_function def assign_connection_urls(o, **more)
+    u = Webhookdb::Organization::DbBuilder.available_server_urls.sample
+    raise "no server url?" if u.blank?
+    o.update(
+      readonly_connection_url_raw: u,
+      admin_connection_url_raw: u,
+      **more,
+    )
+  end
+
+  module_function def create_dependency(service_integration)
+    return service_integration.depends_on unless service_integration.depends_on.nil?
+    dependency_descriptor = service_integration.replicator.descriptor.dependency_descriptor
+    if dependency_descriptor.present?
+      dependency = Webhookdb::Fixtures.service_integration.create(
+        organization: service_integration.organization,
+        service_name: dependency_descriptor.name,
+      )
+      service_integration.update(depends_on: dependency)
+      return dependency
+    end
+    return nil
+  end
+
+  # If a service has dependencies, and those dependencies have dependencies, create
+  # them recursively until all requirements are satisfied.
+  module_function def create_all_dependencies(service_integration)
+    sint = service_integration
+    created = []
+    loop do
+      sint = create_dependency(sint)
+      break if sint.nil?
+      created << sint
+    end
+    return created
+  end
+
+  module_function def setup_dependencies(service_integration, insert_required_data_callback=nil)
+    service_integration.replicator.create_table
+    dep_sint = service_integration.depends_on
+    return [] if dep_sint.nil?
+    org = service_integration.organization
+    dep_repls = []
+    while dep_sint
+      # Make sure all service integration orgs are the same instance, since it may be mutated
+      # when we set up urls.
+      raise Webhookdb::InvariantViolation, "service integration orgs must match" unless
+        dep_sint.organization === org
+      dep_sint.organization = org
+      dep_repl = dep_sint.replicator
+      dep_repl.create_table
+      dep_repls << dep_repl
+      dep_sint = dep_sint.depends_on
+      break if dep_sint.nil?
+    end
+    insert_required_data_callback&.call(*dep_repls)
+    return dep_repls
+  end
+
+  module_function def setup_upsert_webhook_example(this)
+    this.let(:request_path) { nil }
+    this.let(:request_method) { nil }
+    this.let(:request_body) { nil }
+    this.let(:request_headers) { nil }
+    this.let(:webhook_request) do
+      Webhookdb::Replicator::WebhookRequest.new(
+        body: request_body, method: request_method, path: request_path, headers: request_headers,
+      )
+    end
+    this.define_method(:upsert_webhook) do |svc, **kw|
+      params = {body: request_body, headers: request_headers, method: request_method, path: request_path}
+      params.merge!(**kw)
+      svc.upsert_webhook(Webhookdb::Replicator::WebhookRequest.new(**params))
+    end
+  end
+
+  # Creates and returns a new backfill job for the given integration or replicator,
+  # and also runs the backfill.
+  module_function def backfill(sint, **kw)
+    sint = sint.service_integration if sint.respond_to?(:service_integration)
+    bfjob = Webhookdb::Fixtures.backfill_job.for(sint).create(**kw)
+    sint.replicator.backfill(bfjob)
+    return bfjob
+  end
+
+  def refresh_row(row, replicator: nil)
+    replicator ||= svc
+    raise "Must provide :replicator or have :svc available" if replicator.nil?
+    return replicator.readonly_dataset { |ds| ds[pk: row.fetch(:pk)] }
+  end
+
+  def update_row(row, replicator: nil, **fields)
+    replicator ||= svc
+    raise "Must provide :replicator or have :svc available" if replicator.nil?
+    return replicator.admin_dataset { |ds| ds.where(pk: row.fetch(:pk)).update(fields) }
+  end
+end

data/lib/webhookdb/spec_helpers.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "oj"
+require "webhookdb"
+
+RSpec::Matchers.define_negated_matcher(:exclude, :include)
+RSpec::Matchers.define_negated_matcher(:not_include, :include)
+RSpec::Matchers.define_negated_matcher(:not_change, :change)
+RSpec::Matchers.define_negated_matcher(:not_be_nil, :be_nil)
+RSpec::Matchers.define_negated_matcher(:not_eq, :eq)
+RSpec::Matchers.define_negated_matcher(:not_be_empty, :be_empty)
+
+module Webhookdb::SpecHelpers
+  # The directory to look in for fixture data
+  TEST_DATA_DIR = Pathname("spec/data").expand_path
+
+  def self.included(context)
+    context.before(:all) do
+      Webhookdb::Customer.password_hash_cost = 1
+    end
+    context.before(:each) do
+      allow(Kernel).to receive(:sleep) do |n|
+        raise "Never sleep with > 0 during tests" if n.positive?
+      end
+    end
+    super
+  end
+
+  module_function def test_data_dir
+    return TEST_DATA_DIR
+  end
+
+  module_function def json_headers(**more)
+    return {"Content-Type" => "application/json"}.merge(**more)
+  end
+
+  module_function def json_response(body, status: 200, headers: {})
+    return {status:, body: body.to_json, headers: json_headers(**headers)}
+  end
+
+  ### Load data from the spec/data directory with the specified +name+,
+  ### deserializing it if it's YAML or JSON, and returning it.
+  module_function def load_fixture_data(name, raw: false)
+    name = name.to_s
+    path = TEST_DATA_DIR + name
+    path = TEST_DATA_DIR + "#{name}.json" unless path.exist? || !File.extname(name).empty?
+    path = TEST_DATA_DIR + "#{name}.yaml" unless path.exist? || !File.extname(name).empty?
+    path = TEST_DATA_DIR + "#{name}.yml" unless path.exist? || !File.extname(name).empty?
+
+    rawdata = path.read(encoding: "utf-8")
+
+    return rawdata if raw
+
+    return case path.extname
+      when ".json"
+        Oj.load(rawdata)
+      when ".yml", ".yaml"
+        YAML.safe_load(rawdata)
+      else
+        rawdata
+    end
+  end
+end

data/lib/webhookdb/sponsy.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "appydays/configurable"
+
+module Webhookdb::Sponsy
+  include Appydays::Configurable
+
+  configurable(:sponsy) do
+    setting :cron_expression, "*/30 */4 * * *" # “At every 30th minute past every 4th hour.”
+    setting :http_timeout, 30
+    setting :page_size, 100
+    setting :parallel_backfill, 3
+  end
+end

data/lib/webhookdb/stripe.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Webhookdb::Stripe
+  extend Webhookdb::MethodUtilities
+  include Appydays::Configurable
+  include Appydays::Loggable
+
+  configurable(:stripe) do
+    setting :api_key, "whdb_stripe_api_key", key: "STRIPE_API_KEY"
+    setting :http_timeout, 30
+    setting :webhook_secret, "whdb_stripe_webhook_secret", key: "STRIPE_WEBHOOK_SECRET"
+
+    after_configured do
+      ::Stripe.api_key = self.api_key
+    end
+  end
+
+  def self.webhook_response(request, webhook_secret)
+    auth = request.env["HTTP_STRIPE_SIGNATURE"]
+
+    return Webhookdb::WebhookResponse.error("missing hmac") if auth.nil?
+
+    request.body.rewind
+    request_data = request.body.read
+
+    begin
+      Stripe::Webhook.construct_event(
+        request_data, auth, webhook_secret,
+      )
+    rescue Stripe::SignatureVerificationError => e
+      self.logger.warn "stripe_signature_verification_error", message: e.to_s
+      return Webhookdb::WebhookResponse.error("invalid hmac")
+    end
+
+    return Webhookdb::WebhookResponse.ok
+  end
+end

data/lib/webhookdb/subscription.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+class Webhookdb::Subscription < Webhookdb::Postgres::Model(:subscriptions)
+  extend Webhookdb::MethodUtilities
+  include Appydays::Configurable
+  include Appydays::Loggable
+
+  class Plan
+    attr_accessor :key, :description, :price, :stripe_price_id, :stripe_product_id
+
+    def initialize(key, stripe_price)
+      @key = key
+      @description = stripe_price.nickname
+      @price = Money.new(stripe_price.unit_amount)
+      @stripe_price_id = stripe_price.id
+      @stripe_product_id = stripe_price.product
+    end
+
+    def as_json
+      return {key:, description:, price:}
+    end
+  end
+
+  plugin :timestamps
+  plugin :soft_deletes
+
+  configurable(:subscription) do
+    setting :billing_enabled, false
+    setting :free_integrations_with_billing, 2
+  end
+
+  class << self
+    def billing_enabled? = self.billing_enabled
+    def billing_disabled? = !self.billing_enabled?
+    def max_free_integrations = self.billing_enabled? ? self.free_integrations_with_billing : 9999
+  end
+
+  one_to_one :organization, class: "Webhookdb::Organization", key: :stripe_customer_id, primary_key: :stripe_customer_id
+
+  def self.list_plans
+    return [] if self.billing_disabled?
+    prices = Stripe::Price.list(active: true)
+    monthly = prices.find { |pr| pr.recurring.interval == "month" }
+    yearly = prices.find { |pr| pr.recurring.interval == "year" }
+    raise "Expected month and year prices in: #{prices.to_json}" unless monthly && yearly
+    return [Plan.new("monthly", monthly), Plan.new("yearly", yearly)]
+  end
+
+  def initialize(*)
+    super
+    self[:stripe_json] ||= Sequel.pg_json({})
+  end
+
+  def status
+    return self.stripe_json["status"]
+  end
+
+  def plan_name
+    return self.stripe_json.dig("plan", "nickname") || ""
+  end
+
+  def self.create_or_update_from_stripe_hash(obj)
+    created = false
+    orig_status = nil
+    sub = self.update_or_create(stripe_id: obj.fetch("id")) do |o|
+      o.stripe_customer_id = obj.fetch("customer")
+      if o.new?
+        created = true
+      else
+        orig_status = o.status
+      end
+      o.stripe_json = obj.to_json
+    end
+    common_fields = [
+      {title: "Subscription", value: sub.id, short: true},
+      {title: "Status", value: sub.status, short: true},
+      {title: "Stripe ID", value: sub.stripe_id, short: true},
+      {title: "Customer ID", value: sub.stripe_customer_id, short: true},
+    ]
+    if sub.organization.nil?
+      Webhookdb::DeveloperAlert.new(
+        subsystem: "Subscription Error",
+        emoji: ":hook:",
+        fallback: "Subscription with Stripe ID #{sub.stripe_id} has no organization",
+        fields: common_fields + [
+          {title: "Message", value: "Has no organization in WebhookDB", short: false},
+        ],
+      ).emit
+    elsif created
+      Webhookdb::DeveloperAlert.new(
+        subsystem: "Subscription Created",
+        emoji: ":hook:",
+        fallback: "Subscription with Stripe ID #{sub.stripe_id} created",
+        fields: common_fields + [
+          {title: "Organization", value: sub.organization.display_string, short: true},
+          {title: "Message", value: "Created", short: true},
+        ],
+      ).emit
+      elsif orig_status != sub.status
+        Webhookdb::DeveloperAlert.new(
+          subsystem: "Subscription Status Change",
+          emoji: ":hook:",
+          fallback: "Subscription with Stripe ID #{sub.stripe_id} changed status",
+          fields: common_fields + [
+            {title: "Organization", value: sub.organization.display_string, short: true},
+            {title: "Message", value: "Status updated", short: true},
+          ],
+        ).emit
+    end
+    return sub
+  end
+
+  def self.create_or_update_from_webhook(webhook_body)
+    obj = webhook_body["data"]["object"]
+    self.create_or_update_from_stripe_hash(obj)
+  end
+
+  def self.create_or_update_from_id(id)
+    subscription_obj = Stripe::Subscription.retrieve(id)
+    self.create_or_update_from_stripe_hash(subscription_obj.as_json)
+  end
+
+  class Status
+    attr_reader :data
+
+    def initialize(**kw)
+      @data = kw
+    end
+
+    def display_headers
+      return [
+        [:organization_formatted, "Organization"],
+        [:billing_email, "Billing email"],
+        [:plan_name, "Plan name"],
+        [:integrations_used_formatted, "Integrations used"],
+        [:integrations_remaining_formatted, "Integrations left"],
+        [:sub_status, "Status"],
+      ]
+    end
+
+    def message
+      return "Use `webhookdb subscription edit` to set up or modify your subscription."
+    end
+
+    def as_json(*_o)
+      return @data.merge(message: self.message,        display_headers: self.display_headers)
+    end
+  end
+
+  def self.status_for_org(org)
+    service_integrations = org.service_integrations
+    used = service_integrations.count
+    data = {
+      organization_name: org.name,
+      organization_key: org.key,
+      organization_formatted: org.display_string,
+      billing_email: org.billing_email,
+      integrations_used: used,
+      integrations_used_formatted: used.to_s,
+    }
+    subscription = Webhookdb::Subscription[stripe_customer_id: org.stripe_customer_id]
+    # TODO: Modify the Stripe JSON to store the values of the fields for paid plans,
+    # rather than hard-coding them.
+    if subscription.nil?
+      data[:plan_name] = "Free"
+      data[:integrations_remaining] = [0, Webhookdb::Subscription.max_free_integrations - used].max
+      data[:integrations_remaining_formatted] = data[:integrations_remaining].to_s
+      data[:sub_status] = ""
+    else
+      data[:plan_name] = subscription.plan_name
+      data[:integrations_remaining] = 2_000_000_000
+      data[:integrations_remaining_formatted] = "unlimited"
+      data[:sub_status] = subscription.status
+    end
+    return Status.new(**data)
+  end
+
+  def self.backfill_from_stripe(limit: 50, page_size: 50)
+    subs = Stripe::Subscription.list({limit: page_size})
+    done = 0
+    subs.auto_paging_each do |sub|
+      self.create_or_update_from_stripe_hash(sub.as_json)
+      done += 1
+      break if !limit.nil? && done >= limit
+    end
+  end
+end
+
+# Table: subscriptions
+# ---------------------------------------------------------------------------------------------
+# Columns:
+#  id                 | integer                  | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
+#  created_at         | timestamp with time zone | NOT NULL DEFAULT now()
+#  updated_at         | timestamp with time zone |
+#  soft_deleted_at    | timestamp with time zone |
+#  stripe_id          | text                     | NOT NULL
+#  stripe_customer_id | text                     | NOT NULL DEFAULT ''::text
+#  stripe_json        | jsonb                    | DEFAULT '{}'::jsonb
+# Indexes:
+#  subscriptions_pkey                     | PRIMARY KEY btree (id)
+#  subscriptions_stripe_id_key            | UNIQUE btree (stripe_id)
+#  subscriptions_stripe_customer_id_index | btree (stripe_customer_id)
+# ---------------------------------------------------------------------------------------------