webhookdb 0.1.0

data/lib/webhookdb/message/delivery.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "webhookdb/postgres/model"
+
+require "webhookdb/message"
+
+class Webhookdb::Message::Delivery < Webhookdb::Postgres::Model(:message_deliveries)
+  plugin :timestamps
+  plugin :soft_deletes
+
+  many_to_one :recipient, class: "Webhookdb::Customer"
+  one_to_many :bodies, class: "Webhookdb::Message::Body"
+
+  dataset_module do
+    def unsent
+      return self.not_soft_deleted.where(sent_at: nil)
+    end
+
+    def sent
+      return self.not_soft_deleted.exclude(sent_at: nil)
+    end
+
+    def to_customers(customers)
+      emails = customers.is_a?(Sequel::Dataset) ? customers.select(:email) : customers.map(&:email)
+      return self.where(Sequel[to: emails] | Sequel[recipient: customers])
+    end
+  end
+
+  def initialize(*)
+    super
+    self[:extra_fields] ||= {}
+  end
+
+  def body_with_mediatype(mt)
+    return self.bodies.find { |b| b.mediatype == mt }
+  end
+
+  def body_with_mediatype!(mt)
+    (b = self.body_with_mediatype(mt)) or raise "Delivery #{self.id} has no body with mediatype #{mt}"
+    return b
+  end
+
+  def sent?
+    return self.sent_at ? true : false
+  end
+
+  def send!
+    return nil if self.sent? || self.soft_deleted?
+    self.db.transaction do
+      self.lock!
+      return nil if self.sent? || self.soft_deleted?
+      begin
+        transport_message_id = self.transport.send!(self)
+      rescue Webhookdb::Message::Transport::UndeliverableRecipient
+        self.logger.warn("undeliverable_recipient", recipient: self.to, message_delivery_id: self.id)
+        self.soft_delete
+        return self
+      end
+      if transport_message_id.blank?
+        self.logger.error("empty_transport_message_id", message_delivery_id: self.id)
+        transport_message_id = "WARNING-NOT-SET"
+      end
+      self.update(transport_message_id:, sent_at: Time.now)
+      return self
+    end
+  end
+
+  def transport
+    return Webhookdb::Message::Transport.for(self.transport_type)
+  end
+
+  def transport!
+    return Webhookdb::Message::Transport.for!(self.transport_type)
+  end
+
+  def self.preview(template_class_name, transport: :email, rack_env: Webhookdb::RACK_ENV, commit: false)
+    raise "Can only preview in development or commit:false" unless rack_env == "development" || !commit
+
+    Gem.find_files("webhookdb/messages/**/*.rb").each do |path|
+      require path
+    end
+
+    begin
+      template_class = "Webhookdb::Messages::#{template_class_name}".constantize
+    rescue NameError
+      raise Webhookdb::Message::MissingTemplateError, "Webhookdb::Messages::#{template_class_name} not found"
+    end
+
+    require "webhookdb/fixtures"
+    Webhookdb::Fixtures.load_all
+
+    delivery = nil
+    self.db.transaction(rollback: commit ? nil : :always) do
+      to = Webhookdb::Fixtures.customer.create
+      template = template_class.fixtured(to)
+      delivery = template.dispatch(to, transport:)
+      delivery.bodies # Fetch this ahead of time so it is there after rollback
+    end
+    return delivery
+  end
+end
+
+# Table: message_deliveries
+# ---------------------------------------------------------------------------------------------------------------------
+# Columns:
+#  id                   | integer                  | PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY
+#  created_at           | timestamp with time zone | NOT NULL DEFAULT now()
+#  updated_at           | timestamp with time zone |
+#  template             | text                     | NOT NULL
+#  transport_type       | text                     | NOT NULL
+#  transport_service    | text                     | NOT NULL
+#  transport_message_id | text                     |
+#  sent_at              | timestamp with time zone |
+#  to                   | text                     | NOT NULL
+#  recipient_id         | integer                  |
+#  extra_fields         | jsonb                    | NOT NULL DEFAULT '{}'::jsonb
+#  soft_deleted_at      | timestamp with time zone |
+# Indexes:
+#  message_deliveries_pkey                     | PRIMARY KEY btree (id)
+#  message_deliveries_transport_message_id_key | UNIQUE btree (transport_message_id)
+#  message_deliveries_recipient_id_index       | btree (recipient_id)
+#  message_deliveries_sent_at_index            | btree (sent_at)
+# Foreign key constraints:
+#  message_deliveries_recipient_id_fkey | (recipient_id) REFERENCES customers(id) ON DELETE SET NULL
+# Referenced By:
+#  message_bodies | message_bodies_delivery_id_fkey | (delivery_id) REFERENCES message_deliveries(id) ON DELETE CASCADE
+# ---------------------------------------------------------------------------------------------------------------------

