···

       
1
       
 
       
defmodule Atex.Handle do

     

       
2
       
-
       
  @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])?$/

     

       
3
       
 
       


     

       
4
       
 
       
  @spec re() :: Regex.t()

     

       
5
       
 
       
  def re, do: @re

     

···

       
1
       
 
       
defmodule Atex.Handle do

     

       
2
       
+
       
  @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])?$/

     

       
3
       
 
       


     

       
4
       
 
       
  @spec re() :: Regex.t()

     

       
5
       
 
       
  def re, do: @re

     

···

       
64
       
 
       
         def_name,

     

       
65
       
 
       
         %{

     

       
66
       
 
       
           type: "object",

     

       
67
       
-
       
           properties: properties,

     

       
68
       
-
       
           required: required

     

       
69
       
 
       
         } = def

     

       
70
       
 
       
       ) do

     

       
0
       
 
       

     

       
71
       
 
       
    nullable = Map.get(def, :nullable, [])

     

       
72
       
 
       


     

       
73
       
 
       
    properties

     
···

       
114
       
 
       
        [schema] =

     

       
115
       
 
       
          def_to_schema(nsid, "params", %{

     

       
116
       
 
       
            type: "object",

     

       
117
       
-
       
            required: def.parameters.required,

     

       
118
       
-
       
            nullable: [],

     

       
119
       
 
       
            properties: def.parameters.properties

     

       
120
       
 
       
          })

     

       
121
       
 
       


     
···

       
123
       
 
       
      end

     

       
124
       
 
       


     

       
125
       
 
       
    output =

     

       
126
       
-
       
      if def.output && def.output.schema do

     

       
127
       
 
       
        [schema] = def_to_schema(nsid, "output", def.output.schema)

     

       
128
       
 
       
        schema

     

       
129
       
 
       
      end

     
···

       
139
       
 
       
        [schema] =

     

       
140
       
 
       
          def_to_schema(nsid, "params", %{

     

       
141
       
 
       
            type: "object",

     

       
142
       
-
       
            required: def.parameters.required,

     

       
143
       
 
       
            properties: def.parameters.properties

     

       
144
       
 
       
          })

     

       
145
       
 
       


     
···

       
147
       
 
       
      end

     

       
148
       
 
       


     

       
149
       
 
       
    output =

     

       
150
       
-
       
      if def[:output] && def.output.schema do

     

       
151
       
 
       
        [schema] = def_to_schema(nsid, "output", def.output.schema)

     

       
152
       
 
       
        schema

     

       
153
       
 
       
      end

     

       
154
       
 
       


     

       
155
       
 
       
    input =

     

       
156
       
-
       
      if def[:input] && def.input.schema do

     

       
157
       
-
       
        [schema] = def_to_schema(nsid, "output", def.input.schema)

     

       
158
       
 
       
        schema

     

       
159
       
 
       
      end

     

       
160
       
 
       


     
···

       
168
       
 
       
        [schema] =

     

       
169
       
 
       
          def_to_schema(nsid, "params", %{

     

       
170
       
 
       
            type: "object",

     

       
171
       
-
       
            required: def.parameters.required,

     

       
172
       
 
       
            properties: def.parameters.properties

     

       
173
       
 
       
          })

     

       
174
       
 
       


     
···

       
234
       
 
       
      |> Enum.map(fn {k, v} -> {Recase.to_snake(k), v} end)

     

       
235
       
 
       
      |> then(&{:custom, {Validators.String, :validate, [&1]}})

     

       
236
       
 
       
      |> maybe_default(field)

     

       
237
       
-
       
      |> then(

     

       
238
       
-
       
        &{Macro.escape(&1),

     

       
239
       
-
       
         quote do

     

       
240
       
-
       
           String.t()

     

       
241
       
-
       
         end}

     

       
242
       
-
       
      )

     

       
243
       
 
       
    end

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
244
       
 
       
  end

     

       
