webhookdb 0.1.0

data/lib/webhookdb/admin_api/database_documents.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "grape"
+
+require "webhookdb/admin_api"
+
+class Webhookdb::AdminAPI::DatabaseDocuments < Webhookdb::AdminAPI::V1
+  resource :database_documents do
+    route_param :id, type: Integer do
+      auth(:skip)
+      get :view do
+        (doc = Webhookdb::DatabaseDocument[params[:id]]) or forbidden!
+        doc.check_url(request.url) or forbidden!
+        content_type doc.content_type
+        env["api.format"] = :binary
+        body doc.content
+      end
+    end
+  end
+end

data/lib/webhookdb/admin_api/entities.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "grape_entity"
+
+require "webhookdb/service/entities"
+require "webhookdb/admin_api" unless defined? Webhookdb::AdminAPI
+
+module Webhookdb::AdminAPI
+  CurrentCustomerEntity = Webhookdb::Service::Entities::CurrentCustomer
+  MoneyEntity = Webhookdb::Service::Entities::Money
+  TimeRangeEntity = Webhookdb::Service::Entities::TimeRange
+
+  class BaseEntity < Webhookdb::Service::Entities::Base; end
+
+  class RoleEntity < BaseEntity
+    expose :id
+    expose :name
+  end
+
+  class CustomerEntity < BaseEntity
+    expose :id
+    expose :created_at
+    expose :email
+    expose :name
+    expose :note
+  end
+
+  class CustomerResetCodes < BaseEntity
+    expose :id
+    expose :created_at
+    expose :transport
+    expose :token
+    expose :used
+    expose :expire_at
+  end
+
+  class DetailedCustomerEntity < CustomerEntity
+    expose :roles do |instance|
+      instance.roles.map(&:name)
+    end
+    expose :reset_codes, with: CustomerResetCodes
+  end
+
+  class MessageBodyEntity < BaseEntity
+    expose :id
+    expose :content
+    expose :mediatype
+  end
+
+  class MessageDeliveryEntity < BaseEntity
+    expose :id
+    expose :created_at
+    expose :updated_at
+    expose :soft_deleted_at
+    expose :template
+    expose :transport_type
+    expose :transport_service
+    expose :transport_message_id
+    expose :sent_at
+    expose :to
+  end
+
+  class MessageDeliveryWithBodiesEntity < MessageDeliveryEntity
+    expose :bodies, with: MessageBodyEntity
+  end
+end

data/lib/webhookdb/admin_api/message_deliveries.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "grape"
+
+require "webhookdb/admin_api"
+
+class Webhookdb::AdminAPI::MessageDeliveries < Webhookdb::AdminAPI::V1
+  helpers do
+    def lookup_delivery(params)
+      (batch = Webhookdb::Message::Delivery[params[:id]]) or not_found!
+      return batch
+    end
+  end
+
+  resource :message_deliveries do
+    desc "Return all message deliveries, newest first"
+    params do
+      use :pagination
+      use :ordering, model: Webhookdb::Message::Delivery
+      use :searchable
+    end
+    get do
+      ds = Webhookdb::Message::Delivery.dataset
+      if (to_like = search_param_to_sql(params, :to))
+        criteria = to_like | search_param_to_sql(params, :template)
+        ds = ds.where(criteria)
+      end
+      ds = order(ds, params)
+      ds = paginate(ds, params)
+      present_collection ds, with: Webhookdb::AdminAPI::MessageDeliveryEntity
+    end
+
+    desc "Return the delivery with the last ID"
+    get :last do
+      delivery = Webhookdb::Message::Delivery.last
+      present delivery, with: Webhookdb::AdminAPI::MessageDeliveryWithBodiesEntity
+    end
+
+    route_param :id, type: Integer do
+      desc "Return the delivery"
+      get do
+        delivery = lookup_delivery(params)
+        present delivery, with: Webhookdb::AdminAPI::MessageDeliveryWithBodiesEntity
+      end
+    end
+  end
+
+  resource :customers do
+    route_param :id, type: Integer do
+      resource :message_deliveries do
+        desc "Return all message deliveries for customer the given customers, as recipients or to their emails"
+        get do
+          # rubocop:disable Layout/LineLength
+          ds = Webhookdb::Message::Delivery.to_customers(Webhookdb::Customer.where(id: params[:id])).order(Sequel.desc(:id))
+          # rubocop:enable Layout/LineLength
+          present_collection ds, with: Webhookdb::AdminAPI::MessageDeliveryEntity
+        end
+      end
+    end
+  end
+end