data/lib/webhookdb/message/email_transport.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "appydays/configurable"
+require "mail"
+require "premailer"
+
+require "webhookdb/message/transport"
+
+class Webhookdb::Message::EmailTransport < Webhookdb::Message::Transport
+  include Appydays::Configurable
+
+  register_transport(:email)
+
+  configurable(:email) do
+    setting :allowlist, ["*@lithic.tech", "*@webhookdb.com"], convert: ->(s) { s.split }
+    setting :from, "WebhookDB <hello@webhookdb.com>"
+
+    setting :smtp_host, "localhost"
+    setting :smtp_port, 18_012
+    setting :smtp_user, ""
+    setting :smtp_password, ""
+    setting :smtp_starttls, false
+
+    # If this is a recognized value, certain special behavior is used,
+    # particularly around message ids and metadata.
+    # Currently supported values:
+    #
+    # - postmark: Set the X-PM-Metadata-messageid field and some other fields.
+    #
+    # If you need other behavior, you can open an issue or pull request.
+    # Unsupported values are ignored.
+    setting :smtp_provider, ""
+    # Additional headers sent in each email.
+    setting :smtp_headers, {}, convert: ->(s) { JSON.parse(s) }
+
+    # Only really used during testing and development.
+    # We don't expect this to be running in production.
+    setting :mailpit_url, "http://localhost:18011"
+  end
+
+  def type
+    return :email
+  end
+
+  def service
+    return "smtp"
+  end
+
+  def supports_layout?
+    return true
+  end
+
+  def add_bodies(delivery, content)
+    pm = Premailer.new(
+      content.to_s,
+      with_html_string: true,
+      warn_level: Premailer::Warnings::SAFE,
+    )
+
+    begin
+      subject = content[:subject]
+    rescue TypeError, NoMethodError
+      subject = nil
+    end
+
+    raise "content %p is missing a subject" % content unless subject
+
+    bodies = []
+    bodies << delivery.add_body(content: content[:subject], mediatype: "subject")
+    bodies << delivery.add_body(content: pm.to_plain_text, mediatype: "text/plain")
+    bodies << delivery.add_body(content: pm.to_inline_css, mediatype: "text/html")
+    return bodies
+  end
+
+  def allowlisted?(address)
+    return self.class.allowlist.any? { |pattern| File.fnmatch(pattern, address) }
+  end
+
+  def send!(delivery)
+    unless allowlisted?(delivery.to)
+      raise Webhookdb::Message::Transport::UndeliverableRecipient,
+            "#{delivery.to} is not allowlisted"
+    end
+
+    from = delivery.extra_fields["from"].present? ? delivery.extra_fields["from"] : self.class.from
+    to = self.format_email_name(delivery.to, delivery.recipient&.name)
+    message_id = SecureRandom.uuid.to_s
+    this = self
+    Mail.deliver do
+      delivery_method(
+        :smtp,
+        address: this.class.smtp_host,
+        port: this.class.smtp_port,
+        user_name: this.class.smtp_user,
+        password: this.class.smtp_password,
+        enable_starttls_auto: this.class.smtp_starttls,
+      )
+      this.class.smtp_headers.each do |k, v|
+        header[k] = v
+      end
+      custom_method = :"_handle_#{this.class.smtp_provider}"
+      this.send(custom_method, delivery, self, message_id) if this.respond_to?(custom_method)
+      from from
+      to to
+      reply_to(delivery.extra_fields["reply_to"]) if delivery.extra_fields["reply_to"].present?
+      subject delivery.body_with_mediatype("subject")&.content
+      text_part do
+        content_type "text/plain; charset=UTF-8"
+        body delivery.body_with_mediatype!("text/plain")&.content
+      end
+      html_part do
+        content_type "text/html; charset=UTF-8"
+        body delivery.body_with_mediatype!("text/html")&.content
+      end
+    end
+    return message_id
+  end
+
+  protected def extract_email_part(email)
+    split = /(?:(?<address>.+)\s)?<?(?<email>.+@[^>]+)>?/.match(email)
+    return split[:email]
+  end
+
+  def format_email_name(email, name)
+    return email if name.blank?
+    return "#{name} <#{email}>"
+  end
+
+  def _handle_postmark(delivery, mail, message_id)
+    mail.header["X-PM-Metadata-messageid"] = message_id
+    mail.header["X-PM-Tag"] = delivery.template
+  end
+end

