work on steps

lib/memex/pipelines/pipeline.ex

@@ -5,7 +5,7 @@ defmodule Memex.Pipelines.Pipeline do
   use Ecto.Schema
   import Ecto.Changeset
   alias Ecto.{Changeset, UUID}
-  alias Memex.Accounts.User
+  alias Memex.{Accounts.User, Pipelines.Step}
 
   @primary_key {:id, :binary_id, autogenerate: true}
   @foreign_key_type :binary_id
@@ -18,6 +18,8 @@ defmodule Memex.Pipelines.Pipeline do
 
     belongs_to :user, User
 
+    has_many :steps, Step, preload_order: [asc: :position]
+
     timestamps()
   end
 

lib/memex/pipelines/step.ex

@@ -0,0 +1,65 @@
+defmodule Memex.Pipelines.Step do
+  @moduledoc """
+  Represents a step taken while executing a pipeline
+  """
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Ecto.{Changeset, UUID}
+  alias Memex.{Accounts.User, Contexts.Context}
+  alias Memex.Pipelines.{Pipeline, StepContext}
+
+  @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
+  schema "steps" do
+    field :title, :string
+    field :content, :string
+    field :position, :integer
+
+    belongs_to :pipeline, Pipeline
+    belongs_to :user, User
+
+    many_to_many :contexts, Context, join_through: StepContext
+
+    timestamps()
+  end
+
+  @type t :: %__MODULE__{
+          title: String.t(),
+          content: String.t(),
+          position: non_neg_integer(),
+          pipeline: Pipeline.t() | Ecto.Association.NotLoaded.t(),
+          pipeline_id: Pipeline.id(),
+          user: User.t() | Ecto.Association.NotLoaded.t(),
+          user_id: User.id(),
+          inserted_at: NaiveDateTime.t(),
+          updated_at: NaiveDateTime.t()
+        }
+  @type id :: UUID.t()
+  @type changeset :: Changeset.t(t())
+
+  @doc false
+  @spec create_changeset(attrs :: map(), position :: non_neg_integer(), Pipeline.t(), User.t()) ::
+          changeset()
+  def create_changeset(attrs, position, %Pipeline{id: pipeline_id, user_id: user_id}, %User{
+        id: user_id
+      }) do
+    %__MODULE__{}
+    |> cast(attrs, [:title, :content])
+    |> change(pipeline_id: pipeline_id, user_id: user_id, position: position)
+    |> validate_required([:title, :content, :user_id, :position])
+  end
+
+  @spec update_changeset(t(), attrs :: map(), position :: non_neg_integer(), User.t()) ::
+          changeset()
+  def update_changeset(
+        %{user_id: user_id} = step,
+        attrs,
+        position,
+        %User{id: user_id}
+      ) do
+    step
+    |> cast(attrs, [:title, :content])
+    |> change(position: position)
+    |> validate_required([:title, :content, :user_id, :position])
+  end
+end

lib/memex/pipelines/step_context.ex

