webhookdb 1.0.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eaccd930255b228e07aec00b36d43b6bfc47d0d57fca0ff7fe721e2bee3e09d1
-  data.tar.gz: e51b55c7dd624833ba56d11ecd666e6d3977c8c4e3d92f4b8146c3f8c9c2a47a
+  metadata.gz: d2c4da6abd3c5def6f27e180aaf435a4e9293eae4a1f926a065b87c1979372b3
+  data.tar.gz: 72de7406adc5049255878c5bf16fe05e92716d18c2f2492d996dbddb6b0aa307
 SHA512:
-  metadata.gz: 1b83e8bd2da2e8857e4fbfc4fce5ec2b92ebf22438d047014a337540bfab293412d3327acf13d470cd2063b6f2b712f568e7e225355af8b978a631befc17eea0
-  data.tar.gz: b5ef0bb3313894aab5b8c939905cbbd0f19196a96255ca3346a139b4f9338cedf55ad94ee55ac418395651c6d9a0d9d6949614de5965e651f1ea232354abd33b
+  metadata.gz: 725e0d6183cd7bfd259a4202c888e419658f77288de59adf2df1a6e48c36a06dd4f91857d43ac07f54e81aa9ee882a8e65813d3cb92d6cee0576d74a745ed28c
+  data.tar.gz: 6811f58d123c6693758c75c3e5ba4de991c7a5e3d621de581ac32fe76efb63ca8e910757cc3e42d18029fd10389c11d74b8255601781ed5c9267e042e0f7ca96

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/db/migrations/039_saved_query.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  change do
+    create_table(:saved_queries) do
+      primary_key :id
+      timestamptz :created_at, null: false, default: Sequel.function(:now)
+      timestamptz :updated_at
+      foreign_key :organization_id, :organizations, null: false, unique: true, on_delete: :cascade
+      foreign_key :created_by_id, :customers, on_delete: :set_null
+      text :opaque_id, null: false, unique: true
+      text :description, null: false
+      text :sql, null: false
+      boolean :public, null: false, default: false
+    end
+  end
+end

data/lib/webhookdb/api/db.rb

@@ -124,25 +124,8 @@ class Webhookdb::API::Db < Webhookdb::API::V1
       end
       post :sql do
         org = lookup_org!(allow_connstr_auth: true)
-        begin
-          r = org.execute_readonly_query(params[:query])
-        rescue Sequel::DatabaseError => e
-          self.logger.error("db_query_database_error", error: e)
-          # We want to handle InsufficientPrivileges and UndefinedTable explicitly
-          # since we can hint the user at what to do.
-          # Otherwise, we should just return the Postgres exception.
-          case e.wrapped_exception
-            when PG::UndefinedTable
-              missing_table = e.wrapped_exception.message.match(/relation (.+) does not/)&.captures&.first
-              msg = "The table #{missing_table} does not exist. Run `webhookdb db tables` to see available tables." if
-                missing_table
-            when PG::InsufficientPrivilege
-              msg = "You do not have permission to perform this query. Queries must be read-only."
-          else
-              msg = e.wrapped_exception.message
-          end
-          merror!(403, msg, code: "invalid_query")
-        end
+        r, msg = execute_readonly_query(org, params[:query])
+        merror!(403, msg, code: "invalid_query") if r.nil?
         status 200
         present({rows: r.rows, headers: r.columns, max_rows_reached: r.max_rows_reached})
       end

data/lib/webhookdb/api/helpers.rb

@@ -250,4 +250,31 @@ module Webhookdb::API::Helpers
       service_integration_opaque_id: opaque_id,
     )
   end