245
       
 
       


     

       
246
       
 
       
  defp field_to_schema(%{type: "boolean"} = field, _nsid) do

     
···

       
351
       
 
       
  end

     

       
352
       
 
       


     

       
353
       
 
       
  defp field_to_schema(%{type: "union", refs: refs}, nsid) do

     

       
354
       
-
       
    refs

     

       
355
       
-
       
    |> Enum.map(fn ref ->

     

       
356
       
-
       
      {nsid, fragment} =

     

       
357
       
-
       
        nsid

     

       
358
       
-
       
        |> Atex.NSID.expand_possible_fragment_shorthand(ref)

     

       
359
       
-
       
        |> Atex.NSID.to_atom_with_fragment()

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
360
       
 
       


     

       
361
       
-
       
      {quote do

     

       
362
       
-
       
         unquote(nsid).get_schema(unquote(fragment))

     

       
363
       
-
       
       end,

     

       
364
       
-
       
       quote do

     

       
365
       
-
       
         unquote(nsid).unquote(fragment)()

     

       
366
       
-
       
       end}

     

       
367
       
-
       
    end)

     

       
368
       
-
       
    |> Enum.reduce({[], []}, fn {quoted_schema, quoted_type}, {schemas, types} ->

     

       
369
       
-
       
      {[quoted_schema | schemas], [quoted_type | types]}

     

       
370
       
-
       
    end)

     

       
371
       
-
       
    |> then(fn {schemaa, types} ->

     

       
372
       
-
       
      {quote do

     

       
373
       
-
       
         {:oneof, unquote(schemaa)}

     

       
374
       
-
       
       end,

     

       
375
       
-
       
       quote do

     

       
376
       
-
       
         unquote(join_with_pipe(types))

     

       
377
       
-
       
       end}

     

       
378
       
-
       
    end)

     

       
0
       
 
       

     

       
379
       
 
       
  end

     

       
380
       
 
       


     

       
381
       
 
       
  # TODO: apparently should be a data object, not a primitive?

     

···

       
64
       
 
       
         def_name,

     

       
65
       
 
       
         %{

     

       
66
       
 
       
           type: "object",

     

       
67
       
+
       
           properties: properties

     

       
0
       
 
       

     

       
68
       
 
       
         } = def

     

       
69
       
 
       
       ) do

     

       
70
       
+
       
    required = Map.get(def, :required, [])

     

       
71
       
 
       
    nullable = Map.get(def, :nullable, [])

     

       
72
       
 
       


     

       
73
       
 
       
    properties

     
···

       
114
       
 
       
        [schema] =

     

       
115
       
 
       
          def_to_schema(nsid, "params", %{

     

       
116
       
 
       
            type: "object",

     

       
117
       
+
       
            required: Map.get(def.parameters, :required, []),

     

       
0
       
 
       

     

       
118
       
 
       
            properties: def.parameters.properties

     

       
119
       
 
       
          })

     

       
120
       
 
       


     
···

       
122
       
 
       
      end

     

       
123
       
 
       


     

       
124
       
 
       
    output =

     

       
125
       
+
       
      if def[:output] && def.output[:schema] do

     

       
126
       
 
       
        [schema] = def_to_schema(nsid, "output", def.output.schema)

     

       
127
       
 
       
        schema

     

       
128
       
 
       
      end

     
···

       
138
       
 
       
        [schema] =

     

       
139
       
 
       
          def_to_schema(nsid, "params", %{

     

       
140
       
 
       
            type: "object",

     

       
141
       
+
       
            required: Map.get(def.parameters, :required, []),

     

       
142
       
 
       
            properties: def.parameters.properties

     

       
143
       
 
       
          })

     

       
144
       
 
       


     
···

       
146
       
 
       
      end

     

       
147
       
 
       


     

       
148
       
 
       
    output =

     

       
149
       
+
       
      if def[:output] && def.output[:schema] do

     

       
150
       
 
       
        [schema] = def_to_schema(nsid, "output", def.output.schema)

     

       