@@ -0,0 +1,41 @@
+defmodule Memex.Pipelines.StepContext do
+  @moduledoc """
+  Represents a has-many relation between a step and related contexts
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Ecto.{Changeset, UUID}
+  alias Memex.{Contexts.Context, Pipelines.Step}
+
+  @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
+  schema "step_contexts" do
+    belongs_to :step, Step
+    belongs_to :context, Context
+
+    timestamps()
+  end
+
+  @type t :: %__MODULE__{
+          step: Step.t() | Ecto.Association.NotLoaded.t(),
+          step_id: Step.id(),
+          context: Context.t() | Ecto.Association.NotLoaded.t(),
+          context_id: Context.id(),
+          inserted_at: NaiveDateTime.t(),
+          updated_at: NaiveDateTime.t()
+        }
+  @type id :: UUID.t()
+  @type changeset :: Changeset.t(t())
+
+  @doc false
+  @spec create_changeset(Step.t(), Context.t()) :: changeset()
+  def create_changeset(
+        %Step{id: step_id, user_id: user_id},
+        %Context{id: context_id, user_id: user_id}
+      ) do
+    %__MODULE__{}
+    |> change(step_id: step_id, context_id: context_id)
+    |> validate_required([:step_id, :context_id])
+  end
+end

lib/memex/pipelines/steps.ex

@@ -0,0 +1,159 @@
+defmodule Memex.Pipelines.Steps do
+  @moduledoc """
+  The context for steps within a pipeline
+  """
+
+  import Ecto.Query, warn: false
+  alias Memex.{Accounts.User, Repo}
+  alias Memex.Pipelines.{Pipeline, Step}
+
+  @doc """
+  Returns the list of steps.
+
+  ## Examples
+
+      iex> list_steps(%User{id: 123})
+      [%Step{}, ...]
+
+      iex> list_steps("my step", %User{id: 123})
+      [%Step{title: "my step"}, ...]
+
+  """
+  @spec list_steps(Pipeline.t(), User.t()) :: [Step.t()]
+  def list_steps(%{id: pipeline_id}, %{id: user_id}) do
+    Repo.all(
+      from s in Step,
+        where: s.pipeline_id == ^pipeline_id,
+        where: s.user_id == ^user_id,
+        order_by: s.position
+    )
+  end
+
+  def list_steps(%{id: pipeline_id, visibility: visibility}, _invalid_user)
+      when visibility in [:unlisted, :public] do
+    Repo.all(
+      from s in Step,
+        where: s.pipeline_id == ^pipeline_id,
+        order_by: s.position
+    )
+  end
+
+  @doc """
+  Preloads the `:steps` field on a Memex.Pipelines.Pipeline
+  """
+  @spec preload_steps(Pipeline.t(), User.t()) :: Pipeline.t()
+  def preload_steps(pipeline, user) do
+    %{pipeline | steps: list_steps(pipeline, user)}
+  end
+
+  @doc """
+  Gets a single step.
+
+  Raises `Ecto.NoResultsError` if the Step does not exist.
+
+  ## Examples
+
+      iex> get_step!(123, %User{id: 123})
+      %Step{}
+
+      iex> get_step!(456, %User{id: 123})
+      ** (Ecto.NoResultsError)
+
+  """
+  @spec get_step!(Step.id(), User.t()) :: Step.t()
+  def get_step!(id, %{id: user_id}) do
+    Repo.one!(from n in Step, where: n.id == ^id, where: n.user_id == ^user_id)
+  end
+
+  def get_step!(id, _invalid_user) do
+    Repo.one!(
+      from n in Step,
+        where: n.id == ^id,
+        where: n.visibility in [:public, :unlisted]
+    )
+  end
+
+  @doc """
+  Creates a step.
+
+  ## Examples
+
+      iex> create_step(%{field: value}, %User{id: 123})
+      {:ok, %Step{}}
+
+      iex> create_step(%{field: bad_value}, %User{id: 123})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  @spec create_step(position :: non_neg_integer(), Pipeline.t(), User.t()) ::
+          {:ok, Step.t()} | {:error, Step.changeset()}
+  @spec create_step(attrs :: map(), position :: non_neg_integer(), Pipeline.t(), User.t()) ::
+          {:ok, Step.t()} | {:error, Step.changeset()}
+  def create_step(attrs \\ %{}, position, pipeline, user) do
+    Step.create_changeset(attrs, position, pipeline, user) |> Repo.insert()
+  end
+
+  @doc """
+  Updates a step.
+
+  ## Examples
+
+      iex> update_step(step, %{field: new_value}, %User{id: 123})
+      {:ok, %Step{}}
+
+      iex> update_step(step, %{field: bad_value}, %User{id: 123})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  @spec update_step(Step.t(), attrs :: map(), position :: non_neg_integer(), User.t()) ::
+          {:ok, Step.t()} | {:error, Step.changeset()}
+  def update_step(%Step{} = step, attrs, position, user) do
+    step
+    |> Step.update_changeset(attrs, position, user)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a step.
+
+  ## Examples
+
+      iex> delete_step(%Step{user_id: 123}, %User{id: 123})
+      {:ok, %Step{}}
+
+      iex> delete_step(%Step{}, %User{role: :admin})
+      {:ok, %Step{}}
+
+      iex> delete_step(%Step{}, %User{id: 123})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  @spec delete_step(Step.t(), User.t()) :: {:ok, Step.t()} | {:error, Step.changeset()}
+  def delete_step(%Step{user_id: user_id} = step, %{id: user_id}) do
+    step |> Repo.delete()
+  end
+
+  def delete_step(%Step{} = step, %{role: :admin}) do
+    step |> Repo.delete()
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking step changes.
+
+  ## Examples
+
+      iex> change_step(step, %User{id: 123})
+      %Ecto.Changeset{data: %Step{}}
+
+      iex> change_step(step, %{title: "new title"}, %User{id: 123})
+      %Ecto.Changeset{data: %Step{}}
+
+  """
+  @spec change_step(Step.t(), position :: non_neg_integer(), Pipeline.t(), User.t()) ::
+          Step.changeset()
+  @spec change_step(Step.t(), attrs :: map(), position :: non_neg_integer(), User.t()) ::
+          Step.changeset()
+  def change_step(%Step{} = step, attrs \\ %{}, position, user) do
+    step |> Step.update_changeset(attrs, position, user)
+  end
+end