+
+  # Run the given SQL inside the org, and use special error handling if it fails.
+  # @return [Array<Webhookdb::Organization::QueryResult,String,nil>] Tuple of query result, and optional message.
+  #   On query success, return <QueryResult, nil>.
+  #   On DatabaseError, return <nil, message>.
+  #   On other types of errors, raise.
+  def execute_readonly_query(org, sql)
+    result = org.execute_readonly_query(sql)
+    return result, nil
+  rescue Sequel::DatabaseError => e
+    self.logger.error("db_query_database_error", error: e)
+    # We want to handle InsufficientPrivileges and UndefinedTable explicitly
+    # since we can hint the user at what to do.
+    # Otherwise, we should just return the Postgres exception.
+    msg = ""
+    case e.wrapped_exception
+      when PG::UndefinedTable
+        missing_table = e.wrapped_exception.message.match(/relation (.+) does not/)&.captures&.first
+        msg = "The table #{missing_table} does not exist. Run `webhookdb db tables` to see available tables." if
+          missing_table
+      when PG::InsufficientPrivilege
+        msg = "You do not have permission to perform this query. Queries must be read-only."
+      else
+        msg = e.wrapped_exception.message
+    end
+    return [nil, msg]
+  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/saved_queries.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require "webhookdb/api"
+require "webhookdb/saved_query"
+
+class Webhookdb::API::SavedQueries < Webhookdb::API::V1
+  resource :organizations do
+    route_param :org_identifier do
+      resource :saved_queries do
+        helpers do
+          def lookup!
+            org = lookup_org!
+            # We can add other identifiers in the future
+            cq = org.saved_queries_dataset[opaque_id: params[:query_identifier]]
+            merror!(403, "There is no saved query with that identifier.") if cq.nil?
+            return cq
+          end
+
+          def guard_editable!(customer, cq)
+            return if customer === cq.created_by
+            return if has_admin?(cq.organization, customer:)
+            permission_error!("You must be the query's creator or an org admin.")
+          end
+
+          def execute_readonly_query_with_suggestion(org, sql)
+            r, message = execute_readonly_query(org, sql)
+            return r, nil unless r.nil?
+            msg = "Something went wrong running your query. Perhaps a table it depends on was deleted. " \
+                  "Check out #{Webhookdb::SavedQuery::DOCS_URL} for troubleshooting tips. " \
+                  "Here's what went wrong: #{message}"
+            return r, msg
+          end
+        end
+
+        desc "Returns a list of all custom queries associated with the org."
+        get do
+          queries = lookup_org!.saved_queries
+          message = ""
+          if queries.empty?
+            message = "This organization doesn't have any saved queries yet.\n" \
+                      "Use `webhookdb saved-query create` to set one up."
+          end
+          present_collection queries, with: SavedQueryEntity, message:
+        end
+
+        desc "Creates a custom query."
+        params do
+          optional :description, type: String, prompt: "What is the query used for? "
+          optional :sql, type: String, prompt: "Enter the SQL you would like to run: "
+          optional :public, type: Boolean
+        end
+        post :create do
+          cust = current_customer
+          org = lookup_org!
+          _, errmsg = execute_readonly_query_with_suggestion(org, params[:sql])
+          if errmsg
+            Webhookdb::API::Helpers.prompt_for_required_param!(
+              request,
+              :sql,
+              "Enter a new query:",
+              output: "That query was invalid. #{errmsg}\n" \
+                      "You can iterate on your query by connecting to your database from any SQL editor.\n" \
+                      "Use `webhookdb db connection` to get your query string.",
+            )
+          end
+          cq = Webhookdb::SavedQuery.create(
+            description: params[:description],
+            sql: params[:sql],
+            organization: org,
+            created_by: cust,
+            public: params[:public] || false,
+          )
+          message = "You have created a new saved query with an id of '#{cq.opaque_id}'. " \
+                    "You can run it through the CLI, or through the API with or without authentication. " \
+                    "See #{Webhookdb::SavedQuery::DOCS_URL} for more information."
+          status 200
+          present cq, with: SavedQueryEntity, message:
+        end
+
+        route_param :query_identifier, type: String do
+          desc "Returns the query with the given identifier."
+          get do
+            cq = lookup!
+            status 200
+            message = "See #{Webhookdb::SavedQuery::DOCS_URL} to see how to run or modify your query."
+            present cq, with: SavedQueryEntity, message:
+          end
+
+          desc "Runs the query with the given identifier."
+          get :run do
+            _customer = current_customer
+            org = lookup_org!
+            cq = lookup!
+            r, msg = execute_readonly_query_with_suggestion(org, cq.sql)
+            merror!(400, msg) if r.nil?
+            status 200
+            present({rows: r.rows, headers: r.columns, max_rows_reached: r.max_rows_reached})
+          end
+
+          desc "Updates the field on a custom query."
+          params do
+            optional :field, type: String, prompt: "What field would you like to update (one of: " \
+                                                   "#{Webhookdb::SavedQuery::CLI_EDITABLE_FIELDS.join(', ')}): "
+            optional :value, type: String, prompt: "What is the new value? "
+          end
+          post :update do
+            customer = current_customer
+            cq = lookup!
+            guard_editable!(customer, cq)
+            # Instead of specifying which values are valid for the optional `field` param in the param declaration,
+            # we do the validation here so that we can provide a more helpful error message
+            unless Webhookdb::SavedQuery::CLI_EDITABLE_FIELDS.include?(params[:field])
+              merror!(400, "That field is not editable.")
+            end
+            value = params[:value]
+            case params[:field]
+              when "public"
+                begin
+                  value = Webhookdb.parse_bool(value)
+                rescue ArgumentError => e
+                  Webhookdb::API::Helpers.prompt_for_required_param!(
+                    request,
+                    :value,
+                    e.message + "\nAny boolean-like string (true, false, yes, no, etc) will work:",
+                  )
+                end
+                cq.public = value
+              when "sql"
+                r, msg = execute_readonly_query_with_suggestion(cq.organization, value)
+                if r.nil?
+                  Webhookdb::API::Helpers.prompt_for_required_param!(
+                    request,
+                    :value,
+                    "Enter your query:",
+                    output: msg,
+                  )
+                end
+                cq.sql = value
+              else
+                cq.send(:"#{params[:field]}=", value)
+            end
+            cq.save_changes
+            status 200
+            # Do not render the value here, it can be very long.
+            message = "You have updated '#{params[:field]}' on saved query '#{cq.opaque_id}'."
+            present cq, with: SavedQueryEntity, message:
+          end
+
+          params do
+            optional :field, type: String, values: Webhookdb::SavedQuery::INFO_FIELDS.keys + [""]
+          end
+          post :info do
+            cq = lookup!
+            data = Webhookdb::SavedQuery::INFO_FIELDS.
+              to_h { |k, v| [k.to_sym, cq.send(v)] }
+
+            field_name = params[:field]
+            blocks = Webhookdb::Formatting.blocks
+            if field_name.present?
+              blocks.line(data.fetch(field_name.to_sym))
+            else
+              rows = data.map do |k, v|
+                [k.to_s.humanize, v.to_s]
+              end
+              blocks.table(["Field", "Value"], rows)
+            end
+            r = {blocks: blocks.as_json}
+            status 200
+            present r
+          end
+
+          post :delete do
+            customer = current_customer
+            cq = lookup!
+            guard_editable!(customer, cq)
+            cq.destroy
+            status 200
+            present cq, with: SavedQueryEntity,
+                        message: "You have successfully deleted the saved query '#{cq.description}'."
+          end
+        end
+      end
+    end
+  end
+
+  resource :saved_queries do
+    route_param :query_identifier, type: String do
+      get :run do
+        # This endpoint can be used publicly, so should expose as little information as possible.
+        # Do not expose permissions or query details.
+        cq = Webhookdb::SavedQuery[opaque_id: params[:query_identifier]]
+        forbidden! if cq.nil?
+        if cq.private?
+          authed = Webhookdb::API::ConnstrAuth.find_authed([cq.organization], request)
+          if !authed && (cust = current_customer?)
+            authed = !cust.verified_memberships_dataset.where(organization: cq.organization).empty?
+            end
+          forbidden! unless authed
+        end
+        r, _ = execute_readonly_query(cq.organization, cq.sql)
+        merror!(400, "Something went wrong running the query.") if r.nil?
+        status 200
+        present({rows: r.rows, headers: r.columns, max_rows_reached: r.max_rows_reached})
+      end
+    end
+  end
+
+  class SavedQueryEntity < Webhookdb::API::BaseEntity
+    expose :opaque_id, as: :id
+    expose :description
+    expose :sql
+    expose :public
+    expose :run_url
+
+    def self.display_headers
+      return [[:id, "Id"], [:description, "Description"], [:public, "Public"], [:run_url, "Run URL"]]
+    end
+  end
+end

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/sync_targets.rb

