webhookdb 0.1.0

data/lib/webhookdb/replicator/fake.rb

@@ -0,0 +1,453 @@
+# frozen_string_literal: true
+
+class Webhookdb::Replicator::Fake < Webhookdb::Replicator::Base
+  extend Webhookdb::MethodUtilities
+
+  singleton_attr_accessor :webhook_response
+  singleton_attr_accessor :upsert_has_deps
+  singleton_attr_accessor :resource_and_event_hook
+  singleton_attr_accessor :dispatch_request_to_hook
+  singleton_attr_accessor :process_webhooks_synchronously
+  singleton_attr_accessor :obfuscate_headers_for_logging
+  singleton_attr_accessor :requires_sequence
+
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "fake_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::Fake.new(sint) },
+      feature_roles: ["internal"],
+      resource_name_singular: "Fake",
+      supports_webhooks: true,
+      supports_backfill: true,
+    )
+  end
+
+  def self.reset
+    self.webhook_response = Webhookdb::WebhookResponse.ok
+    self.upsert_has_deps = false
+    self.resource_and_event_hook = nil
+    self.dispatch_request_to_hook = nil
+    self.process_webhooks_synchronously = nil
+    self.obfuscate_headers_for_logging = []
+    self.requires_sequence = false
+  end
+
+  def self.stub_backfill_request(items, status: 200)
+    return WebMock::API.stub_request(:get, "https://fake-integration/?token=").
+        to_return(status:, body: [items, nil].to_json, headers: {"Content-Type" => "application/json"})
+  end
+
+  def process_webhooks_synchronously?
+    return self.class.process_webhooks_synchronously ? true : false
+  end
+
+  def preprocess_headers_for_logging(headers)
+    self.class.obfuscate_headers_for_logging.each { |h| headers[h] = "***" }
+  end
+
+  def synchronous_processing_response_body(**)
+    return super unless self.process_webhooks_synchronously?
+    return self.class.process_webhooks_synchronously
+  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.output = "You're creating a fake_v1 service integration."
+      return step.prompting("fake API secret").webhook_secret(self.service_integration)
+    end
+
+    step.output = "The integration creation flow is working correctly. Here is " \
+                  "the integration's opaque id, which you'll need to enter in a second: " \
+                  "#{self.service_integration.opaque_id}"
+    return step.completed
+  end
+
+  def calculate_backfill_state_machine
+    step = Webhookdb::Replicator::StateMachineStep.new
+    # if the service integration doesn't exist, create it with some standard values
+    unless self.service_integration.backfill_secret.present?
+      step.needs_input = true
+      step.output = "Now let's test the backfill flow."
+      step.prompt = "Paste or type a string here:"
+      step.prompt_is_secret = false
+      step.post_to_url = self.service_integration.unauthed_webhook_path + "/transition/backfill_secret"
+      step.complete = false
+      return step
+    end
+
+    step.needs_input = false
+    step.output = "The backfill flow is working correctly."
+    step.complete = true
+    return step
+  end
+
+  def _webhook_response(_request)
+    r = self.class.webhook_response
+    raise r if r.is_a?(Exception)
+    return r
+  end
+
+  def _remote_key_column
+    return Webhookdb::Replicator::Column.new(:my_id, TEXT)
+  end
+
+  def _denormalized_columns
+    return [
+      Webhookdb::Replicator::Column.new(
+        :at,
+        TIMESTAMP,
+        index: true,
+        converter: Webhookdb::Replicator::Column::CONV_PARSE_TIME,
+      ),
+    ]
+  end
+
+  def _timestamp_column_name
+    return :at
+  end
+
+  def _resource_and_event(request)
+    body = request.body
+    return self.class.resource_and_event_hook.call(body) if self.class.resource_and_event_hook
+    return body, nil
+  end
+
+  def _update_where_expr
+    return Sequel[self.qualified_table_sequel_identifier][:at] < Sequel[:excluded][:at]
+  end
+
+  def requires_sequence?
+    return self.class.requires_sequence
+  end
+
+  def dispatch_request_to(request)
+    return self.class.dispatch_request_to_hook.call(request) if self.class.dispatch_request_to_hook
+    return super
+  end
+
+  def _fetch_backfill_page(pagination_token, **_kwargs)
+    r = Webhookdb::Http.get("https://fake-integration?token=#{pagination_token}", logger: nil, timeout: 30)
+    raise "Expected 2-item array" unless r.parsed_response.is_a?(Array) && r.parsed_response.length == 2
+    return r.parsed_response
+  end
+
+  def upsert_has_deps?
+    return self.class.upsert_has_deps
+  end
+end
+
+class Webhookdb::Replicator::FakeWithEnrichments < Webhookdb::Replicator::Fake
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "fake_with_enrichments_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::FakeWithEnrichments.new(sint) },
+      feature_roles: ["internal"],
+      resource_name_singular: "Enriched Fake",
+      supports_webhooks: true,
+      supports_backfill: true,
+    )
+  end
+
+  def _denormalized_columns
+    return super << Webhookdb::Replicator::Column.new(:extra, TEXT, from_enrichment: true)
+  end
+
+  def _store_enrichment_body?
+    return true
+  end
+
+  def _fetch_enrichment(resource, _event, _request)
+    r = Webhookdb::Http.get("https://fake-integration/enrichment/" + resource["my_id"], logger: nil, timeout: 30)
+    return r.parsed_response
+  end
+end
+
+class Webhookdb::Replicator::FakeDependent < Webhookdb::Replicator::Fake
+  singleton_attr_accessor :on_dependency_webhook_upsert_callback
+
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "fake_dependent_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::FakeDependent.new(sint) },
+      feature_roles: ["internal"],
+      resource_name_singular: "FakeDependent",
+      dependency_descriptor: Webhookdb::Replicator::Fake.descriptor,
+      supports_webhooks: true,
+      supports_backfill: true,
+    )
+  end
+
+  def on_dependency_webhook_upsert(replicator, payload, changed:)
+    self.class.on_dependency_webhook_upsert_callback&.call(replicator, payload, changed:)
+  end
+
+  def calculate_webhook_state_machine
+    dependency_help = "This is where you would explain things like the relationship between stripe cards and customers."
+    if (step = self.calculate_dependency_state_machine_step(dependency_help:))
+      return step
+    end
+    return super
+  end
+end
+
+class Webhookdb::Replicator::FakeDependentDependent < Webhookdb::Replicator::Fake
+  singleton_attr_accessor :on_dependency_webhook_upsert_callback
+
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "fake_dependent_dependent_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::FakeDependentDependent.new(sint) },
+      feature_roles: ["internal"],
+      resource_name_singular: "FakeDependentDependent",
+      dependency_descriptor: Webhookdb::Replicator::FakeDependent.descriptor,
+      supports_webhooks: true,
+      supports_backfill: true,
+    )
+  end
+
+  def on_dependency_webhook_upsert(replicator, payload, changed:)
+    self.class.on_dependency_webhook_upsert_callback&.call(replicator, payload, changed:)
+  end
+
+  def calculate_webhook_state_machine
+    dependency_help = "This is where you would explain things like the relationship between stripe cards and customers."
+    if (step = self.calculate_dependency_state_machine_step(dependency_help:))
+      return step
+    end
+    return super
+  end
+end
+
+class Webhookdb::Replicator::FakeEnqueueBackfillOnCreate < Webhookdb::Replicator::Fake
+  singleton_attr_accessor :on_dependency_webhook_upsert_callback
+
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "fake_enqueue_backfill_on_create_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::FakeEnqueueBackfillOnCreate.new(sint) },
+      feature_roles: ["internal"],
+      resource_name_singular: "FakeEnqueueBackfillOnCreate",
+      supports_webhooks: true,
+      supports_backfill: true,
+    )
+  end
+
+  def calculate_backfill_state_machine
+    # To mimic situations where it is possible to enqueue a backfill job on create, this backfill machine does
+    # not require any extra information--its initial step is "complete." The main situation where this would
+    # happen is if a replicator gets backfill creds from a dependency.
+    step = Webhookdb::Replicator::StateMachineStep.new
+    step.needs_input = false
+    step.output = "The backfill flow is working correctly."
+    step.complete = true
+    return step
+  end
+end
+
+class Webhookdb::Replicator::FakeWebhooksOnly < Webhookdb::Replicator::Fake
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "fake_webhooks_only_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::FakeWebhooksOnly.new(sint) },
+      feature_roles: ["internal"],
+      resource_name_singular: "Fake Webhooks Only (No Backfill)",
+      supports_webhooks: true,
+      supports_backfill: false,
+    )
+  end
+
+  def documentation_url = "https://abc.xyz"
+
+  def calculate_backfill_state_machine = raise NotImplementedError
+end
+
+class Webhookdb::Replicator::FakeBackfillOnly < Webhookdb::Replicator::Fake
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "fake_backfill_only_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::FakeBackfillOnly.new(sint) },
+      feature_roles: ["internal"],
+      resource_name_singular: "Fake Backfill Only (No Webhooks)",
+      supports_webhooks: false,
+      supports_backfill: true,
+    )
+  end
+
+  def calculate_webhook_state_machine = raise NotImplementedError
+end
+
+class Webhookdb::Replicator::FakeBackfillWithCriteria < Webhookdb::Replicator::Fake
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "fake_backfill_with_criteria_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::FakeBackfillWithCriteria.new(sint) },
+      feature_roles: ["internal"],
+      resource_name_singular: "Fake Backfill with Criteria",
+      dependency_descriptor: Webhookdb::Replicator::Fake,
+      supports_backfill: true,
+    )
+  end
+
+  def _denormalized_columns
+    return super << Webhookdb::Replicator::Column.new(:backfill_kwargs, OBJECT, optional: true)
+  end
+
+  def _backfillers(**kwargs)
+    return [CriteriaStoringBackfiller.new(self, kwargs)]
+  end
+
+  class CriteriaStoringBackfiller < Webhookdb::Backfiller
+    def initialize(svc, kw)
+      @svc = svc
+      @kw = kw
+      super()
+    end
+
+    def handle_item(body)
+      body["backfill_kwargs"] = @kw
+      @svc.upsert_webhook_body(body)
+    end
+
+    def fetch_backfill_page(_pagination_token, **_kwargs)
+      return [[{"my_id" => "x", "at" => "2022-01-01T00:00:00Z"}], nil]
+    end
+  end
+end
+
+class Webhookdb::Replicator::FakeExhaustiveConverter < Webhookdb::Replicator::Fake
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "fake_exhaustive_converter_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::FakeExhaustiveConverter.new(sint) },
+      feature_roles: ["internal"],
+      resource_name_singular: "Fake with all converters",
+      supports_webhooks: true,
+      supports_backfill: false,
+    )
+  end
+
+  def requires_sequence? = true
+
+  # True to return only the superclass columns. Used to test column updates.
+  attr_accessor :super_cols_only
+  # True to return only the columns that can be used for updates. Used to test column updates.
+  # Should be true when testing Ruby converters.
+  attr_accessor :exclude_unimplemented_sql_update_cols
+
+  def _denormalized_columns
+    cols = super
+    return cols if self.super_cols_only
+    cols += [
+      Webhookdb::Replicator::Column.new(
+        :comma_sep,
+        TEXT_ARRAY,
+        converter: Webhookdb::Replicator::Column::CONV_COMMA_SEP,
+      ),
+      Webhookdb::Replicator::Column.new(
+        :geo_lat,
+        DECIMAL,
+        data_key: "latlng",
+        converter: Webhookdb::Replicator::Column.converter_array_element(index: 0, sep: " ", cls: DECIMAL),
+      ),
+      Webhookdb::Replicator::Column.new(
+        :geo_lng,
+        DECIMAL,
+        data_key: "latlng",
+        converter: Webhookdb::Replicator::Column.converter_array_element(index: 1, sep: " ", cls: DECIMAL),
+      ),
+      Webhookdb::Replicator::Column.new(:date, DATE, converter: :date),
+      Webhookdb::Replicator::Column.new(:datetime, TIMESTAMP, converter: :time),
+      Webhookdb::Replicator::Column.new(:parsed_int, INTEGER, converter: :to_i),
+      Webhookdb::Replicator::Column.new(:unix_ts, TIMESTAMP, converter: :tsat),
+      Webhookdb::Replicator::Column.new(
+        :strptime,
+        TIMESTAMP,
+        converter: Webhookdb::Replicator::Column.converter_strptime("%d%m%Y %H%M%S%Z", "DDMMYYYY HH24MISS", cls: Time),
+      ),
+      Webhookdb::Replicator::Column.new(
+        :strptime_date,
+        DATE,
+        converter: Webhookdb::Replicator::Column.converter_strptime("%d%Y%m", "DDYYYYMM", cls: Date),
+      ),
+      Webhookdb::Replicator::Column.new(
+        :int_array,
+        BIGINT_ARRAY,
+        data_key: "obj_array",
+        converter: Webhookdb::Replicator::Column.converter_array_pluck("id", BIGINT),
+      ),
+      Webhookdb::Replicator::Column.new(
+        :text_array,
+        TEXT_ARRAY,
+        data_key: "obj_array",
+        converter: Webhookdb::Replicator::Column.converter_array_pluck("name", TEXT),
+      ),
+      Webhookdb::Replicator::Column.new(
+        :subtext,
+        TEXT,
+        converter: Webhookdb::Replicator::Column.converter_gsub("^hello", "goodbye"),
+      ),
+      Webhookdb::Replicator::Column.new(
+        :regex_extract,
+        TEXT,
+        data_key: "regex_conv",
+        converter: Webhookdb::Replicator::Column.converter_from_regex('/resources/(\d+)'),
+      ),
+      Webhookdb::Replicator::Column.new(
+        :regex_conv,
+        INTEGER,
+        converter: Webhookdb::Replicator::Column.converter_from_regex('/resources/(\d+)', dbtype: INTEGER),
+      ),
+      Webhookdb::Replicator::Column.new(
+        :to_utc_date,
+        DATE,
+        converter: Webhookdb::Replicator::Column::CONV_TO_UTC_DATE,
+      ),
+      Webhookdb::Replicator::Column.new(
+        :using_backfill_expr,
+        TEXT,
+        data_key: "my_id",
+        backfill_expr: "hi there",
+      ),
+      Webhookdb::Replicator::Column.new(
+        :using_backfill_statement,
+        TEXT,
+        data_key: "my_id",
+        backfill_statement: Sequel.lit(<<~SQL),
+          CREATE OR REPLACE FUNCTION pg_temp.fake_backfiller_update_tests(text)
+            RETURNS text AS 'SELECT $1 || $1' LANGUAGE sql IMMUTABLE
+        SQL
+        backfill_expr: Sequel.lit("pg_temp.fake_backfiller_update_tests(my_id)"),
+      ),
+    ]
+    return cols if self.exclude_unimplemented_sql_update_cols
+    cols << Webhookdb::Replicator::Column.new(
+      :int_or_seq_has,
+      INTEGER,
+      converter: Webhookdb::Replicator::Column.converter_int_or_sequence_from_regex('/resources/(\d+)'),
+    )
+    cols << Webhookdb::Replicator::Column.new(
+      :int_or_seq_has_not,
+      INTEGER,
+      converter: Webhookdb::Replicator::Column.converter_int_or_sequence_from_regex('/resources/(\d+)'),
+    )
+    cols << Webhookdb::Replicator::Column.new(
+      :map_lookup,
+      TEXT,
+      converter: Webhookdb::Replicator::Column.converter_map_lookup(
+        array: false,
+        map: {"a" => "A", "b" => "B"},
+      ),
+    )
+    cols << Webhookdb::Replicator::Column.new(
+      :map_lookup_array,
+      TEXT_ARRAY,
+      converter: Webhookdb::Replicator::Column.converter_map_lookup(
+        array: true,
+        map: {"a" => "A", "b" => "B"},
+      ),
+    )
+    return cols
+  end
+end