lib/memex/steps.ex

@@ -1,104 +0,0 @@
-defmodule Memex.Steps do
-  @moduledoc """
-  The Steps context.
-  """
-
-  import Ecto.Query, warn: false
-  alias Memex.Repo
-
-  alias Memex.Steps.Step
-
-  @doc """
-  Returns the list of steps.
-
-  ## Examples
-
-      iex> list_steps()
-      [%Step{}, ...]
-
-  """
-  def list_steps do
-    Repo.all(Step)
-  end
-
-  @doc """
-  Gets a single step.
-
-  Raises `Ecto.NoResultsError` if the Step does not exist.
-
-  ## Examples
-
-      iex> get_step!(123)
-      %Step{}
-
-      iex> get_step!(456)
-      ** (Ecto.NoResultsError)
-
-  """
-  def get_step!(id), do: Repo.get!(Step, id)
-
-  @doc """
-  Creates a step.
-
-  ## Examples
-
-      iex> create_step(%{field: value})
-      {:ok, %Step{}}
-
-      iex> create_step(%{field: bad_value})
-      {:error, %Ecto.Changeset{}}
-
-  """
-  def create_step(attrs \\ %{}) do
-    %Step{}
-    |> Step.changeset(attrs)
-    |> Repo.insert()
-  end
-
-  @doc """
-  Updates a step.
-
-  ## Examples
-
-      iex> update_step(step, %{field: new_value})
-      {:ok, %Step{}}
-
-      iex> update_step(step, %{field: bad_value})
-      {:error, %Ecto.Changeset{}}
-
-  """
-  def update_step(%Step{} = step, attrs) do
-    step
-    |> Step.changeset(attrs)
-    |> Repo.update()
-  end
-
-  @doc """
-  Deletes a step.
-
-  ## Examples
-
-      iex> delete_step(step)
-      {:ok, %Step{}}
-
-      iex> delete_step(step)
-      {:error, %Ecto.Changeset{}}
-
-  """
-  def delete_step(%Step{} = step) do
-    Repo.delete(step)
-  end
-
-  @doc """
-  Returns an `%Ecto.Changeset{}` for tracking step changes.
-
-  ## Examples
-
-      iex> change_step(step)
-      %Ecto.Changeset{data: %Step{}}
-
-  """
-  def change_step(%Step{} = step, attrs \\ %{}) do
-    Step.changeset(step, attrs)
-  end
-end

lib/memex/steps/step.ex

@@ -1,22 +0,0 @@
-defmodule Memex.Steps.Step do
-  use Ecto.Schema
-  import Ecto.Changeset
-
-  @primary_key {:id, :binary_id, autogenerate: true}
-  @foreign_key_type :binary_id
-  schema "steps" do
-    field :description, :string
-    field :position, :integer
-    field :title, :string
-    field :pipeline_id, :binary_id
-
-    timestamps()
-  end
-
-  @doc false
-  def changeset(step, attrs) do
-    step
-    |> cast(attrs, [:title, :description, :position])
-    |> validate_required([:title, :description, :position])
-  end
-end

lib/memex/steps/step_context.ex

@@ -1,20 +0,0 @@
-defmodule Memex.Steps.StepContext do
-  use Ecto.Schema
-  import Ecto.Changeset
-
-  @primary_key {:id, :binary_id, autogenerate: true}
-  @foreign_key_type :binary_id
-  schema "step_contexts" do
-    field :step_id, :binary_id
-    field :context_id, :binary_id
-
-    timestamps()
-  end
-
-  @doc false
-  def changeset(step_context, attrs) do
-    step_context
-    |> cast(attrs, [])
-    |> validate_required([])
-  end
-end

priv/repo/migrations/20220726001809_create_steps.exs

@@ -5,13 +5,16 @@ defmodule Memex.Repo.Migrations.CreateSteps do
     create table(:steps, primary_key: false) do
       add :id, :binary_id, primary_key: true
       add :title, :string
-      add :description, :text
+      add :content, :text
       add :position, :integer
+
       add :pipeline_id, references(:pipelines, on_delete: :nothing, type: :binary_id)
+      add :user_id, references(:users, on_delete: :nothing, type: :binary_id)
 
       timestamps()
     end
 
     create index(:steps, [:pipeline_id])
+    create index(:steps, [:user_id])
   end
 end

test/memex/steps_test.exs

@@ -1,68 +1,94 @@
 defmodule Memex.StepsTest do
   use Memex.DataCase
-
+  import Memex.{PipelinesFixtures, StepsFixtures}
-  alias Memex.Steps
+  alias Memex.Pipelines.{Step, Steps}
+  @moduletag :steps_test
+  @invalid_attrs %{content: nil, title: nil}
 
   describe "steps" do
-    alias Memex.Steps.Step
+    setup do
+      user = user_fixture()
+      pipeline = pipeline_fixture(user)
 
-    import Memex.StepsFixtures
+      [user: user, pipeline: pipeline]
-
-    @invalid_attrs %{description: nil, position: nil, title: nil}
-
-    test "list_steps/0 returns all steps" do
-      step = step_fixture()
-      assert Steps.list_steps() == [step]
     end
 
-    test "get_step!/1 returns the step with given id" do
+    test "list_steps/1 returns all steps for a user", %{pipeline: pipeline, user: user} do
-      step = step_fixture()
+      step_a = step_fixture(0, pipeline, user)
-      assert Steps.get_step!(step.id) == step
+      step_b = step_fixture(1, pipeline, user)
+      step_c = step_fixture(2, pipeline, user)
+      assert Steps.list_steps(pipeline, user) == [step_a, step_b, step_c]
     end
 
-    test "create_step/1 with valid data creates a step" do
+    test "get_step!/1 returns the step with given id", %{pipeline: pipeline, user: user} do
-      valid_attrs = %{description: "some description", position: 42, title: "some title"}
+      step = step_fixture(0, pipeline, user)
+      assert Steps.get_step!(step.id, user) == step
+    end
 
-      assert {:ok, %Step{} = step} = Steps.create_step(valid_attrs)
+    test "get_step!/1 only returns unlisted or public steps for other users", %{user: user} do
-      assert step.description == "some description"
+      another_user = user_fixture()
-      assert step.position == 42
+      another_pipeline = pipeline_fixture(another_user)
+      step = step_fixture(0, another_pipeline, another_user)
+
+      assert_raise Ecto.NoResultsError, fn ->
+        Steps.get_step!(step.id, user)
+      end
+    end
+
+    test "create_step/1 with valid data creates a step", %{pipeline: pipeline, user: user} do
+      valid_attrs = %{
+        "content" => "some content",
+        "title" => "some title"
+      }
+
+      assert {:ok, %Step{} = step} = Steps.create_step(valid_attrs, 0, pipeline, user)
+      assert step.content == "some content"
       assert step.title == "some title"
     end
 
-    test "create_step/1 with invalid data returns error changeset" do
+    test "create_step/1 with invalid data returns error changeset",
-      assert {:error, %Ecto.Changeset{}} = Steps.create_step(@invalid_attrs)
+         %{pipeline: pipeline, user: user} do
+      assert {:error, %Ecto.Changeset{}} = Steps.create_step(@invalid_attrs, 0, pipeline, user)
     end
 
-    test "update_step/2 with valid data updates the step" do
+    test "update_step/2 with valid data updates the step", %{pipeline: pipeline, user: user} do
-      step = step_fixture()
+      step = step_fixture(0, pipeline, user)
 
       update_attrs = %{
-        description: "some updated description",
+        "content" => "some updated content",
-        position: 43,
+        "title" => "some updated title"
-        title: "some updated title"
       }
 
-      assert {:ok, %Step{} = step} = Steps.update_step(step, update_attrs)
+      assert {:ok, %Step{} = step} = Steps.update_step(step, update_attrs, 0, user)
-      assert step.description == "some updated description"
+      assert step.content == "some updated content"
-      assert step.position == 43
       assert step.title == "some updated title"
     end
 
-    test "update_step/2 with invalid data returns error changeset" do
+    test "update_step/2 with invalid data returns error changeset", %{
-      step = step_fixture()
+      pipeline: pipeline,
-      assert {:error, %Ecto.Changeset{}} = Steps.update_step(step, @invalid_attrs)
+      user: user
-      assert step == Steps.get_step!(step.id)
+    } do
+      step = step_fixture(0, pipeline, user)
+      assert {:error, %Ecto.Changeset{}} = Steps.update_step(step, @invalid_attrs, 0, user)
+      assert step == Steps.get_step!(step.id, user)
     end
 
-    test "delete_step/1 deletes the step" do
+    test "delete_step/1 deletes the step", %{pipeline: pipeline, user: user} do
-      step = step_fixture()
+      step = step_fixture(0, pipeline, user)
-      assert {:ok, %Step{}} = Steps.delete_step(step)
+      assert {:ok, %Step{}} = Steps.delete_step(step, user)
-      assert_raise Ecto.NoResultsError, fn -> Steps.get_step!(step.id) end
+      assert_raise Ecto.NoResultsError, fn -> Steps.get_step!(step.id, user) end
     end
 
-    test "change_step/1 returns a step changeset" do
+    test "delete_step/1 deletes the step for an admin user", %{pipeline: pipeline, user: user} do
-      step = step_fixture()
+      admin_user = admin_fixture()
-      assert %Ecto.Changeset{} = Steps.change_step(step)
+      step = step_fixture(0, pipeline, user)
+      assert {:ok, %Step{}} = Steps.delete_step(step, admin_user)
+      assert_raise Ecto.NoResultsError, fn -> Steps.get_step!(step.id, user) end
+    end
+
+    test "change_step/1 returns a step changeset", %{pipeline: pipeline, user: user} do
+      step = step_fixture(0, pipeline, user)
+      assert %Ecto.Changeset{} = Steps.change_step(step, 0, user)
     end
   end
 end

test/support/fixtures/steps_fixtures.ex

@@ -3,19 +3,19 @@ defmodule Memex.StepsFixtures do
   This module defines test helpers for creating
   entities via the `Memex.Steps` context.
   """
+  alias Memex.Pipelines.Steps
 
   @doc """
   Generate a step.
   """
-  def step_fixture(attrs \\ %{}) do
+  def step_fixture(attrs \\ %{}, position, pipeline, user) do
     {:ok, step} =
       attrs
       |> Enum.into(%{
-        description: "some description",
+        content: "some content",
-        position: 42,
         title: "some title"
       })
-      |> Memex.Steps.create_step()
+      |> Steps.create_step(position, pipeline, user)
 
     step
   end