feat: mix task to codegen lexicon validations

Author: Ovyerus

lib/atex/lexicon.ex

@@ -24,12 +24,21 @@ defmodule Atex.Lexicon do
       |> then(&Recase.Enumerable.atomize_keys/1)
       |> then(&Atex.Lexicon.Schema.lexicon!/1)
 
-    # TODO: support returning typedefs
     defs =
       lexicon.defs
       |> Enum.flat_map(fn {def_name, def} -> def_to_schema(lexicon.id, def_name, def) end)
-      |> Enum.map(fn {schema_key, quoted_schema} ->
+      |> Enum.map(fn {schema_key, quoted_schema, quoted_type} ->
+        identity_type =
+          if schema_key === :main do
+            quote do
+              @type t() :: unquote(quoted_type)
+            end
+          end
+
         quote do
+          @type unquote(schema_key)() :: unquote(quoted_type)
+          unquote(identity_type)
+
           defschema unquote(schema_key), unquote(quoted_schema)
         end
       end)
@@ -41,15 +50,15 @@ defmodule Atex.Lexicon do
     end
   end
 
-  # TODO: generate typedefs
   @spec def_to_schema(nsid :: String.t(), def_name :: String.t(), lexicon_def :: map()) ::
-          list({key :: atom(), quoted :: term()})
+          list({key :: atom(), quoted_schema :: term(), quoted_type :: term()})
 
   defp def_to_schema(nsid, def_name, %{type: "record", record: record}) do
     # TODO: record rkey format validator
     def_to_schema(nsid, def_name, record)
   end
 
+  # TODO: add `$type` field. It's just a string though.
   defp def_to_schema(
          nsid,
          def_name,
@@ -63,15 +72,39 @@ defmodule Atex.Lexicon do
 
     properties
     |> Enum.map(fn {key, field} ->
-      field_to_schema(field, nsid)
-      |> then(
-        &if key in nullable, do: quote(do: {:either, {{:literal, nil}, unquote(&1)}}), else: &1
-      )
-      |> then(&if key in required, do: quote(do: {:required, unquote(&1)}), else: &1)
-      |> then(&{key, &1})
+      {quoted_schema, quoted_type} = field_to_schema(field, nsid)
+      is_nullable = key in nullable
+      is_required = key in required
+
+      quoted_schema =
+        quoted_schema
+        |> then(
+          &if is_nullable, do: quote(do: {:either, {{:literal, nil}, unquote(&1)}}), else: &1
+        )
+        |> then(&if is_required, do: quote(do: {:required, unquote(&1)}), else: &1)
+        |> then(&{key, &1})
+
+      key_type = if is_required, do: :required, else: :optional
+
+      quoted_type =
+        quoted_type
+        |> then(
+          &if is_nullable do
+            {:|, [], [&1, nil]}
+          else
+            &1
+          end
+        )
+        |> then(&{{key_type, [], [key]}, &1})
+
+      {quoted_schema, quoted_type}
+    end)
+    |> Enum.reduce({[], []}, fn {quoted_schema, quoted_type}, {schemas, types} ->
+      {[quoted_schema | schemas], [quoted_type | types]}
+    end)
+    |> then(fn {quoted_schemas, quoted_types} ->
+      [{atomise(def_name), {:%{}, [], quoted_schemas}, {:%{}, [], quoted_types}}]
     end)
-    |> then(&{:%{}, [], &1})
-    |> then(&[{atomise(def_name), &1}])
   end
 
   # TODO: validating errors?
@@ -154,7 +187,15 @@ defmodule Atex.Lexicon do
 
   defp def_to_schema(_nsid, def_name, %{type: "token"}) do
     # TODO: make it a validator that expects the nsid + key.
-    [{atomise(def_name), :string}]
+    [
+      {
+        atomise(def_name),
+        :string,
+        quote do
+          String.t()
+        end
+      }
+    ]
   end
 
   defp def_to_schema(nsid, def_name, %{type: type} = def)
@@ -168,10 +209,12 @@ defmodule Atex.Lexicon do
               "cid-link",
               "unknown"
             ] do
-    [{atomise(def_name), field_to_schema(def, nsid)}]
+    {quoted_schema, quoted_type} = field_to_schema(def, nsid)
+    [{atomise(def_name), quoted_schema, quoted_type}]
   end
 
-  @spec field_to_schema(field_def :: %{type: String.t()}, nsid :: String.t()) :: Peri.schema_def()
+  @spec field_to_schema(field_def :: %{type: String.t()}, nsid :: String.t()) ::
+          {quoted_schema :: term(), quoted_typespec :: term()}
   defp field_to_schema(%{type: "string"} = field, _nsid) do
     fixed_schema = const_or_enum(field)
 
@@ -189,14 +232,24 @@ defmodule Atex.Lexicon do
       |> Enum.map(fn {k, v} -> {Recase.to_snake(k), v} end)
       |> then(&{:custom, {Validators.String, :validate, [&1]}})
       |> maybe_default(field)
-      |> then(&Macro.escape/1)
+      |> then(
+        &{Macro.escape(&1),
+         quote do
+           String.t()
+         end}
+      )
     end
   end
 
   defp field_to_schema(%{type: "boolean"} = field, _nsid) do
     (const(field) || :boolean)
     |> maybe_default(field)
-    |> then(&Macro.escape/1)
+    |> then(
+      &{Macro.escape(&1),
+       quote do
+         boolean()
+       end}
+    )
   end
 
   defp field_to_schema(%{type: "integer"} = field, _nsid) do
@@ -211,11 +264,19 @@ defmodule Atex.Lexicon do
       |> then(&{:custom, {Validators.Integer, [&1]}})
       |> maybe_default(field)
     end
-    |> then(&Macro.escape/1)
+    |> then(
+      &{
+        Macro.escape(&1),
+        # TODO: turn into range definition based on maximum/minimum
+        quote do
+          integer()
+        end
+      }
+    )
   end
 
   defp field_to_schema(%{type: "array", items: items} = field, nsid) do
-    inner_schema = field_to_schema(items, nsid)
+    {inner_schema, inner_type} = field_to_schema(items, nsid)
 
     field
     |> Map.take([:maxLength, :minLength])
@@ -228,27 +289,48 @@ defmodule Atex.Lexicon do
       {inner_schema, _} = Code.eval_quoted(quoted_inner_schema)
       {:custom, {:{}, c, [Validators.Array, :validate, [inner_schema | args]]}}
     end)