data/lib/webhookdb/admin_api/roles.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "grape"
+
+require "webhookdb/admin_api"
+
+class Webhookdb::AdminAPI::Roles < Webhookdb::AdminAPI::V1
+  resource :roles do
+    desc "Return all roles, ordered by name"
+    get do
+      ds = Webhookdb::Role.dataset.order(:name)
+      present_collection ds, with: Webhookdb::AdminAPI::RoleEntity
+    end
+  end
+end

data/lib/webhookdb/admin_api.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "grape"
+
+require "webhookdb"
+require "webhookdb/service"
+
+# API is the namespace module for Admin API resources.
+module Webhookdb::AdminAPI
+  require "webhookdb/admin_api/entities"
+
+  class V1 < Webhookdb::Service
+    def self.inherited(subclass)
+      super
+      subclass.instance_eval do
+        version "v1", using: :path
+        format :json
+
+        content_type :csv, "text/csv"
+
+        require "webhookdb/service/helpers"
+        helpers Webhookdb::Service::Helpers
+
+        auth(:admin)
+
+        before do
+          Sentry.configure_scope do |scope|
+            scope.set_tags(application: "admin-api")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/webhookdb/aggregate_result.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "webhookdb" unless defined?(Webhookdb)
+
+# Value returned or raised from a method that deals with aggregate success or failure.
+#
+# Sometimes we want to process a collection of items,
+# and not fail the entire thing if some fail. In this case, we can return an AggregateResult.
+# If the AggregateResult is returned, we know all items processed.
+# If it is raised, at least some of the items errored.
+#
+# Example:
+#   ag = AggregateResult.new
+#   items.each do |item|
+#     ag.success(myfunc(item))
+#   rescue => e
+#     ag.failure(item, e)
+#   end
+#   return ag.finish
+#
+class Webhookdb::AggregateResult < StandardError
+  attr_reader :successes, :failures, :errors
+
+  def initialize(existing=nil)
+    if existing.nil?
+      @successes = []
+      @failures = []
+      @errors = []
+      super("awaiting result")
+      return
+    end
+    # We can only set the exception message from initialization
+    @successes = existing.successes
+    @failures = existing.failures
+    @errors = existing.errors
+    if @failures.empty?
+      super("No errors")
+      return
+    end
+
+    lines = ["Multiple errors occurred:"]
+    @failures.each_with_index do |f, i|
+      lines << " #{f.inspect}: #{@errors[i].message}"
+    end
+    super(lines.join("\n"))
+  end
+
+  def success(i)
+    @successes << i
+  end
+
+  def failure(i, e)
+    @failures << i
+    @errors << e
+  end
+
+  def finish
+    raise InvalidPrecondition, "failures.length must equal errors.length" unless @failures.length == @errors.length
+    result = Webhookdb::AggregateResult.new(self)
+    return result if self.failures.empty?
+    raise result
+  end
+end

