8a215eb3f714f8dc47a0edb1d9b77c2e56987123

Committed 30 May 2025 03:05AM UTC coverage: 57.384% (-0.07%) from 57.458%

Build # 8a215eb3f714f8dc47a0edb1d9b77c2e56987123

Build Type

push

github

Committed by NSHkr

Commit Message

Update phoenix test app

Run Details

6186 of 10780 relevant lines covered (57.38%)

3118.34 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.78

/lib/elixir_scope/ast_repository/query_builder/validator.ex

defmodule ElixirScope.ASTRepository.QueryBuilder.Validator do
  @moduledoc """
  Validates query structures for correctness and safety.
  """

  alias ElixirScope.ASTRepository.QueryBuilder.Types

  @doc """
  Validates a complete query structure.
  """
  @spec validate_query(Types.query_t()) :: {:ok, Types.query_t()} | {:error, term()}
  def validate_query(%Types{} = query) do
    with :ok <- validate_from_clause(query.from),
         :ok <- validate_select_clause(query.select),
         :ok <- validate_where_clause(query.where),
         :ok <- validate_order_by_clause(query.order_by) do
      {:ok, query}
    else
      error -> error
    end
  end

  @doc """
  Validates the FROM clause.
  """
  @spec validate_from_clause(atom()) :: :ok | {:error, :invalid_from_clause}
  def validate_from_clause(from) when from in [:functions, :modules, :patterns], do: :ok
  def validate_from_clause(_), do: {:error, :invalid_from_clause}

  @doc """
  Validates the SELECT clause.
  """
  @spec validate_select_clause(:all | list(atom())) :: :ok | {:error, :invalid_select_clause}
  def validate_select_clause(:all), do: :ok
  def validate_select_clause(fields) when is_list(fields), do: :ok
  def validate_select_clause(_), do: {:error, :invalid_select_clause}

  @doc """
  Validates WHERE conditions.
  """
  @spec validate_where_clause(list(Types.filter_condition())) :: :ok | {:error, :invalid_where_condition}
  def validate_where_clause(conditions) when is_list(conditions) do
    if Enum.all?(conditions, &valid_condition?/1) do
      :ok
    else
      {:error, :invalid_where_condition}
    end
  end

  @doc """
  Validates ORDER BY clause.
  """
  @spec validate_order_by_clause(term()) :: :ok | {:error, :invalid_order_by_clause}
  def validate_order_by_clause(nil), do: :ok
  def validate_order_by_clause({field, direction}) when is_atom(field) and direction in [:asc, :desc], do: :ok
  def validate_order_by_clause({direction, field}) when is_atom(field) and direction in [:asc, :desc], do: :ok
  def validate_order_by_clause(list) when is_list(list) do
    if Enum.all?(list, fn
      {field, direction} when is_atom(field) and direction in [:asc, :desc] -> true
      {direction, field} when is_atom(field) and direction in [:asc, :desc] -> true
      _ -> false
    end) do
      :ok
    else
      {:error, :invalid_order_by_clause}
    end
  end
  def validate_order_by_clause(_), do: {:error, :invalid_order_by_clause}

  # Private validation helpers

  defp valid_condition?({field, op, _value}) when is_atom(field) do
    op in [:eq, :ne, :gt, :lt, :gte, :lte, :in, :not_in, :contains, :not_contains, :matches, :similar_to, :not_nil, :nil]
  end

  defp valid_condition?({field, op}) when is_atom(field) and op in [:not_nil, :nil] do
    true
  end

  defp valid_condition?({op, _value}) when op in [:similar_to, :matches] do
    true
  end

  defp valid_condition?({special_field, _value}) when special_field in [:similarity_threshold] do
    true
  end

  defp valid_condition?({:and, conditions}) when is_list(conditions) do
    Enum.all?(conditions, &valid_condition?/1)
  end

  defp valid_condition?({:or, conditions}) when is_list(conditions) do
    Enum.all?(conditions, &valid_condition?/1)
  end

  defp valid_condition?({:not, condition}) do
    valid_condition?(condition)
  end

  defp valid_condition?(_), do: false
end

