[PoC] Implement support for building funnels without goals

assets/js/liveview/live_socket.js

@@ -7,7 +7,7 @@
 import 'phoenix_html'
 import { Socket } from 'phoenix'
 import { LiveSocket } from 'phoenix_live_view'
-import { Modal, Dropdown } from 'prima'
+import { Modal, Dropdown, Combobox } from 'prima'
 import topbar from 'topbar'
 /* eslint-enable import/no-unresolved */
 
@@ -19,7 +19,7 @@ import MemberRows from './member-rows'
 let csrfToken = document.querySelector("meta[name='csrf-token']")
 let websocketUrl = document.querySelector("meta[name='websocket-url']")
 if (csrfToken && websocketUrl) {
-  let Hooks = { Modal, Dropdown, CopySnippet, MemberRows }
+  let Hooks = { Modal, Dropdown, Combobox, CopySnippet, MemberRows }
 
   Hooks.VerificationLifecycle = {
     mounted() {

extra/lib/plausible/funnel.ex

@@ -18,6 +18,7 @@ defmodule Plausible.Funnel do
   import Ecto.Changeset
 
   alias Plausible.Funnel.Step
+  alias Plausible.Funnel.DynamicStep
 
   @funnel_types [:sequential, :flexible, :strict]
 
@@ -62,6 +63,8 @@ defmodule Plausible.Funnel do
 
     belongs_to :site, Plausible.Site
 
+    embeds_many :dynamic_steps, DynamicStep, on_replace: :delete
+
     has_many :steps, Step,
       preload_order: [
         asc: :step_order
@@ -72,25 +75,106 @@ defmodule Plausible.Funnel do
     timestamps()
   end
 
+  def goals(funnel) do
+    funnel
+    |> steps()
+    |> Enum.map(&as_goal/1)
+  end
+
+  def steps(funnel) do
+    funnel.steps
+    |> Enum.concat(funnel.dynamic_steps)
+    |> Enum.sort_by(& &1.step_order)
+  end
+
+  def as_goal(%Step{} = step), do: Step.as_goal(step)
+  def as_goal(%DynamicStep{} = step), do: DynamicStep.as_goal(step)
+
   def changeset(funnel \\ %__MODULE__{}, attrs \\ %{}) do
     funnel
     |> cast(attrs, [:name, :funnel_type])
     |> validate_required([:name])
     |> set_funnel_type()
     |> put_steps(attrs[:steps] || attrs["steps"])
-    |> validate_length(:steps, min: @min_steps, max: @max_steps)
+    |> validate_steps_length()
     |> unique_constraint(:name,
       name: :funnels_name_site_id_index
     )
   end
 
-  def put_steps(changeset, steps) do
-    steps
-    |> Enum.map(&Step.changeset(%Step{}, &1))
-    |> Enum.with_index(fn step, step_order ->
-      Ecto.Changeset.put_change(step, :step_order, step_order + 1)
-    end)
-    |> then(&Ecto.Changeset.put_assoc(changeset, :steps, &1))
+  @spec swap(t(), Keyword.t()) :: t()
+  def swap(funnel, opts) do
+    funnel_type = Keyword.get(opts, :funnel_type, funnel.funnel_type)
+
+    funnel
+    |> Map.put(:funnel_type, funnel_type)
+    |> swap_steps(Keyword.get(opts, :steps))
+  end
+
+  defp swap_steps(funnel, nil), do: funnel
+
+  defp swap_steps(funnel, steps) do
+    {static_steps, dynamic_steps} =
+      steps
+      |> Enum.with_index(1)
+      |> Enum.map(fn {step, idx} -> %{step | step_order: idx} end)
+      |> Enum.split_with(fn
+        %Step{} -> true
+        _ -> false
+      end)
+
+    %{funnel | steps: static_steps, dynamic_steps: dynamic_steps}
+  end
+
+  defp put_steps(changeset, steps) do
+    {static_steps, dynamic_steps} =
+      steps
+      |> Enum.with_index(1)
+      |> Enum.map(fn {input, idx} ->
+        input
+        |> schema_by_input()
+        |> build_step(input, idx)
+      end)
+      |> Enum.split_with(fn
+        %{data: %Step{}} -> true
+        _ -> false
+      end)
+
+    changeset
+    |> Ecto.Changeset.put_assoc(:steps, static_steps)
+    |> Ecto.Changeset.put_embed(:dynamic_steps, dynamic_steps)
+  end
+
+  defp validate_steps_length(changeset) do
+    steps_count =
+      length(Ecto.Changeset.get_assoc(changeset, :steps)) +
+        length(Ecto.Changeset.get_embed(changeset, :dynamic_steps))
+
+    if steps_count < @min_steps or steps_count > @max_steps do
+    end
+
+    cond do
+      steps_count < @min_steps ->
+        add_error(changeset, :steps, "should have at least #{@min_steps} item(s)")
+
+      steps_count > @max_steps ->
+        add_error(changeset, :steps, "should have no more than #{@max_steps} item(s)")
+
+      true ->
+        changeset
+    end
+  end
+
+  defp schema_by_input(%Plausible.Goal{}), do: Step
+  defp schema_by_input(%Step{}), do: Step
+  defp schema_by_input(%{goal_id: _}), do: Step
+  defp schema_by_input(%{"goal_id" => _}), do: Step
+  defp schema_by_input(_), do: DynamicStep
+
+  defp build_step(step_schema, params, step_order) do
+    params
+    |> step_schema.changeset()
+    |> Ecto.Changeset.put_change(:step_order, step_order)
   end
 
   defp set_funnel_type(%{valid?: true} = changeset) do

extra/lib/plausible/funnel/dynamic_step.ex

@@ -0,0 +1,75 @@
+defmodule Plausible.Funnel.DynamicStep do
+  @moduledoc """
+  This module defines the database schema for a single Dynamic Funnel step.
+  See: `Plausible.Funnel` for more information.
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @type t() :: %__MODULE__{}
+
+  @fields [
+    :event_name,
+    :page_path,
+    :display_name,
+    :scroll_threshold,
+    :custom_props,
+    :currency
+  ]
+
+  @primary_key false
+  embedded_schema do
+    field :step_order, :integer
+    field :event_name, :string
+    field :page_path, :string
+    field :display_name, :string, virtual: true
+    field :scroll_threshold, :integer, default: -1
+    field :currency, Ecto.Enum, values: Money.Currency.known_current_currencies()
+
+    field :custom_props, :map, default: %{}
+  end
+
+  @spec changeset(map() | t()) :: Ecto.Changeset.t()
+  def changeset(step_or_attrs \\ %{})
+
+  def changeset(%__MODULE__{} = step), do: change(step)
+
+  def changeset(attrs) do
+    %__MODULE__{}
+    |> cast(attrs, @fields)
+    |> Plausible.Goal.base_changeset()
+    |> validate_page_or_custom_goal()
+  end
+
+  @spec as_goal(t()) :: Plausible.Goal.t()
+  def as_goal(step) do
+    %Plausible.Goal{
+      id: 0,
+      display_name: step.display_name || display_name(step),
+      event_name: step.event_name,
+      page_path: step.page_path,
+      scroll_threshold: step.scroll_threshold,
+      custom_props: step.custom_props,
+      currency: step.currency
+    }
+  end
+
+  defp validate_page_or_custom_goal(changeset) do
+    if get_field(changeset, :event_name) && get_field(changeset, :page_path) do
+      add_error(changeset, :event_name, "cannot co-exist with page_path")
+    else
+      changeset
+    end
+  end
+
+  defp display_name(step) do
+    case step do
+      %{page_path: page_path} when is_binary(page_path) ->
+        "Visit " <> page_path
+
+      %{event_name: event_name} when is_binary(event_name) ->
+        event_name
+    end
+  end
+end

extra/lib/plausible/funnel/step.ex

@@ -15,19 +15,27 @@ defmodule Plausible.Funnel.Step do
     timestamps()
   end
 
-  def changeset(step, goal_or_attrs \\ %{})
+  @spec changeset(map() | Plausible.Goal.t() | t()) :: Ecto.Changeset.t()
+  def changeset(goal_step_or_attrs \\ %{})
 
-  def changeset(step, %Plausible.Goal{id: goal_id}) do
-    changeset(step, %{goal_id: goal_id})
+  def changeset(%__MODULE__{} = step), do: change(step)
+
+  def changeset(%Plausible.Goal{id: goal_id}) do
+    changeset(%{goal_id: goal_id})
   end
 
-  def changeset(step, attrs) do
-    step
+  def changeset(attrs) do
+    %__MODULE__{}
     |> cast(attrs, [:goal_id])
     |> cast_assoc(:goal)
     |> validate_required([:goal_id])
     |> unique_constraint(:goal,
       name: :funnel_steps_goal_id_funnel_id_index
     )
   end
+
+  @spec as_goal(t()) :: Plausible.Goal.t()
+  def as_goal(step) do
+    step.goal
+  end
 end

extra/lib/plausible/funnels.ex

@@ -94,11 +94,16 @@ defmodule Plausible.Funnels do
   def list(%Plausible.Site{} = site) do
     q =
       from(f in Funnel,
-        inner_join: steps in assoc(f, :steps),
+        left_join: steps in assoc(f, :steps),
         where: f.site_id == ^site.id,
         group_by: f.id,
         order_by: [desc: :id],
-        select: %{name: f.name, id: f.id, steps_count: count(steps)}
+        select: %{
+          name: f.name,
+          id: f.id,
+          steps_count:
+            count(steps) + fragment("coalesce(jsonb_array_length(?), 0)", f.dynamic_steps)
+        }
       )
 
     Repo.all(q)
@@ -137,7 +142,6 @@ defmodule Plausible.Funnels do
   @spec with_goals_query(Plausible.Site.t()) :: Ecto.Query.t()
   def with_goals_query(site) do
     from(f in Funnel,
-      inner_join: steps in assoc(f, :steps),
       where: f.site_id == ^site.id,
       group_by: f.id,
       order_by: [desc: :id],
@@ -148,8 +152,8 @@ defmodule Plausible.Funnels do
   defp base_get_query(site_id) do
     from(f in Funnel,
       where: f.site_id == ^site_id,
-      inner_join: steps in assoc(f, :steps),
-      inner_join: goal in assoc(steps, :goal),
+      left_join: steps in assoc(f, :steps),
+      left_join: goal in assoc(steps, :goal),
       order_by: steps.step_order,
       preload: [
         steps: {steps, goal: goal}