webhookdb 0.1.0

data/lib/webhookdb/replicator/signalwire_message_v1.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "webhookdb/signalwire"
+
+class Webhookdb::Replicator::SignalwireMessageV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+
+  # @return [Webhookdb::Replicator::Descriptor]
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "signalwire_message_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::SignalwireMessageV1.new(sint) },
+      feature_roles: [],
+      resource_name_singular: "SignalWire Message",
+      supports_backfill: true,
+      api_docs_url: "https://developer.signalwire.com/compatibility-api/rest/list-all-messages",
+    )
+  end
+
+  def _webhook_response(request)
+    auth = request.get_header("Authorization")
+    if auth.nil? || !auth.match(/^Basic /)
+      return Webhookdb::WebhookResponse.new(
+        status: 401,
+        body: "",
+        reason: "challenge",
+        headers: {"Content-Type" => "text/plain", "WWW-Authenticate" => 'Basic realm="Webhookdb"'},
+      )
+    end
+    user_and_pass = Base64.decode64(auth.gsub(/^Basic /, ""))
+    if user_and_pass != self.service_integration.webhook_secret
+      return Webhookdb::WebhookResponse.new(
+        status: 401,
+        body: "",
+        reason: "invalid",
+        headers: {"Content-Type" => "text/plain"},
+      )
+    end
+    return Webhookdb::WebhookResponse.new(
+      status: 202,
+      headers: {"Content-Type" => "text/xml"},
+      body: "<Response></Response>",
+    )
+  end
+
+  def calculate_backfill_state_machine
+    step = Webhookdb::Replicator::StateMachineStep.new
+    unless self.service_integration.api_url.present?
+      step.output = %(Let's finish setting up your SignalWire Messaging (SMS) integration.
+
+Rather than using your phone number's webhooks (of which each number can have only one),
+we poll SignalWire for changes, and will also backfill historical messages.
+
+To do this, we need your Space URL, Project ID, and an API Token.
+
+First enter your Space URL. You can see this on your SignalWire dashboard.
+It's the part of your dashboard URL before '.signalwire.com'.)
+      return step.prompting("Space URL").api_url(self.service_integration)
+    end
+
+    unless self.service_integration.backfill_key.present?
+      step.output = %(You can get your Project ID from the 'API' section of your SignalWire dashboard.
+
+Go to https://#{self.service_integration.api_url}.signalwire.com/credentials and copy your Project ID.)
+      return step.prompting("Project ID").backfill_key(self.service_integration)
+    end
+
+    unless self.service_integration.backfill_secret.present?
+      step.needs_input = true
+      step.output = %(Let's create or reuse an API token. Press the 'New' button on your dashboard,
+name the token something like 'WebhookDB', and under Scopes, ensure the 'Messaging' checkbox is checked.
+Then press 'Save'.
+
+Press 'Show' next to the newly-created API token, and copy it.)
+      return step.secret_prompt("API Token").backfill_secret(self.service_integration)
+    end
+
+    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 = %(We are going to start replicating your SignalWire Messages, and will keep it updated.
+#{self._query_help_output}
+      )
+    return step.completed
+  end
+
+  def _verify_backfill_401_err_msg
+    return "It looks like that API Key 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 _remote_key_column
+    return Webhookdb::Replicator::Column.new(:signalwire_id, TEXT, data_key: "sid")
+  end
+
+  def _denormalized_columns
+    return [
+      Webhookdb::Replicator::Column.new(
+        :date_created,
+        TIMESTAMP,
+        index: true,
+        converter: Webhookdb::Replicator::Column::CONV_PARSE_TIME,
+      ),
+      Webhookdb::Replicator::Column.new(
+        :date_sent,
+        TIMESTAMP,
+        index: true,
+        converter: Webhookdb::Replicator::Column::CONV_PARSE_TIME,
+      ),
+      Webhookdb::Replicator::Column.new(
+        :date_updated,
+        TIMESTAMP,
+        index: true,
+        converter: Webhookdb::Replicator::Column::CONV_PARSE_TIME,
+      ),
+      Webhookdb::Replicator::Column.new(:direction, TEXT),
+      Webhookdb::Replicator::Column.new(:from, TEXT, index: true),
+      Webhookdb::Replicator::Column.new(:status, TEXT),
+      Webhookdb::Replicator::Column.new(:to, TEXT, index: true),
+    ]
+  end
+
+  def _timestamp_column_name
+    return :date_updated
+  end
+
+  def _resource_and_event(request)
+    return request.body, nil
+  end
+
+  def _update_where_expr
+    return self.qualified_table_sequel_identifier[:date_updated] < Sequel[:excluded][:date_updated]
+  end
+
+  def _fetch_backfill_page(pagination_token, last_backfilled:)
+    url = "https://#{self.service_integration.api_url}.signalwire.com"
+    if pagination_token.blank?
+      date_send_max = Date.tomorrow
+      url += "/2010-04-01/Accounts/#{self.service_integration.backfill_key}/Messages.json" \
+             "?PageSize=100&DateSend%3C=#{date_send_max}"
+    else
+      url += 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::Signalwire.http_timeout,
+    )
+    data = response.parsed_response
+    messages = data["messages"]
+
+    if last_backfilled.present?
+      earliest_data_created = messages.empty? ? Time.at(0) : messages[-1].fetch("date_created")
+      paged_to_already_seen_records = earliest_data_created < last_backfilled
+
+      return messages, nil if paged_to_already_seen_records
+    end
+
+    return messages, data["next_page_uri"]
+  end
+end

data/lib/webhookdb/replicator/sponsy_customer_v1.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "webhookdb/replicator/sponsy_v1_mixin"
+
+class Webhookdb::Replicator::SponsyCustomerV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+  include Webhookdb::Replicator::SponsyV1Mixin
+
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "sponsy_customer_v1",
+      ctor: self,
+      feature_roles: [],
+      resource_name_singular: "Sponsy Customer",
+      dependency_descriptor: Webhookdb::Replicator::SponsySlotV1.descriptor,
+      supports_backfill: true,
+      api_docs_url: "https://api.getsponsy.com/docs",
+    )
+  end
+
+  def _denormalized_columns
+    return [
+      Webhookdb::Replicator::Column.new(:name, TEXT),
+      Webhookdb::Replicator::Column.new(:logo, TEXT, optional: true),
+      Webhookdb::Replicator::Column.new(:notes, TEXT, optional: true),
+      Webhookdb::Replicator::Column.new(:portal_text, TEXT, data_key: "portalText", optional: true),
+      Webhookdb::Replicator::Column.new(:portal_id, TEXT, data_key: "portalId", index: true, optional: true),
+    ].concat(self._ts_columns)
+  end
+
+  def _backfillers
+    return [Backfiller.new(service: self)]
+  end
+
+  class Backfiller < Webhookdb::Backfiller
+    def initialize(service:)
+      @service = service
+      @slot_service = service.service_integration.depends_on.replicator
+      super()
+    end
+
+    def handle_item(body)
+      @service.upsert_webhook_body(body)
+    end
+
+    def fetch_backfill_page(_pagination_token, last_backfilled:)
+      customers = @slot_service.admin_dataset do |ds|
+        (ds = ds.where { updated_at > last_backfilled }) if last_backfilled
+        ds.select_map(Sequel.pg_json(:data)["customer"].as(:customer))
+      end
+      return customers, nil
+    end
+  end
+end

data/lib/webhookdb/replicator/sponsy_placement_v1.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "webhookdb/replicator/sponsy_v1_mixin"
+
+class Webhookdb::Replicator::SponsyPlacementV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+  include Webhookdb::Replicator::SponsyV1Mixin
+
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "sponsy_placement_v1",
+      ctor: self,
+      feature_roles: [],
+      resource_name_singular: "Sponsy Placement",
+      dependency_descriptor: Webhookdb::Replicator::SponsyPublicationV1.descriptor,
+      supports_backfill: true,
+      api_docs_url: "https://api.getsponsy.com/docs",
+    )
+  end
+
+  def _denormalized_columns
+    return [
+      Webhookdb::Replicator::Column.new(:publication_id, TEXT, index: true),
+      Webhookdb::Replicator::Column.new(:name, TEXT),
+      Webhookdb::Replicator::Column.new(:slug, TEXT),
+      Webhookdb::Replicator::Column.new(:color, TEXT),
+      Webhookdb::Replicator::Column.new(:order, INTEGER),
+    ].concat(self._ts_columns)
+  end
+
+  def _backfillers(publication_ids: nil, publication_slugs: nil)
+    return self._publication_backfillers("/placements", publication_ids:, publication_slugs:)
+  end
+end

data/lib/webhookdb/replicator/sponsy_publication_v1.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "webhookdb/replicator/sponsy_v1_mixin"
+
+class Webhookdb::Replicator::SponsyPublicationV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+  include Webhookdb::Replicator::SponsyV1Mixin
+
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "sponsy_publication_v1",
+      ctor: self,
+      feature_roles: [],
+      resource_name_singular: "Sponsy Publication",
+      supports_backfill: true,
+      api_docs_url: "https://api.getsponsy.com/docs",
+    )
+  end
+
+  def _denormalized_columns
+    col = Webhookdb::Replicator::Column
+    return [
+      col.new(:name, TEXT),
+      col.new(:slug, TEXT),
+      col.new(:type, TEXT),
+      col.new(:deleted_at, TIMESTAMP, optional: true),
+      col.new(
+        :days,
+        INTEGER_ARRAY,
+        converter: col.converter_map_lookup(
+          array: true,
+          # 'MONDAY' => 0, 0 defaults to 0
+          map: col::DAYS_OF_WEEK.rotate.each_with_index.to_h { |dow, idx| [dow, idx] },
+        ),
+      ),
+      col.new(
+        :days_normalized,
+        INTEGER_ARRAY,
+        data_key: "days",
+        converter: col.converter_map_lookup(
+          array: true,
+          # 'MONDAY' => 1, 0 => 1
+          map: col::DAYS_OF_WEEK.each_with_index.to_a.concat((0..6).zip((0..6).to_a.rotate)).to_h,
+        ),
+        backfill_statement: Sequel.lit(<<~SQL),
+          CREATE OR REPLACE FUNCTION pg_temp.sponsy_publication_v1_normalize_days(integer[])
+            RETURNS integer[] AS 'SELECT ARRAY(SELECT ((n + 1) % 7) FROM unnest($1) AS n)' LANGUAGE sql IMMUTABLE
+        SQL
+        backfill_expr: Sequel.lit("pg_temp.sponsy_publication_v1_normalize_days(days)"),
+      ),
+      col.new(
+        :day_names,
+        TEXT_ARRAY,
+        data_key: "days",
+        converter: col.converter_map_lookup(
+          array: true,
+          # 0 => 'MONDAY'
+          map: col::DAYS_OF_WEEK.rotate.each_with_index.to_h { |dow, idx| [idx, dow] },
+        ),
+        # Big switch statement to map dow number to name
+        backfill_statement: Sequel.lit(<<~SQL),
+          CREATE OR REPLACE FUNCTION pg_temp.sponsy_publication_v1_day_names(integer[])
+            RETURNS text[] AS 'SELECT ARRAY(SELECT (CASE WHEN n = 0 THEN ''MONDAY'' WHEN n = 1 THEN ''TUESDAY'' WHEN n = 2 THEN ''WEDNESDAY'' WHEN n = 3 THEN ''THURSDAY'' WHEN n = 4 THEN ''FRIDAY'' WHEN n = 5 THEN ''SATURDAY'' WHEN n = 6 THEN ''SUNDAY'' END) FROM unnest($1) AS n)' LANGUAGE sql IMMUTABLE
+        SQL
+        backfill_expr: Sequel.lit("pg_temp.sponsy_publication_v1_day_names(days)"),
+      ),
+    ].concat(self._ts_columns)
+  end
+
+  def _backfillers
+    return [Backfiller.new(self)]
+  end
+
+  def _fetch_backfill_page(pagination_token, last_backfilled:)
+    return self.fetch_sponsy_page("/v1/publications", pagination_token, last_backfilled)
+  end
+
+  def calculate_backfill_state_machine
+    step = Webhookdb::Replicator::StateMachineStep.new
+    unless self.service_integration.backfill_secret.present?
+      step.needs_input = true
+      step.output = %(Great! Let's work on your Sponsy Publications integration.
+
+Head over to your Sponsy dashboard and copy your API key:
+
+https://getsponsy.com/settings/workspace
+)
+      return step.secret_prompt("API key").backfill_secret(self.service_integration)
+    end
+
+    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_secret(self.service_integration)
+    end
+
+    step.output = %(We are going to start replicating your Sponsy Publications
+and will keep them updated. You can can also add more Sponsy integrations.
+Run `webhookdb services list` to see what's available.
+#{self._query_help_output}
+)
+    return step.completed
+  end
+
+  def _verify_backfill_401_err_msg
+    return "It looks like that API Key is invalid. Head back to https://getsponsy.com/settings/workspace, " \
+           "copy the API key, and try again:"
+  end
+
+  # Normal backfiller that keeps track of inserted items,
+  # and marks anything not backfilled as deleted.
+  class Backfiller < Webhookdb::Replicator::Base::ServiceBackfiller
+    def handle_item(item)
+      super
+      @seen_ids ||= []
+      @seen_ids << item.fetch("id")
+    end
+
+    def flush_pending_inserts
+      self.svc.admin_dataset do |ds|
+        ds.exclude(sponsy_id: @seen_ids).where(deleted_at: nil).update(deleted_at: Sequel.function(:now))
+      end
+    end
+  end
+end