data/lib/webhookdb/message/fake_transport.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "webhookdb/message/transport"
+
+class Webhookdb::Message::FakeTransport < Webhookdb::Message::Transport
+  extend Webhookdb::MethodUtilities
+
+  register_transport(:fake)
+
+  singleton_attr_reader :sent_deliveries
+  @sent_deliveries = []
+
+  singleton_attr_accessor :disable_func
+  @disable_func = nil
+
+  singleton_attr_accessor :return_nil_on_send
+  @return_nil_on_send = false
+
+  def self.reset!
+    self.sent_deliveries.clear
+    self.disable_func = nil
+    self.return_nil_on_send = false
+  end
+
+  def type
+    return :fake
+  end
+
+  def service
+    return "fake"
+  end
+
+  def supports_layout?
+    return true
+  end
+
+  def add_bodies(delivery, content)
+    bodies = []
+    bodies << delivery.add_body(content: content.to_s, mediatype: "text/plain")
+    return bodies
+  end
+
+  def send!(delivery)
+    if Webhookdb::Message::FakeTransport.disable_func&.call(delivery)
+      raise Webhookdb::Message::Transport::UndeliverableRecipient,
+            "Did not deliver Delivery[#{delivery.id}] to #{delivery.to} because it was skipped by disable_func"
+    end
+
+    Webhookdb.logger.debug "Storing Delivery[%d] to %s as sent" % [delivery.id, delivery.to]
+    Webhookdb::Message::FakeTransport.sent_deliveries << delivery
+    return nil if Webhookdb::Message::FakeTransport.return_nil_on_send
+    return "#{delivery.id}-#{SecureRandom.hex(6)}"
+  end
+end

data/lib/webhookdb/message/liquid_drops.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Webhookdb::Message
+  class CustomerDrop < Liquid::Drop
+    def initialize(recipient)
+      @recipient = recipient
+      super()
+    end
+
+    def to
+      return @recipient.to
+    end
+
+    def name
+      return @recipient.customer&.name
+    end
+
+    def greeting
+      return nil unless @recipient.customer
+      return @recipient.customer.greeting
+    end
+  end
+
+  class EnvironmentDrop < Liquid::Drop
+    def name
+      return Webhookdb::RACK_ENV
+    end
+  end
+end

data/lib/webhookdb/message/template.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "webhookdb/message"
+
+# Template is the base class for all message templates.
+# Every message (email, and/or SMS, etc) has a Template
+# that defines how to look up its text template and the dynamic data
+# for rendering into the template.
+# Subclasses should override methods to control the rendering behavior;
+# see the method docs to see what is expected to be overridden.
+class Webhookdb::Message::Template
+  # Override to return a new version of the template,
+  # with its data fixtured. It is used for message previewing.
+  # The argument is the message recipient,
+  # because they may need to be used to build resources off of.
+  #
+  # Only needs to be overridden if the template constructor takes arguments.
+  # Assume that fixtures are loaded when this method is called;
+  # do not require them as part of your code.
+  def self.fixtured(_recipient)
+    return self.new
+  end
+
+  def dispatch(to, transport: Webhookdb::Message::DEFAULT_TRANSPORT)
+    return Webhookdb::Message.dispatch(self, to, transport)
+  end
+
+  def dispatch_email(to)
+    return self.dispatch(to, transport: :email)
+  end
+
+  # The folder containing this template. Templates in the root template directory should use nil.
+  def template_folder
+    return nil
+  end
+
+  # The name of the template. By default, it is tied to the name of the class,
+  # so Messages::NewCustomer looks for 'new_customer' templates.
+  # However, a subclass can override this to not tie the template to the class name.
+  def template_name
+    return self.class.name.demodulize.underscore
+  end
+
+  def full_template_name
+    fld = self.template_folder.present? ? "#{self.template_folder}/" : ""
+    return "#{fld}#{self.template_name}"
+  end
+
+  def template_path(transport)
+    return Webhookdb::Message::DATA_DIR + "templates/#{self.full_template_name}.#{transport}.liquid"
+  end
+
+  # The layout for the template. See the 'layouts' folder in the message data directory.
+  def layout
+    return "standard"
+  end
+
+  def layout_path(transport)
+    return nil if self.layout.nil?
+    return Webhookdb::Message::DATA_DIR + "layouts/#{self.layout}.#{transport}.liquid"
+  end
+
+  # The hash that is used for the rendering of the template.
+  # These must be simple types (strings, ints, bools, etc), or Liquid::Drop subclasses.
+  # By default, templates are rendered with some default variables,
+  # such as 'recipient', 'environment', and 'app_url'.
+  def liquid_drops
+    return {
+      api_url: Webhookdb.api_url,
+      support_email: Webhookdb.support_email,
+      oss_repo: Webhookdb.oss_repo_url,
+      docs_url: "https://docs.webhookdb.com",
+    }
+  end
+
+  # Liquify wraps any object in a Liquification.
+  def liquify(o)
+    return Webhookdb::Liquid::Liquification.new(o)
+  end
+
+  # Return a hash of special fields for that this delivery should use.
+  # Necessary for deliveries that need to carry along some metadata. For example:
+  #   {'reply_to' => 'customer@gmail.com'}
+  # for customers who send support requests.
+  # These fields are subject to flux and change and may only be applicable to some transports.
+  def extra_fields
+    return {}
+  end
+end