151
       
 
       
        schema

     

       
152
       
 
       
      end

     

       
153
       
 
       


     

       
154
       
 
       
    input =

     

       
155
       
+
       
      if def[:input] && def.input[:schema] do

     

       
156
       
+
       
        [schema] = def_to_schema(nsid, "input", def.input.schema)

     

       
157
       
 
       
        schema

     

       
158
       
 
       
      end

     

       
159
       
 
       


     
···

       
167
       
 
       
        [schema] =

     

       
168
       
 
       
          def_to_schema(nsid, "params", %{

     

       
169
       
 
       
            type: "object",

     

       
170
       
+
       
            required: Map.get(def.parameters, :required, []),

     

       
171
       
 
       
            properties: def.parameters.properties

     

       
172
       
 
       
          })

     

       
173
       
 
       


     
···

       
233
       
 
       
      |> Enum.map(fn {k, v} -> {Recase.to_snake(k), v} end)

     

       
234
       
 
       
      |> then(&{:custom, {Validators.String, :validate, [&1]}})

     

       
235
       
 
       
      |> maybe_default(field)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
236
       
 
       
    end

     

       
237
       
+
       
    |> then(

     

       
238
       
+
       
      &{Macro.escape(&1),

     

       
239
       
+
       
       quote do

     

       
240
       
+
       
         String.t()

     

       
241
       
+
       
       end}

     

       
242
       
+
       
    )

     

       
243
       
 
       
  end

     

       
244
       
 
       


     

       
245
       
 
       
  defp field_to_schema(%{type: "boolean"} = field, _nsid) do

     
···

       
350
       
 
       
  end

     

       
351
       
 
       


     

       
352
       
 
       
  defp field_to_schema(%{type: "union", refs: refs}, nsid) do

     

       
353
       
+
       
    if refs == [] do

     

       
354
       
+
       
      {quote do

     

       
355
       
+
       
         {:oneof, []}

     

       
356
       
+
       
       end, nil}

     

       
357
       
+
       
    else

     

       
358
       
+
       
      refs

     

       
359
       
+
       
      |> Enum.map(fn ref ->

     

       
360
       
+
       
        {nsid, fragment} =

     

       
361
       
+
       
          nsid

     

       
362
       
+
       
          |> Atex.NSID.expand_possible_fragment_shorthand(ref)

     

       
363
       
+
       
          |> Atex.NSID.to_atom_with_fragment()

     

       
364
       
 
       


     

       
365
       
+
       
        {quote do

     

       
366
       
+
       
           unquote(nsid).get_schema(unquote(fragment))

     

       
367
       
+
       
         end,

     

       
368
       
+
       
         quote do

     

       
369
       
+
       
           unquote(nsid).unquote(fragment)()

     

       
370
       
+
       
         end}

     

       
371
       
+
       
      end)

     

       
372
       
+
       
      |> Enum.reduce({[], []}, fn {quoted_schema, quoted_type}, {schemas, types} ->

     

       
373
       
+
       
        {[quoted_schema | schemas], [quoted_type | types]}

     

       
374
       
+
       
      end)

     

       
375
       
+
       
      |> then(fn {schemas, types} ->

     

       
376
       
+
       
        {quote do

     

       
377
       
+
       
           {:oneof, unquote(schemas)}

     

       
378
       
+
       
         end,

     

       
379
       
+
       
         quote do

     

       
380
       
+
       
           unquote(join_with_pipe(types))

     

       
381
       
+
       
         end}

     

       
382
       
+
       
      end)

     

       
383
       
+
       
    end

     

       
384
       
 
       
  end

     

       
385
       
 
       


     

       
386
       
 
       
  # TODO: apparently should be a data object, not a primitive?

     

