heya 0.3.0 → 0.4.0

data/README.md

@@ -58,10 +58,10 @@ end
   ```ruby
   OnboardingCampaign.add(user)
   ```
-  
+
   Add the following to your `User` model to send them the campaign
   when they first signup:
-  
+
   ```ruby
   after_create_commit do
     OnboardingCampaign.add(self)
@@ -353,7 +353,7 @@ To remove a user from a campaign:
 OnboardingCampaign.remove(user)
 ```
 
-Adding users to campaigns from Rails opens up some interesting automation possibilities--for instance, you can start or stop campaigns from `ActiveRecord` callbacks, or in response to other events that you're already tracking in your application. [See here for a list of ideas](#).
+Adding users to campaigns from Rails opens up some interesting automation possibilities--for instance, you can start or stop campaigns from `ActiveRecord` callbacks, or in response to other events that you're already tracking in your application. [See here for a list of ideas](#automation-ideas).
 
 Because Heya stacks campaigns by default (meaning it will never send more than one at a time), you can also queue up several campaigns for a user, and they'll receive them in order:
 
@@ -543,6 +543,13 @@ Yep. Use the `restart` option to resend a campaign to a user (if they are alread
 Yep. By default, Heya sends campaigns ain order of `priority`. Use the `concurrent` option to send campaigns concurrently.
 </details>
 
+## Upgrading Heya
+Heya adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html), and
+should be considered **unstable** until version 1.0.0. Always check
+[CHANGELOG.md](./CHANGELOG.md) prior to upgrading (breaking changes will always
+be called out there). Upgrade instructions for breaking changes are in
+[UPGRADING.md](./UPGRADING.md).
+
 ## Roadmap
 See [here](https://github.com/honeybadger-io/heya/projects/1) for things we're
 considering adding to Heya.
@@ -550,10 +557,17 @@ considering adding to Heya.
 ## Contributing
 1. Fork it.
 2. Create a topic branch `git checkout -b my_branch`
-3. Make your changes and add an entry to the [CHANGELOG](CHANGELOG.md).
+3. Make your changes and add an entry to [CHANGELOG.md](CHANGELOG.md).
 4. Commit your changes `git commit -am "Boom"`
 5. Push to your branch `git push origin my_branch`
 6. Send a [pull request](https://github.com/honeybadger-io/heya/pulls)
 
+## Releasing
+1. `gem install gem-release`
+2. `gem bump -v [version] -t -r`
+3. Update unreleased heading in [CHANGELOG.md](./CHANGELOG.md) (TODO: automate
+   this in gem-release command)
+4. `git push origin master --tags`
+
 ## License
-This package is free to use for noncommercial purposes and for commercial purposes during a trial period under the terms of the [Prosperity Public License](LICENSE).
+Heya is licensed under the [AGPL](./LICENSE).

data/app/models/heya/campaign_membership.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Heya
   class CampaignMembership < ApplicationRecord
     belongs_to :user, polymorphic: true
@@ -5,5 +7,84 @@ module Heya
     before_create do
       self.last_sent_at = Time.now
     end
+
+    scope :with_steps, -> {
+      joins(
+        %(INNER JOIN "heya_steps" ON "heya_steps".gid = "heya_campaign_memberships".step_gid)
+      )
+    }
+
+    scope :active, -> {
+      priority_gids = Heya.config.campaigns.priority.map { |c| (c.is_a?(String) ? c.constantize : c).gid }
+      where(<<~SQL, priority_gids: priority_gids)
+        "heya_campaign_memberships".concurrent = TRUE
+        OR "heya_campaign_memberships"."campaign_gid" IN (
+          SELECT
+            "active_membership"."campaign_gid"
+          FROM
+            "heya_campaign_memberships" as "active_membership"
+          WHERE
+            "active_membership"."concurrent" = FALSE
+            AND
+            (
+              "active_membership".user_type = "heya_campaign_memberships".user_type
+              AND
+              "active_membership".user_id = "heya_campaign_memberships".user_id
+            )
+          ORDER BY
+            array_position(ARRAY[:priority_gids], "active_membership".campaign_gid::text) ASC,
+            "active_membership".created_at ASC
+          LIMIT 1
+        )
+      SQL
+    }
+
+    scope :upcoming, -> {
+      with_steps
+        .active
+        .order(
+          Arel.sql(
+            %("heya_campaign_memberships".last_sent_at + make_interval(secs := "heya_steps".wait) DESC)
+          )
+        )
+    }
+
+    scope :to_process, ->(now: Time.now, user: nil) {
+      upcoming
+        .where(<<~SQL, now: now.utc, user_type: user&.class&.base_class&.name, user_id: user&.id)
+          ("heya_campaign_memberships".last_sent_at <= (TIMESTAMP :now - make_interval(secs := "heya_steps".wait)))
+          AND (
+            (:user_type IS NULL OR :user_id IS NULL)
+            OR (
+              "heya_campaign_memberships".user_type = :user_type
+              AND
+              "heya_campaign_memberships".user_id = :user_id
+            )
+          )
+        SQL
+    }
+
+    def self.migrate_next_step!
+      find_each do |membership|
+        campaign = GlobalID::Locator.locate(membership.campaign_gid)
+        receipt = campaign && CampaignReceipt.where(user: membership.user, step_gid: campaign.steps.map(&:gid)).order("created_at desc").first
+
+        next_step = if receipt
+          last_step = GlobalID::Locator.locate(receipt.step_gid)
+          current_index = campaign.steps.index(last_step)
+          campaign.steps[current_index + 1]
+        else
+          campaign&.steps&.first
+        end
+
+        if next_step
+          membership.update(step_gid: next_step.gid)
+        else
+          membership.destroy
+        end
+      end
+
+      CampaignReceipt.where(sent_at: nil).destroy_all
+    end
   end
 end

data/lib/generators/heya/install/templates/migration.rb.tt

@@ -4,6 +4,7 @@ class CreateHeyaTables < ActiveRecord::Migration[<%= ActiveRecord::VERSION::MAJO
       t.references :user, null: false, polymorphic: true, index: false
 
       t.string :campaign_gid, null: false
+      t.string :step_gid, null: false
       t.boolean :concurrent, null: false, default: false
 
       t.datetime :last_sent_at, null: false

data/lib/heya.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require "heya/version"
+require "heya/active_record_extension"
 require "heya/engine"
 require "heya/config"
-require "heya/license"
 require "heya/campaigns/action"
 require "heya/campaigns/actions/email"
 require "heya/campaigns/actions/block"
@@ -46,45 +46,4 @@ module Heya
     return user.send(segment) if segment.is_a?(Symbol)
     segment.call(user)
   end
-
-  def verify_license!
-    unless File.file?(config.license_file)
-      puts(<<-NOTICE.strip_heredoc)
-        This copy of Heya is licensed for non-commercial non-profit, or 30-day trial usage only.
-        For a commercial use license, please visit https://www.heya.email
-      NOTICE
-      return
-    end
-
-    begin
-      license = License.import(File.read(config.license_file))
-    rescue License::ImportError
-      warn(<<-NOTICE.strip_heredoc)
-        Your Heya license is invalid.
-        If you need support, please visit https://www.heya.email
-      NOTICE
-      return
-    end
-
-    if license.expired?
-      warn(<<-NOTICE.strip_heredoc)
-        Your Heya license has expired.
-        To update your license, please visit https://www.heya.email
-      NOTICE
-      return
-    end
-
-    if (max_user_count = license.restrictions[:user_count]&.to_i)
-      user_count = config.user_type.constantize.count
-      if user_count > max_user_count
-        warn(<<-NOTICE.strip_heredoc)
-          Your app exceeds the number of users for your Heya license.
-          To upgrade your license, please visit https://www.heya.email
-        NOTICE
-      end
-      return # rubocop:disable Style/RedundantReturn
-    end
-
-    # Valid license
-  end
 end

data/lib/heya/active_record_extension.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "active_record/relation"
+
+module Heya
+  module ActiveRecordRelationExtension
+    TABLE_REGEXP = /heya_steps/
+
+    def build_arel(aliases)
+      arel = super(aliases)
+
+      if table_name == "heya_campaign_memberships" && arel.to_sql =~ TABLE_REGEXP
+        # https://www.postgresql.org/docs/9.4/queries-values.html
+        values = Heya
+          .campaigns.reduce([]) { |steps, campaign| steps | campaign.steps }
+          .map { |step|
+            ActiveRecord::Base.sanitize_sql_array(
+              ["(?, ?)", step.gid, step.wait.to_i]
+            )
+          }
+
+        if values.any?
+          arel.with(
+            Arel::Nodes::As.new(
+              Arel::Table.new(:heya_steps),
+              Arel::Nodes::SqlLiteral.new("(SELECT * FROM (VALUES #{values.join(", ")}) AS heya_steps (gid,wait))")
+            )
+          )
+        end
+      end
+
+      arel
+    end
+  end
+
+  ActiveRecord::Relation.prepend(ActiveRecordRelationExtension)
+end

data/lib/heya/campaigns/base.rb

@@ -41,12 +41,15 @@ module Heya
             .delete_all
         end
 
-        membership.create! do |m|
-          m.concurrent = concurrent
-        end
+        if (step = steps.first)
+          membership.create! do |m|
+            m.concurrent = concurrent
+            m.step_gid = step.gid
+          end
 
-        if send_now && (step = steps.first) && step.wait <= 0
-          Scheduler.process(self, step, user)
+          if send_now && step.wait == 0
+            Scheduler.new.run(user: user)
+          end
         end
 
         true
@@ -57,18 +60,6 @@ module Heya
         true
       end
 
-      def users
-        base_class = user_class.base_class
-        user_class
-          .joins(
-            sanitize_sql_array([
-              "inner join heya_campaign_memberships on heya_campaign_memberships.user_type = ? and heya_campaign_memberships.user_id = #{base_class.table_name}.id and heya_campaign_memberships.campaign_gid = ?",
-              base_class.name,
-              gid
-            ])
-          ).all
-      end
-
       def user_class
         @user_class ||= self.class.user_type.constantize
       end
@@ -105,7 +96,7 @@ module Heya
           instance
         end
 
-        delegate :steps, :add, :remove, :users, :gid, :user_class, :handle_exception, to: :instance
+        delegate :steps, :add, :remove, :gid, :user_class, :handle_exception, to: :instance
 
         def default(**params)
           self.__defaults = __defaults.merge(params).freeze

data/lib/heya/campaigns/queries.rb

@@ -3,97 +3,16 @@
 module Heya
   module Campaigns
     module Queries
-      NEXT_STEP_SUBQUERY = <<~SQL
-        (WITH steps AS (SELECT * FROM (VALUES :steps_values) AS m (step_gid,campaign_gid,position))
-         SELECT m.step_gid FROM steps AS m
-         WHERE m.campaign_gid = :campaign_gid
-           AND m.position > coalesce((SELECT m.position FROM heya_campaign_receipts AS r
-             INNER JOIN steps AS m ON m.step_gid = r.step_gid
-               AND m.campaign_gid = :campaign_gid
-             WHERE r.user_type = heya_campaign_memberships.user_type
-               AND r.user_id = heya_campaign_memberships.user_id
-             ORDER BY m.position DESC
-             LIMIT 1), -1)
-         ORDER BY m.position ASC
-         LIMIT 1
-        ) = :step_gid
-      SQL
-
-      ACTIVE_CAMPAIGN_SUBQUERY = <<~SQL
-        (WITH heya_campaigns AS (SELECT * FROM (VALUES :campaigns_values) AS campaigns (campaign_gid,position))
-        SELECT memberships.campaign_gid FROM heya_campaign_memberships AS memberships
-         INNER JOIN heya_campaigns AS campaigns
-           ON campaigns.campaign_gid = memberships.campaign_gid
-         WHERE memberships.user_type = heya_campaign_memberships.user_type
-           AND memberships.user_id = heya_campaign_memberships.user_id
-           AND memberships.concurrent = FALSE
-         ORDER BY campaigns.position DESC, memberships.created_at ASC
-         LIMIT 1
-        ) = :campaign_gid
-      SQL
-
-      # Given a campaign and a step, {Queries::UsersForStep} returns the
-      # users who should complete the step.
-      UsersForStep = ->(campaign, step) {
-        wait_threshold = Time.now.utc - step.wait
-
-        # Safeguard to make sure we never complete the same step twice.
-        receipt_query = CampaignReceipt
-          .select("heya_campaign_receipts.user_id")
-          .where(user_type: campaign.user_class.name)
-          .where("heya_campaign_receipts.step_gid = ?", step.gid)
-
-        # https://www.postgresql.org/docs/9.4/queries-values.html
-        steps_values = campaign.steps.map { |m|
-          ActiveRecord::Base.sanitize_sql_array(
-            ["(?, ?, ?)", m.gid, campaign.gid, m.position]
-          )
-        }.join(", ")
-
-        priority = Heya.config.campaigns.priority.reverse.map { |c| c.is_a?(String) ? c : c.name }
-        campaigns_values = Heya.campaigns.map { |c|
-          ActiveRecord::Base.sanitize_sql_array(
-            ["(?, ?)", c.gid, priority.index(c.name) || -1]
-          )
-        }.join(", ")
-
-        users = campaign.users
-        users
-          .where.not(id: receipt_query)
-          .where(NEXT_STEP_SUBQUERY.gsub(":steps_values", steps_values), {
-            campaign_gid: campaign.gid,
-            step_gid: step.gid
-          })
-          .merge(
-            users
-              .where("heya_campaign_memberships.concurrent = ?", true)
-              .or(
-                users.where(ACTIVE_CAMPAIGN_SUBQUERY.gsub(":campaigns_values", campaigns_values), {
-                  campaign_gid: campaign.gid
-                })
-              )
-          )
-          .where(
-            "heya_campaign_memberships.last_sent_at <= ?", wait_threshold
-          )
-      }
-
-      # Given a campaign and a step, {Queries::UsersCompletedStep}
-      # returns the users who have completed the step.
-      UsersCompletedStep = ->(campaign, step) {
-        receipt_query = CampaignReceipt
-          .select("heya_campaign_receipts.user_id")
-          .where(user_type: campaign.user_class.name)
-          .where("heya_campaign_receipts.step_gid = ?", step.gid)
-
-        campaign.users
-          .where(id: receipt_query)
+      # {Queries::MembershipsToProcess} returns the CampaignMembership records
+      # which should be processed by the scheduler.
+      MembershipsToProcess = ->(user: nil) {
+        Heya::CampaignMembership.to_process(user: user)
       }
 
-      # Given a campaign and a user, {Queries::CampaignMembershipsForUpdate}
+      # Given a campaign and a user, {Queries::MembershipsForUpdate}
       # returns the user's campaign memberships which should be updated
       # concurrently.
-      CampaignMembershipsForUpdate = ->(campaign, user) {
+      MembershipsForUpdate = ->(campaign, user) {
         membership = CampaignMembership.where(user: user, campaign_gid: campaign.gid).first
         if membership.concurrent?
           CampaignMembership
@@ -104,14 +23,12 @@ module Heya
         end
       }
 
-      # Given a campaign, {Queries::OrphanedCampaignMemberships} returns the
-      # campaign memberships which belong to users who no longer exist in the
-      # database.
-      OrphanedCampaignMemberships = ->(campaign) {
+      # Given a campaign, {Queries::OrphanedMemberships} returns the campaign
+      # memberships which are on steps have been removed from the campaign.
+      OrphanedMemberships = ->(campaign) {
         CampaignMembership
           .where(campaign_gid: campaign.gid)
-          .where(user_type: campaign.user_class.base_class.name)
-          .where.not(user_id: campaign.users.select("id"))
+          .where.not(step_gid: campaign.steps.map(&:gid))
       }
     end
   end

data/lib/heya/campaigns/scheduler.rb

@@ -11,36 +11,37 @@ module Heya
     #   3. Create CampaignReceipt (excludes user in subsequent steps)
     #   4. Process job
     class Scheduler
-      def run
+      def run(user: nil)
         Heya.campaigns.each do |campaign|
-          Queries::OrphanedCampaignMemberships.call(campaign).delete_all
-
-          campaign.steps.each do |step|
-            Queries::UsersForStep.call(campaign, step).find_each do |user|
-              self.class.process(campaign, step, user)
-            end
+          if campaign.steps.any?
+            Queries::OrphanedMemberships.call(campaign).update_all(step_gid: campaign.steps.first.gid)
           end
+        end
 
-          if (last_step = campaign.steps.last)
-            CampaignMembership.where(
-              user: Queries::UsersCompletedStep.call(campaign, last_step),
-              campaign_gid: campaign.gid
-            ).delete_all
+        Queries::MembershipsToProcess.call(user: user).find_each do |membership|
+          step = GlobalID::Locator.locate(membership.step_gid)
+          campaign = GlobalID::Locator.locate(membership.campaign_gid)
+          process(campaign, step, membership.user)
+          current_index = campaign.steps.index(step)
+          if (next_step = campaign.steps[current_index + 1])
+            membership.update(step_gid: next_step.gid)
+          else
+            membership.destroy
           end
         end
       end
 
-      def self.process(campaign, step, user)
+      private
+
+      def process(campaign, step, user)
         ActiveRecord::Base.transaction do
           return if CampaignReceipt.where(user: user, step_gid: step.gid).exists?
 
           if step.in_segment?(user)
             now = Time.now.utc
-            Queries::CampaignMembershipsForUpdate.call(campaign, user).update_all(last_sent_at: now)
+            Queries::MembershipsForUpdate.call(campaign, user).update_all(last_sent_at: now)
             CampaignReceipt.create!(user: user, step_gid: step.gid, sent_at: now)
             step.action.new(user: user, step: step).deliver_later
-          else
-            CampaignReceipt.create!(user: user, step_gid: step.gid)
           end
         end
       end