webhookdb 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eaccd930255b228e07aec00b36d43b6bfc47d0d57fca0ff7fe721e2bee3e09d1
-  data.tar.gz: e51b55c7dd624833ba56d11ecd666e6d3977c8c4e3d92f4b8146c3f8c9c2a47a
+  metadata.gz: d22b47783f1aaabc29dcc0fa023c0fee5bc9088d303103d1cf0cf859f807df0f
+  data.tar.gz: 41f7fcafef5d6724060e99fd40c5cfd19e9cd8d58c5736ccdd1bbaef9ecca826
 SHA512:
-  metadata.gz: 1b83e8bd2da2e8857e4fbfc4fce5ec2b92ebf22438d047014a337540bfab293412d3327acf13d470cd2063b6f2b712f568e7e225355af8b978a631befc17eea0
-  data.tar.gz: b5ef0bb3313894aab5b8c939905cbbd0f19196a96255ca3346a139b4f9338cedf55ad94ee55ac418395651c6d9a0d9d6949614de5965e651f1ea232354abd33b
+  metadata.gz: 5d33bedf7341af3216f623a9cc4328615d7a383251fc6d6b7b21000ce0366c99ea53d31f15f92d4a0bc754084faa063b1feb81e0174a966b27c7fda538f65a9a
+  data.tar.gz: 57d0fe4657c4c54a2b36fc3f71f7ca14017473b06be658f87f813670d79d424d51692717e6c1e9558ce0c1314f068b1b78c967bbf49c5d3d8c43bb08c3af874f

data/data/messages/web/install-customer-login.liquid

@@ -11,7 +11,7 @@
             <form method="POST" action="{{ action_url }}">
                 {% if view == "email" %}
                     <p>
-                        Welcome to Webhookdb! In order to complete this integration, we need your email address so that
+                        Welcome to WebhookDB! In order to complete this integration, we need your email address so that
                         we can associate your information with an organization.
                     </p>
                     <p>Enter your email:</p>

data/data/messages/web/install-success.liquid

@@ -19,9 +19,9 @@
                 </p>
             {% endif %}
             <p>
-                You can access the information using the following url:
+                You can connect to your replicated database with the following url:
             </p>
-            <p>{{ database_url }}</p>
+            <p><code>{{ database_url }}</code></p>
             <p>
                 To get more out of WebhookDB, like to replicate other APIs or set up Change Data Capture
                 to HTTP endpoints or databases, you can use the WebhookDB CLI.

data/db/migrations/038_webhookdb_api_key.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  change do
+    alter_table(:service_integrations) do
+      add_column :webhookdb_api_key, :text, null: true
+    end
+
+    alter_table(:idempotencies) do
+      add_column :stored_result, :jsonb, null: true
+    end
+  end
+end

data/lib/webhookdb/api/install.rb

@@ -3,6 +3,7 @@
 require "webhookdb/api"
 require "webhookdb/oauth"
 require "webhookdb/service/view_api"
+require "webhookdb/front"
 
 class Webhookdb::API::Install < Webhookdb::API::V1
   include Webhookdb::Service::ViewApi
@@ -37,6 +38,7 @@ class Webhookdb::API::Install < Webhookdb::API::V1
 
       def find_and_verify_user(email:, otp_token:)
         (me = Webhookdb::Customer.with_email(email)) or forbidden!
+        return me if me.should_skip_authentication?
         begin
           Webhookdb::Customer::ResetCode.use_code_with_token(otp_token) do |code|
             raise Webhookdb::Customer::ResetCode::Unusable unless code.customer === me
@@ -189,7 +191,7 @@ class Webhookdb::API::Install < Webhookdb::API::V1
       post :webhook do
         is_initial_request = request.headers["X-Front-Challenge"].present?
         if is_initial_request
-          whresp = Webhookdb::Front.initial_verification_request_response(request)
+          whresp = Webhookdb::Front.initial_verification_request_response(request, Webhookdb::Front.app_secret)
           s_status, s_headers, s_body = whresp.to_rack
           s_headers.each { |k, v| header k, v }
           if s_headers["Content-Type"] == "application/json"
@@ -236,6 +238,26 @@ class Webhookdb::API::Install < Webhookdb::API::V1
       end
     end
 
+    resource :front_signalwire do
+      params do
+        requires :type, type: String, values: Webhookdb::Front::CHANNEL_EVENT_TYPES
+        optional :payload, type: JSON
+      end
+      route [:post, :delete], :channel do
+        handle_webhook_request("front-signalwire-channel") do
+          auth_header = request.headers["Authorization"]
+          merror!(401, "Missing Authorization header", code: "unauthenticated") if
+            auth_header.nil?
+          merror!(401, "Expected Bearer authorization", code: "unauthenticated") unless
+            auth_header.start_with?("Bearer ")
+          apikey = auth_header[7..]
+          sint = Webhookdb::ServiceIntegration.for_api_key(apikey)
+          merror!(401, "Invalid API key", code: "unauthenticated") if sint.nil?
+          sint
+        end
+      end
+    end
+
     resource :intercom do
       post :webhook do
         # Because the `_webhook_response` function is always the same here, I'm wondering if it's even

data/lib/webhookdb/api/service_integrations.rb

@@ -187,19 +187,14 @@ If the list does not look correct, you can contact support at #{Webhookdb.suppor
 
           desc "Returns information about the integration."
           params do
-            optional :field, type: String, values: Webhookdb::ServiceIntegration::INTEGRATION_INFO_FIELDS
+            optional :field, type: String, values: Webhookdb::ServiceIntegration::INTEGRATION_INFO_FIELDS.keys + [""]
           end
           post :info do
             ensure_plan_supports!
             org = lookup_org!
             sint = lookup_service_integration!(org, params[:sint_identifier])
-            data = {
-              id: sint.opaque_id,
-              service: sint.service_name,
-              table: sint.table_name,
-              url: sint.replicator.webhook_endpoint,
-              webhook_secret: sint.webhook_secret,
-            }
+            data = Webhookdb::ServiceIntegration::INTEGRATION_INFO_FIELDS.
+              to_h { |k, v| [k.to_sym, sint.send(v)] }
 
             field_name = params[:field]
             blocks = Webhookdb::Formatting.blocks
@@ -207,7 +202,7 @@ If the list does not look correct, you can contact support at #{Webhookdb.suppor
               blocks.line(data.fetch(field_name.to_sym))
             else
               rows = data.map do |k, v|
-                [k.to_s.capitalize, v]
+                [k.to_s.humanize, v]
               end
               blocks.table(["Field", "Value"], rows)
             end
@@ -216,6 +211,16 @@ If the list does not look correct, you can contact support at #{Webhookdb.suppor
             present r
           end
 
+          post :roll_api_key do
+            ensure_plan_supports!
+            org = lookup_org!
+            sint = lookup_service_integration!(org, params[:sint_identifier])
+            sint.update(webhookdb_api_key: sint.new_api_key)
+            r = {webhookdb_api_key: sint.webhookdb_api_key}
+            status 200
+            present r
+          end
+
           resource :backfill do
             helpers do
               def lookup_backfillable_replicator(customer:, allow_connstr_auth: false)
@@ -370,9 +375,9 @@ The tables and all data for this integration and its dependents will also be rem
             if sint.dependents.empty?
               confirmation_msg = "Great! We've deleted all secrets for #{sint.service_name}. " \
                                  "The table #{sint.table_name} containing its data has been dropped."
-          else
-            confirmation_msg = "Great! We've deleted all secrets for #{sint.service_name} and its dependents. " \
-                               "The following tables have been dropped: \n\n #{sint.table_name} \n #{dependents_lines}"
+            else
+              confirmation_msg = "Great! We've deleted all secrets for #{sint.service_name} and its dependents. " \
+                                 "The following tables have been dropped:\n\n#{sint.table_name}\n#{dependents_lines}"
                                end
             present sint, with: Webhookdb::API::ServiceIntegrationEntity, message: confirmation_msg
           end

data/lib/webhookdb/api/system.rb