···

       
3
       
 
       


     

       
4
       
 
       
  defschema :lexicon, %{

     

       
5
       
 
       
    lexicon: {:required, {:literal, 1}},

     

       
6
       
-
       
    id:

     

       
7
       
-
       
      {:required,

     

       
8
       
-
       
       {:string,

     

       
9
       
-
       
        {:regex,

     

       
10
       
-
       
         ~r/^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z]([a-zA-Z]{0,61}[a-zA-Z])?)$/}}},

     

       
11
       
 
       
    revision: {:integer, {:gte, 0}},

     

       
12
       
 
       
    description: :string,

     

       
13
       
 
       
    defs: {

     
···

       
66
       
 
       
  defschema :parameters, %{

     

       
67
       
 
       
    type: {:required, {:literal, "params"}},

     

       
68
       
 
       
    description: :string,

     

       
69
       
-
       
    required: {{:list, :string}, {:default, []}},

     

       
0
       
 
       

     

       
70
       
 
       
    properties:

     

       
71
       
 
       
      {:required, {:map, {:either, {get_schema(:primitive), get_schema(:primitive_array)}}}}

     

       
72
       
 
       
  }

     
···

       
145
       
 
       
  defschema :object, %{

     

       
146
       
 
       
    type: {:required, {:literal, "object"}},

     

       
147
       
 
       
    description: :string,

     

       
148
       
-
       
    required: {{:list, :string}, {:default, []}},

     

       
149
       
-
       
    nullable: {{:list, :string}, {:default, []}},

     

       
0
       
 
       

     

       
0
       
 
       

     

       
150
       
 
       
    properties:

     

       
151
       
 
       
      {:required,

     

       
152
       
 
       
       {:map,

     

···

       
3
       
 
       


     

       
4
       
 
       
  defschema :lexicon, %{

     

       
5
       
 
       
    lexicon: {:required, {:literal, 1}},

     

       
6
       
+
       
    id: {:required, {:string, {:regex, Atex.NSID.re()}}},

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
7
       
 
       
    revision: {:integer, {:gte, 0}},

     

       
8
       
 
       
    description: :string,

     

       
9
       
 
       
    defs: {

     
···

       
62
       
 
       
  defschema :parameters, %{

     

       
63
       
 
       
    type: {:required, {:literal, "params"}},

     

       
64
       
 
       
    description: :string,

     

       
65
       
+
       
    # required: {{:list, :string}, {:default, []}},

     

       
66
       
+
       
    required: {:list, :string},

     

       
67
       
 
       
    properties:

     

       
68
       
 
       
      {:required, {:map, {:either, {get_schema(:primitive), get_schema(:primitive_array)}}}}

     

       
69
       
 
       
  }

     
···

       
142
       
 
       
  defschema :object, %{

     

       
143
       
 
       
    type: {:required, {:literal, "object"}},

     

       
144
       
 
       
    description: :string,

     

       
145
       
+
       
    # required: {{:list, :string}, {:default, []}},

     

       
146
       
+
       
    # nullable: {{:list, :string}, {:default, []}},

     

       
147
       
+
       
    required: {:list, :string},

     

       
148
       
+
       
    nullable: {:list, :string},

     

       
149
       
 
       
    properties:

     

       
150
       
 
       
      {:required,

     

       
151
       
 
       
       {:map,

     

···

       
1
       
 
       
defmodule Atex.NSID do

     

       
2
       
-
       
  @re ~r/^[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?:\\.[a-zA-Z](?:[a-zA-Z0-9]{0,62})?)$/

     

       
0
       
 
       

     

       
3
       
 
       


     

       
4
       
 
       
  @spec re() :: Regex.t()

     

       
5
       
 
       
  def re, do: @re

     

···

       
1
       
 
       
defmodule Atex.NSID do

     

       
2
       
+
       
  @re ~r/^[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?:\.[a-zA-Z](?:[a-zA-Z0-9]{0,62})?)$/

     

       
3
       
+
       
  # TODO: regex with support for fragment

     

       
4
       
 
       


     

       
5
       
 
       
  @spec re() :: Regex.t()

     

       
6
       
 
       
  def re, do: @re