data/lib/webhookdb/replicator/front_conversation_v1.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "webhookdb/replicator/front_v1_mixin"
+
+class Webhookdb::Replicator::FrontConversationV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+  include Webhookdb::DBAdapter::ColumnTypes
+  include Webhookdb::Replicator::FrontV1Mixin
+
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "front_conversation_v1",
+      ctor: self,
+      feature_roles: ["front"],
+      resource_name_singular: "Front Conversation",
+      dependency_descriptor: Webhookdb::Replicator::FrontMarketplaceRootV1.descriptor,
+      supports_webhooks: true,
+      api_docs_url: "https://dev.frontapp.com/reference/conversations",
+    )
+  end
+
+  def _remote_key_column
+    return Webhookdb::Replicator::Column.new(:front_id, TEXT, data_key: "id")
+  end
+
+  def _denormalized_columns
+    return [
+      Webhookdb::Replicator::Column.new(:subject, TEXT),
+      Webhookdb::Replicator::Column.new(:status, TEXT),
+      Webhookdb::Replicator::Column.new(:created_at, TIMESTAMP, converter: :tsat),
+    ]
+  end
+
+  def _timestamp_column_name
+    return :created_at
+  end
+
+  def _resource_and_event(request)
+    return request.body.dig("payload", "conversation"), request.body.fetch("payload")
+  end
+
+  def _update_where_expr
+    return self.qualified_table_sequel_identifier[:data] !~ Sequel[:excluded][:data]
+  end
+end

