webhookdb 0.1.0

data/lib/webhookdb/replicator/plivo_sms_inbound_v1.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "webhookdb/plivo"
+
+class Webhookdb::Replicator::PlivoSmsInboundV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+
+  # @return [Webhookdb::Replicator::Descriptor]
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "plivo_sms_inbound_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::PlivoSmsInboundV1.new(sint) },
+      feature_roles: ["beta"],
+      resource_name_singular: "Plivo Inbound SMS Message",
+      supports_webhooks: true,
+      api_docs_url: "https://www.plivo.com/docs/sms/api/message#the-message-object",
+    )
+  end
+
+  def _remote_key_column
+    return Webhookdb::Replicator::Column.new(:plivo_message_uuid, TEXT, data_key: "MessageUUID")
+  end
+
+  def _denormalized_columns
+    return [
+      Webhookdb::Replicator::Column.new(:row_inserted_at, TIMESTAMP, defaulter: :now, optional: true, index: true),
+      Webhookdb::Replicator::Column.new(:from_number, TEXT, data_key: "From", index: true),
+      Webhookdb::Replicator::Column.new(:to_number, TEXT, data_key: "To", index: true),
+    ]
+  end
+
+  def _timestamp_column_name
+    return :row_inserted_at
+  end
+
+  def _update_where_expr
+    # These are immutable events, not updates, so never update after inserted.
+    return Sequel[false]
+  end
+
+  def _webhook_response(request)
+    return Webhookdb::Plivo.webhook_response(request, self.service_integration.backfill_secret)
+  end
+
+  def _resource_and_event(request)
+    body = request.body
+    raise Webhookdb::InvalidPrecondition, "body should be form-encoded string" unless body.is_a?(String)
+    resource = URI.decode_www_form(body).to_h
+    return resource, nil
+  end
+
+  INTEGER_KEYS = ["TotalAmount", "TotalRate", "Units"].freeze
+
+  def _resource_to_data(resource, *)
+    super
+    h = resource.dup
+    INTEGER_KEYS.each do |k|
+      h[k] = h[k].to_i if h.key?(k)
+    end
+    return h
+  end
+
+  def calculate_webhook_state_machine
+    step = Webhookdb::Replicator::StateMachineStep.new
+    if self.service_integration.backfill_key.blank?
+      step.output = %(You are about to set up an endpoint to receive #{self.resource_name_plural}.
+You'll need to give us your Auth ID and Auth Token so we can validate webhooks.
+Once that is set up, we'll help you set up your WebhookDB endpoint in Plivo.)
+      return step.secret_prompt("Auth ID").backfill_key(self.service_integration)
+    end
+    if self.service_integration.backfill_secret.blank?
+      return step.secret_prompt("Auth Token").backfill_secret(self.service_integration)
+    end
+    begin
+      Webhookdb::Plivo.request(
+        :get,
+        "/",
+        auth_id: self.service_integration.backfill_key,
+        auth_token: self.service_integration.backfill_secret,
+        timeout: Webhookdb::Plivo.http_timeout,
+      )
+    rescue Webhookdb::Http::Error => e
+      self.service_integration.update(backfill_key: "", backfill_secret: "")
+      step.output = %(Those credentials didn't work (Plivo returned an HTTP #{e.status} error).
+Let's start over with your Auth ID (it probably begins with an MA or SA).)
+      return step.secret_prompt("Auth ID").backfill_key(self.service_integration)
+    end
+    step.output = %(Perfect, those credentials check out.
+You can use this endpoint in your Plivo Application to receive webhooks:
+
+  #{self._webhook_endpoint}
+
+This can be done through the UI, or the API by creating or updating an Application under your Account.
+
+As messages comes in, they'll be upserted into your table.
+#{self._query_help_output}
+
+You can also use `webhookdb httpsync` to set up notifications to your own server
+when rows are modified.)
+    return step.completed
+  end
+end

data/lib/webhookdb/replicator/postmark_inbound_message_v1.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "webhookdb/postmark"
+
+class Webhookdb::Replicator::PostmarkInboundMessageV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+
+  # @return [Webhookdb::Replicator::Descriptor]
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "postmark_inbound_message_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::PostmarkInboundMessageV1.new(sint) },
+      feature_roles: [],
+      resource_name_singular: "Postmark Inbound Message",
+      supports_webhooks: true,
+      api_docs_url: "https://postmarkapp.com/developer/user-guide/inbound/parse-an-email",
+    )
+  end
+
+  def _remote_key_column
+    return Webhookdb::Replicator::Column.new(:message_id, TEXT, data_key: "MessageID")
+  end
+
+  def _denormalized_columns
+    col = Webhookdb::Replicator::Column
+    return [
+      col.new(:from_email, TEXT, index: true, data_key: ["FromFull", "Email"]),
+      col.new(:to_email, TEXT, index: true, data_key: ["ToFull", 0, "Email"]),
+      col.new(:subject, TEXT, index: true, data_key: "Subject"),
+      col.new(:timestamp, TIMESTAMP, index: true, data_key: "Date"),
+      col.new(:tag, TEXT, index: true, data_key: "Tag"),
+    ]
+  end
+
+  def _prepare_for_insert(*)
+    h = super
+    ts_str = h[:timestamp]
+    # We get some weird time formats, like 'Wed, 05 Jul 2023 22:27:31 +0000 (UTC)'.
+    # Ruby can parse these, but PG cannot, so sanitize the ' (UTC)' out of here.
+    # Depending on what other random stuff we see, we can make this more general later.
+    h[:timestamp] = ts_str.gsub(/ \(UTC\)$/, "")
+    return h
+  end
+
+  def _timestamp_column_name
+    return :timestamp
+  end
+
+  def _resource_and_event(request)
+    return request.body, nil
+  end
+
+  def _update_where_expr
+    # These are immutable events, not updates, so never update after inserted.
+    return Sequel[false]
+  end
+
+  def _webhook_response(request)
+    return Webhookdb::Postmark.webhook_response(request)
+  end
+
+  def calculate_webhook_state_machine
+    step = Webhookdb::Replicator::StateMachineStep.new
+    if self.service_integration.webhook_secret.blank?
+      step.output = %(You are about to set up webhooks for Postmark Inbound Messages.
+When emails are sent to the email address configured in Postmark,
+they will show up in WebhookDB automatically.
+
+1. Go to https://account.postmarkapp.com/servers
+2. Choose the server you want to replicator.
+3. Choose the Inbound Stream to replicate.
+2. Go to the 'Settings' tab.
+3. Use this Webhook URL: #{self.webhook_endpoint}
+5. Hit 'Check' and verify it works. If it does not, double check your settings.
+6. Hit 'Save Webhook'.)
+      step.set_prompt("Press Enter after Save Webhook succeeds:")
+      step.transition_field(self.service_integration, "noop_create")
+      self.service_integration.update(webhook_secret: "placeholder")
+      return step
+    end
+    step.output = %(
+All set! Inbound Messages will be synced as they come in.
+
+#{self._query_help_output})
+    return step.completed
+  end
+
+  def backfill_not_supported_message
+    return %(We don't yet support backfilling Postmark Inbound Messages.
+File an issue at #{Webhookdb.oss_repo_url} or email hello@webhookdb.com to let us know if this is something you want!
+
+Run `webhookdb integration reset #{self.service_integration.opaque_id}` to go through webhook setup.)
+  end
+end

data/lib/webhookdb/replicator/postmark_outbound_message_event_v1.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "webhookdb/postmark"
+
+class Webhookdb::Replicator::PostmarkOutboundMessageEventV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+
+  # @return [Webhookdb::Replicator::Descriptor]
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "postmark_outbound_message_event_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::PostmarkOutboundMessageEventV1.new(sint) },
+      feature_roles: [],
+      resource_name_singular: "Postmark Outbound Message Event",
+      supports_webhooks: true,
+      api_docs_url: "https://postmarkapp.com/developer/webhooks/webhooks-overview",
+    )
+  end
+
+  TIMESTAMP_KEYS = ["ReceivedAt", "DeliveredAt", "BouncedAt", "ChangedAt"].freeze
+
+  LOOKUP_TIMESTAMP = Webhookdb::Replicator::Column::IsomorphicProc.new(
+    ruby: lambda do |resource:, **|
+      tskey = TIMESTAMP_KEYS.find { |k| resource[k] }
+      raise KeyError, "Cannot find valid timestamp key in #{resource}" if tskey.nil?
+      resource[tskey]
+    end,
+  )
+
+  BUILD_EVENT_MD5 = Webhookdb::Replicator::Column::IsomorphicProc.new(
+    ruby: lambda do |resource:, **|
+      md5 = Digest::MD5.new
+      md5.update(resource.fetch("MessageID"))
+      md5.update(resource.fetch("RecordType"))
+      md5.update(LOOKUP_TIMESTAMP.ruby.call(resource:))
+      md5.hexdigest
+    end,
+  )
+
+  def _remote_key_column
+    return Webhookdb::Replicator::Column.new(:event_id, UUID, optional: true, defaulter: BUILD_EVENT_MD5)
+  end
+
+  def _denormalized_columns
+    col = Webhookdb::Replicator::Column
+    return [
+      col.new(:message_id, TEXT, index: true, data_key: "MessageID"),
+      col.new(:timestamp, TIMESTAMP, index: true, optional: true, defaulter: LOOKUP_TIMESTAMP),
+      col.new(:record_type, TEXT, index: true, optional: true, data_key: "RecordType"),
+      col.new(:tag, TEXT, index: true, optional: true, data_key: "Tag"),
+      col.new(:recipient, TEXT, index: true, optional: true, data_key: "Recipient"),
+      col.new(:changed_at, TIMESTAMP, index: true, optional: true, data_key: "ChangedAt"),
+      col.new(:delivered_at, TIMESTAMP, index: true, optional: true, data_key: "DeliveredAt"),
+      col.new(:received_at, TIMESTAMP, index: true, optional: true, data_key: "ReceivedAt"),
+      col.new(:bounced_at, TIMESTAMP, index: true, optional: true, data_key: "BouncedAt"),
+    ]
+  end
+
+  def _timestamp_column_name
+    return :timestamp
+  end
+
+  def _resource_and_event(request)
+    return request.body, nil
+  end
+
+  def _update_where_expr
+    # Since the primary key is based on the timestamp, we never do updates
+    return Sequel[false]
+  end
+
+  def _webhook_response(request)
+    return Webhookdb::Postmark.webhook_response(request)
+  end
+
+  def calculate_webhook_state_machine
+    step = Webhookdb::Replicator::StateMachineStep.new
+    if self.service_integration.webhook_secret.blank?
+      step.output = %(You are about to set up webhooks for Postmark Outbound Message Events,
+like deliveries, clicks, and opens.
+
+1. In the Postmark UI, locate the server and stream (Transactional or Broadcast) you want to record.
+2. Click on the 'Webhooks' tab.
+3. Use this Webhook URL: #{self.webhook_endpoint}
+4. Check the events you want to send.
+5. Hit 'Send test' and verify it works. If it does not, double check your settings.
+6. Hit 'Save Changes')
+      step.set_prompt("Press Enter after Saved Changes succeeds:")
+      step.transition_field(self.service_integration, "noop_create")
+      self.service_integration.update(webhook_secret: "placeholder")
+      return step
+    end
+    step.output = %(
+All set! Events will be synced as they come in.
+
+#{self._query_help_output})
+    return step.completed
+  end
+
+  def backfill_not_supported_message
+    return %(We don't yet support backfilling Postmark Outbound Message Events.
+
+File an issue at #{Webhookdb.oss_repo_url} or email hello@webhookdb.com to let us know if this is something you want!
+
+Run `webhookdb integration reset #{self.service_integration.opaque_id}` to go through webhook setup.)
+  end
+end

data/lib/webhookdb/replicator/schema_modification.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Webhookdb::Replicator::SchemaModification
+  # All of these statements can be sent to the server at once.
+  # @return [Array<String>]
+  attr_reader :transaction_statements
+  # Each of these statements must be executed one-at-a-time.
+  # An example would be creating indices concurrently in PG.
+  # @return [Array<String>]
+  attr_reader :nontransaction_statements
+  # Each of these statements are executed in the application database,
+  # NOT whatever database the schema modification itself is executed against.
+  # @return [Array<String>]
+  attr_reader :application_database_statements
+
+  def initialize
+    @transaction_statements = []
+    @nontransaction_statements = []
+    @application_database_statements = []
+  end
+
+  def noop?
+    return @transaction_statements.empty? &&
+        @nontransaction_statements.empty? &&
+        @application_database_statements.empty?
+  end
+
+  def execute(db)
+    db << stmt2str(@transaction_statements)
+    @nontransaction_statements.each { |stmt| db << stmt }
+    Webhookdb::Postgres::Model.db << stmt2str(@application_database_statements)
+  end
+
+  private def stmt2str(lines)
+    return "" if lines.empty?
+    return lines.join(";\n") + ";"
+  end
+
+  def to_s
+    return [stmt2str(@transaction_statements), stmt2str(@nontransaction_statements)].reject(&:blank?).join("\n")
+  end
+end

data/lib/webhookdb/replicator/shopify_customer_v1.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "webhookdb/shopify"
+require "webhookdb/replicator/shopify_v1_mixin"
+
+class Webhookdb::Replicator::ShopifyCustomerV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+  include Webhookdb::Replicator::ShopifyV1Mixin
+
+  # @return [Webhookdb::Replicator::Descriptor]
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "shopify_customer_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::ShopifyCustomerV1.new(sint) },
+      feature_roles: [],
+      resource_name_singular: "Shopify Customer",
+      supports_webhooks: true,
+      supports_backfill: true,
+      api_docs_url: "https://shopify.dev/docs/api/admin-rest/2023-10/resources/customer",
+    )
+  end
+
+  def _remote_key_column
+    return Webhookdb::Replicator::Column.new(:shopify_id, TEXT, data_key: "id")
+  end
+
+  def _denormalized_columns
+    return [
+      Webhookdb::Replicator::Column.new(:created_at,  TIMESTAMP, index: true),
+      Webhookdb::Replicator::Column.new(:email, TEXT, index: true),
+      Webhookdb::Replicator::Column.new(:first_name, TEXT),
+      Webhookdb::Replicator::Column.new(:last_name, TEXT),
+      Webhookdb::Replicator::Column.new(:last_order_id, TEXT),
+      Webhookdb::Replicator::Column.new(:last_order_name, TEXT),
+      Webhookdb::Replicator::Column.new(:phone, TEXT, index: true),
+      Webhookdb::Replicator::Column.new(:state, TEXT),
+      Webhookdb::Replicator::Column.new(:updated_at, TIMESTAMP, index: true),
+    ]
+  end
+
+  def _update_where_expr
+    return self.qualified_table_sequel_identifier[:updated_at] < Sequel[:excluded][:updated_at]
+  end
+
+  def _mixin_backfill_url
+    return "/admin/api/2021-04/customers.json"
+  end
+
+  def _mixin_backfill_hashkey
+    return "customers"
+  end
+
+  def _mixin_backfill_warning
+    return %(Shopify allows us to backfill your entire Customer history,
+so you're in good shape.
+)
+  end
+end

data/lib/webhookdb/replicator/shopify_order_v1.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "webhookdb/shopify"
+require "webhookdb/replicator/shopify_v1_mixin"
+
+class Webhookdb::Replicator::ShopifyOrderV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+  include Webhookdb::Replicator::ShopifyV1Mixin
+
+  # @return [Webhookdb::Replicator::Descriptor]
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "shopify_order_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::ShopifyOrderV1.new(sint) },
+      feature_roles: [],
+      resource_name_singular: "Shopify Order",
+      supports_webhooks: true,
+      supports_backfill: true,
+      api_docs_url: "https://shopify.dev/docs/api/admin-rest/2023-10/resources/order",
+    )
+  end
+
+  def _remote_key_column
+    return Webhookdb::Replicator::Column.new(:shopify_id, TEXT, data_key: "id")
+  end
+
+  def _denormalized_columns
+    return [
+      Webhookdb::Replicator::Column.new(:app_id, TEXT),
+      Webhookdb::Replicator::Column.new(:cancelled_at, TIMESTAMP, index: true),
+      Webhookdb::Replicator::Column.new(:cart_token, TEXT),
+      Webhookdb::Replicator::Column.new(:checkout_token, TEXT),
+      Webhookdb::Replicator::Column.new(:closed_at, TIMESTAMP, index: true),
+      Webhookdb::Replicator::Column.new(:created_at, TIMESTAMP, index: true),
+      Webhookdb::Replicator::Column.new(:customer_id, TEXT,
+                                        index: true, data_key: ["customer", "id"], optional: true,),
+      Webhookdb::Replicator::Column.new(:email, TEXT, index: true),
+      Webhookdb::Replicator::Column.new(:name, TEXT),
+      Webhookdb::Replicator::Column.new(:order_number, INTEGER, index: true),
+      Webhookdb::Replicator::Column.new(:phone, TEXT, index: true),
+      Webhookdb::Replicator::Column.new(:token, TEXT),
+      Webhookdb::Replicator::Column.new(:updated_at, TIMESTAMP, index: true),
+      Webhookdb::Replicator::Column.new(:user_id, TEXT, index: true),
+    ]
+  end
+
+  def _update_where_expr
+    return self.qualified_table_sequel_identifier[:updated_at] < Sequel[:excluded][:updated_at]
+  end
+
+  def _mixin_backfill_url
+    return "/admin/api/2021-04/orders.json?status=any"
+  end
+
+  def _mixin_backfill_hashkey
+    return "orders"
+  end
+
+  def _mixin_backfill_warning
+    return %(Note that Shopify only allows access to orders made in the last 60 days,
+so this history will not be comprehensive.
+Please email #{Webhookdb.support_email} if you need a complete history backfill.)
+  end
+end

data/lib/webhookdb/replicator/shopify_v1_mixin.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "webhookdb/shopify"
+
+module Webhookdb::Replicator::ShopifyV1Mixin
+  def _mixin_backfill_url
+    raise NotImplementedError
+  end
+
+  def _mixin_backfill_hashkey
+    raise NotImplementedError
+  end
+
+  def _mixin_backfill_warning
+    raise NotImplementedError
+  end
+
+  def _timestamp_column_name
+    return :updated_at
+  end
+
+  # For Shopify endpoints the object and webhook have the same shape—the webhook is simply the updated object
+  def _resource_and_event(request)
+    return request.body, nil
+  end
+
+  def _webhook_response(request)
+    # info for debugging
+    shopify_auth = request.env["HTTP_X_SHOPIFY_HMAC_SHA256"]
+    log_params = {shopify_auth:, shopify_body: request.params}
+    self.logger.debug "webhook hit shopify endpoint", log_params
+
+    return Webhookdb::WebhookResponse.error("missing hmac") if shopify_auth.nil?
+    request.body.rewind
+    request_data = request.body.read
+    verified = Webhookdb::Shopify.verify_webhook(request_data, shopify_auth, self.service_integration.webhook_secret)
+    return Webhookdb::WebhookResponse.ok if verified
+    return Webhookdb::WebhookResponse.error("invalid hmac")
+  end
+
+  def process_state_change(field, value)
+    # special handling for converting a shop name into an api url
+    if field == "shop_name"
+      # revisionist history
+      field = "api_url"
+      value = "https://#{value}.myshopify.com"
+    end
+    return super(field, value)
+  end
+
+  def calculate_webhook_state_machine
+    step = Webhookdb::Replicator::StateMachineStep.new
+    # if the service integration doesn't exist, create it with some standard values
+    unless self.service_integration.webhook_secret.present?
+      step.needs_input = true
+      step.output = %(You are about to start replicating #{self.resource_name_plural} into WebhookDB.
+We've made an endpoint available for #{self.resource_name_singular} webhooks:
+
+#{self._webhook_endpoint}
+
+From your Shopify admin dashboard, go to Settings -> Notifications.
+Scroll down to the Webhook Section.
+You will need to create a separate webhook for each #{self.resource_name_singular} event,
+but you can use the URL above and select JSON as the desired format for all of them.
+
+At the very bottom of the page, you should see a signing secret that will be used to verify all webhooks.
+Copy that value.)
+      return step.secret_prompt("secret").webhook_secret(self.service_integration)
+    end
+
+    step.output = %(Great! WebhookDB is now listening for #{self.resource_name_singular} webhooks.
+#{self._query_help_output}
+In order to backfill existing #{self.resource_name_plural}, run this from a shell:
+
+  #{self._backfill_command}
+      )
+    return step.completed
+  end
+
+  def calculate_backfill_state_machine
+    step = Webhookdb::Replicator::StateMachineStep.new
+    unless self.service_integration.backfill_key.present?
+      step.output = \
+        %(In order to backfill #{self.resource_name_plural}, we need an API key and password
+(file an issue at #{Webhookdb.oss_repo_url} if you need token support).
+
+- From your Shopify Dashboard, go to Apps and click the "Manage Private Apps" link at the bottom of the page.
+- Then click "Create Private App" and fill out the necessary information.
+- When you get to the "Admin API" section,
+  select "Read Access" for the #{self.resource_name_singular} API and leave the rest as is.
+- Then hit "Save" and create the app.
+- You'll be presented with a page that has info about your app's credentials.
+
+We need both the API Key and Password.)
+      return step.secret_prompt("API Key").backfill_key(self.service_integration)
+    end
+
+    unless self.service_integration.backfill_secret.present?
+      return step.secret_prompt("Password").backfill_secret(self.service_integration)
+    end
+
+    unless self.service_integration.api_url.present?
+      step.output = %(Nice! Now we need the name of your shop so that we can construct the api url.
+This is the name that is used by Shopify for URL purposes.
+It should be in the top left corner of your Admin Dashboard next to the Shopify logo.)
+      step.post_to_url = self.service_integration.authed_api_path + "/transition/shop_name"
+      return step.prompting("Shop Name")
+    end
+
+    # we check backfill credentials *after* entering the api_url because it is required to establish the auth connection
+    unless (result = self.verify_backfill_credentials).verified
+      self.service_integration.replicator.clear_backfill_information
+      step.output = result.message
+      return step.secret_prompt("API Key").backfill_key(self.service_integration)
+    end
+
+    step.output = %(Great! We are going to start backfilling your #{self.resource_name_plural}.
+#{self._mixin_backfill_warning}
+#{self._query_help_output})
+    return step.completed
+  end
+
+  def _verify_backfill_403_err_msg
+    return "It looks like that API Key does not have permission to access #{self.resource_name_singular} Records. " \
+           "Please check the permissions by going to your private app page and " \
+           "looking at the list of active permissions. " \
+           "Once you've verified or corrected the permissions for this key, " \
+           "please reenter the API Key you just created:"
+  end
+
+  def _verify_backfill_401_err_msg
+    return "It looks like that API Key/Access Token combination is invalid. " \
+           "Please reenter the API Key you just created:"
+  end
+
+  def _verify_backfill_err_msg
+    return "An error occurred. Please reenter the API Key you just created:"
+  end
+
+  def _fetch_backfill_page(pagination_token, **_kwargs)
+    url = if pagination_token.blank?
+            self.service_integration.api_url + self._mixin_backfill_url
+    else
+      pagination_token
+    end
+    response = Webhookdb::Http.get(
+      url,
+      basic_auth: {username: self.service_integration.backfill_key,
+                   password: self.service_integration.backfill_secret,},
+      logger: self.logger,
+      timeout: Webhookdb::Shopify.http_timeout,
+    )
+    data = response.parsed_response
+    next_link = nil
+    if response.headers.key?("link")
+      links = Webhookdb::Shopify.parse_link_header(response.headers["link"])
+      next_link = links[:next] if links.key?(:next)
+    end
+    return data[self._mixin_backfill_hashkey], next_link
+  end
+end