data/lib/webhookdb/api/auth.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "webhookdb/api"
+require "webhookdb/demo_mode"
+
+class Webhookdb::API::Auth < Webhookdb::API::V1
+  include Webhookdb::Service::Types
+
+  resource :auth do
+    helpers do
+      def guard_logged_in!
+        c = current_customer?
+        return if c.nil?
+        merror!(403, "You are already logged in as #{c.email}. You must log out first.", code: "already_logged_in")
+      end
+    end
+
+    helpers do
+      def finish_auth(me)
+        set_customer(me) if me
+        extras = {}
+        extras[:current_customer] = Webhookdb::API::CurrentCustomerEntity.represent(me).as_json if me
+        return extras
+      end
+    end
+
+    params do
+      optional :email,
+               type: String,
+               coerce_with: NormalizedEmail,
+               prompt: {
+                 message: "Welcome to WebhookDB!\nPlease enter your email:",
+                 demo_mode_proc: ->(r) { r.params[:email] = "demo@webhookdb.com" },
+               }
+      optional :token, type: String
+    end
+    post do
+      message = ""
+      if Webhookdb::DemoMode.client_enabled?
+        membership, step, message = Webhookdb::DemoMode.handle_auth
+        me = membership.customer
+        extras = finish_auth(me)
+        status 200
+      elsif params[:token].blank?
+        guard_logged_in!
+        begin
+          step, _ = Webhookdb::Customer.register_or_login(email: params[:email])
+        rescue Webhookdb::Customer::SignupDisabled
+          merror!(402, "Sorry, new signups are currently disabled.", code: "signup_disabled")
+        end
+        extras = {}
+        status 202
+      else
+        guard_logged_in!
+        step, me = Webhookdb::Customer.finish_otp(
+          Webhookdb::Customer[email: params[:email]], token: params[:token],
+        )
+        extras = finish_auth(me)
+        status 200
+      end
+      present step, with: Webhookdb::API::StateMachineEntity, extras:, message:
+    end
+
+    resource :login_otp do
+      route_param :opaque_id do
+        desc "Verify the OTP and auth the customer"
+        params do
+          requires :value
+        end
+        post do
+          guard_logged_in!
+          step, me = Webhookdb::Customer.finish_otp(
+            Webhookdb::Customer[opaque_id: params[:opaque_id]], token: params[:value],
+          )
+          extras = finish_auth(me)
+          status 200
+          present step, with: Webhookdb::API::StateMachineEntity, extras:
+        end
+      end
+    end
+
+    post :logout do
+      delete_session_cookies
+      status 200
+      present({}, with: Webhookdb::API::BaseEntity, message: "You have logged out.")
+    end
+
+    params do
+      requires :form_name, type: String
+      optional :email, type: String
+      optional :name, type: String
+      optional :message, type: String
+    end
+    post :contact do
+      fields = []
+      fields << {title: "Form", value: params[:form_name], short: true}
+      fields << {title: "IP", value: request.ip, short: true}
+      fields << {title: "User Agent", value: request.user_agent || "", short: false}
+      if (email = params[:email])
+        fields << {title: "Email", value: email, short: true}
+      end
+      if (name = params[:name])
+        fields << {title: "Name", value: name, short: true}
+      end
+      if (msg = params[:message])
+        fields << {title: "Message", value: msg, short: false}
+      end
+
+      Webhookdb::DeveloperAlert.new(
+        subsystem: "New Contact",
+        emoji: ":mailbox_with_mail:",
+        fallback: fields.
+          map { |f| "#{f[:title]}: #{f[:value]}" }.
+          join(", "),
+        fields:,
+      ).emit
+
+      status 200
+      present({message: "ok"})
+    end
+  end
+end

data/lib/webhookdb/api/connstr_auth.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "grape"
+
+# Some routes allow the SHA256 hash hexdigest connection string
+# to be used in place of normal authentication (for example, queries to the database,
+# which are not tied to a user). Do NOT extract this automatically (like org_identifier)
+# since we want endpoints to specify that they use the param explicitly.
+module Webhookdb::API::ConnstrAuth
+  ALGOS = ["Sha256"].freeze
+
+  def self.headers_desc
+    return ALGOS.to_h do |algo|
+      h = {
+        required: false,
+        algo:,
+        description: "Hex digest of the #{algo} hash of the organization connection string, " \
+                     "like Ruby's Digest::#{algo.upcase}.hexdigest(conn_str). " \
+                     "Can be used in place of normal auth.",
+      }
+      ["Whdb-#{algo}-Conn", h]
+    end
+  end
+
+  def self.find_authed(orgs, request)
+    orgs.find do |o|
+      self.headers_desc.each do |header_name, desc|
+        header_value = request.headers[header_name]
+        next if header_value.blank?
+        org_value = Digest.const_get(desc.fetch(:algo).upcase.to_sym).send(:hexdigest, o.readonly_connection_url)
+        return o if header_value == org_value
+      end
+    end
+    return nil
+  end
+end