@@ -112,18 +112,14 @@ class Webhookdb::API::SyncTargets < Webhookdb::API::V1
             params do
               use :connection_url
               use :sync_target_params
-              optional :service_integration_opaque_id,
-                       type: String, allow_blank: false,
-                       desc: "This is a deprecated parameter. In the future, please use `service_integration_identifier`."
-              optional :service_integration_identifier, type: String, allow_blank: false
-              at_least_one_of :service_integration_opaque_id, :service_integration_identifier
+              requires :service_integration_identifier, type: String, allow_blank: false
             end
             route_setting :target_type, target_type_resource
             post :create do
               customer = current_customer
               org = lookup_org!(customer:)
               ensure_admin!(org, customer:)
-              identifier = params[:service_integration_identifier] || params[:service_integration_opaque_id]
+              identifier = params[:service_integration_identifier]
               sint = lookup_service_integration!(org, identifier)
 
               validate_period!(sint.organization, params[:period_seconds])

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/api/webhook_subscriptions.rb

@@ -6,46 +6,40 @@ class Webhookdb::API::WebhookSubscriptions < Webhookdb::API::V1
   resource :organizations do
     route_param :org_identifier, type: String do
       resource :webhook_subscriptions do
-        desc "Return all webhook subscriptions for the given org, and all integrations."
+        desc "Return all notifications for the given org and its integrations."
         get do
           org = lookup_org!
           subs = org.all_webhook_subscriptions
           message = ""
           if subs.empty?
             message = "Organization #{org.name} has no webhook subscriptions set up.\n" \
-                      "Use `webhookdb webhooks create` to set one up."
+                      "Use `webhookdb notifications create` to set one up."
           end
           status 200
           present_collection subs, with: Webhookdb::API::WebhookSubscriptionEntity, message:
         end
 
         params do