+    |> then(
+      &{&1,
+       quote do
+         list(unquote(inner_type))
+       end}
+    )
   end
 
   defp field_to_schema(%{type: "blob"} = field, _nsid) do
     field
     |> Map.take([:accept, :maxSize])
     |> Enum.map(fn {k, v} -> {Recase.to_snake(k), v} end)
     |> Validators.blob()
-    |> then(&Macro.escape/1)
+    |> then(
+      &{Macro.escape(&1),
+       quote do
+         Validators.blob()
+       end}
+    )
   end
 
   defp field_to_schema(%{type: "bytes"} = field, _nsid) do
     field
     |> Map.take([:maxLength, :minLength])
     |> Enum.map(fn {k, v} -> {Recase.to_snake(k), v} end)
     |> Validators.bytes()
-    |> then(&Macro.escape/1)
+    |> then(
+      &{Macro.escape(&1),
+       quote do
+         Validators.bytes()
+       end}
+    )
   end
 
   defp field_to_schema(%{type: "cid-link"}, _nsid) do
     Validators.cid_link()
-    |> then(&Macro.escape/1)
+    |> then(
+      &{Macro.escape(&1),
+       quote do
+         Validators.cid_link()
+       end}
+    )
   end
 
   # TODO: do i need to make sure these two deal with brands? Check objects in atp.tools
@@ -258,37 +340,52 @@ defmodule Atex.Lexicon do
       |> Atex.NSID.expand_possible_fragment_shorthand(ref)
       |> Atex.NSID.to_atom_with_fragment()
 
-    quote do
-      unquote(nsid).get_schema(unquote(fragment))
-    end
+    {quote do
+       unquote(nsid).get_schema(unquote(fragment))
+     end,
+     quote do
+       unquote(nsid).unquote(fragment)()
+     end}
   end
 
   defp field_to_schema(%{type: "union", refs: refs}, nsid) do
-    # refs =
     refs
     |> Enum.map(fn ref ->
       {nsid, fragment} =
         nsid
         |> Atex.NSID.expand_possible_fragment_shorthand(ref)
         |> Atex.NSID.to_atom_with_fragment()
 
-      quote do
-        unquote(nsid).get_schema(unquote(fragment))
-      end
+      {quote do
+         unquote(nsid).get_schema(unquote(fragment))
+       end,
+       quote do
+         unquote(nsid).unquote(fragment)()
+       end}
+    end)
+    |> Enum.reduce({[], []}, fn {quoted_schema, quoted_type}, {schemas, types} ->
+      {[quoted_schema | schemas], [quoted_type | types]}
+    end)
+    |> then(fn {schemaa, types} ->
+      {quote do
+         {:oneof, unquote(schemaa)}
+       end,
+       quote do
+         unquote(join_with_pipe(types))
+       end}
+      |> IO.inspect()
     end)
-    |> then(
-      &quote do
-        {:oneof, unquote(&1)}
-      end
-    )
   end
 
   # TODO: apparently should be a data object, not a primitive?
   defp field_to_schema(%{type: "unknown"}, _nsid) do
-    :any
+    {:any,
+     quote do
+       term()
+     end}
   end
 
-  defp field_to_schema(_field_def, _nsid), do: nil
+  defp field_to_schema(_field_def, _nsid), do: {nil, nil}
 
   defp maybe_default(schema, field) do
     if field[:default] != nil,
@@ -306,4 +403,13 @@ defmodule Atex.Lexicon do
 
   defp atomise(x) when is_atom(x), do: x
   defp atomise(x) when is_binary(x), do: String.to_atom(x)
+
+  defp join_with_pipe(list) when is_list(list) do
+    [piped] = do_join_with_pipe(list)
+    piped
+  end
+
+  defp do_join_with_pipe([head]), do: [head]
+  defp do_join_with_pipe([head | tail]), do: [{:|, [], [head | do_join_with_pipe(tail)]}]
+  defp do_join_with_pipe([]), do: []
 end

lib/atex/lexicon/validators.ex

@@ -3,7 +3,7 @@ defmodule Atex.Lexicon.Validators do
 
   @type blob_option() :: {:accept, list(String.t())} | {:max_size, pos_integer()}
 
-  @type blob_t() ::
+  @type blob() ::
           %{
             "$type": String.t(),
             ref: %{"$link": String.t()},
@@ -15,6 +15,10 @@ defmodule Atex.Lexicon.Validators do
               mimeType: String.t()
             }
 
+  @type cid_link() :: %{"$link": String.t()}
+
+  @type bytes() :: %{"$bytes": binary()}
+
   @spec string(list(Validators.String.option())) :: Peri.custom_def()
   def string(options \\ []), do: {:custom, {Validators.String, :validate, [options]}}