data/lib/webhookdb/replicator/sponsy_slot_v1.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "webhookdb/replicator/sponsy_v1_mixin"
+
+class Webhookdb::Replicator::SponsySlotV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+  include Webhookdb::Replicator::SponsyV1Mixin
+
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "sponsy_slot_v1",
+      ctor: self,
+      feature_roles: [],
+      resource_name_singular: "Sponsy Slot",
+      dependency_descriptor: Webhookdb::Replicator::SponsyPublicationV1.descriptor,
+      supports_backfill: true,
+      api_docs_url: "https://api.getsponsy.com/docs",
+    )
+  end
+
+  def _denormalized_columns
+    return [
+      Webhookdb::Replicator::Column.new(:publication_id, TEXT, index: true),
+      Webhookdb::Replicator::Column.new(:date, DATE, index: true),
+      Webhookdb::Replicator::Column.new(:notes, TEXT),
+      Webhookdb::Replicator::Column.new(
+        :customer_id, TEXT, data_key: ["customer", "id"], optional: true, index: true,
+      ),
+      Webhookdb::Replicator::Column.new(
+        :placement_id, TEXT, data_key: ["placement", "id"], optional: true, index: true,
+      ),
+      Webhookdb::Replicator::Column.new(
+        :status_id, TEXT, data_key: ["status", "id"], optional: true, index: true,
+      ),
+    ].concat(self._ts_columns)
+  end
+
+  def _backfillers(publication_ids: nil, publication_slugs: nil)
+    return self._publication_backfillers("/slots", publication_ids:, publication_slugs:)
+  end
+end

data/lib/webhookdb/replicator/sponsy_status_v1.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "webhookdb/replicator/sponsy_v1_mixin"
+
+class Webhookdb::Replicator::SponsyStatusV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+  include Webhookdb::Replicator::SponsyV1Mixin
+
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "sponsy_status_v1",
+      ctor: self,
+      feature_roles: [],
+      resource_name_singular: "Sponsy Status",
+      resource_name_plural: "Sponsy Statuses",
+      dependency_descriptor: Webhookdb::Replicator::SponsyPublicationV1.descriptor,
+      supports_backfill: true,
+      api_docs_url: "https://api.getsponsy.com/docs",
+    )
+  end
+
+  def _denormalized_columns
+    return [
+      Webhookdb::Replicator::Column.new(:publication_id, TEXT, index: true),
+      Webhookdb::Replicator::Column.new(:name, TEXT),
+      Webhookdb::Replicator::Column.new(:slug, TEXT),
+      Webhookdb::Replicator::Column.new(:color, TEXT),
+      Webhookdb::Replicator::Column.new(:order, INTEGER),
+    ].concat(self._ts_columns)
+  end
+
+  def _backfillers(publication_ids: nil, publication_slugs: nil)
+    return self._publication_backfillers("/status", publication_ids:, publication_slugs:)
+  end
+end

