feat: peri validation for Lexicons

array validator

Author: Ovyerus

.gitignore

@@ -24,4 +24,5 @@ atex-*.tar
 
 .envrc
 .direnv
-.vscode/
+.vscode/
+.elixir_ls

.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-  "git.enabled": false
-}

lib/atex/did.ex

@@ -0,0 +1,16 @@
+defmodule Atex.DID do
+  @re ~r/^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$/
+  @blessed_re ~r/^did:(?:plc|web):[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$/
+
+  @spec re() :: Regex.t()
+  def re, do: @re
+
+  @spec match?(String.t()) :: boolean()
+  def match?(value), do: Regex.match?(@re, value)
+
+  @spec blessed_re() :: Regex.t()
+  def blessed_re, do: @blessed_re
+
+  @spec match_blessed?(String.t()) :: boolean()
+  def match_blessed?(value), do: Regex.match?(@blessed_re, value)
+end

lib/atex/handle.ex

@@ -0,0 +1,9 @@
+defmodule Atex.Handle do
+  @re ~r/^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/
+
+  @spec re() :: Regex.t()
+  def re, do: @re
+
+  @spec match?(String.t()) :: boolean()
+  def match?(value), do: Regex.match?(@re, value)
+end

lib/atex/lexicon/validators.ex

@@ -0,0 +1,76 @@
+defmodule Atex.Lexicon.Validators do
+  alias Atex.Lexicon.Validators
+
+  @type blob_option() :: {:accept, list(String.t())} | {:max_size, integer()}
+
+  @type blob_t() ::
+          %{
+            "$type": String.t(),
+            req: %{"$link": String.t()},
+            mimeType: String.t(),
+            size: integer()
+          }
+          | %{}
+
+  @spec string(list(Validators.String.option())) :: Peri.custom_def()
+  def string(options \\ []), do: {:custom, {Validators.String, :validate, [options]}}
+
+  @spec integer(list(Validators.Integer.option())) :: Peri.custom_def()
+  def integer(options \\ []), do: {:custom, {Validators.Integer, :validate, [options]}}
+
+  @spec array(Peri.schema_def(), list(Validators.Array.option())) :: Peri.custom_def()
+  def array(inner_type, options \\ []) do
+    {:ok, ^inner_type} = Peri.validate_schema(inner_type)
+    {:custom, {Validators.Array, :validate, [inner_type, options]}}
+  end
+
+  @spec blob(list(blob_option())) :: Peri.schema_def()
+  def blob(options \\ []) do
+    options = Keyword.validate!(options, accept: nil, max_size: nil)
+    accept = Keyword.get(options, :accept)
+    max_size = Keyword.get(options, :max_size)
+
+    mime_type =
+      {:required,
+       if(accept,
+         do: {:string, {:regex, strings_to_re(accept)}},
+         else: {:string, {:regex, ~r"^.+/.+$"}}
+       )}
+
+    {
+      :either,
+      {
+        # Newer blobs
+        %{
+          "$type": {:required, {:literal, "blob"}},
+          ref: {:required, %{"$link": {:required, :string}}},
+          mimeType: mime_type,
+          size: {:required, if(max_size != nil, do: {:integer, {:lte, max_size}}, else: :integer)}
+        },
+        # Old deprecated blobs
+        %{
+          cid: {:reqiured, :string},
+          mimeType: mime_type
+        }
+      }
+    }
+  end
+
+  @spec boolean_validate(boolean(), String.t(), keyword() | map()) ::
+          Peri.validation_result()
+  def boolean_validate(success?, error_message, context \\ []) do
+    if success? do
+      :ok
+    else
+      {:error, error_message, context}
+    end
+  end
+
+  @spec strings_to_re(list(String.t())) :: Regex.t()
+  defp strings_to_re(strings) do
+    strings
+    |> Enum.map(&String.replace(&1, "*", ".+"))
+    |> Enum.join("|")
+    |> then(&~r/^(#{&1})$/)
+  end
+end

lib/atex/lexicon/validators/array.ex

@@ -0,0 +1,52 @@
+defmodule Atex.Lexicon.Validators.Array do
+  @type option() :: {:min_length, non_neg_integer()} | {:max_length, non_neg_integer()}
+
+  @option_keys [:min_length, :max_length]
+
+  # Needs type input
+  @spec validate(Peri.schema_def(), term(), list(option())) :: Peri.validation_result()
+  def validate(inner_type, value, options) when is_list(value) do
+    # TODO: validate inner_type with Peri to make sure it's correct?
+
+    options
+    |> Keyword.validate!(min_length: nil, max_length: nil)
+    |> Stream.map(&validate_option(value, &1))
+    |> Enum.find(:ok, fn x -> x != :ok end)
+    |> case do
+      :ok ->
+        value
+        |> Stream.map(&Peri.validate(inner_type, &1))
+        |> Enum.find({:ok, nil}, fn
+          {:ok, _} -> false
+          {:error, _} -> true
+        end)
+        |> case do
+          {:ok, _} -> :ok
+          e -> e
+        end
+
+      e ->
+        e
+    end
+  end
+
+  def validate(_inner_type, value, _options),
+    do: {:error, "expected type of `array`, received #{value}", [expected: :array, actual: value]}
+
+  @spec validate_option(list(), option()) :: Peri.validation_result()
+  defp validate_option(value, option)
+
+  defp validate_option(_value, {option, nil}) when option in @option_keys, do: :ok
+
+  defp validate_option(value, {:min_length, expected}) when length(value) >= expected,
+    do: :ok
+
+  defp validate_option(value, {:min_length, expected}) when length(value) < expected,
+    do: {:error, "should have a minimum length of #{expected}", [length: expected]}
+
+  defp validate_option(value, {:max_length, expected}) when length(value) <= expected,
+    do: :ok
+
+  defp validate_option(value, {:max_length, expected}) when length(value) > expected,
+    do: {:error, "should have a maximum length of #{expected}", [length: expected]}
+end

lib/atex/lexicon/validators/integer.ex

@@ -0,0 +1,55 @@
+defmodule Atex.Lexicon.Validators.Integer do
+  alias Atex.Lexicon.Validators
+
+  @type option() ::
+          {:minimum, integer()}
+          | {:maximum, integer()}
+          | {:enum, list(integer())}
+          | {:const, integer()}
+
+  @option_keys [:minimum, :maximum, :enum, :const]
+
+  @spec validate(term(), list(option())) :: Peri.validation_result()
+  def validate(value, options) when is_integer(value) do
+    options
+    |> Keyword.validate!(
+      minimum: nil,
+      maximum: nil,
+      enum: nil,
+      const: nil
+    )
+    |> Stream.map(&validate_option(value, &1))
+    |> Enum.find(:ok, fn x -> x != :ok end)
+  end
+
+  def validate(value, _options),
+    do:
+      {:error, "expected type of `integer`, received #{value}",
+       [expected: :integer, actual: value]}
+
+  @spec validate_option(integer(), option()) :: Peri.validation_result()
+  defp validate_option(value, option)
+
+  defp validate_option(_value, {option, nil}) when option in @option_keys, do: :ok
+
+  defp validate_option(value, {:minimum, expected}) when value >= expected, do: :ok
+
+  defp validate_option(value, {:minimum, expected}) when value < expected,
+    do: {:error, "", [value: expected]}
+
+  defp validate_option(value, {:maximum, expected}) when value <= expected, do: :ok
+
+  defp validate_option(value, {:maximum, expected}) when value > expected,
+    do: {:error, "", [value: expected]}
+
+  defp validate_option(value, {:enum, values}),
+    do:
+      Validators.boolean_validate(value in values, "should be one of the expected values",
+        enum: values
+      )
+
+  defp validate_option(value, {:const, expected}) when value == expected, do: :ok
+
+  defp validate_option(value, {:const, expected}),
+    do: {:error, "should match constant value", [actual: value, expected: expected]}
+end