1	defmodule ElixirScope.ASTRepository.QueryBuilder.Validator do
2	@moduledoc """
3	Validates query structures for correctness and safety.
4	"""
5
6	alias ElixirScope.ASTRepository.QueryBuilder.Types
7
8	@doc """
9	Validates a complete query structure.
10	"""
11	@spec validate_query(Types.query_t()) :: {:ok, Types.query_t()} \| {:error, term()}
12	def validate_query(%Types{} = query) do
13	with :ok <- validate_from_clause(query.from),	26✔
14	:ok <- validate_select_clause(query.select),	26✔
15	:ok <- validate_where_clause(query.where),	26✔
16	:ok <- validate_order_by_clause(query.order_by) do	23✔
17	{:ok, query}
18	else
19	error -> error	3✔
20	end
21	end
22
23	@doc """
24	Validates the FROM clause.
25	"""
26	@spec validate_from_clause(atom()) :: :ok \| {:error, :invalid_from_clause}
27	def validate_from_clause(from) when from in [:functions, :modules, :patterns], do: :ok	26✔
28	def validate_from_clause(_), do: {:error, :invalid_from_clause}	×
29
30	@doc """
31	Validates the SELECT clause.
32	"""
33	@spec validate_select_clause(:all \| list(atom())) :: :ok \| {:error, :invalid_select_clause}
34	def validate_select_clause(:all), do: :ok	21✔
35	def validate_select_clause(fields) when is_list(fields), do: :ok	5✔
36	def validate_select_clause(_), do: {:error, :invalid_select_clause}	×
37
38	@doc """
39	Validates WHERE conditions.
40	"""
41	@spec validate_where_clause(list(Types.filter_condition())) :: :ok \| {:error, :invalid_where_condition}
42	def validate_where_clause(conditions) when is_list(conditions) do
43	if Enum.all?(conditions, &valid_condition?/1) do	26✔
44	:ok
45	else
46	{:error, :invalid_where_condition}
47	end
48	end
49
50	@doc """
51	Validates ORDER BY clause.
52	"""
53	@spec validate_order_by_clause(term()) :: :ok \| {:error, :invalid_order_by_clause}
54	def validate_order_by_clause(nil), do: :ok	16✔
55	def validate_order_by_clause({field, direction}) when is_atom(field) and direction in [:asc, :desc], do: :ok	×
56	def validate_order_by_clause({direction, field}) when is_atom(field) and direction in [:asc, :desc], do: :ok	5✔
57	def validate_order_by_clause(list) when is_list(list) do
58	if Enum.all?(list, fn	2✔
59	{field, direction} when is_atom(field) and direction in [:asc, :desc] -> true	5✔
60	{direction, field} when is_atom(field) and direction in [:asc, :desc] -> true	×
61	_ -> false	×
62	end) do
63	:ok
64	else
65	{:error, :invalid_order_by_clause}
66	end
67	end
68	def validate_order_by_clause(_), do: {:error, :invalid_order_by_clause}	×
69
70	# Private validation helpers
71
72	defp valid_condition?({field, op, _value}) when is_atom(field) do
73	op in [:eq, :ne, :gt, :lt, :gte, :lte, :in, :not_in, :contains, :not_contains, :matches, :similar_to, :not_nil, :nil]	34✔
74	end
75
76	defp valid_condition?({field, op}) when is_atom(field) and op in [:not_nil, :nil] do	3✔
77	true
78	end
79
80	defp valid_condition?({op, _value}) when op in [:similar_to, :matches] do	8✔
81	true
82	end
83
84	defp valid_condition?({special_field, _value}) when special_field in [:similarity_threshold] do	1✔
85	true
86	end
87
88	defp valid_condition?({:and, conditions}) when is_list(conditions) do
89	Enum.all?(conditions, &valid_condition?/1)	3✔
90	end
91
92	defp valid_condition?({:or, conditions}) when is_list(conditions) do
93	Enum.all?(conditions, &valid_condition?/1)	4✔
94	end
95
96	defp valid_condition?({:not, condition}) do
97	valid_condition?(condition)	2✔
98	end
99
100	defp valid_condition?(_), do: false	2✔
101	end

nshkrdotcom / ElixirScope / 8a215eb3f714f8dc47a0edb1d9b77c2e56987123

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous