Current section
Files
Jump to
Current section
Files
src/json_typedef.erl
-module(json_typedef).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-export([codegen/0, root_name/2, generate_encoders/2, generate_decoders/2, generate/2, decoder/1, to_json/1]).
-export_type([root_schema/0, type/0, schema/0, properties_schema/0, generator/0, out/0, codegen_error/0, property_data_name/0]).
-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.
?MODULEDOC(
" <https://jsontypedef.com/>\n"
"\n"
" <https://datatracker.ietf.org/doc/html/rfc8927>\n"
).
-type root_schema() :: {root_schema, list({binary(), schema()}), schema()}.
-type type() :: boolean |
string |
timestamp |
float32 |
float64 |
int8 |
uint8 |
int16 |
uint16 |
int32 |
uint32.
-type schema() :: empty |
{type, boolean(), list({binary(), gleam@dynamic:dynamic_()}), type()} |
{enum,
boolean(),
list({binary(), gleam@dynamic:dynamic_()}),
list(binary())} |
{properties,
boolean(),
list({binary(), gleam@dynamic:dynamic_()}),
properties_schema()} |
{elements, boolean(), list({binary(), gleam@dynamic:dynamic_()}), schema()} |
{values, boolean(), list({binary(), gleam@dynamic:dynamic_()}), schema()} |
{discriminator,
boolean(),
list({binary(), gleam@dynamic:dynamic_()}),
binary(),
list({binary(), properties_schema()})} |
{ref, boolean(), list({binary(), gleam@dynamic:dynamic_()}), binary()}.
-type properties_schema() :: {properties_schema,
list({binary(), schema()}),
list({binary(), schema()}),
boolean()}.
-opaque generator() :: {generator,
boolean(),
boolean(),
boolean(),
boolean(),
boolean(),
boolean(),
gleam@dict:dict(binary(), binary()),
gleam@dict:dict(binary(), binary()),
binary(),
gleam@set:set(binary())}.
-type out() :: {out, binary(), binary()}.
-type codegen_error() :: cannot_convert_empty_to_json_error |
empty_enum_error |
{duplicate_property_error, binary(), binary(), binary()} |
{duplicate_constructor_error, binary()} |
{duplicate_type_error, binary()} |
{duplicate_function_error, binary()}.
-type property_data_name() :: property_data_none |
property_data_direct |
{property_data_access, binary()}.
-file("src/json_typedef.gleam", 174).
-spec type_to_json(type()) -> gleam@json:json().
type_to_json(T) ->
gleam@json:string(case T of
boolean ->
<<"boolean"/utf8>>;
float32 ->
<<"float32"/utf8>>;
float64 ->
<<"float64"/utf8>>;
int16 ->
<<"int16"/utf8>>;
int32 ->
<<"int32"/utf8>>;
int8 ->
<<"int8"/utf8>>;
string ->
<<"string"/utf8>>;
timestamp ->
<<"timestamp"/utf8>>;
uint16 ->
<<"uint16"/utf8>>;
uint32 ->
<<"uint32"/utf8>>;
uint8 ->
<<"uint8"/utf8>>
end).
-file("src/json_typedef.gleam", 230).
-spec key_decoder(
gleam@dict:dict(binary(), gleam@dynamic:dynamic_()),
binary(),
fun((gleam@dynamic:dynamic_(), gleam@dict:dict(binary(), gleam@dynamic:dynamic_())) -> {ok,
MEB} |
{error, list(gleam@dynamic:decode_error())})
) -> {ok, fun(() -> {ok, MEB} | {error, list(gleam@dynamic:decode_error())})} |
{error, nil}.
key_decoder(Dict, Key, Constructor) ->
case gleam_stdlib:map_get(Dict, Key) of
{ok, Value} ->
{ok, fun() -> Constructor(Value, Dict) end};
{error, E} ->
{error, E}
end.
-file("src/json_typedef.gleam", 260).
-spec decode_object_as_list(
gleam@dynamic:dynamic_(),
fun((gleam@dynamic:dynamic_()) -> {ok, MEP} |
{error, list(gleam@dynamic:decode_error())})
) -> {ok, list({binary(), MEP})} | {error, list(gleam@dynamic:decode_error())}.
decode_object_as_list(Data, Inner) ->
_pipe = (gleam@dynamic:dict(fun gleam@dynamic:string/1, Inner))(Data),
gleam@result:map(_pipe, fun maps:to_list/1).
-file("src/json_typedef.gleam", 347).
-spec decode_empty(gleam@dict:dict(binary(), gleam@dynamic:dynamic_())) -> {ok,
schema()} |
{error, list(gleam@dynamic:decode_error())}.
decode_empty(Data) ->
case maps:size(Data) of
0 ->
{ok, empty};
_ ->
{error, [{decode_error, <<"Schema"/utf8>>, <<"Dict"/utf8>>, []}]}
end.
-file("src/json_typedef.gleam", 378).
-spec push_path(
{ok, MGH} | {error, list(gleam@dynamic:decode_error())},
binary()
) -> {ok, MGH} | {error, list(gleam@dynamic:decode_error())}.
push_path(Result, Segment) ->
gleam@result:map_error(
Result,
fun(_capture) -> gleam@list:map(_capture, fun(E) -> _record = E,
{decode_error,
erlang:element(2, _record),
erlang:element(3, _record),
[Segment | erlang:element(4, E)]} end) end
).
-file("src/json_typedef.gleam", 388).
-spec get_metadata(gleam@dict:dict(binary(), gleam@dynamic:dynamic_())) -> {ok,
list({binary(), gleam@dynamic:dynamic_()})} |
{error, list(gleam@dynamic:decode_error())}.
get_metadata(Data) ->
case gleam_stdlib:map_get(Data, <<"metadata"/utf8>>) of
{ok, Data@1} ->
_pipe = (gleam@dynamic:dict(
fun gleam@dynamic:string/1,
fun gleam@dynamic:dynamic/1
))(Data@1),
_pipe@1 = gleam@result:map(_pipe, fun maps:to_list/1),
push_path(_pipe@1, <<"metadata"/utf8>>);
{error, _} ->
{ok, []}
end.
-file("src/json_typedef.gleam", 400).
-spec get_nullable(gleam@dict:dict(binary(), gleam@dynamic:dynamic_())) -> {ok,
boolean()} |
{error, list(gleam@dynamic:decode_error())}.
get_nullable(Data) ->
case gleam_stdlib:map_get(Data, <<"nullable"/utf8>>) of
{ok, Data@1} ->
_pipe = gleam@dynamic:bool(Data@1),
push_path(_pipe, <<"nullable"/utf8>>);
{error, _} ->
{ok, false}
end.
-file("src/json_typedef.gleam", 301).
-spec decode_type(
gleam@dynamic:dynamic_(),
gleam@dict:dict(binary(), gleam@dynamic:dynamic_())
) -> {ok, schema()} | {error, list(gleam@dynamic:decode_error())}.
decode_type(Type_, Data) ->
gleam@result:'try'(
begin
_pipe = gleam@dynamic:string(Type_),
push_path(_pipe, <<"type"/utf8>>)
end,
fun(Type_@1) ->
gleam@result:'try'(
get_nullable(Data),
fun(Nullable) ->
gleam@result:'try'(
get_metadata(Data),
fun(Metadata) -> case Type_@1 of
<<"boolean"/utf8>> ->
{ok, {type, Nullable, Metadata, boolean}};
<<"float32"/utf8>> ->
{ok, {type, Nullable, Metadata, float32}};
<<"float64"/utf8>> ->
{ok, {type, Nullable, Metadata, float64}};
<<"int16"/utf8>> ->
{ok, {type, Nullable, Metadata, int16}};
<<"int32"/utf8>> ->
{ok, {type, Nullable, Metadata, int32}};
<<"int8"/utf8>> ->
{ok, {type, Nullable, Metadata, int8}};
<<"string"/utf8>> ->
{ok, {type, Nullable, Metadata, string}};
<<"timestamp"/utf8>> ->
{ok, {type, Nullable, Metadata, timestamp}};
<<"uint16"/utf8>> ->
{ok, {type, Nullable, Metadata, uint16}};
<<"uint32"/utf8>> ->
{ok, {type, Nullable, Metadata, uint32}};
<<"uint8"/utf8>> ->
{ok, {type, Nullable, Metadata, uint8}};
_ ->
{error,
[{decode_error,
<<"Type"/utf8>>,
<<"String"/utf8>>,
[<<"type"/utf8>>]}]}
end end
)
end
)
end
).
-file("src/json_typedef.gleam", 325).
-spec decode_enum(
gleam@dynamic:dynamic_(),
gleam@dict:dict(binary(), gleam@dynamic:dynamic_())
) -> {ok, schema()} | {error, list(gleam@dynamic:decode_error())}.
decode_enum(Type_, Data) ->
gleam@result:'try'(
get_nullable(Data),
fun(Nullable) ->
gleam@result:'try'(
get_metadata(Data),
fun(Metadata) ->
_pipe = (gleam@dynamic:list(fun gleam@dynamic:string/1))(
Type_
),
_pipe@1 = push_path(_pipe, <<"enum"/utf8>>),
gleam@result:map(
_pipe@1,
fun(_capture) ->
{enum, Nullable, Metadata, _capture}
end
)
end
)
end
).
-file("src/json_typedef.gleam", 336).
-spec decode_ref(
gleam@dynamic:dynamic_(),
gleam@dict:dict(binary(), gleam@dynamic:dynamic_())
) -> {ok, schema()} | {error, list(gleam@dynamic:decode_error())}.
decode_ref(Type_, Data) ->
gleam@result:'try'(
get_nullable(Data),
fun(Nullable) ->
gleam@result:'try'(
get_metadata(Data),
fun(Metadata) -> _pipe = gleam@dynamic:string(Type_),
_pipe@1 = push_path(_pipe, <<"ref"/utf8>>),
gleam@result:map(
_pipe@1,
fun(_capture) -> {ref, Nullable, Metadata, _capture} end
) end
)
end
).
-file("src/json_typedef.gleam", 409).
-spec metadata_value_to_json(gleam@dynamic:dynamic_()) -> gleam@json:json().
metadata_value_to_json(Data) ->
Decoder = gleam@dynamic:any([fun(A) -> _pipe = gleam@dynamic:string(A),
gleam@result:map(_pipe, fun gleam@json:string/1) end, fun(A@1) ->
_pipe@1 = gleam@dynamic:int(A@1),
gleam@result:map(_pipe@1, fun gleam@json:int/1)
end, fun(A@2) -> _pipe@2 = gleam@dynamic:float(A@2),
gleam@result:map(_pipe@2, fun gleam@json:float/1) end]),
case Decoder(Data) of
{ok, Data@1} ->
Data@1;
{error, _} ->
gleam@json:string(gleam@string:inspect(Data))
end.
-file("src/json_typedef.gleam", 422).
-spec add_metadata(
list({binary(), gleam@json:json()}),
list({binary(), gleam@dynamic:dynamic_()})
) -> list({binary(), gleam@json:json()}).
add_metadata(Data, Metadata) ->
case Metadata of
[] ->
Data;
_ ->
Metadata@2 = gleam@list:map(
Metadata,
fun(Metadata@1) ->
{erlang:element(1, Metadata@1),
metadata_value_to_json(erlang:element(2, Metadata@1))}
end
),
[{<<"metadata"/utf8>>, gleam@json:object(Metadata@2)} | Data]
end.
-file("src/json_typedef.gleam", 438).
-spec add_nullable(list({binary(), gleam@json:json()}), boolean()) -> list({binary(),
gleam@json:json()}).
add_nullable(Data, Nullable) ->
case Nullable of
false ->
Data;
true ->
[{<<"nullable"/utf8>>, gleam@json:bool(true)} | Data]
end.
-file("src/json_typedef.gleam", 463).
-spec codegen() -> generator().
codegen() ->
{generator,
false,
false,
false,
false,
false,
false,
maps:new(),
maps:new(),
<<"Data"/utf8>>,
gleam@set:new()}.
-file("src/json_typedef.gleam", 478).
-spec root_name(generator(), binary()) -> generator().
root_name(Gen, Root_name) ->
_record = Gen,
{generator,
erlang:element(2, _record),
erlang:element(3, _record),
erlang:element(4, _record),
erlang:element(5, _record),
erlang:element(6, _record),
erlang:element(7, _record),
erlang:element(8, _record),
erlang:element(9, _record),
Root_name,
erlang:element(11, _record)}.
-file("src/json_typedef.gleam", 482).
-spec generate_encoders(generator(), boolean()) -> generator().
generate_encoders(Gen, X) ->
_record = Gen,
{generator,
erlang:element(2, _record),
X,
erlang:element(4, _record),
erlang:element(5, _record),
erlang:element(6, _record),
erlang:element(7, _record),
erlang:element(8, _record),
erlang:element(9, _record),
erlang:element(10, _record),
erlang:element(11, _record)}.
-file("src/json_typedef.gleam", 486).
-spec generate_decoders(generator(), boolean()) -> generator().
generate_decoders(Gen, X) ->
_record = Gen,
{generator,
X,
erlang:element(3, _record),
erlang:element(4, _record),
erlang:element(5, _record),
erlang:element(6, _record),
erlang:element(7, _record),
erlang:element(8, _record),
erlang:element(9, _record),
erlang:element(10, _record),
erlang:element(11, _record)}.
-file("src/json_typedef.gleam", 596).
-spec type_name(schema(), binary()) -> binary().
type_name(Schema, Name) ->
Nullable@1 = case Schema of
empty ->
false;
{discriminator, Nullable, _, _, _} ->
Nullable;
{elements, Nullable, _, _} ->
Nullable;
{enum, Nullable, _, _} ->
Nullable;
{properties, Nullable, _, _} ->
Nullable;
{ref, Nullable, _, _} ->
Nullable;
{type, Nullable, _, _} ->
Nullable;
{values, Nullable, _, _} ->
Nullable
end,
Name@2 = case Schema of
{enum, _, _, _} ->
Name;
{properties, _, _, _} ->
Name;
{discriminator, _, _, _, _} ->
Name;
{ref, _, _, Name@1} ->
Name@1;
{values, _, _, Schema@1} ->
<<<<"dict.Dict("/utf8, (type_name(Schema@1, Name))/binary>>/binary,
")"/utf8>>;
{elements, _, _, Schema@2} ->
<<<<"List("/utf8,
(type_name(Schema@2, <<Name/binary, "Element"/utf8>>))/binary>>/binary,
")"/utf8>>;
empty ->
<<"dynamic.Dynamic"/utf8>>;
{type, _, _, Type_} ->
case Type_ of
boolean ->
<<"Bool"/utf8>>;
float32 ->
<<"Float"/utf8>>;
float64 ->
<<"Float"/utf8>>;
int16 ->
<<"Int"/utf8>>;
int32 ->
<<"Int"/utf8>>;
int8 ->
<<"Int"/utf8>>;
uint16 ->
<<"Int"/utf8>>;
uint32 ->
<<"Int"/utf8>>;
uint8 ->
<<"Int"/utf8>>;
string ->
<<"String"/utf8>>;
timestamp ->
<<"String"/utf8>>
end
end,
case Nullable@1 of
true ->
<<<<"option.Option("/utf8, Name@2/binary>>/binary, ")"/utf8>>;
false ->
Name@2
end.
-file("src/json_typedef.gleam", 674).
-spec ensure_no_duplicate_properties(
properties_schema(),
gleam@option:option(binary()),
binary(),
binary()
) -> {ok, nil} | {error, codegen_error()}.
ensure_no_duplicate_properties(Schema, Extra, Type_name, Constructor_name) ->
Names = lists:append(erlang:element(2, Schema), erlang:element(3, Schema)),
Recorded = case Extra of
none ->
gleam@set:new();
{some, K} ->
gleam@set:from_list([justin:snake_case(K)])
end,
_pipe = gleam@list:try_fold(
Names,
Recorded,
fun(Recorded@1, Pair) ->
Field_name = justin:snake_case(erlang:element(1, Pair)),
Before = gleam@set:size(Recorded@1),
Recorded@2 = gleam@set:insert(Recorded@1, Field_name),
case Before =:= gleam@set:size(Recorded@2) of
false ->
{ok, Recorded@2};
true ->
{error,
{duplicate_property_error,
Type_name,
Constructor_name,
Field_name}}
end
end
),
gleam@result:replace(_pipe, nil).
-file("src/json_typedef.gleam", 749).
-spec ensure_constructor_unique(generator(), binary()) -> {ok, generator()} |
{error, codegen_error()}.
ensure_constructor_unique(Gen, Name) ->
Before = gleam@set:size(erlang:element(11, Gen)),
Constructors = gleam@set:insert(erlang:element(11, Gen), Name),
case Before =:= gleam@set:size(Constructors) of
false ->
{ok,
begin
_record = Gen,
{generator,
erlang:element(2, _record),
erlang:element(3, _record),
erlang:element(4, _record),
erlang:element(5, _record),
erlang:element(6, _record),
erlang:element(7, _record),
erlang:element(8, _record),
erlang:element(9, _record),
erlang:element(10, _record),
Constructors}
end};
true ->
{error, {duplicate_constructor_error, Name}}
end.
-file("src/json_typedef.gleam", 775).
-spec gen_register_nullable(generator(), boolean()) -> generator().
gen_register_nullable(Gen, Nullable) ->
case Nullable of
false ->
Gen;
true ->
_record = Gen,
{generator,
erlang:element(2, _record),
erlang:element(3, _record),
erlang:element(4, _record),
true,
erlang:element(6, _record),
erlang:element(7, _record),
erlang:element(8, _record),
erlang:element(9, _record),
erlang:element(10, _record),
erlang:element(11, _record)}
end.
-file("src/json_typedef.gleam", 811).
-spec gen_add_function(generator(), binary(), binary()) -> {ok, generator()} |
{error, codegen_error()}.
gen_add_function(Gen, Name, Body) ->
Before = maps:size(erlang:element(9, Gen)),
Functions = gleam@dict:insert(erlang:element(9, Gen), Name, Body),
case maps:size(Functions) =:= Before of
false ->
{ok,
begin
_record = Gen,
{generator,
erlang:element(2, _record),
erlang:element(3, _record),
erlang:element(4, _record),
erlang:element(5, _record),
erlang:element(6, _record),
erlang:element(7, _record),
erlang:element(8, _record),
Functions,
erlang:element(10, _record),
erlang:element(11, _record)}
end};
true ->
{error, {duplicate_function_error, Name}}
end.
-file("src/json_typedef.gleam", 824).
-spec gen_add_type(generator(), binary(), binary()) -> {ok, generator()} |
{error, codegen_error()}.
gen_add_type(Gen, Name, Body) ->
Before = maps:size(erlang:element(8, Gen)),
Types = gleam@dict:insert(erlang:element(8, Gen), Name, Body),
case maps:size(Types) =:= Before of
false ->
{ok,
begin
_record = Gen,
{generator,
erlang:element(2, _record),
erlang:element(3, _record),
erlang:element(4, _record),
erlang:element(5, _record),
erlang:element(6, _record),
erlang:element(7, _record),
Types,
erlang:element(9, _record),
erlang:element(10, _record),
erlang:element(11, _record)}
end};
true ->
{error, {duplicate_type_error, Name}}
end.
-file("src/json_typedef.gleam", 761).
-spec gen_enum_type(generator(), binary(), list(binary())) -> {ok, generator()} |
{error, codegen_error()}.
gen_enum_type(Gen, Name, Variants) ->
gleam@bool:guard(
Variants =:= [],
{error, empty_enum_error},
fun() ->
Variants@1 = begin
_pipe = Variants,
_pipe@1 = gleam@list:map(
_pipe,
fun(V) ->
<<<<" "/utf8, (justin:pascal_case(V))/binary>>/binary,
"\n"/utf8>>
end
),
gleam@string:join(_pipe@1, <<""/utf8>>)
end,
Src = <<<<<<<<"pub type "/utf8, Name/binary>>/binary, " {\n"/utf8>>/binary,
Variants@1/binary>>/binary,
"}"/utf8>>,
gen_add_type(Gen, Name, Src)
end
).
-file("src/json_typedef.gleam", 837).
-spec gen_to_string(generator()) -> binary().
gen_to_string(Gen) ->
Imp = fun(Used, Module) -> case Used of
true ->
[<<"import "/utf8, Module/binary>>];
false ->
[]
end end,
Imports = begin
_pipe = [Imp(erlang:element(2, Gen), <<"decode"/utf8>>),
Imp(erlang:element(6, Gen), <<"gleam/dict"/utf8>>),
Imp(erlang:element(4, Gen), <<"gleam/dynamic"/utf8>>),
Imp(erlang:element(3, Gen), <<"gleam/json"/utf8>>),
Imp(erlang:element(5, Gen), <<"gleam/option"/utf8>>)],
_pipe@1 = gleam@list:flatten(_pipe),
gleam@string:join(_pipe@1, <<"\n"/utf8>>)
end,
Defs = fun(Items) -> _pipe@2 = Items,
_pipe@3 = maps:to_list(_pipe@2),
_pipe@4 = gleam@list:sort(
_pipe@3,
fun(A, B) ->
gleam@string:compare(erlang:element(1, A), erlang:element(1, B))
end
),
_pipe@5 = gleam@list:map(
_pipe@4,
fun(A@1) -> erlang:element(2, A@1) end
),
gleam@string:join(_pipe@5, <<"\n\n"/utf8>>) end,
Block = fun(S) -> case S of
<<""/utf8>> ->
[];
_ ->
[S]
end end,
Helper__optional_property = case erlang:element(3, Gen) andalso erlang:element(
7,
Gen
) of
false ->
[];
true ->
[<<"fn helper__optional_property(
object: List(#(String, json.Json)),
key: String,
value: option.Option(a),
to_json: fn(a) -> json.Json,
) -> List(#(String, json.Json)) {
case value {
option.Some(value) -> [#(key, to_json(value)), ..object]
option.None -> object
}
}"/utf8>>]
end,
Helper__dict_to_json = case erlang:element(3, Gen) andalso erlang:element(
6,
Gen
) of
false ->
[];
true ->
[<<"fn helper__dict_to_json(
data: dict.Dict(String, t),
to_json: fn(t) -> json.Json,
) -> json.Json {
data
|> dict.to_list
|> list.map(fn(pair) { #(pair.0, to_json(pair.1)) })
|> json.object
}"/utf8>>]
end,
_pipe@6 = [Block(Imports),
Block(Defs(erlang:element(8, Gen))),
Block(Defs(erlang:element(9, Gen))),
Helper__dict_to_json,
Helper__optional_property],
_pipe@7 = gleam@list:flatten(_pipe@6),
gleam@string:join(_pipe@7, <<"\n\n"/utf8>>).
-file("src/json_typedef.gleam", 938).
-spec en_ref(binary(), gleam@option:option(binary()), boolean()) -> {ok, out()} |
{error, codegen_error()}.
en_ref(Name, Data, Nullable) ->
Src = <<(justin:snake_case(Name))/binary, "_to_json"/utf8>>,
Src@1 = case {Data, Nullable} of
{none, false} ->
Src;
{none, true} ->
<<<<"json.nullable(_, "/utf8, Src/binary>>/binary, ")"/utf8>>;
{{some, Data@1}, false} ->
<<<<<<Src/binary, "("/utf8>>/binary, Data@1/binary>>/binary,
")"/utf8>>;
{{some, Data@2}, true} ->
<<<<<<<<"json.nullable("/utf8, Data@2/binary>>/binary, ", "/utf8>>/binary,
Src/binary>>/binary,
")"/utf8>>
end,
Type_name = justin:pascal_case(Name),
Type_name@1 = case Nullable of
false ->
Type_name;
true ->
<<<<"option.Option("/utf8, Type_name/binary>>/binary, ")"/utf8>>
end,
{ok, {out, Src@1, Type_name@1}}.
-file("src/json_typedef.gleam", 960).
-spec de_ref(binary(), boolean()) -> {ok, out()} | {error, codegen_error()}.
de_ref(Name, Nullable) ->
Src = <<(justin:snake_case(Name))/binary, "_decoder()"/utf8>>,
Src@1 = case Nullable of
false ->
Src;
true ->
<<<<"decode.optional("/utf8, Src/binary>>/binary, ")"/utf8>>
end,
Type_name = justin:pascal_case(Name),
Type_name@1 = case Nullable of
false ->
Type_name;
true ->
<<<<"option.Option("/utf8, Type_name/binary>>/binary, ")"/utf8>>
end,
{ok, {out, Src@1, Type_name@1}}.
-file("src/json_typedef.gleam", 976).
-spec pro_data_name(gleam@option:option(binary())) -> property_data_name().
pro_data_name(Name) ->
case Name of
none ->
property_data_none;
{some, N} ->
{property_data_access, N}
end.
-file("src/json_typedef.gleam", 1217).
-spec en_enum(
list(binary()),
boolean(),
gleam@option:option(binary()),
binary()
) -> {ok, out()} | {error, codegen_error()}.
en_enum(Variants, Nullable, Data, Position_name) ->
Type_name = Position_name,
Src = <<<<"json.string(case "/utf8,
(gleam@option:unwrap(Data, <<"data"/utf8>>))/binary>>/binary,
" {\n"/utf8>>,
Variants@1 = begin
_pipe = Variants,
_pipe@1 = gleam@list:map(
_pipe,
fun(V) ->
<<<<<<<<" "/utf8, (justin:pascal_case(V))/binary>>/binary,
" -> \""/utf8>>/binary,
V/binary>>/binary,
"\"\n"/utf8>>
end
),
gleam@string:concat(_pipe@1)
end,
Src@1 = <<<<Src/binary, Variants@1/binary>>/binary, " })"/utf8>>,
Src@2 = case Nullable orelse (Data =:= none) of
true ->
<<<<"fn(data) { "/utf8, Src@1/binary>>/binary, " }"/utf8>>;
false ->
Src@1
end,
Out = case Nullable of
true ->
Type_name@1 = <<<<"option.Option("/utf8, Type_name/binary>>/binary,
")"/utf8>>,
Src@3 = case Data of
{some, Data@1} ->
<<<<<<<<"json.nullable("/utf8, Data@1/binary>>/binary,
", "/utf8>>/binary,
Src@2/binary>>/binary,
")"/utf8>>;
none ->
<<<<"json.nullable(_, "/utf8, Src@2/binary>>/binary,
")"/utf8>>
end,
{out, Src@3, Type_name@1};
false ->
{out, Src@2, Type_name}
end,
{ok, Out}.
-file("src/json_typedef.gleam", 1394).
-spec en_nullable(binary(), binary(), boolean(), gleam@option:option(binary())) -> out().
en_nullable(Src, Type_name, Nullable, Data) ->
case Nullable of
true ->
Type_name@1 = <<<<"option.Option("/utf8, Type_name/binary>>/binary,
")"/utf8>>,
Src@1 = case Data of
{some, Data@1} ->
<<<<<<<<"json.nullable("/utf8, Data@1/binary>>/binary,
", "/utf8>>/binary,
Src/binary>>/binary,
")"/utf8>>;
none ->
<<<<"json.nullable(_, "/utf8, Src/binary>>/binary,
")"/utf8>>
end,
{out, Src@1, Type_name@1};
false ->
Src@2 = case Data of
{some, Data@2} ->
<<<<<<Src/binary, "("/utf8>>/binary, Data@2/binary>>/binary,
")"/utf8>>;
none ->
Src
end,
{out, Src@2, Type_name}
end.
-file("src/json_typedef.gleam", 1384).
-spec en_type(type(), boolean(), gleam@option:option(binary())) -> out().
en_type(T, Nullable, Data) ->
{Src, Type_name} = case T of
boolean ->
{<<"json.bool"/utf8>>, <<"Bool"/utf8>>};
float32 ->
{<<"json.float"/utf8>>, <<"Float"/utf8>>};
float64 ->
{<<"json.float"/utf8>>, <<"Float"/utf8>>};
string ->
{<<"json.string"/utf8>>, <<"String"/utf8>>};
timestamp ->
{<<"json.string"/utf8>>, <<"String"/utf8>>};
int16 ->
{<<"json.int"/utf8>>, <<"Int"/utf8>>};
int32 ->
{<<"json.int"/utf8>>, <<"Int"/utf8>>};
int8 ->
{<<"json.int"/utf8>>, <<"Int"/utf8>>};
uint16 ->
{<<"json.int"/utf8>>, <<"Int"/utf8>>};
uint32 ->
{<<"json.int"/utf8>>, <<"Int"/utf8>>};
uint8 ->
{<<"json.int"/utf8>>, <<"Int"/utf8>>}
end,
en_nullable(Src, Type_name, Nullable, Data).
-file("src/json_typedef.gleam", 1419).
-spec de_nullable(binary(), binary(), boolean()) -> out().
de_nullable(Src, Type_name, Nullable) ->
case Nullable of
true ->
Type_name@1 = <<<<"option.Option("/utf8, Type_name/binary>>/binary,
")"/utf8>>,
Src@1 = <<<<"decode.optional("/utf8, Src/binary>>/binary, ")"/utf8>>,
{out, Src@1, Type_name@1};
false ->
{out, Src, Type_name}
end.
-file("src/json_typedef.gleam", 1333).
-spec de_enum(list(binary()), boolean(), binary()) -> {ok, out()} |
{error, codegen_error()}.
de_enum(Variants, Nullable, Position_name) ->
Type_name = Position_name,
Src = <<"decode.then(decode.string, fn(s) {
case s {\n"/utf8>>,
Variants@1 = gleam@list:map(
Variants,
fun(V) ->
<<<<<<<<" \""/utf8, V/binary>>/binary,
"\" -> decode.into("/utf8>>/binary,
(justin:pascal_case(V))/binary>>/binary,
")\n"/utf8>>
end
),
Src@1 = <<Src/binary, (gleam@string:concat(Variants@1))/binary>>,
Src@2 = <<<<<<Src@1/binary, " _ -> decode.fail(\""/utf8>>/binary,
Type_name/binary>>/binary,
"\")\n"/utf8>>,
Src@3 = <<Src@2/binary, " }\n })"/utf8>>,
{ok, de_nullable(Src@3, Type_name, Nullable)}.
-file("src/json_typedef.gleam", 1374).
-spec de_type(type(), boolean()) -> out().
de_type(T, Nullable) ->
{Src, Type_name} = case T of
boolean ->
{<<"decode.bool"/utf8>>, <<"Bool"/utf8>>};
float32 ->
{<<"decode.float"/utf8>>, <<"Float"/utf8>>};
float64 ->
{<<"decode.float"/utf8>>, <<"Float"/utf8>>};
string ->
{<<"decode.string"/utf8>>, <<"String"/utf8>>};
timestamp ->
{<<"decode.string"/utf8>>, <<"String"/utf8>>};
int16 ->
{<<"decode.int"/utf8>>, <<"Int"/utf8>>};
int32 ->
{<<"decode.int"/utf8>>, <<"Int"/utf8>>};
int8 ->
{<<"decode.int"/utf8>>, <<"Int"/utf8>>};
uint16 ->
{<<"decode.int"/utf8>>, <<"Int"/utf8>>};
uint32 ->
{<<"decode.int"/utf8>>, <<"Int"/utf8>>};
uint8 ->
{<<"decode.int"/utf8>>, <<"Int"/utf8>>}
end,
de_nullable(Src, Type_name, Nullable).
-file("src/json_typedef.gleam", 1103).
-spec en_properties_schema(
properties_schema(),
boolean(),
property_data_name(),
binary(),
gleam@option:option({binary(), binary()})
) -> {ok, out()} | {error, codegen_error()}.
en_properties_schema(Schema, Nullable, Data, Name, Extra) ->
{properties_schema, Properties, Optional_properties, _} = Schema,
Property_data = fun(Field_name) ->
Field_name@1 = justin:snake_case(Field_name),
case Data of
property_data_direct ->
Field_name@1;
{property_data_access, Name@1} when not Nullable ->
<<<<Name@1/binary, "."/utf8>>/binary, Field_name@1/binary>>;
_ ->
<<"data."/utf8, Field_name@1/binary>>
end
end,
gleam@result:'try'(
gleam@list:try_map(
Properties,
fun(P) ->
Name@2 = <<Name/binary,
(justin:pascal_case(erlang:element(1, P)))/binary>>,
Data@1 = Property_data(erlang:element(1, P)),
gleam@result:map(
en_schema(erlang:element(2, P), {some, Data@1}, Name@2),
fun(Out) ->
{erlang:element(1, P), erlang:element(2, Out)}
end
)
end
),
fun(Properties@1) ->
Properties@2 = begin
_pipe = case Extra of
none ->
Properties@1;
{some, {K, V}} ->
[{K,
<<<<"json.string(\""/utf8, V/binary>>/binary,
"\")"/utf8>>} |
Properties@1]
end,
gleam@list:map(
_pipe,
fun(P@1) ->
<<<<<<<<"\n #(\""/utf8,
(erlang:element(1, P@1))/binary>>/binary,
"\", "/utf8>>/binary,
(erlang:element(2, P@1))/binary>>/binary,
"),"/utf8>>
end
)
end,
gleam@result:map(
gleam@list:try_map(
Optional_properties,
fun(P@2) ->
N = <<Name/binary,
(justin:pascal_case(erlang:element(1, P@2)))/binary>>,
D = Property_data(erlang:element(1, P@2)),
gleam@result:map(
en_schema(erlang:element(2, P@2), none, Name),
fun(_use0) ->
{out, S, _} = _use0,
<<<<<<<<<<<<" |> helper__optional_property("/utf8,
D/binary>>/binary,
", \""/utf8>>/binary,
N/binary>>/binary,
"\", "/utf8>>/binary,
S/binary>>/binary,
")"/utf8>>
end
)
end
),
fun(Optionals) ->
Src = case Properties@2 of
[] ->
<<"[]"/utf8>>;
P@3 ->
<<<<"["/utf8, (gleam@string:concat(P@3))/binary>>/binary,
"\n ]"/utf8>>
end,
Src@1 = case Optional_properties of
[] ->
<<<<"json.object("/utf8, Src/binary>>/binary,
")"/utf8>>;
_ ->
<<<<<<Src/binary, "\n"/utf8>>/binary,
(gleam@string:join(Optionals, <<"\n"/utf8>>))/binary>>/binary,
"\n |> json.object"/utf8>>
end,
Src@2 = case Nullable of
true ->
Data@2 = case Data of
{property_data_access, Name@3} ->
Name@3;
property_data_direct ->
<<"data"/utf8>>;
property_data_none ->
<<"data"/utf8>>
end,
<<<<<<<<"case "/utf8, Data@2/binary>>/binary,
" {
option.Some(data) -> "/utf8>>/binary,
Src@1/binary>>/binary,
"
option.None -> json.null()
}"/utf8>>;
false ->
Src@1
end,
Src@3 = case Data of
property_data_none ->
<<<<"fn(data) { "/utf8, Src@2/binary>>/binary,
" }"/utf8>>;
_ ->
Src@2
end,
Type_name = case Nullable of
true ->
<<<<"option.Option("/utf8, Name/binary>>/binary,
")"/utf8>>;
false ->
Name
end,
{out, Src@3, Type_name}
end
)
end
).
-file("src/json_typedef.gleam", 916).
-spec en_schema(schema(), gleam@option:option(binary()), binary()) -> {ok,
out()} |
{error, codegen_error()}.
en_schema(Schema, Data, Name) ->
case Schema of
{discriminator, Nullable, _, Tag, Mapping} ->
en_discriminator(Mapping, Tag, Nullable, Data, Name);
{elements, Nullable@1, _, Schema@1} ->
en_elements(
Schema@1,
Nullable@1,
Data,
<<Name/binary, "Element"/utf8>>
);
empty ->
{error, cannot_convert_empty_to_json_error};
{enum, Nullable@2, _, Variants} ->
en_enum(Variants, Nullable@2, Data, Name);
{properties, Nullable@3, _, Schema@2} ->
en_properties_schema(
Schema@2,
Nullable@3,
pro_data_name(Data),
Name,
none
);
{ref, Nullable@4, _, Name@1} ->
en_ref(Name@1, Data, Nullable@4);
{type, Nullable@5, _, Type_} ->
{ok, en_type(Type_, Nullable@5, Data)};
{values, Nullable@6, _, Schema@3} ->
en_values(Schema@3, Nullable@6, Data, Name)
end.
-file("src/json_typedef.gleam", 782).
-spec gen_add_encoder(generator(), binary(), schema()) -> {ok, generator()} |
{error, codegen_error()}.
gen_add_encoder(Gen, Name, Schema) ->
gleam@result:'try'(
en_schema(Schema, {some, <<"data"/utf8>>}, Name),
fun(Out) ->
Name@1 = <<(justin:snake_case(Name))/binary, "_to_json"/utf8>>,
Src = <<<<<<<<<<<<"pub fn "/utf8, Name@1/binary>>/binary,
"(data: "/utf8>>/binary,
(erlang:element(3, Out))/binary>>/binary,
") -> json.Json {
"/utf8>>/binary,
(erlang:element(2, Out))/binary>>/binary,
"
}"/utf8>>,
gen_add_function(Gen, Name@1, Src)
end
).
-file("src/json_typedef.gleam", 541).
-spec gen_encoders(generator(), binary(), root_schema()) -> {ok, generator()} |
{error, codegen_error()}.
gen_encoders(Gen, Root, Schema) ->
gen_add_encoder(Gen, Root, erlang:element(3, Schema)).
-file("src/json_typedef.gleam", 1039).
-spec en_discriminator(
list({binary(), properties_schema()}),
binary(),
boolean(),
gleam@option:option(binary()),
binary()
) -> {ok, out()} | {error, codegen_error()}.
en_discriminator(Mapping, Tag, Nullable, Data, Name) ->
gleam@result:'try'(
gleam@list:try_map(
Mapping,
fun(Pair) ->
Name@1 = <<Name/binary,
(justin:pascal_case(erlang:element(1, Pair)))/binary>>,
Result = en_properties_schema(
erlang:element(2, Pair),
false,
property_data_direct,
Name@1,
{some, {Tag, erlang:element(1, Pair)}}
),
Props = lists:append(
gleam@list:map(
erlang:element(2, (erlang:element(2, Pair))),
fun(P) -> erlang:element(1, P) end
),
gleam@list:map(
erlang:element(3, (erlang:element(2, Pair))),
fun(P@1) -> erlang:element(1, P@1) end
)
),
gleam@result:map(
Result,
fun(_use0) ->
{out, Src, _} = _use0,
{erlang:element(1, Pair),
Src,
gleam@list:sort(Props, fun gleam@string:compare/2)}
end
)
end
),
fun(Properties) ->
Clauses = gleam@list:map(
Properties,
fun(Pair@1) ->
Name@2 = <<Name/binary,
(justin:pascal_case(erlang:element(1, Pair@1)))/binary>>,
Args = case erlang:element(3, Pair@1) of
[] ->
<<""/utf8>>;
A ->
<<<<"("/utf8,
(gleam@string:join(A, <<":, "/utf8>>))/binary>>/binary,
":)"/utf8>>
end,
<<<<<<<<" "/utf8, Name@2/binary>>/binary, Args/binary>>/binary,
" -> "/utf8>>/binary,
(erlang:element(2, Pair@1))/binary>>
end
),
Src@1 = <<<<<<<<"case "/utf8,
(gleam@option:unwrap(Data, <<"data"/utf8>>))/binary>>/binary,
" {\n"/utf8>>/binary,
(gleam@string:join(Clauses, <<"\n"/utf8>>))/binary>>/binary,
"\n }"/utf8>>,
Out = case Nullable of
true ->
Type_name = <<<<"option.Option("/utf8, Name/binary>>/binary,
")"/utf8>>,
Data@1 = gleam@option:unwrap(Data, <<"data"/utf8>>),
Src@2 = <<<<<<<<"case "/utf8, Data@1/binary>>/binary,
" {
option.Some(data) -> "/utf8>>/binary,
Src@1/binary>>/binary,
"
option.None -> json.null()
}"/utf8>>,
{out, Src@2, Type_name};
false ->
{out, Src@1, Name}
end,
case Data of
none ->
{ok,
begin
_record = Out,
{out,
<<<<"fn(data) { "/utf8,
(erlang:element(2, Out))/binary>>/binary,
" }"/utf8>>,
erlang:element(3, _record)}
end};
{some, _} ->
{ok, Out}
end
end
).
-file("src/json_typedef.gleam", 1194).
-spec en_values(schema(), boolean(), gleam@option:option(binary()), binary()) -> {ok,
out()} |
{error, codegen_error()}.
en_values(Schema, Nullable, Data, Position_name) ->
gleam@result:map(
en_schema(Schema, none, Position_name),
fun(_use0) ->
{out, Src, Type_name} = _use0,
Type_name@1 = <<<<"dict.Dict(String, "/utf8, Type_name/binary>>/binary,
")"/utf8>>,
Data@1 = gleam@option:unwrap(Data, <<"_"/utf8>>),
case Nullable of
false ->
Src@1 = <<<<<<<<"helper__dict_to_json("/utf8,
Data@1/binary>>/binary,
", "/utf8>>/binary,
Src/binary>>/binary,
")"/utf8>>,
{out, Src@1, Type_name@1};
true ->
Type_name@2 = <<<<"option.Option("/utf8,
Type_name@1/binary>>/binary,
")"/utf8>>,
Src@2 = <<<<"helper__dict_to_json(_, "/utf8, Src/binary>>/binary,
")"/utf8>>,
Src@3 = <<<<<<<<"json.nullable("/utf8, Data@1/binary>>/binary,
", "/utf8>>/binary,
Src@2/binary>>/binary,
")"/utf8>>,
{out, Src@3, Type_name@2}
end
end
).
-file("src/json_typedef.gleam", 1310).
-spec en_elements(schema(), boolean(), gleam@option:option(binary()), binary()) -> {ok,
out()} |
{error, codegen_error()}.
en_elements(Schema, Nullable, Data, Position_name) ->
gleam@result:map(
en_schema(Schema, none, Position_name),
fun(_use0) ->
{out, Src, Type_name} = _use0,
Type_name@1 = <<<<"List("/utf8, Type_name/binary>>/binary,
")"/utf8>>,
Data@1 = gleam@option:unwrap(Data, <<"_"/utf8>>),
case Nullable of
false ->
Src@1 = <<<<<<<<"json.array("/utf8, Data@1/binary>>/binary,
", "/utf8>>/binary,
Src/binary>>/binary,
")"/utf8>>,
{out, Src@1, Type_name@1};
true ->
Type_name@2 = <<<<"option.Option("/utf8,
Type_name@1/binary>>/binary,
")"/utf8>>,
Src@2 = <<<<"json.array(_, "/utf8, Src/binary>>/binary,
")"/utf8>>,
Src@3 = <<<<<<<<"json.nullable("/utf8, Data@1/binary>>/binary,
", "/utf8>>/binary,
Src@2/binary>>/binary,
")"/utf8>>,
{out, Src@3, Type_name@2}
end
end
).
-file("src/json_typedef.gleam", 1252).
-spec de_properties_schema(properties_schema(), boolean(), binary()) -> {ok,
out()} |
{error, codegen_error()}.
de_properties_schema(Schema, Nullable, Name) ->
{properties_schema, Properties, Optional_properties, _} = Schema,
Properties@1 = begin
_pipe = lists:append(
gleam@list:map(
Properties,
fun(P) ->
{erlang:element(1, P), erlang:element(2, P), false}
end
),
gleam@list:map(
Optional_properties,
fun(P@1) ->
{erlang:element(1, P@1), erlang:element(2, P@1), true}
end
)
),
gleam@list:sort(
_pipe,
fun(A, B) ->
gleam@string:compare(erlang:element(1, A), erlang:element(1, B))
end
)
end,
gleam@result:'try'(
gleam@list:try_map(
Properties@1,
fun(Prop) ->
gleam@result:map(
de_schema(
erlang:element(2, Prop),
<<Name/binary,
(justin:pascal_case(erlang:element(1, Prop)))/binary>>
),
fun(S) ->
{erlang:element(1, Prop), S, erlang:element(3, Prop)}
end
)
end
),
fun(Properties@2) ->
Params = begin
_pipe@1 = Properties@2,
_pipe@2 = gleam@list:map(
_pipe@1,
fun(N) ->
Name@1 = justin:snake_case(erlang:element(1, N)),
<<<<" use "/utf8, Name@1/binary>>/binary,
" <- decode.parameter"/utf8>>
end
),
gleam@string:join(_pipe@2, <<"\n"/utf8>>)
end,
Fields = begin
_pipe@3 = Properties@2,
_pipe@4 = gleam@list:map(
_pipe@3,
fun(P@2) ->
Field = case erlang:element(3, P@2) of
true ->
<<" |> decode.optional_field(\""/utf8>>;
false ->
<<" |> decode.field(\""/utf8>>
end,
<<<<<<<<Field/binary, (erlang:element(1, P@2))/binary>>/binary,
"\", "/utf8>>/binary,
(erlang:element(2, (erlang:element(2, P@2))))/binary>>/binary,
")"/utf8>>
end
),
gleam@string:join(_pipe@4, <<"\n"/utf8>>)
end,
Keys = begin
_pipe@5 = Properties@2,
_pipe@6 = gleam@list:map(
_pipe@5,
fun(N@1) ->
<<(justin:snake_case(erlang:element(1, N@1)))/binary,
":"/utf8>>
end
),
gleam@string:join(_pipe@6, <<", "/utf8>>)
end,
Src = <<<<<<<<<<<<<<"decode.into({
"/utf8, Params/binary>>/binary,
"
"/utf8>>/binary,
Name/binary>>/binary,
"("/utf8>>/binary,
Keys/binary>>/binary,
")
})
"/utf8>>/binary,
Fields/binary>>,
{ok, de_nullable(Src, Name, Nullable)}
end
).
-file("src/json_typedef.gleam", 983).
-spec de_schema(schema(), binary()) -> {ok, out()} | {error, codegen_error()}.
de_schema(Schema, Name) ->
case Schema of
{discriminator, Nullable, _, Tag, Mapping} ->
de_discriminator(Mapping, Tag, Nullable, Name);
{elements, Nullable@1, _, Schema@1} ->
de_elements(Schema@1, Nullable@1, <<Name/binary, "Element"/utf8>>);
empty ->
{ok, {out, <<"decode.dynamic"/utf8>>, <<"dynamic.Dynamic"/utf8>>}};
{enum, Nullable@2, _, Variants} ->
de_enum(Variants, Nullable@2, Name);
{properties, Nullable@3, _, Schema@2} ->
de_properties_schema(Schema@2, Nullable@3, Name);
{ref, Nullable@4, _, Name@1} ->
de_ref(Name@1, Nullable@4);
{type, Nullable@5, _, Type_} ->
{ok, de_type(Type_, Nullable@5)};
{values, Nullable@6, _, Schema@3} ->
de_values(Schema@3, Nullable@6, Name)
end.
-file("src/json_typedef.gleam", 796).
-spec gen_add_decoder(generator(), binary(), schema()) -> {ok, generator()} |
{error, codegen_error()}.
gen_add_decoder(Gen, Name, Schema) ->
gleam@result:'try'(
de_schema(Schema, Name),
fun(Out) ->
Fn_name = <<(justin:snake_case(Name))/binary, "_decoder"/utf8>>,
Src = <<<<<<<<<<<<"pub fn "/utf8, Fn_name/binary>>/binary,
"() -> decode.Decoder("/utf8>>/binary,
(erlang:element(3, Out))/binary>>/binary,
") {
"/utf8>>/binary,
(erlang:element(2, Out))/binary>>/binary,
"
}"/utf8>>,
gen_add_function(Gen, Name, Src)
end
).
-file("src/json_typedef.gleam", 549).
-spec gen_decoders(generator(), binary(), root_schema()) -> {ok, generator()} |
{error, codegen_error()}.
gen_decoders(Gen, Root, Schema) ->
gen_add_decoder(Gen, Root, erlang:element(3, Schema)).
-file("src/json_typedef.gleam", 999).
-spec de_discriminator(
list({binary(), properties_schema()}),
binary(),
boolean(),
binary()
) -> {ok, out()} | {error, codegen_error()}.
de_discriminator(Mapping, Tag, Nullable, Name) ->
gleam@result:'try'(
gleam@list:try_map(
Mapping,
fun(Pair) ->
Result = de_properties_schema(
erlang:element(2, Pair),
false,
<<Name/binary,
(justin:pascal_case(erlang:element(1, Pair)))/binary>>
),
gleam@result:map(
Result,
fun(Out) ->
{erlang:element(1, Pair), erlang:element(2, Out)}
end
)
end
),
fun(Mapping@1) ->
Clauses = gleam@list:map(
Mapping@1,
fun(Pair@1) ->
<<<<<<" \""/utf8, (erlang:element(1, Pair@1))/binary>>/binary,
"\" -> "/utf8>>/binary,
(erlang:element(2, Pair@1))/binary>>
end
),
Src = <<<<<<<<<<<<"decode.at([\""/utf8, Tag/binary>>/binary,
"\"], decode.string)
|> decode.then(fn(tag) {
case tag {
"/utf8>>/binary,
(gleam@string:join(Clauses, <<"\n"/utf8>>))/binary>>/binary,
"
_ -> decode.fail(\""/utf8>>/binary,
Name/binary>>/binary,
"\")
}
})"/utf8>>,
Type_name = case Nullable of
false ->
Name;
true ->
<<<<"option.Option("/utf8, Name/binary>>/binary, ")"/utf8>>
end,
{ok, {out, Src, Type_name}}
end
).
-file("src/json_typedef.gleam", 1352).
-spec de_values(schema(), boolean(), binary()) -> {ok, out()} |
{error, codegen_error()}.
de_values(Schema, Nullable, Position_name) ->
gleam@result:map(
de_schema(Schema, Position_name),
fun(_use0) ->
{out, Src, Type_name} = _use0,
Type_name@1 = <<<<"dict.Dict(String, "/utf8, Type_name/binary>>/binary,
")"/utf8>>,
Src@1 = <<<<"decode.dict(decode.string, "/utf8, Src/binary>>/binary,
")"/utf8>>,
de_nullable(Src@1, Type_name@1, Nullable)
end
).
-file("src/json_typedef.gleam", 1363).
-spec de_elements(schema(), boolean(), binary()) -> {ok, out()} |
{error, codegen_error()}.
de_elements(Schema, Nullable, Position_name) ->
gleam@result:map(
de_schema(Schema, Position_name),
fun(_use0) ->
{out, Src, Type_name} = _use0,
Type_name@1 = <<<<"List("/utf8, Type_name/binary>>/binary,
")"/utf8>>,
Src@1 = <<<<"decode.list("/utf8, Src/binary>>/binary, ")"/utf8>>,
de_nullable(Src@1, Type_name@1, Nullable)
end
).
-file("src/json_typedef.gleam", 699).
-spec type_variant(generator(), binary(), properties_schema()) -> {ok,
{generator(), binary()}} |
{error, codegen_error()}.
type_variant(Gen, Name, Schema) ->
Gen@1 = case erlang:element(3, Schema) of
[] ->
Gen;
_ ->
_record = Gen,
{generator,
erlang:element(2, _record),
erlang:element(3, _record),
erlang:element(4, _record),
erlang:element(5, _record),
erlang:element(6, _record),
true,
erlang:element(8, _record),
erlang:element(9, _record),
erlang:element(10, _record),
erlang:element(11, _record)}
end,
{properties_schema, Properties, Optional_properties, _} = Schema,
gleam@result:'try'(
gleam@list:try_fold(
Properties,
Gen@1,
fun(Gen@2, Prop) ->
gen_type(
Gen@2,
<<Name/binary,
(justin:pascal_case(erlang:element(1, Prop)))/binary>>,
erlang:element(2, Prop)
)
end
),
fun(Gen@3) ->
gleam@result:'try'(
gleam@list:try_fold(
Optional_properties,
Gen@3,
fun(Gen@4, Prop@1) ->
Gen@5 = begin
_record@1 = Gen@4,
{generator,
erlang:element(2, _record@1),
erlang:element(3, _record@1),
erlang:element(4, _record@1),
true,
erlang:element(6, _record@1),
erlang:element(7, _record@1),
erlang:element(8, _record@1),
erlang:element(9, _record@1),
erlang:element(10, _record@1),
erlang:element(11, _record@1)}
end,
gen_type(
Gen@5,
<<Name/binary,
(justin:pascal_case(erlang:element(1, Prop@1)))/binary>>,
erlang:element(2, Prop@1)
)
end
),
fun(Gen@6) ->
Properties@1 = begin
_pipe = lists:append(
gleam@list:map(
Properties,
fun(P) ->
{erlang:element(1, P),
erlang:element(2, P),
false}
end
),
gleam@list:map(
Optional_properties,
fun(P@1) ->
{erlang:element(1, P@1),
erlang:element(2, P@1),
true}
end
)
),
_pipe@1 = gleam@list:sort(
_pipe,
fun(A, B) ->
gleam@string:compare(
erlang:element(1, A),
erlang:element(1, B)
)
end
),
_pipe@2 = gleam@list:map(
_pipe@1,
fun(P@2) ->
N = justin:snake_case(erlang:element(1, P@2)),
<<<<<<" "/utf8, N/binary>>/binary,
": "/utf8>>/binary,
(type_name(
erlang:element(2, P@2),
<<Name/binary,
(justin:pascal_case(
erlang:element(1, P@2)
))/binary>>
))/binary>>
end
),
gleam@string:join(_pipe@2, <<",\n"/utf8>>)
end,
gleam@result:'try'(
ensure_constructor_unique(Gen@6, Name),
fun(Gen@7) ->
Src = <<<<<<<<" "/utf8, Name/binary>>/binary,
"(
"/utf8>>/binary,
Properties@1/binary>>/binary,
",
)"/utf8>>,
{ok, {Gen@7, Src}}
end
)
end
)
end
).
-file("src/json_typedef.gleam", 557).
-spec gen_type(generator(), binary(), schema()) -> {ok, generator()} |
{error, codegen_error()}.
gen_type(Gen, Name, Schema) ->
Name@1 = justin:pascal_case(Name),
case Schema of
empty ->
{ok,
begin
_record = Gen,
{generator,
erlang:element(2, _record),
erlang:element(3, _record),
true,
erlang:element(5, _record),
erlang:element(6, _record),
erlang:element(7, _record),
erlang:element(8, _record),
erlang:element(9, _record),
erlang:element(10, _record),
erlang:element(11, _record)}
end};
{ref, Nullable, _, _} ->
{ok, gen_register_nullable(Gen, Nullable)};
{type, Nullable@1, _, _} ->
{ok, gen_register_nullable(Gen, Nullable@1)};
{enum, Nullable@2, _, Variants} ->
Gen@1 = gen_register_nullable(Gen, Nullable@2),
gen_enum_type(Gen@1, Name@1, Variants);
{properties, Nullable@3, _, Schema@1} ->
Gen@2 = gen_register_nullable(Gen, Nullable@3),
gen_register_properties(Gen@2, Name@1, Schema@1);
{elements, Nullable@4, _, Schema@2} ->
Gen@3 = gen_register_nullable(Gen, Nullable@4),
gen_type(Gen@3, <<Name@1/binary, "Element"/utf8>>, Schema@2);
{values, Nullable@5, _, Schema@3} ->
Gen@4 = gen_register_nullable(Gen, Nullable@5),
Gen@5 = begin
_record@1 = Gen@4,
{generator,
erlang:element(2, _record@1),
erlang:element(3, _record@1),
erlang:element(4, _record@1),
erlang:element(5, _record@1),
true,
erlang:element(7, _record@1),
erlang:element(8, _record@1),
erlang:element(9, _record@1),
erlang:element(10, _record@1),
erlang:element(11, _record@1)}
end,
gen_type(Gen@5, <<Name@1/binary, "Value"/utf8>>, Schema@3);
{discriminator, Nullable@6, _, Tag, Mapping} ->
Gen@6 = gen_register_nullable(Gen, Nullable@6),
gen_register_discriminator(Gen@6, Tag, Name@1, Mapping)
end.
-file("src/json_typedef.gleam", 658).
-spec gen_register_properties(generator(), binary(), properties_schema()) -> {ok,
generator()} |
{error, codegen_error()}.
gen_register_properties(Gen, Name, Schema) ->
gleam@result:'try'(
ensure_no_duplicate_properties(Schema, none, Name, Name),
fun(_) ->
gleam@result:'try'(
type_variant(Gen, Name, Schema),
fun(_use0) ->
{Gen@1, Src} = _use0,
Src@1 = <<<<<<<<"pub type "/utf8, Name/binary>>/binary,
" {
"/utf8>>/binary,
Src/binary>>/binary,
"
}"/utf8>>,
Type_name = Name,
gen_add_type(Gen@1, Type_name, Src@1)
end
)
end
).
-file("src/json_typedef.gleam", 528).
-spec gen_types(generator(), binary(), root_schema()) -> {ok, generator()} |
{error, codegen_error()}.
gen_types(Gen, Root, Schema) ->
gleam@result:'try'(
gleam@list:try_fold(
erlang:element(2, Schema),
Gen,
fun(Gen@1, Def) ->
gen_type(Gen@1, erlang:element(1, Def), erlang:element(2, Def))
end
),
fun(Gen@2) -> gen_type(Gen@2, Root, erlang:element(3, Schema)) end
).
-file("src/json_typedef.gleam", 507).
-spec generate(generator(), root_schema()) -> {ok, binary()} |
{error, codegen_error()}.
generate(Gen, Schema) ->
Root = justin:pascal_case(erlang:element(10, Gen)),
gleam@result:'try'(
gen_types(Gen, Root, Schema),
fun(Gen@1) -> gleam@result:'try'(case erlang:element(2, Gen@1) of
true ->
gen_decoders(Gen@1, Root, Schema);
false ->
{ok, Gen@1}
end, fun(Gen@2) ->
gleam@result:map(case erlang:element(3, Gen@2) of
true ->
gen_encoders(Gen@2, Root, Schema);
false ->
{ok, Gen@2}
end, fun(Gen@3) -> gen_to_string(Gen@3) end)
end) end
).
-file("src/json_typedef.gleam", 632).
-spec gen_register_discriminator(
generator(),
binary(),
binary(),
list({binary(), properties_schema()})
) -> {ok, generator()} | {error, codegen_error()}.
gen_register_discriminator(Gen, Tag, Name, Mapping) ->
Type_name = Name,
gleam@result:'try'(
gleam@list:try_fold(
Mapping,
{Gen, []},
fun(Pair, Mapping@1) ->
Name@1 = <<Name/binary,
(justin:pascal_case(erlang:element(1, Mapping@1)))/binary>>,
Result = ensure_no_duplicate_properties(
erlang:element(2, Mapping@1),
{some, Tag},
Type_name,
Name@1
),
gleam@result:'try'(
Result,
fun(_) ->
Result@1 = type_variant(
erlang:element(1, Pair),
Name@1,
erlang:element(2, Mapping@1)
),
gleam@result:map(
Result@1,
fun(_use0) ->
{Gen@1, Src} = _use0,
{Gen@1, [Src | erlang:element(2, Pair)]}
end
)
end
)
end
),
fun(_use0@1) ->
{Gen@2, Src@1} = _use0@1,
Src@2 = <<<<<<<<"pub type "/utf8, Name/binary>>/binary, " {
"/utf8>>/binary,
(gleam@string:join(Src@1, <<"\n"/utf8>>))/binary>>/binary,
"
}"/utf8>>,
Type_name@1 = Name,
gen_add_type(Gen@2, Type_name@1, Src@2)
end
).
-file("src/json_typedef.gleam", 279).
-spec decode_properties_schema(gleam@dynamic:dynamic_()) -> {ok,
properties_schema()} |
{error, list(gleam@dynamic:decode_error())}.
decode_properties_schema(Data) ->
Field = fun(Name, Data@1) ->
case (gleam@dynamic:field(Name, fun gleam@dynamic:dynamic/1))(Data@1) of
{ok, D} ->
_pipe = decode_object_as_list(D, fun decode_schema/1),
push_path(_pipe, Name);
{error, _} ->
{ok, []}
end
end,
(gleam@dynamic:decode3(
fun(Field@0, Field@1, Field@2) -> {properties_schema, Field@0, Field@1, Field@2} end,
fun(_capture) -> Field(<<"properties"/utf8>>, _capture) end,
fun(_capture@1) -> Field(<<"optionalProperties"/utf8>>, _capture@1) end,
fun(D@1) ->
case (gleam@dynamic:field(
<<"additionalProperties"/utf8>>,
fun gleam@dynamic:dynamic/1
))(D@1) of
{ok, D@2} ->
_pipe@1 = gleam@dynamic:bool(D@2),
push_path(_pipe@1, <<"additionalProperties"/utf8>>);
{error, _} ->
{ok, false}
end
end
))(Data).
-file("src/json_typedef.gleam", 205).
-spec decode_schema(gleam@dynamic:dynamic_()) -> {ok, schema()} |
{error, list(gleam@dynamic:decode_error())}.
decode_schema(Data) ->
gleam@result:'try'(
(gleam@dynamic:dict(
fun gleam@dynamic:string/1,
fun gleam@dynamic:dynamic/1
))(Data),
fun(Data@1) ->
Decoder = begin
_pipe = key_decoder(Data@1, <<"type"/utf8>>, fun decode_type/2),
_pipe@1 = gleam@result:lazy_or(
_pipe,
fun() ->
key_decoder(Data@1, <<"enum"/utf8>>, fun decode_enum/2)
end
),
_pipe@2 = gleam@result:lazy_or(
_pipe@1,
fun() ->
key_decoder(Data@1, <<"ref"/utf8>>, fun decode_ref/2)
end
),
_pipe@3 = gleam@result:lazy_or(
_pipe@2,
fun() ->
key_decoder(
Data@1,
<<"values"/utf8>>,
fun decode_values/2
)
end
),
_pipe@4 = gleam@result:lazy_or(
_pipe@3,
fun() ->
key_decoder(
Data@1,
<<"elements"/utf8>>,
fun decode_elements/2
)
end
),
_pipe@5 = gleam@result:lazy_or(
_pipe@4,
fun() ->
key_decoder(
Data@1,
<<"discriminator"/utf8>>,
fun decode_discriminator/2
)
end
),
_pipe@6 = gleam@result:lazy_or(
_pipe@5,
fun() ->
key_decoder(
Data@1,
<<"properties"/utf8>>,
fun decode_properties/2
)
end
),
_pipe@7 = gleam@result:lazy_or(
_pipe@6,
fun() ->
key_decoder(
Data@1,
<<"extraProperties"/utf8>>,
fun decode_properties/2
)
end
),
_pipe@8 = gleam@result:lazy_or(
_pipe@7,
fun() ->
key_decoder(
Data@1,
<<"additionalProperties"/utf8>>,
fun decode_properties/2
)
end
),
gleam@result:unwrap(_pipe@8, fun() -> decode_empty(Data@1) end)
end,
Decoder()
end
).
-file("src/json_typedef.gleam", 242).
-spec decode_discriminator(
gleam@dynamic:dynamic_(),
gleam@dict:dict(binary(), gleam@dynamic:dynamic_())
) -> {ok, schema()} | {error, list(gleam@dynamic:decode_error())}.
decode_discriminator(Tag, Data) ->
gleam@result:'try'(
get_nullable(Data),
fun(Nullable) ->
gleam@result:'try'(
get_metadata(Data),
fun(Metadata) ->
gleam@result:'try'(
begin
_pipe = gleam@dynamic:string(Tag),
push_path(_pipe, <<"discriminator"/utf8>>)
end,
fun(Tag@1) ->
gleam@result:'try'(
case gleam_stdlib:map_get(
Data,
<<"mapping"/utf8>>
) of
{ok, Mapping} ->
{ok, Mapping};
{error, _} ->
{error,
[{decode_error,
<<"field"/utf8>>,
<<"nothing"/utf8>>,
[<<"mapping"/utf8>>]}]}
end,
fun(Mapping@1) ->
gleam@result:'try'(
begin
_pipe@1 = decode_object_as_list(
Mapping@1,
fun decode_properties_schema/1
),
push_path(
_pipe@1,
<<"mapping"/utf8>>
)
end,
fun(Properties) ->
{ok,
{discriminator,
Nullable,
Metadata,
Tag@1,
Properties}}
end
)
end
)
end
)
end
)
end
).
-file("src/json_typedef.gleam", 201).
-spec decoder(gleam@dynamic:dynamic_()) -> {ok, root_schema()} |
{error, list(gleam@dynamic:decode_error())}.
decoder(Data) ->
(gleam@dynamic:decode2(
fun(Field@0, Field@1) -> {root_schema, Field@0, Field@1} end,
fun(_) -> {ok, []} end,
fun decode_schema/1
))(Data).
-file("src/json_typedef.gleam", 268).
-spec decode_properties(
gleam@dynamic:dynamic_(),
gleam@dict:dict(binary(), gleam@dynamic:dynamic_())
) -> {ok, schema()} | {error, list(gleam@dynamic:decode_error())}.
decode_properties(_, Data) ->
gleam@result:'try'(
get_nullable(Data),
fun(Nullable) ->
gleam@result:'try'(
get_metadata(Data),
fun(Metadata) -> _pipe = gleam_stdlib:identity(Data),
_pipe@1 = decode_properties_schema(_pipe),
gleam@result:map(
_pipe@1,
fun(_capture) ->
{properties, Nullable, Metadata, _capture}
end
) end
)
end
).
-file("src/json_typedef.gleam", 356).
-spec decode_values(
gleam@dynamic:dynamic_(),
gleam@dict:dict(binary(), gleam@dynamic:dynamic_())
) -> {ok, schema()} | {error, list(gleam@dynamic:decode_error())}.
decode_values(Values, Data) ->
gleam@result:'try'(
get_nullable(Data),
fun(Nullable) ->
gleam@result:'try'(
get_metadata(Data),
fun(Metadata) -> _pipe = decode_schema(Values),
_pipe@1 = push_path(_pipe, <<"values"/utf8>>),
gleam@result:map(
_pipe@1,
fun(_capture) ->
{values, Nullable, Metadata, _capture}
end
) end
)
end
).
-file("src/json_typedef.gleam", 367).
-spec decode_elements(
gleam@dynamic:dynamic_(),
gleam@dict:dict(binary(), gleam@dynamic:dynamic_())
) -> {ok, schema()} | {error, list(gleam@dynamic:decode_error())}.
decode_elements(Elements, Data) ->
gleam@result:'try'(
get_nullable(Data),
fun(Nullable) ->
gleam@result:'try'(
get_metadata(Data),
fun(Metadata) -> _pipe = decode_schema(Elements),
_pipe@1 = push_path(_pipe, <<"elements"/utf8>>),
gleam@result:map(
_pipe@1,
fun(_capture) ->
{elements, Nullable, Metadata, _capture}
end
) end
)
end
).
-file("src/json_typedef.gleam", 106).
-spec properties_schema_to_json(properties_schema()) -> list({binary(),
gleam@json:json()}).
properties_schema_to_json(Schema) ->
Props_json = fun(Props) ->
gleam@json:object(
gleam@list:map(
Props,
fun(Property) ->
{erlang:element(1, Property),
gleam@json:object(
schema_to_json(erlang:element(2, Property))
)}
end
)
)
end,
{properties_schema, Properties, Optional_properties, Additional_properties} = Schema,
Data = [],
Data@1 = case Additional_properties of
false ->
Data;
_ ->
[{<<"additionalProperties"/utf8>>, gleam@json:bool(true)} | Data]
end,
Data@2 = case Optional_properties of
[] ->
Data@1;
P ->
[{<<"optionalProperties"/utf8>>, Props_json(P)} | Data@1]
end,
Data@3 = case Properties of
[] ->
Data@2;
P@1 ->
[{<<"properties"/utf8>>, Props_json(P@1)} | Data@2]
end,
Data@3.
-file("src/json_typedef.gleam", 141).
-spec schema_to_json(schema()) -> list({binary(), gleam@json:json()}).
schema_to_json(Schema) ->
case Schema of
empty ->
[];
{ref, Nullable, Metadata, Name} ->
_pipe = [{<<"values"/utf8>>, gleam@json:string(Name)}],
_pipe@1 = add_nullable(_pipe, Nullable),
add_metadata(_pipe@1, Metadata);
{type, Nullable@1, Metadata@1, Type_} ->
_pipe@2 = [{<<"type"/utf8>>, type_to_json(Type_)}],
_pipe@3 = add_nullable(_pipe@2, Nullable@1),
add_metadata(_pipe@3, Metadata@1);
{enum, Nullable@2, Metadata@2, Variants} ->
_pipe@4 = [{<<"enum"/utf8>>,
gleam@json:array(Variants, fun gleam@json:string/1)}],
_pipe@5 = add_nullable(_pipe@4, Nullable@2),
add_metadata(_pipe@5, Metadata@2);
{values, Nullable@3, Metadata@3, Schema@1} ->
_pipe@6 = [{<<"values"/utf8>>,
gleam@json:object(schema_to_json(Schema@1))}],
_pipe@7 = add_nullable(_pipe@6, Nullable@3),
add_metadata(_pipe@7, Metadata@3);
{elements, Nullable@4, Metadata@4, Schema@2} ->
_pipe@8 = [{<<"elements"/utf8>>,
gleam@json:object(schema_to_json(Schema@2))}],
_pipe@9 = add_nullable(_pipe@8, Nullable@4),
add_metadata(_pipe@9, Metadata@4);
{properties, Nullable@5, Metadata@5, Schema@3} ->
_pipe@10 = properties_schema_to_json(Schema@3),
_pipe@11 = add_nullable(_pipe@10, Nullable@5),
add_metadata(_pipe@11, Metadata@5);
{discriminator, Nullable@6, _, Tag, Mapping} ->
_pipe@12 = discriminator_to_json(Tag, Mapping),
add_nullable(_pipe@12, Nullable@6)
end.
-file("src/json_typedef.gleam", 90).
-spec to_json(root_schema()) -> gleam@json:json().
to_json(Schema) ->
Properties = schema_to_json(erlang:element(3, Schema)),
Properties@1 = case erlang:element(2, Schema) of
[] ->
Properties;
Definitions ->
Definitions@1 = gleam@list:map(
Definitions,
fun(Definition) ->
{erlang:element(1, Definition),
gleam@json:object(
schema_to_json(erlang:element(2, Definition))
)}
end
),
[{<<"definitions"/utf8>>, gleam@json:object(Definitions@1)} |
Properties]
end,
gleam@json:object(Properties@1).
-file("src/json_typedef.gleam", 190).
-spec discriminator_to_json(binary(), list({binary(), properties_schema()})) -> list({binary(),
gleam@json:json()}).
discriminator_to_json(Tag, Mapping) ->
Mapping@1 = gleam@list:map(
Mapping,
fun(Variant) ->
{erlang:element(1, Variant),
gleam@json:object(
properties_schema_to_json(erlang:element(2, Variant))
)}
end
),
[{<<"discriminator"/utf8>>, gleam@json:string(Tag)},
{<<"mapping"/utf8>>, gleam@json:object(Mapping@1)}].