Merge pull request #15 from florinpatrascu/more_about_node_id

Updated code to support custom primary keys in CTE

Author: florinpatrascu

.formatter.exs

@@ -1,5 +1,6 @@
 # Used by "mix format"
 [
+  import_deps: [:ecto, :ecto_sql],
   inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"],
   locals_without_parens: [add: :*],
   import_deps: [:ecto]

.gitignore

@@ -23,3 +23,4 @@ erl_crash.dump
 closure_table-*.tar
 .vale.ini
 .favorites.json
+.envrc

CHANGELOG.md

@@ -1,5 +1,38 @@
 # CHANGELOG
 
+## 2.0.5
+
+**Highlights**
+
+- Updated code to support custom primary keys in CTE. You are no longer required to name your primary keys `id`. Although `id` remains the default, you now have the option to use your own keys and data types. Example:
+
+    ```elixir
+    use CTE,
+      repo: Repo,
+      nodes: Tag,
+      paths: TagTreePath,
+      options: %{
+        node: %{primary_key: :name, type: :string},
+        paths: %{
+          ancestor: [type: :string],
+          descendant: [type: :string]
+        }
+      }
+    ```
+
+**Improvements**
+
+- Added support for nodes with custom primary keys
+- Updated formatter configuration
+- Modified Ecto queries to use dynamic fields instead of hardcoded 'id'
+- Introduced new test cases for products and tags with custom IDs
+- Adjusted existing tests to accommodate changes
+- Updated migration files to include new tables and extensions
+
+**Fixes**
+
+- Finally crushed a sneaky bug that had been hiding out for way too long. The `depth` was stealthily hanging out in the descendants list and, on occasion, masquerading as one of the descendants if its value matched one of the nodes ids.
+
 ## 2.0.0
 
 This version is introducing major breaking changes. We drop the concept of a CT Adapter and focus on using Ecto, for the core functions. The (in)memory adapter is gone.

README.md

@@ -16,14 +16,43 @@ Warning:
 
 ## Quick start
 
-The current implementation is depending on Ecto ~> 3.1; using [Ecto.SubQuery](https://hexdocs.pm/ecto/Ecto.SubQuery.html)!
+The current implementation is depending on Ecto >= 3.1; using [Ecto.SubQuery](https://hexdocs.pm/ecto/Ecto.SubQuery.html)!
 
 For this implementation to work you'll have to provide two tables, and the name of the Repo used by your application:
 
-1. a table containing the nodes, with `id` as the primary key. This is the default for now, but it will be configurable in the near future.
-2. a table name where the tree paths will be stored.
+1. a table containing the nodes, with `id` as the primary key. With this new version, you are no longer required to name your primary keys `id`. Although `id` remains the default, you now have the option to use your own keys and data types. Example:
+
+    ```elixir
+    # For more details and an example of designing and implementing simple
+    # hierarchical structures of tags, see test/custom_node_id_test.exs (excerpt below)
+    use CTE,
+      repo: Repo,
+      nodes: Tag,
+      paths: TagTreePath,
+      options: %{
+        node: %{primary_key: :name, type: :string},
+        paths: %{
+          ancestor: [type: :string],
+          descendant: [type: :string]
+        }
+      }
+    ```
+
+2. a table name for storing the tree paths.
 3. the name of the Ecto.Repo, defined by your app
 
+Using a structure like the one above and just a few functions from this library, you will be able to create highly efficient hierarchies such as these. Their management will be quick, accurate, and straightforward:
+
+    food
+    ├── vegetable
+    ├── fruit
+    │  ├── apple
+    │  ├── orange
+    │  └── berry
+    │     └── tomato
+    └── meat
+      └── burger
+
 In a future version we will provide you with a convenient migration template to help you starting, but for now you must supply these tables.
 
 For example, given you have the following Schemas for comments:
@@ -193,7 +222,7 @@ end
 ## License
 
 ```txt
-Copyright 2023 Florin T.PATRASCU & the Contributors
+Copyright 2024 Florin T.PATRASCU & the Contributors
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

lib/cte.ex

@@ -47,16 +47,25 @@ defmodule CTE do
           nodes: nodes | nil,
           paths: paths | nil,
           repo: repo | nil,
-          name: name | nil
+          name: name | nil,
+          options: map() | nil
         }
-  defstruct [:nodes, :paths, :adapter, :repo, :name]
+  defstruct [:nodes, :paths, :adapter, :repo, :name, :options]
 
   defmacro __using__(opts) do
     quote bind_quoted: [opts: opts] do
       @opts %CTE{
         nodes: Keyword.get(opts, :nodes, []),
         paths: Keyword.get(opts, :paths, []),
-        repo: Keyword.get(opts, :repo, nil)
+        repo: Keyword.get(opts, :repo, nil),
+        options:
+          Keyword.get(opts, :options, %{
+            node: %{primary_key: :id, type: :integer},
+            paths: %{
+              ancestor: [type: :integer],
+              descendant: [type: :integer]
+            }
+          })
       }
 
       def insert(leaf, ancestor, opts \\ [])

lib/cte/ecto.ex

@@ -57,7 +57,8 @@ defmodule CTE.Ecto do
   """
 
   def tree(leaf, opts, config) do
-    %CTE{paths: paths, nodes: nodes, repo: repo} = config
+    %CTE{paths: paths, nodes: nodes, repo: repo, options: options} = config
+    %{primary_key: pk} = options.node
 
     descendants_opts = [itself: true] ++ Keyword.take(opts, [:depth])
     descendants = _descendants(leaf, descendants_opts, config)
@@ -74,14 +75,14 @@ defmodule CTE.Ecto do
 
     unique_descendants =
       subtree
-      |> List.flatten()
+      |> Enum.map(fn [_ancestor, descendant, _depth] -> descendant end)
       |> Enum.uniq()
 
-    query = from n in nodes, where: n.id in ^unique_descendants
+    query = from n in nodes, where: field(n, ^pk) in ^unique_descendants
 
     some_nodes =
       repo.all(query)
-      |> Enum.reduce(%{}, fn node, acc -> Map.put(acc, node.id, node) end)
+      |> Enum.reduce(%{}, fn node, acc -> Map.put(acc, Map.get(node, pk), node) end)
 
     {:ok, %{paths: subtree, nodes: some_nodes}}
   end
@@ -92,14 +93,20 @@ defmodule CTE.Ecto do
 
   @doc false
   defp _insert(leaf, ancestor, config) do
-    %CTE{paths: paths, repo: repo} = config
+    %CTE{paths: paths, repo: repo, options: options} = config
+    %{descendant: [type: descendant_type]} = options.paths
 
     descendants =
       from p in paths,
         where: p.descendant == ^ancestor,
-        select: %{ancestor: p.ancestor, descendant: type(^leaf, :integer), depth: p.depth + 1}
+        select: %{
+          ancestor: p.ancestor,
+          descendant: type(^leaf, ^descendant_type),
+          depth: p.depth + 1
+        }
 
     new_records = repo.all(descendants) ++ [%{ancestor: leaf, descendant: leaf, depth: 0}]
+
     descendants = Enum.map(new_records, fn r -> [r.ancestor, r.descendant] end)
 
     case repo.insert_all(paths, new_records, on_conflict: :nothing) do
@@ -113,13 +120,15 @@ defmodule CTE.Ecto do
 
   @doc false
   defp _descendants(ancestor, opts, config) do
-    %CTE{paths: paths, nodes: nodes, repo: repo} = config
+    %CTE{paths: paths, nodes: nodes, repo: repo, options: options} = config
+    %{primary_key: pk} = options.node
+    # %{descendant: [type: descendant_type]} = options.paths
 
     query =
       from n in nodes,
         join: p in ^paths,
         as: :tree,
-        on: n.id == p.descendant,
+        on: field(n, ^pk) == p.descendant,
         where: p.ancestor == ^ancestor,
         order_by: [asc: p.depth]
 
@@ -133,13 +142,14 @@ defmodule CTE.Ecto do
 
   @doc false
   defp _ancestors(descendant, opts, config) do
-    %CTE{paths: paths, nodes: nodes, repo: repo} = config
+    %CTE{paths: paths, nodes: nodes, repo: repo, options: options} = config
+    %{primary_key: pk} = options.node
 
     query =
       from n in nodes,
         join: p in ^paths,
         as: :tree,
-        on: n.id == p.ancestor,
+        on: field(n, ^pk) == p.ancestor,
         where: p.descendant == ^descendant,
         order_by: [desc: p.depth]
 
@@ -193,11 +203,14 @@ defmodule CTE.Ecto do
   ######################################
   # Utils
   ######################################
-  defp selected(query, opts, _config) do
+  defp selected(query, opts, config) do
+    %CTE{options: options} = config
+    %{primary_key: pk} = options.node
+
     if Keyword.get(opts, :nodes, false) do
       from(n in query)
     else
-      from n in query, select: n.id
+      from n in query, select: field(n, ^pk)
     end
   end
 
@@ -226,8 +239,8 @@ defmodule CTE.Ecto do
   end
 
   defp prune(query, descendants, opts, _config) do
-    if Keyword.get(opts, :depth) do
-      from t in query, where: t.descendant in ^descendants
+    if depth = Keyword.get(opts, :depth) do
+      from t in query, where: t.descendant in ^descendants and t.depth <= ^max(depth, 0)
     else
       query
     end

lib/cte/utils.ex

@@ -88,7 +88,9 @@ defmodule CTE.Utils do
   def print_tree(tree, id, opts \\ [])
 
   def print_tree(%{paths: paths, nodes: nodes}, id, opts) do
-    user_callback = Keyword.get(opts, :callback, fn id, _nodes -> {id, "info..."} end)
+    user_callback =
+      Keyword.get(opts, :callback, fn id, _nodes -> {id, "#{inspect(id)} => more..."} end)
+
     direct_children = direct_children(paths)
 
     callback = fn

mix.exs

@@ -1,7 +1,7 @@
 defmodule CTE.MixProject do
   use Mix.Project
 
-  @version "2.0.0"
+  @version "2.0.5"
   @url_docs "https://hexdocs.pm/closure_table"
   @url_github "https://github.com/florinpatrascu/closure_table"
 

test/cte_test.exs

@@ -12,7 +12,7 @@ defmodule CTE.Ecto.Test do
         ├── (8) I’m sold! And I’ll use its Elixir implementation! <3
         └── (9) w⦿‿⦿t!
   """
-  use CTE.DataCase
+  use CTE.DataCase, async: false
   import ExUnit.CaptureIO
 
   @moduletag :ecto