-          optional :url, prompt: "Enter the URL that WebhookDB should POST webhooks to:"
-          optional :webhook_secret, prompt: "Enter a random secret used to sign and verify webhooks to the given url:"
           optional :service_integration_identifier,
                    type: String,
-                   desc: "If provided, attach the webhook subscription to this integration rather than the org."
-          optional :service_integration_opaque_id,
-                   type: String,
-                   desc: "This is a deprecated parameter. In the future, please use `service_integration_identifier`."
+                   desc: "If provided, attach the webhook subscription to this integration rather than the org.",
+                   prompt: "Which integration is this for? Use the service name, table name, or opaque id.\n" \
+                           "See your integrations with `webhookdb integrations list`:"
+          optional :url, prompt: "Enter the URL that WebhookDB should POST notifications to:"
+          optional :webhook_secret,
+                   prompt: "Enter a random secret used to sign and verify notifications to the given url:"
         end
         post :create do
           org = lookup_org!
-          sint = nil
-          identifier = params[:service_integration_identifier] || params[:service_integration_opaque_id]
-          sint = lookup_service_integration!(org, identifier) if identifier.present?
+          sint = lookup_service_integration!(org, params[:service_integration_identifier])
+          url = params[:url]
           webhook_sub = Webhookdb::WebhookSubscription.create(
             webhook_secret: params[:webhook_secret],
-            deliver_to_url: params[:url],
-            organization: sint ? nil : org,
+            deliver_to_url: url,
             service_integration: sint,
             created_by: current_customer,
           )
-          message = if sint
-                      "All webhooks for this #{sint.service_name} integration will be sent to #{params[:url]}"
-          else
-            "All webhooks for all integrations belonging to organization #{org.name} will be sent to #{params[:url]}."
-          end
+          message = "All notifications for this #{sint.service_name} integration will be sent to #{url}"
           status 200
           present webhook_sub, with: Webhookdb::API::WebhookSubscriptionEntity, message:
         end

data/lib/webhookdb/api.rb

@@ -60,13 +60,22 @@ module Webhookdb::API
             return org
           end
 
-          def ensure_admin!(org=nil, customer: nil)
+          # rubocop:disable Naming/PredicateName
+          def has_admin?(org=nil, customer: nil)
+            # rubocop:enable Naming/PredicateName
             customer ||= current_customer
             org ||= lookup_org!
             has_no_admin = org.verified_memberships_dataset.
               where(customer:, membership_role: Webhookdb::Role.admin_role).
               empty?
-            permission_error!("You don't have admin privileges with #{org.name}.") if has_no_admin
+            return !has_no_admin
+          end
+
+          def ensure_admin!(org=nil, customer: nil)
+            org ||= lookup_org!
+            admin = has_admin?(org, customer:)
+            # noinspection RubyNilAnalysis
+            permission_error!("You don't have admin privileges with #{org.name}.") unless admin
           end
         end
 

data/lib/webhookdb/apps.rb

@@ -17,6 +17,7 @@ require "webhookdb/api/install"
 require "webhookdb/api/me"
 require "webhookdb/api/organizations"
 require "webhookdb/api/replay"
+require "webhookdb/api/saved_queries"
 require "webhookdb/api/service_integrations"
 require "webhookdb/api/services"
 require "webhookdb/api/stripe"
@@ -68,6 +69,7 @@ module Webhookdb::Apps
     mount Webhookdb::API::Me
     mount Webhookdb::API::Organizations
     mount Webhookdb::API::Replay
+    mount Webhookdb::API::SavedQueries
     mount Webhookdb::API::ServiceIntegrations
     mount Webhookdb::API::Services
     mount Webhookdb::API::Stripe

data/lib/webhookdb/email_octopus.rb

@@ -2,6 +2,8 @@
 
 require "appydays/configurable"
 
+require "webhookdb/crypto"
+
 module Webhookdb::EmailOctopus
   include Appydays::Configurable
 

data/lib/webhookdb/envfixer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Webhookdb
+  module Envfixer
+    # If DOCKER_DEV is set, replace 'localhost' urls with 'host.docker.internal'.
+    def self.replace_localhost_for_docker(env)
+      return unless env["DOCKER_DEV"]
+      env.each do |k, v|
+        begin
+          localhost = URI(v).host == "localhost"
+        rescue StandardError
+          next
+        end
+        next unless localhost
+        env[k] = v.gsub("localhost", "host.docker.internal")
+      end
+    end
+
+    # If MERGE_HEROKU_ENV, merge all of its environment vars into the current env
+    def self.merge_heroku_env(env)
+      return unless (heroku_app = env.fetch("MERGE_HEROKU_ENV", nil))
+      text = `heroku config -j --app=#{heroku_app}`
+      json = Oj.load(text)
+      json.each do |k, v|
+        env[k] = v
+      end
+    end
+  end
+end