data/lib/webhookdb/api/db.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "grape"
+
+require "webhookdb/api"
+require "webhookdb/replicator"
+
+class Webhookdb::API::Db < Webhookdb::API::V1
+  helpers do
+    params :fdw do
+      optional :message_fdw, type: Boolean
+      optional :message_views, type: Boolean
+      optional :message_all, type: Boolean
+      requires :remote_server_name, type: String
+      requires :fetch_size, type: String
+      requires :local_schema, type: String
+      requires :view_schema, type: String
+    end
+
+    def run_fdw
+      org = lookup_org!
+      resp = Webhookdb::Organization::DbBuilder.new(org).generate_fdw_payload(
+        remote_server_name: params[:remote_server_name],
+        fetch_size: params[:fetch_size],
+        local_schema: params[:local_schema],
+        view_schema: params[:view_schema],
+      )
+      resp[:message] = if params[:message_fdw]
+                         resp[:fdw_sql]
+      elsif params[:message_views]
+        resp[:views_sql]
+      else
+        resp[:compound_sql]
+      end
+      status 200
+      present resp
+    end
+  end
+
+  resource :db do
+    route_param :org_identifier, type: String do
+      desc "Returns the connection string"
+      get :connection do
+        _customer = current_customer
+        org = lookup_org!
+        r = {connection_url: org.readonly_connection_url}
+        present r
+      end
+
+      desc "Returns a list of all tables in the organization's db."
+      get :tables do
+        _customer = current_customer
+        org = lookup_org!
+        tables = org.readonly_connection do |db|
+          db.tables(schema: org.replication_schema)
+        end
+        message = ""
+        if tables.empty?
+          message = "You have not set up any service integrations.\n" \
+                    "Use `webhookdb services list` and `webhookdb integrations create` to get started."
+        end
+        present({tables:, message:})
+      end
+
+      desc "Enqueues a database migration."
+      params do
+        optional :admin_url, type: String, prompt: {
+          message: "ADMIN Postgres connection URL, in the form 'postgres://user:password@host:port/dbname',\n" \
+                   "that is capable of administrative operations on your database,\n" \
+                   "such as creating and dropping schemas and tables.\n" \
+                   "Input ADMIN URL, then press Enter:",
+          secret: true,
+          disable: ->(_) { !Webhookdb::Organization::DbBuilder.allow_public_migrations },
+        }
+
+        optional :readonly_url, type: String, prompt: {
+          message: "READONLY Postgres connection URL.\n" \
+                   "This string is displayed when you ask for your organization's connection information.\n" \
+                   "If you are okay with this being your ADMIN URL, leave it blank.\n" \
+                   "Input READONLY URL, or leave blank, then press Enter:",
+          secret: true,
+          optional: true,
+          disable: ->(_) { !Webhookdb::Organization::DbBuilder.allow_public_migrations },
+        }
+      end
+      post :migrate_database do
+        unless Webhookdb::Organization::DbBuilder.allow_public_migrations
+          merror!(403,
+                  "Public database migrations are not enabled. Email #{Webhookdb.oss_repo_url} for more information.",
+                  code: "migrations_disabled",
+                  alert: true,)
+        end
+        ensure_admin!
+        org = lookup_org!
+        # if the readonly url is blank, default to the admin url
+        readonly_url = params[:readonly_url].blank? ? params[:admin_url] : params[:readonly_url]
+        dbm = Webhookdb::Organization::DatabaseMigration.enqueue(
+          admin_connection_url_raw: params[:admin_url],
+          readonly_connection_url_raw: readonly_url,
+          public_host: "",
+          started_by: current_customer,
+          organization: org,
+        )
+        message = "Your database migration has been enqueued. You'll recieve an email when it is complete."
+        status 200
+        present dbm, with: Webhookdb::API::DatabaseMigrationEntity, message:
+      end
+
+      desc "Gets list of database migrations for org."
+      get :migrations do
+        org = lookup_org!
+        dbms = org.database_migrations
+        message = ""
+        message = "Organization #{org.name} has no database migrations" if dbms.empty?
+        status 200
+        present_collection dbms, with: Webhookdb::API::DatabaseMigrationEntity, message:
+      end
+
+      desc "Execute an arbitrary query against an org's connection string" do
+        headers Webhookdb::API::ConnstrAuth.headers_desc
+      end
+      params do
+        optional :query, type: String, prompt: "Input your SQL query, and then press Enter:"
+      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
+        status 200
+        present({rows: r.rows, headers: r.columns, max_rows_reached: r.max_rows_reached})
+      end
+
+      params do
+        optional :guard_confirm, prompt: {
+          message: "WARNING: This will invalidate your existing database credentials. " \
+                   "Enter to proceed, or Ctrl+C to quit:",
+          confirm: true,
+        }
+      end
+      post :roll_credentials do
+        ensure_admin!
+        org = lookup_org!
+        org.roll_database_credentials
+        connection_url = org.readonly_connection_url
+        status 200
+        present(
+          {connection_url:},
+          with: Webhookdb::API::BaseEntity,
+          message: "Your database connection string is now: #{connection_url}",
+        )
+      end
+
+      params do
+        use :fdw
+      end
+      post :fdw do
+        run_fdw
+      end
+    end
+  end
+
+  resource :organizations do
+    route_param :org_identifier, type: String do
+      # See https://github.com/webhookdb/webhookdb/issues/286
+      desc "DEPRECATED: Use /v1/db/:key/fdw instead"
+      post :fdw do
+        run_fdw
+      end
+    end
+  end
+end

data/lib/webhookdb/api/demo.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "webhookdb/api"
+
+class Webhookdb::API::Demo < Webhookdb::API::V1
+  resource :demo do
+    post :data do
+      merror!(403, "Demo mode is not enabled") unless Webhookdb::DemoMode.server_enabled?
+      r = Webhookdb::DemoMode.build_demo_data
+      status 200
+      present(r)
+    end
+  end
+end