data/lib/webhookdb/message/transport.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "webhookdb/message"
+
+class Webhookdb::Message::Transport
+  extend Webhookdb::MethodUtilities
+
+  class Error < StandardError; end
+  class UndeliverableRecipient < Error; end
+
+  singleton_attr_reader :transports
+  @transports = {}
+
+  singleton_attr_accessor :override
+
+  def self.register_transport(type)
+    Webhookdb::Message::Transport.transports[type] = self.new
+  end
+
+  def self.for(type)
+    type = Webhookdb::Message::Transport.override || type
+    return Webhookdb::Message::Transport.transports[type.to_sym]
+  end
+
+  def self.for!(type)
+    (t = self.for(type)) or raise Webhookdb::Message::InvalidTransportError, "invalid transport: %p" % type
+    return t
+  end
+
+  # Override this if a transport needs a different 'to' than the email,
+  # like for text messages.
+  def recipient(to)
+    if to.is_a?(Webhookdb::Customer)
+      (email = to.email) or raise "Customer #{to.id} has no default email"
+      return Webhookdb::Message::Recipient.new(email, to)
+    end
+    return Webhookdb::Message::Recipient.new(to, nil)
+  end
+
+  def send!(_delivery)
+    raise "Must implement in subclass. Call 3rd party with message/content and return transport ID."
+  end
+end

