feat: bulk operations

.github/workflows/publish_hex.yml

@@ -2,7 +2,7 @@ name: Publish package to Hex 📦
 on:
   push:
     tags:
-      - "v[0-9]+.[0-9]+.[0-9]+"
+      - "v[0-9]+.[0-9]+.[0-9]*"
 
 jobs:
   publish:
@@ -14,10 +14,10 @@ jobs:
       - name: Set up Elixir
         uses: erlef/setup-beam@v1
         with:
-          elixir-version: '1.13.4'
-          otp-version: '24.3'
+          elixir-version: "1.13.4"
+          otp-version: "24.3"
       - name: Restore dependencies cache
-        uses: actions/cache@v3.3.1
+        uses: actions/cache@v4
         with:
           path: deps
           key: ${{ runner.os }}-mix-${{ hashFiles('**/mix.lock') }}
@@ -31,4 +31,4 @@ jobs:
       - name: Release & Publish
         run: mix hex.publish --yes
         env:
-          HEX_API_KEY: ${{ secrets.HEX_API_KEY }}
+          HEX_API_KEY: ${{ secrets.HEX_API_KEY }}

lib/arke/core/link.ex

@@ -22,6 +22,26 @@ defmodule Arke.Core.Link do
   arke id: :arke_link do
   end
 