@@ -12,6 +12,10 @@ class Webhookdb::API::System < Webhookdb::Service
   require "webhookdb/service/helpers"
   helpers Webhookdb::Service::Helpers
 
+  get "/" do
+    redirect "/terminal/"
+  end
+
   get :healthz do
     # Do not bother looking at dependencies like databases.
     # If the primary is down, we can still accept webhooks
@@ -34,8 +38,15 @@ class Webhookdb::API::System < Webhookdb::Service
 
   if ["development", "test"].include?(Webhookdb::RACK_ENV)
     resource :debug do
-      get :echo do
-        pp params.to_h
+      resource :echo do
+        [:get, :post, :patch, :put, :delete].each do |m|
+          self.send(m) do
+            pp params.to_h
+            pp request.headers
+            status 200
+            present({})
+          end
+        end
       end
     end
   end

data/lib/webhookdb/fixtures/service_integrations.rb

@@ -39,4 +39,8 @@ module Webhookdb::Fixtures::ServiceIntegrations
     self.backfill_key = "fake_bfkey"
     self.backfill_secret = "fake_bfsecret"
   end
+
+  decorator :with_api_key do
+    self.webhookdb_api_key ||= self.new_api_key
+  end
 end

data/lib/webhookdb/front.rb

@@ -6,34 +6,44 @@ require "appydays/loggable"
 module Webhookdb::Front
   include Appydays::Configurable
 
+  CHANNEL_EVENT_TYPES = Set.new(["authorization", "delete", "message", "message_autoreply", "message_imported"])
+
   configurable(:front) do
-    # The api secret is used for webhook verification, the client id and secret are used for OAuth
-    setting :api_secret, "front_api_secret"
+    setting :http_timeout, 30
+
+    # WebhookDB App: App Secret from Basic Information tab in Front UI.
+    setting :app_secret, "front_api_secret", key: ["FRONT_APP_SECRET", "FRONT_API_SECRET"]
+    # WebhookDB App: Client ID from OAuth tab in Front UI.
     setting :client_id, "front_client_id"
+    # WebhookDB App: Client Secret from OAuth tab in Front UI.
     setting :client_secret, "front_client_secret"
-    setting :http_timeout, 30
-  end
 
-  def self.oauth_callback_url = Webhookdb.api_url + "/v1/install/front/callback"
+    setting :signalwire_channel_app_id, "front_swchan_app_id"
+    setting :signalwire_channel_app_secret, "front_swchan_app_secret"
+    setting :signalwire_channel_client_id, "front_swchan_client_id"
+    setting :signalwire_channel_client_secret, "front_swchan_client_secret"
+
+    setting :channel_sync_refreshness_cutoff, 48.hours.to_i
+  end
 
-  def self.verify_signature(request)
+  def self.verify_signature(request, secret)
     request.body.rewind
     body = request.body.read
     base_string = "#{request.env['HTTP_X_FRONT_REQUEST_TIMESTAMP']}:#{body}"
-    calculated_signature = OpenSSL::HMAC.base64digest(OpenSSL::Digest.new("sha256"), self.api_secret, base_string)
+    calculated_signature = OpenSSL::HMAC.base64digest(OpenSSL::Digest.new("sha256"), secret, base_string)
     return calculated_signature == request.env["HTTP_X_FRONT_SIGNATURE"]
   end
 
-  def self.webhook_response(request)
+  def self.webhook_response(request, secret)
     return Webhookdb::WebhookResponse.error("missing signature") unless request.env["HTTP_X_FRONT_SIGNATURE"]
 
-    from_front = Webhookdb::Front.verify_signature(request)
+    from_front = self.verify_signature(request, secret)
     return Webhookdb::WebhookResponse.ok(status: 200) if from_front
     return Webhookdb::WebhookResponse.error("invalid signature")
   end
 