data/lib/webhookdb/replicator/front_marketplace_root_v1.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "webhookdb/replicator/front_v1_mixin"
+
+class Webhookdb::Replicator::FrontMarketplaceRootV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+
+  # @return [Webhookdb::Replicator::Descriptor]
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "front_marketplace_root_v1",
+      ctor: self,
+      feature_roles: ["front"],
+      resource_name_singular: "Front Auth",
+      resource_name_plural: "Front Auth",
+      supports_webhooks: true,
+      description: "You can replicate your data to WebhookDB Cloud using the Front Marketplace.",
+    )
+  end
+
+  def _remote_key_column
+    return Webhookdb::Replicator::Column.new(:ignore_id, INTEGER)
+  end
+
+  def _denormalized_columns
+    return []
+  end
+
+  def _upsert_webhook(**_kwargs)
+    raise NotImplementedError("This is a stub integration only for auth purposes.")
+  end
+
+  def build_dependents
+    org = self.service_integration.organization
+    conversation_sint = Webhookdb::ServiceIntegration.create_disambiguated(
+      "front_conversation_v1",
+      organization: org,
+      depends_on: self.service_integration,
+    )
+    message_sint = Webhookdb::ServiceIntegration.create_disambiguated(
+      "front_message_v1",
+      organization: org,
+      depends_on: self.service_integration,
+    )
+    conversation_sint.replicator.create_table
+    message_sint.replicator.create_table
+  end
+
+  def calculate_webhook_state_machine
+    step = Webhookdb::Replicator::StateMachineStep.new
+    step.output = "This integration cannot be modified through the command line."
+    step.completed
+    return step
+  end
+end