+  @enforce_keys [:parent_id, :child_id, :type]
+  defstruct [:parent_id, :child_id, :type, metadata: %{}]
+
+  def new(parent_id, child_id, type, metadata \\ %{}) do
+    __struct__(parent_id: parent_id, child_id: child_id, type: type, metadata: metadata)
+  end
+
+  def load(arke_link, %Arke.Core.Unit{arke_id: :arke_link} = unit) do
+    new(unit.data.parent_id, unit.data.child_id, unit.data.type, unit.metadata)
+  end
+
+  def load(arke_link, opts) do
+    {parent_id, opts} = Map.pop(opts, :parent_id, nil)
+    {child_id, opts} = Map.pop(opts, :child_id, nil)
+    {type, opts} = Map.pop(opts, :type, nil)
+    {metadata, opts} = Map.pop(opts, :metadata, arke_link.metadata)
+
+    new(parent_id, child_id, type, metadata)
+  end
+
   def on_create(
         _,
         %{

lib/arke/core/query.ex

@@ -51,11 +51,13 @@ defmodule Arke.Core.Query do
       - parameter => %Arke.Core.Parameter.`ParameterType` => refer to `Arke.Core.Parameter`
       - operator => refer to [operators](#module-operators)
       - value => any => the value that the query will search for
-      - negate => boolean => used to figure out whether the condition is to be denied \n
+      - negate => boolean => used to figure out whether the condition is to be denied
+      - path => [Arke.Core.Parameter.ParameterType] => the path of the parameter
+       \n
       It is used to keep the same logic structure across all the Filter
     """
 
-    defstruct ~w[parameter operator value negate]a
+    defstruct ~w[parameter operator value negate path]a
     @type t() :: %Arke.Core.Query.BaseFilter{}
 
     @doc """
@@ -79,14 +81,16 @@ defmodule Arke.Core.Query do
             parameter :: Arke.Core.Parameter.ParameterType,
             operator :: atom(),
             value :: any,
-            negate :: boolean
+            negate :: boolean(),
+            path :: [Arke.Core.Parameter.ParameterType]
           ) :: Arke.Core.Query.BaseFilter.t()
-    def new(parameter, operator, value, negate) do
+    def new(parameter, operator, value, negate, path) do
       %__MODULE__{
         parameter: parameter,
         operator: operator,
         value: cast_value(parameter, value),
-        negate: negate
+        negate: negate,
+        path: path
       }
     end
 
@@ -111,10 +115,12 @@ defmodule Arke.Core.Query do
     @moduledoc """
       Base struct Order:
       - parameter => %Arke.Core.Parameter.`ParameterType` => refer to `Arke.Core.Parameter`
-      - direction => "child" | "parent" => the direction the query will use to search \n
+      - direction => "child" | "parent" => the direction the query will use to search
+      - path => [Arke.Core.Parameter.ParameterType] => the path of the parameter
+       \n
       It is used to define the return order of a Query
     """
-    defstruct ~w[parameter direction]a
+    defstruct ~w[parameter direction path]a
     @type t() :: %Arke.Core.Query.Order{}
   end
 
@@ -133,18 +139,19 @@ defmodule Arke.Core.Query do
       %Arke.Core.Query{}
 
   """
-  @spec new(arke :: %Arke.Core.Arke{}, project :: atom(), distinct :: atom()) :: Arke.Core.Query.t()
+  @spec new(arke :: %Arke.Core.Arke{}, project :: atom(), distinct :: atom()) ::
+          Arke.Core.Query.t()
   def new(arke, project, distinct \\ nil),
-      do: %__MODULE__{
-        project: project,
-        arke: arke,
-        distinct: distinct,
-        persistence: nil,
-        filters: [],
-        orders: [],
-        offset: nil,
-        limit: nil
-      }
+    do: %__MODULE__{
+      project: project,
+      arke: arke,
+      distinct: distinct,
+      persistence: nil,
+      filters: [],
+      orders: [],
+      offset: nil,
+      limit: nil
+    }
 
   @doc """
   Add a new link filter
@@ -303,8 +310,8 @@ defmodule Arke.Core.Query do
   # TODO: standardize parameter
   #  if it is a string convert it to existing atom and get it from paramater manager
   #  if it is an atom get it from paramater manaager
-  def new_base_filter(parameter, operator, value, negate) do
-    BaseFilter.new(parameter, operator, value, negate)
+  def new_base_filter(parameter, operator, value, negate, path \\ []) do
+    BaseFilter.new(parameter, operator, value, negate, path)
   end
 
   defp parse_base_filters(base_filters) when is_list(base_filters), do: base_filters
@@ -327,6 +334,16 @@ defmodule Arke.Core.Query do
   ## Return
       %Arke.Core.Query{ ... orders: [ %Arke.Core.Query.Order{} ] ... }
   """
+
+  def add_order(query, parameter, direction) when is_list(parameter) do
+    {parameter, path} = List.pop_at(parameter, -1)
+
+    %{
+      query
+      | orders: [%Order{parameter: parameter, direction: direction, path: path} | query.orders]
+    }
+  end
+
   def add_order(query, parameter, direction) do
     %{
       query

lib/arke/core/unit.ex

@@ -47,7 +47,7 @@
           metadata: metadata,
           inserted_at: DatetimeHandler.parse_datetime(inserted_at, true),
           updated_at: DatetimeHandler.parse_datetime(updated_at, true),
           __module__: __module__,
           runtime_data: runtime_data
         )
     end
@@ -99,26 +99,26 @@
             metadata,
             inserted_at,
             updated_at,
             __module__,
             runtime_data
           )
         end
     end
   end
 
   def load_data(%{data: %{parameters: parameters}} = arke, unit_data, opts) do
     Enum.reduce(ArkeManager.get_parameters(arke), unit_data, fn %{
                                                                   id: parameter_id,
                                                                   arke_id: parameter_type
                                                                 } = parameter,
                                                                 new_unit_data ->
       load_parameter_value(parameter, new_unit_data, opts)
     end)
   end
 
   def load_parameter_value(%{id: :id} = _, data, opts), do: data
   def load_parameter_value(%{id: :metadata} = _, data, opts), do: data
   def load_parameter_value(%{id: :metadata} = _, data, opts), do: data
   def load_parameter_value(%{id: :arke_id} = _, data, opts), do: data
   def load_parameter_value(%{id: :inserted_at} = _, data, opts), do: data
   def load_parameter_value(%{id: :updated_at} = _, data, opts), do: data
@@ -169,8 +169,17 @@
 
   defp handle_default_value(_), do: nil
 
-  defp get_link(%{depth: depth, link_metadata: link_metadata,starting_unit: starting_unit} = args),
-    do: {%{depth: depth, metadata: link_metadata,starting_unit: starting_unit}, args}
+  defp get_link(
+         %{
+           depth: depth,
+           link_metadata: link_metadata,
+           starting_unit: starting_unit,
+           link_type: link_type
+         } = args
+       ),
+       do:
+         {%{depth: depth, metadata: link_metadata, starting_unit: starting_unit, type: link_type},
+          args}
 
   defp get_link(args), do: {nil, args}
 
@@ -289,11 +298,11 @@
   defp update_encoded_unit_data(%{data: %{only_runtime: true}}, data, _), do: data
 
   defp update_encoded_unit_data(%{id: id}, data, value),
-       do:
-         Map.put_new(data, Atom.to_string(id), %{
-           :value => value,
-           :datetime => Arke.DatetimeHandler.now(:datetime)
-         })
+    do:
+      Map.put_new(data, Atom.to_string(id), %{
+        :value => value,
+        :datetime => Arke.DatetimeHandler.now(:datetime)
+      })
 
   defp update_encoded_unit_data(_, data, _), do: data
 
@@ -373,7 +382,6 @@
   defp parse_value(value, %{arke_id: :atom}) when is_binary(value),
     do: String.to_existing_atom(value)
 
-
   defp parse_value(value, %{arke_id: :date}) do
     with {:ok, date} <- DatetimeHandler.parse_date(value),
          do: date,

lib/arke/group.ex

@@ -26,8 +26,11 @@ defmodule Arke.System.Group do
 
       #      @before_compile unquote(__MODULE__)
 
-      def group_from_attr(), do: Keyword.get(__MODULE__.__info__(:attributes), :group, []) |> List.first()
-      def is_group?(), do: Keyword.get(__MODULE__.__info__(:attributes), :system_group, []) |> List.first()
+      def group_from_attr(),
+        do: Keyword.get(__MODULE__.__info__(:attributes), :group, []) |> List.first()
+
+      def is_group?(),
+        do: Keyword.get(__MODULE__.__info__(:attributes), :system_group, []) |> List.first()
 
       def on_unit_load(arke, data, _persistence_fn), do: {:ok, data}
       def before_unit_load(_arke, data, _persistence_fn), do: {:ok, data}
@@ -41,6 +44,13 @@ defmodule Arke.System.Group do
       def on_unit_delete(_arke, unit), do: {:ok, unit}
       def before_unit_delete(_arke, unit), do: {:ok, unit}
 
+      def before_unit_bulk_create(_arke, valid, errors), do: {:ok, valid, errors}
+      def on_unit_bulk_create(_arke, valid, errors), do: {:ok, valid, errors}
+      def before_unit_bulk_update(_arke, valid, errors), do: {:ok, valid, errors}
+      def on_unit_bulk_update(_arke, valid, errors), do: {:ok, valid, errors}
+      def before_unit_bulk_delete(_arke, valid, errors), do: {:ok, valid, errors}
+      def on_unit_bulk_delete(_arke, valid, errors), do: {:ok, valid, errors}
+
       defoverridable on_unit_load: 3,
                      before_unit_load: 3,
                      on_unit_validate: 2,
@@ -51,7 +61,13 @@ defmodule Arke.System.Group do
                      on_unit_update: 2,
                      before_unit_update: 2,
                      on_unit_delete: 2,
-                     before_unit_delete: 2
+                     before_unit_delete: 2,
+                     before_unit_bulk_create: 3,
+                     on_unit_bulk_create: 3,
+                     before_unit_bulk_update: 3,
+                     on_unit_bulk_update: 3,
+                     before_unit_bulk_delete: 3,
+                     on_unit_bulk_delete: 3
     end
   end
 
@@ -96,7 +112,7 @@ defmodule Arke.System.Group do
       unquote(block)
 
       @group %{
-        id: id,
+        id: id
       }
     end
   end
@@ -114,7 +130,7 @@ defmodule Arke.System.Group do
   See example above `arke/2`
 
   """
-  @spec parameter(id :: atom(), type:: atom(), opts :: list()) :: Macro.t()
+  @spec parameter(id :: atom(), type :: atom(), opts :: list()) :: Macro.t()
   defmacro parameter(id, type, opts \\ []) do
     # parameter_dict = Arke.System.BaseParameter.parameter_options(opts, id, type)
     quote bind_quoted: [id: id, type: type, opts: opts] do