-  def self.initial_verification_request_response(request)
-    from_front = self.verify_signature(request)
+  def self.initial_verification_request_response(request, secret)
+    from_front = self.verify_signature(request, secret)
     if from_front
       return Webhookdb::WebhookResponse.ok(
         json: {challenge: request.env["HTTP_X_FRONT_CHALLENGE"]},
@@ -46,4 +56,6 @@ module Webhookdb::Front
   def self.auth_headers(token)
     return {"Authorization" => "Bearer #{token}"}
   end
+
+  def self.channel_jwt_jti = SecureRandom.hex(4)
 end

data/lib/webhookdb/idempotency.rb

@@ -26,51 +26,112 @@ require "webhookdb/postgres/model"
 # usually using the :no_transaction_check spec metadata.
 #
 class Webhookdb::Idempotency < Webhookdb::Postgres::Model(:idempotencies)
-  extend Webhookdb::MethodUtilities
-
   NOOP = :skipped
 
-  # Skip the transaction check. Useful in unit tests. See class docs for details.
-  singleton_predicate_accessor :skip_transaction_check
+  class << self
+    # Skip the transaction check. Useful in unit tests. See class docs for details.
+    attr_accessor :skip_transaction_check
 
-  def self.once_ever
-    idem = self.new
-    idem.__once_ever = true
-    return idem
-  end
+    def skip_transaction_check? = self.skip_transaction_check
 
-  def self.every(interval)
-    idem = self.new
-    idem.__every = interval
-    return idem
-  end
+    # @return [Builder]
+    def once_ever
+      b = self::Builder.new
+      b._once_ever = true
+      return b
+    end
 
-  attr_accessor :__every, :__once_ever
+    # @return [Builder]
+    def every(interval)
+      b = self::Builder.new
+      b._every = interval
+      return b
+    end
 
-  def under_key(key, &block)
-    self.key = key
-    return self.execute(&block) if block
-    return self
+    def separate_connection
+      @connection ||= Sequel.connect(
+        uri,
+        logger: self.logger,
+        extensions: [
+          :connection_validator,
+          :pg_json, # Must have this to mirror the main model DB
+        ],
+        **Webhookdb::Dbutil.configured_connection_options,
+      )
+      return @connection
+    end
   end
 
-  def execute
-    Webhookdb::Postgres.check_transaction(
-      self.db,
-      "Cannot use idempotency while already in a transaction, since side effects may not be idempotent",
-    )
+  class Builder
+    attr_accessor :_every, :_once_ever, :_stored, :_sepconn, :_key
+
+    # If set, the result of block is stored as JSON,
+    # and returned when an idempotent call is made.
+    # The JSON value (as_json) is returned from the block in all cases.
+    # @return [Builder]
+    def stored
+      self._stored = true
+      return self
+    end
 
-    self.class.dataset.insert_conflict.insert(key: self.key)
-    self.db.transaction do
-      idem = Webhookdb::Idempotency[key: self.key].lock!
-      if idem.last_run.nil?
+    # Run the idempotency on a separate connection.
+    # Allows use of idempotency within an existing transaction block,
+    # which is normally not allowed. Usually should be used with #stored,
+    # since otherwise the result of the idempotency will be lost.
+    #
+    # NOTE: When calling code with using_seperate_connection,
+    # you may want to use the spec metadata `truncate: Webhookdb::Idempotency`
+    # since the row won't be covered by the spec's transaction.
+    #
+    # @return [Builder]
+    def using_seperate_connection
+      self._sepconn = true
+      return self
+    end
+
+    # @return [Builder]
+    def under_key(key, &block)
+      self._key = key
+      return self.execute(&block) if block
+      return self
+    end
+
+    def execute
+      if self._sepconn
+        db = Webhookdb::Idempotency.separate_connection
+      else
+        db = Webhookdb::Idempotency.db
+        Webhookdb::Postgres.check_transaction(
+          db,
+          "Cannot use idempotency while already in a transaction, since side effects may not be idempotent. " \
+          "You can chain withusing_seperate_connection to run the idempotency itself separately.",
+        )
+      end
+
+      db[:idempotencies].insert_conflict.insert(key: self._key)
+      db.transaction do
+        idem_row = db[:idempotencies].where(key: self._key).for_update.first
+        if idem_row.fetch(:last_run).nil?
+          result = yield()
+          result = self._update_row(db, result)
+          return result
+        end
+        noop_result = self._stored ? idem_row.fetch(:stored_result) : NOOP
+        return noop_result if self._once_ever
+        return noop_result if Time.now < (idem_row[:last_run] + self._every)
         result = yield()
-        idem.update(last_run: Time.now)
+        result = self._update_row(db, result)
         return result
       end
-      return NOOP if self.__once_ever
-      return NOOP if Time.now < (idem.last_run + self.__every)
-      result = yield()
-      idem.update(last_run: Time.now)
+    end
+
+    def _update_row(db, result)
+      updates = {last_run: Time.now}
+      if self._stored
+        result = result.as_json
+        updates[:stored_result] = Sequel.pg_jsonb_wrap(result)
+      end
+      db[:idempotencies].where(key: self._key).update(updates)
       return result
     end
   end

data/lib/webhookdb/jobs/backfill.rb

@@ -19,13 +19,32 @@ class Webhookdb::Jobs::Backfill
   end
 
   def _perform(event)
-    bfjob = self.lookup_model(Webhookdb::BackfillJob, event.payload)
+    begin
+      bfjob = self.lookup_model(Webhookdb::BackfillJob, event.payload)
+    rescue RuntimeError => e
+      self.logger.info "skipping_missing_backfill_job", error: e
+      return
+    end
     sint = bfjob.service_integration
     self.with_log_tags(sint.log_tags.merge(backfill_job_id: bfjob.opaque_id)) do
-      if bfjob.finished?
-        self.logger.info "skipping_finished_backfill_job"
-      else
-        sint.replicator.backfill(bfjob)
+      sint.db.transaction do
+        unless bfjob.lock?
+          self.logger.info "skipping_locked_backfill_job"
+          break
+        end
+        bfjob.refresh
+        if bfjob.finished?
+          self.logger.info "skipping_finished_backfill_job"
+          break
+        end
+        begin
+          sint.replicator.backfill(bfjob)
+        rescue Webhookdb::Replicator::CredentialsMissing
+          # The credentials could have been cleared out, so just finish this job.
+          self.logger.info "skipping_backfill_job_without_credentials"
+          bfjob.update(finished_at: Time.now)
+          break
+        end
       end
     end
   end

data/lib/webhookdb/jobs/scheduled_backfills.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require "webhookdb/email_octopus"
+require "webhookdb/github"
+require "webhookdb/sponsy"
+require "webhookdb/transistor"
+
 module Webhookdb::Jobs
   # Create a single way to do the common task of automatic scheduled backfills.
   # Each integration that needs automated backfills can add a specification here.

data/lib/webhookdb/oauth/{front.rb → front_provider.rb}

@@ -2,29 +2,35 @@
 
 require "webhookdb/front"
 
-class Webhookdb::Oauth::Front < Webhookdb::Oauth::Provider
+class Webhookdb::Oauth::FrontProvider < Webhookdb::Oauth::Provider
   include Appydays::Loggable
 
+  # Override these for custom OAuth of different apps
   def key = "front"
   def app_name = "Front"
+  def client_id = Webhookdb::Front.client_id
+  def client_secret = Webhookdb::Front.client_secret
+
   def requires_webhookdb_auth? = true
   def supports_webhooks? = true
 
   def authorization_url(state:)
-    return "https://app.frontapp.com/oauth/authorize?response_type=code&redirect_uri=#{Webhookdb::Front.oauth_callback_url}&state=#{state}&client_id=#{Webhookdb::Front.client_id}"
+    return "https://app.frontapp.com/oauth/authorize?response_type=code&redirect_uri=#{self.callback_url}&state=#{state}&client_id=#{self.client_id}"
   end
 
+  def callback_url = Webhookdb.api_url + "/v1/install/#{self.key}/callback"
+
   def exchange_authorization_code(code:)
     token = Webhookdb::Http.post(
       "https://app.frontapp.com/oauth/token",
       {
         "code" => code,
-        "redirect_uri" => Webhookdb::Front.oauth_callback_url,
+        "redirect_uri" => self.callback_url,
         "grant_type" => "authorization_code",
       },
       logger: self.logger,
       timeout: Webhookdb::Front.http_timeout,
-      basic_auth: {username: Webhookdb::Front.client_id, password: Webhookdb::Front.client_secret},
+      basic_auth: {username: self.client_id, password: self.client_secret},
     )
     return Webhookdb::Oauth::Tokens.new(
       access_token: token.parsed_response["access_token"],
@@ -56,3 +62,14 @@ class Webhookdb::Oauth::Front < Webhookdb::Oauth::Provider
     root_sint.replicator.build_dependents
   end
 end
+
+class Webhookdb::Oauth::FrontSignalwireChannelProvider < Webhookdb::Oauth::FrontProvider
+  def key = "front_signalwire"
+  def app_name = "Front Signalwire Channel"
+  def client_id = Webhookdb::Front.signalwire_channel_client_id
+  def client_secret = Webhookdb::Front.signalwire_channel_client_secret
+
+  def build_marketplace_integrations(*)
+    raise NotImplementedError, "this should not be called, Front channels have a different setup"
+  end
+end

data/lib/webhookdb/oauth/{intercom.rb → intercom_provider.rb}

@@ -2,7 +2,7 @@
 
 require "webhookdb/intercom"
 
-class Webhookdb::Oauth::Intercom < Webhookdb::Oauth::Provider
+class Webhookdb::Oauth::IntercomProvider < Webhookdb::Oauth::Provider
   include Appydays::Loggable
 
   def key = "intercom"

data/lib/webhookdb/oauth.rb

@@ -56,9 +56,9 @@ module Webhookdb::Oauth
   # rubocop:enable Lint/UnusedMethodArgument
 
   class << self
-    # @return [String, Class]
-    def register(key, cls)
-      raise "#{key} already registered to #{cls}" if self.registry.include?(key)
+    def register(cls)
+      key = cls.new.key
+      raise KeyError, "#{key} already registered to #{cls}" if self.registry.include?(key)
       self.registry[key] = cls
     end
 
@@ -74,7 +74,8 @@ module Webhookdb::Oauth
   end
 end
 
-require "webhookdb/oauth/front"
-Webhookdb::Oauth.register(Webhookdb::Oauth::Front.new.key, Webhookdb::Oauth::Front)
-require "webhookdb/oauth/intercom"
-Webhookdb::Oauth.register(Webhookdb::Oauth::Intercom.new.key, Webhookdb::Oauth::Intercom)
+require "webhookdb/oauth/front_provider"
+Webhookdb::Oauth.register(Webhookdb::Oauth::FrontProvider)
+Webhookdb::Oauth.register(Webhookdb::Oauth::FrontSignalwireChannelProvider)
+require "webhookdb/oauth/intercom_provider"
+Webhookdb::Oauth.register(Webhookdb::Oauth::IntercomProvider)

data/lib/webhookdb/organization/alerting.rb

@@ -7,7 +7,12 @@ class Webhookdb::Organization::Alerting
   include Appydays::Configurable
 
   configurable(:alerting) do
+    # Only send an alert with a given signature (replicator and error signature)
+    # to a given customer this often. Avoid spamming about any single replicator issue.
     setting :interval, 24.hours.to_i
+    # Each customer can only receive this many alerts for a given template per day.
+    # Avoids spamming a customer when many rows of a replicator have problems.
+    setting :max_alerts_per_customer_per_day, 15
   end
 
   attr_reader :org
@@ -25,9 +30,15 @@ class Webhookdb::Organization::Alerting
             "which is a unique identity for this error type, used for grouping and idempotency"
     end
     signature = message_template.signature
+    max_alerts_per_customer_per_day = Webhookdb::Organization::Alerting.max_alerts_per_customer_per_day
     self.org.admin_customers.each do |c|
       idemkey = "orgalert-#{signature}-#{c.id}"
       Webhookdb::Idempotency.every(Webhookdb::Organization::Alerting.interval).under_key(idemkey) do
+        sent_last_day = Webhookdb::Message::Delivery.
+          where(template: message_template.full_template_name, recipient: c).
+          limit(max_alerts_per_customer_per_day).
+          count
+        next unless sent_last_day < max_alerts_per_customer_per_day
         message_template.dispatch_email(c)
       end
     end

data/lib/webhookdb/postgres/model_utilities.rb

@@ -290,6 +290,25 @@ module Webhookdb::Postgres::ModelUtilities
       end
     end
 
+    # Run a SELECT FOR UPDATE SKIP LOCKED.
+    # If the model row is already locked, return false.
+    # Otherwise, acquire the lock and return true.
+    #
+    # If the lock is acquired, callers may want to refresh the receiver to make sure it has the newest values.
+    #
+    # @raise [Webhookdb::LockFailed] if the code is not currently in a transaction.
+    def lock?
+      raise Webhookdb::LockFailed, "must be in a transaction" unless self.db.in_transaction?
+      pk = self[self.class.primary_key]
+      got_lock = self.class.dataset.
+        select(1).
+        where(self.class.primary_key => pk).
+        for_update.
+        skip_locked.
+        first
+      return !got_lock.nil?
+    end
+
     # Round +Time+ t to remove nanoseconds, since Postgres can only store microseconds.
     protected def round_time(t)
       return nil if t.nil?

data/lib/webhookdb/replicator/column.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "uuidx"
 require "webhookdb/db_adapter"
 
 class Webhookdb::Replicator::Column
@@ -248,6 +249,8 @@ class Webhookdb::Replicator::Column
 
   DEFAULTER_NOW = IsomorphicProc.new(ruby: ->(*) { Time.now }, sql: ->(*) { Sequel.function(:now) })
   DEFAULTER_FALSE = IsomorphicProc.new(ruby: ->(*) { false }, sql: ->(*) { false })
+  DEFAULTER_UUID4 = IsomorphicProc.new(ruby: ->(*) { Uuidx.v4 }, sql: ->(*) { Sequel.function(:gen_random_uuid) })
+  DEFAULTER_UUID7 = IsomorphicProc.new(ruby: ->(*) { Uuidx.v7 }, sql: NOT_IMPLEMENTED)
   DEFAULTER_FROM_INTEGRATION_SEQUENCE = IsomorphicProc.new(
     ruby: ->(service_integration:, **_) { service_integration.sequence_nextval },
     sql: ->(service_integration:) { Sequel.function(:nextval, service_integration.sequence_name) },
@@ -259,7 +262,12 @@ class Webhookdb::Replicator::Column
       sql: ->(*) { key.to_sym },
     )
   end
-  KNOWN_DEFAULTERS = {now: DEFAULTER_NOW, tofalse: DEFAULTER_FALSE}.freeze
+  KNOWN_DEFAULTERS = {
+    now: DEFAULTER_NOW,
+    tofalse: DEFAULTER_FALSE,
+    uuid4: DEFAULTER_UUID4,
+    uuid7: DEFAULTER_UUID7,
+  }.freeze
 
   # Use in data_key when a value is an array, and you want to map a value from the array.
   EACH_ITEM = :_each_item

data/lib/webhookdb/replicator/front_conversation_v1.rb

@@ -11,7 +11,7 @@ class Webhookdb::Replicator::FrontConversationV1 < Webhookdb::Replicator::Base
     return Webhookdb::Replicator::Descriptor.new(
       name: "front_conversation_v1",
       ctor: self,
-      feature_roles: ["front"],
+      feature_roles: [],
       resource_name_singular: "Front Conversation",
       dependency_descriptor: Webhookdb::Replicator::FrontMarketplaceRootV1.descriptor,
       supports_webhooks: true,
@@ -42,4 +42,8 @@ class Webhookdb::Replicator::FrontConversationV1 < Webhookdb::Replicator::Base
   def _update_where_expr
     return self.qualified_table_sequel_identifier[:data] !~ Sequel[:excluded][:data]
   end
+
+  def calculate_webhook_state_machine
+    return Webhookdb::Replicator::FrontV1Mixin.marketplace_only_state_machine
+  end
 end