data/lib/webhookdb/replicator/front_message_v1.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "webhookdb/replicator/front_v1_mixin"
+
+class Webhookdb::Replicator::FrontMessageV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+  include Webhookdb::DBAdapter::ColumnTypes
+  include Webhookdb::Replicator::FrontV1Mixin
+
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "front_message_v1",
+      ctor: self,
+      feature_roles: ["front"],
+      resource_name_singular: "Front Message",
+      dependency_descriptor: Webhookdb::Replicator::FrontMarketplaceRootV1.descriptor,
+      supports_webhooks: true,
+      api_docs_url: "https://dev.frontapp.com/reference/messages",
+    )
+  end
+
+  def _remote_key_column
+    return Webhookdb::Replicator::Column.new(:front_id, TEXT, data_key: "id")
+  end
+
+  def _denormalized_columns
+    return [
+      Webhookdb::Replicator::Column.new(:type, TEXT),
+      Webhookdb::Replicator::Column.new(:front_conversation_id, TEXT, event_key: ["conversation", "id"]),
+      Webhookdb::Replicator::Column.new(:created_at, TIMESTAMP, converter: :tsat),
+    ]
+  end
+
+  def _timestamp_column_name
+    return :created_at
+  end
+
+  def _resource_and_event(request)
+    return request.body.dig("payload", "target", "data"), request.body.fetch("payload")
+  end
+
+  def _update_where_expr
+    return self.qualified_table_sequel_identifier[:data] !~ Sequel[:excluded][:data]
+  end
+end