data/lib/webhookdb/message.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "appydays/configurable"
+require "liquid"
+
+module Webhookdb::Messages
+end
+
+module Webhookdb::Liquid
+end
+
+module Webhookdb::Message
+  include Appydays::Configurable
+  extend Webhookdb::MethodUtilities
+
+  require "webhookdb/liquid/expose"
+  require "webhookdb/liquid/filters"
+  require "webhookdb/liquid/liquification"
+  require "webhookdb/liquid/partial"
+
+  require "webhookdb/message/email_transport"
+  require "webhookdb/message/fake_transport"
+  require "webhookdb/message/transport"
+  require "webhookdb/message/liquid_drops"
+  require "webhookdb/message/template"
+
+  DEFAULT_TRANSPORT = :email
+  DATA_DIR = Webhookdb::DATA_DIR + "messages"
+
+  configurable(:messages) do
+    after_configured do
+      Liquid::Template.error_mode = :strict
+      Liquid::Template.file_system = Liquid::LocalFileSystem.new(DATA_DIR, "%s.liquid")
+    end
+  end
+
+  # Create a Webhookdb::Message::Delivery ready to deliver (rendered, all bodies set up)
+  # using the given transport_type to the given user.
+  def self.dispatch(template, to, transport_type)
+    (transport = Webhookdb::Message::Transport.for(transport_type)) or
+      raise InvalidTransportError, "Invalid transport #{transport_type}"
+    recipient = transport.recipient(to)
+
+    contents = self.render(template, transport_type, recipient)
+
+    Webhookdb::Message::Delivery.db.transaction do
+      delivery = Webhookdb::Message::Delivery.create(
+        template: template.full_template_name,
+        transport_type: transport.type,
+        transport_service: transport.service,
+        to: recipient.to,
+        recipient: recipient.customer,
+        extra_fields: template.extra_fields,
+      )
+      transport.add_bodies(delivery, contents)
+      delivery.publish_deferred("dispatched", delivery.id)
+      return delivery
+    end
+  end
+
+  # Render the transport-specific version of the given template
+  # and return a the rendering (content and exposed variables).
+  #
+  # Templates can expose data to the caller by using the 'expose' tag,
+  # like {% expose subject %}Hello from Webhookdb!{% endexpose %}.
+  # This is available as [:subject] on the returned rendering.
+  def self.render(template, transport_type, recipient)
+    template_file = template.template_path(transport_type)
+    raise MissingTemplateError, "#{template_file} does not exist" unless template_file.exist?
+
+    drops = template.liquid_drops.stringify_keys.merge(
+      "recipient" => Webhookdb::Message::CustomerDrop.new(recipient),
+      "environment" => Webhookdb::Message::EnvironmentDrop.new,
+      "app_url" => Webhookdb.app_url,
+    )
+
+    content_tmpl = Liquid::Template.parse(template_file.read)
+    # The 'expose' drop smashes data into the register.
+    # We need to keep track of the register to get the subject back out,
+    # so we need to make our own context.
+    lctx = Liquid::Context.new(
+      [drops, content_tmpl.assigns],
+      content_tmpl.instance_assigns,
+      content_tmpl.registers,
+      true,
+      content_tmpl.resource_limits,
+    )
+    content = content_tmpl.render!(lctx, strict_variables: true)
+
+    transport = Webhookdb::Message::Transport.for(transport_type)
+    if transport.supports_layout?
+      layout_file = template.layout_path(transport_type)
+      if layout_file
+        raise MissingTemplateError, "#{template_file} does not exist" unless layout_file.exist?
+        layout_tmpl = Liquid::Template.parse(layout_file.read)
+        drops["content"] = content.dup
+        content = layout_tmpl.render!(drops, strict_variables: true, registers: content_tmpl.registers)
+      end
+    end
+
+    return Rendering.new(content, lctx.registers)
+  end
+
+  def self.send_unsent
+    Webhookdb::Message::Delivery.unsent.each(&:send!)
+  end
+
+  class InvalidTransportError < StandardError; end
+
+  class MissingTemplateError < StandardError; end
+
+  # Presents a homogeneous interface for a given 'to' value (email vs. customer, for example).
+  # .to will always be a plain object, and .customer will be a +Webhookdb::Customer+ if present.
+  class Recipient
+    attr_reader :to, :customer
+
+    def initialize(to, customer)
+      @to = to
+      @customer = customer
+    end
+  end
+
+  # String-like type representing the output of a rendering operation.
+  # Use [key] to access exposed variables, as per +LiquidExpose+.
+  class Rendering
+    attr_reader :contents, :exposed
+
+    def initialize(contents, exposed={})
+      @contents = contents
+      @exposed = exposed
+    end
+
+    def [](key)
+      return self.exposed[key]
+    end
+
+    def to_s
+      return self.contents
+    end
+
+    def respond_to_missing?(name, *args)
+      return true if super
+      return self.contents.respond_to?(name)
+    end
+
+    def method_missing(name, *, &)
+      return self.contents.respond_to?(name) ? self.contents.send(name, *, &) : super
+    end
+  end
+end

data/lib/webhookdb/messages/error_icalendar_fetch.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "webhookdb/message/template"
+
+class Webhookdb::Messages::ErrorIcalendarFetch < Webhookdb::Message::Template
+  def self.fixtured(_recipient)
+    sint = Webhookdb::Fixtures.service_integration.create
+    return self.new(sint, "calendar123",
+                    response_status: 403, request_url: "/foo", request_method: "GET", response_body: "hi",)
+  end
+
+  def initialize(service_integration, external_calendar_id, request_url:, request_method:, response_status:,
+    response_body:)
+    @service_integration = service_integration
+    @external_calendar_id = external_calendar_id
+    @request_url = request_url
+    @request_method = request_method
+    @response_status = response_status
+    @response_body = response_body
+    super()
+  end
+
+  def signature
+    ehash = Digest::MD5.hexdigest(@kw.to_s)
+    return "msg-#{self.full_template_name}-sint:#{@service_integration.id}-eid:#{@external_calendar_id}-err:#{ehash}"
+  end
+
+  def template_folder = "errors"
+  def template_name = "icalendar_fetch"
+
+  def liquid_drops
+    return super.merge(
+      service_name: @service_integration.service_name,
+      opaque_id: @service_integration.opaque_id,
+      request_method: @request_method,
+      request_url: @request_url,
+      response_status: @response_status,
+      response_body: @response_body,
+      external_calendar_id: @external_calendar_id,
+    )
+  end
+end

data/lib/webhookdb/messages/invite.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "webhookdb/message/template"
+
+class Webhookdb::Messages::Invite < Webhookdb::Message::Template
+  def self.fixtured(recipient)
+    org = Webhookdb::Fixtures.organization.with_member(recipient).create
+    membership = org.all_memberships[0]
+    return self.new(membership)
+  end
+
+  def initialize(membership)
+    @membership = membership
+    super()
+  end
+
+  def liquid_drops
+    return super.merge(
+      organization_name: @membership.organization_name,
+      invite_code: @membership.invitation_code,
+    )
+  end
+end