data/lib/webhookdb/replicator/sponsy_v1_mixin.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "webhookdb/sponsy"
+
+module Webhookdb::Replicator::SponsyV1Mixin
+  include Webhookdb::DBAdapter::ColumnTypes
+
+  def _remote_key_column
+    return Webhookdb::Replicator::Column.new(:sponsy_id, TEXT, data_key: "id")
+  end
+
+  def _timestamp_column_name
+    return :updated_at
+  end
+
+  def _ts_columns
+    return [
+      Webhookdb::Replicator::Column.new(:created_at, TIMESTAMP, data_key: "createdAt"),
+      Webhookdb::Replicator::Column.new(
+        :updated_at, TIMESTAMP,
+        data_key: "updatedAt",
+        defaulter: Webhookdb::Replicator::Column.defaulter_from_resource_field(:created_at),
+      ),
+    ]
+  end
+
+  def _verify_backfill_err_msg
+    return "Looks like your API key is invalid."
+  end
+
+  def api_url
+    return "https://api.getsponsy.com"
+  end
+
+  def auth_headers
+    return {"X-Api-Key" => self.find_api_key}
+  end
+
+  def root_integration
+    return @root_integration ||= Webhookdb::Replicator.find_at_root!(self.service_integration,
+                                                                     service_name: "sponsy_publication_v1",)
+  end
+
+  def find_api_key
+    return self.root_integration.backfill_secret
+  end
+
+  def _resource_and_event(request)
+    return request.body, nil
+  end
+
+  def _update_where_expr
+    return self.qualified_table_sequel_identifier[:updated_at] < Sequel[:excluded][:updated_at]
+  end
+
+  def _webhook_response(_request)
+    # There are no webhooks to respond to, these are backfill-only integrations
+    return Webhookdb::WebhookResponse.ok
+  end
+
+  # @return [Webhookdb::Replicator::StateMachineStep]
+  def calculate_backfill_state_machine
+    check_dep = self.class.descriptor.dependency_descriptor
+    if check_dep && (step = self.calculate_dependency_state_machine_step(dependency_help: ""))
+      return step
+    end
+    step = Webhookdb::Replicator::StateMachineStep.new
+    step.output = %(We will start replicating #{self.resource_name_plural} into your WebhookDB database.
+
+#{self._query_help_output(prefix: "Once data is available, you can query #{self.resource_name_plural}.")})
+    return step.completed
+  end
+
+  def on_dependency_webhook_upsert(_replicator, _payload, *)
+    return
+  end
+
+  def _parallel_backfill = Webhookdb::Sponsy.parallel_backfill
+
+  # Paginate from most recently updated.
+  # We paginate until either:
+  # - There are no more pages (the 'after cursor' is nil), or
+  # - the updated at timestamp predates the time we last backfilled,
+  #   meaning we probably already saw this update.
+  def fetch_sponsy_page(tail, pagination_token, last_backfilled)
+    url = self.api_url + tail
+    begin
+      response = Webhookdb::Http.get(
+        url,
+        query: {
+          limit: Webhookdb::Sponsy.page_size.to_s,
+          afterCursor: pagination_token,
+          orderBy: "updatedAt",
+          orderDirection: "DESC",
+        },
+        headers: self.auth_headers,
+        logger: self.logger,
+        timeout: Webhookdb::Sponsy.http_timeout,
+      )
+    rescue Webhookdb::Http::Error => e
+      raise e unless e.status == 404
+      self.logger.warn("sponsy_404", error: e)
+      return [], nil
+    end
+
+    data = response.parsed_response.fetch("data")
+    after_cursor = response.parsed_response.fetch("cursor", {}).fetch("afterCursor", nil)
+    return data, nil if after_cursor.nil?
+    return [], nil if data.empty?
+    last_updated = data.last.fetch("updatedAt")
+    return data, nil if last_updated < (last_backfilled || Time.at(0))
+    return data, after_cursor
+  end
+
+  def _publication_backfillers(tail, publication_ids: nil, publication_slugs: nil)
+    raise Webhookdb::Replicator::CredentialsMissing, "This Sponsy integration is missing a dependency with auth" if
+      self.find_api_key.blank?
+
+    publications_svc = self.service_integration.depends_on.replicator
+    backfillers = publications_svc.readonly_dataset(timeout: :fast) do |pub_ds|
+      pub_ds = Webhookdb::Dbutil.reduce_expr(
+        pub_ds,
+        :|,
+        [publication_ids && Sequel[sponsy_id: publication_ids], publication_slugs && Sequel[slug: publication_slugs]],
+      )
+      pub_ds = pub_ds.where(deleted_at: nil)
+      pub_ds.select(:sponsy_id).map do |publication|
+        PublicationChildBackfiller.new(
+          service: self,
+          publication_id: publication.fetch(:sponsy_id),
+          tail:,
+        )
+      end
+    end
+    return backfillers
+  end
+
+  class PublicationChildBackfiller < Webhookdb::Backfiller
+    include Webhookdb::Backfiller::Bulk
+
+    attr_reader :upserting_replicator
+
+    def initialize(service:, publication_id:, tail:)
+      @service = service
+      @upserting_replicator = @service
+      @publication_id = publication_id
+      @tail = tail
+      super()
+    end
+
+    def upsert_page_size = 500
+    def conditional_upsert? = true
+
+    def prepare_body(body)
+      body["publication_id"] = @publication_id
+      body
+    end
+
+    def fetch_backfill_page(pagination_token, last_backfilled:)
+      return @service.fetch_sponsy_page(
+        "/v1/publications/#{@publication_id}#{@tail}", pagination_token, last_backfilled,
+      )
+    end
+  end
+end

data/lib/webhookdb/replicator/state_machine_step.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+class Webhookdb::Replicator::StateMachineStep
+  attr_accessor :needs_input,
+                :prompt,
+                :prompt_is_secret,
+                :post_to_url,
+                :complete,
+                :output,
+                :error_code,
+                :post_params,
+                :post_params_value_key
+
+  def initialize
+    @needs_input = false
+    @prompt = ""
+    @prompt_is_secret = false
+    @post_to_url = ""
+    @complete = false
+    @output = ""
+    @error_code = ""
+    @post_params = {}
+    @post_params_value_key = "value"
+  end
+
+  def successful? = return self.complete && self.error_code.blank?
+
+  # @return [Webhookdb::Replicator::StateMachineStep]
+  def completed
+    self.complete = true
+    self.needs_input = false
+    return self
+  end
+
+  # @return [Webhookdb::Replicator::StateMachineStep]
+  def secret_prompt(field)
+    return self.prompting(field, secret: true)
+  end
+
+  def prompting(field, secret: false)
+    return self.set_prompt("Paste or type your #{field} here:", secret:)
+  end
+
+  def set_prompt(value, secret: false)
+    self.needs_input = true
+    self.prompt = value
+    self.prompt_is_secret = secret
+    self.complete = false
+    return self
+  end
+
+  # @return [Webhookdb::Replicator::StateMachineStep]
+  def backfill_secret(sint) = self.transition_field(sint, "backfill_secret")
+
+  # @return [Webhookdb::Replicator::StateMachineStep]
+  def backfill_key(sint) = self.transition_field(sint, "backfill_key")
+
+  # @return [Webhookdb::Replicator::StateMachineStep]
+  def webhook_secret(sint) = self.transition_field(sint, "webhook_secret")
+
+  # @return [Webhookdb::Replicator::StateMachineStep]
+  def api_url(sint) = self.transition_field(sint, "api_url")
+
+  # @return [Webhookdb::Replicator::StateMachineStep]
+  def transition_field(sint, field)
+    self.post_to_url = sint.authed_api_path + "/transition/#{field}"
+    return self
+  end
+end