data/lib/webhookdb/replicator/front_v1_mixin.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "webhookdb/front"
+
+module Webhookdb::Replicator::FrontV1Mixin
+  def calculate_webhook_state_machine
+    if (step = self.calculate_dependency_state_machine_step(dependency_help: ""))
+      return step
+     end
+    step = Webhookdb::Replicator::StateMachineStep.new
+    step.output = %(Great! WebhookDB is now listening for #{self.resource_name_singular} webhooks.)
+    return step.completed
+  end
+
+  def _webhook_response(request)
+    return Webhookdb::Front.webhook_response(request)
+  end
+
+  def on_dependency_webhook_upsert(_replicator, _payload, *)
+    return
+  end
+end

data/lib/webhookdb/replicator/github_issue_comment_v1.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "webhookdb/github"
+require "webhookdb/replicator/github_repo_v1_mixin"
+
+class Webhookdb::Replicator::GithubIssueCommentV1 < Webhookdb::Replicator::Base
+  include Appydays::Loggable
+  include Webhookdb::Replicator::GithubRepoV1Mixin
+
+  def _mixin_backfill_url = "/issues/comments"
+  def _mixin_webhook_events = ["Issue comments"]
+  def _mixin_webhook_key = "comment"
+  def _mixin_fine_grained_permission = "Issues"
+
+  def _mixin_query_params(last_backfilled:)
+    q = {}
+    if last_backfilled
+      q[:sort] = "updated"
+      q[:since] = last_backfilled.utc.iso8601
+    end
+    return q
+  end
+
+  # @return [Webhookdb::Replicator::Descriptor]
+  def self.descriptor
+    return Webhookdb::Replicator::Descriptor.new(
+      name: "github_issue_comment_v1",
+      ctor: ->(sint) { Webhookdb::Replicator::GithubIssueCommentV1.new(sint) },
+      feature_roles: [],
+      resource_name_singular: "GitHub Issue Comment",
+      supports_webhooks: true,
+      supports_backfill: true,
+      api_docs_url: Webhookdb::Replicator::GithubRepoV1Mixin._api_docs_url("/issues/comments"),
+    )
+  end
+
+  def _remote_key_column
+    return Webhookdb::Replicator::Column.new(:github_id, BIGINT, data_key: "id")
+  end
+
+  def _denormalized_columns
+    return [
+      Webhookdb::Replicator::Column.new(
+        :issue_id,
+        BIGINT,
+        index: true,
+        data_key: "issue_url",
+        converter: Webhookdb::Replicator::Column.converter_from_regex('/issues/(\d+)$', dbtype: BIGINT),
+      ),
+      Webhookdb::Replicator::Column.new(:created_at, TIMESTAMP, index: true),
+      Webhookdb::Replicator::Column.new(:updated_at, TIMESTAMP, index: true),
+      Webhookdb::Replicator::Column.new(:user_id, BIGINT, index: true, data_key: ["user", "id"], optional: true),
+      Webhookdb::Replicator::Column.new(:node_id, TEXT, index: true),
+    ]
+  end
+
+  def _timestamp_column_name = :updated_at
+end