envie

-module(envie@schema).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/envie/schema.gleam").
-export([secret/1, optional/1, load/1, fields/1, inspect_fields/1, load_field/1, build1/1, build2/3, build3/4, map2/3, field/2, default/2]).
-export_type([field_meta/0, inspect_field/0, field/1, schema/1]).

-type field_meta() :: {field_meta, binary(), boolean(), boolean(), boolean()}.

-type inspect_field() :: {inspect_field,
        binary(),
        gleam@option:option(binary()),
        boolean(),
        boolean(),
        boolean(),
        gleam@option:option(envie@error:error())}.

-type field(EHA) :: {field,
        field_meta(),
        fun(() -> {ok, EHA} | {error, envie@error:error()}),
        fun(() -> inspect_field())}.

-type schema(EHB) :: {schema,
        list(field_meta()),
        fun(() -> {ok, EHB} | {error, envie@error:error()}),
        fun(() -> list(inspect_field()))}.

-file("src/envie/schema.gleam", 82).
-spec secret(field(EHF)) -> field(EHF).
secret(Field) ->
    {field,
        {field_meta,
            erlang:element(2, erlang:element(2, Field)),
            erlang:element(3, erlang:element(2, Field)),
            erlang:element(4, erlang:element(2, Field)),
            true},
        erlang:element(3, Field),
        fun() ->
            Trace = (erlang:element(4, Field))(),
            {inspect_field,
                erlang:element(2, Trace),
                case erlang:element(3, Trace) of
                    {some, _} ->
                        {some, <<"********"/utf8>>};

                    none ->
                        none
                end,
                erlang:element(4, Trace),
                erlang:element(5, Trace),
                true,
                erlang:element(7, Trace)}
        end}.

-file("src/envie/schema.gleam", 136).
-spec optional(field(EHL)) -> field(gleam@option:option(EHL)).
optional(Field) ->
    {field,
        {field_meta,
            erlang:element(2, erlang:element(2, Field)),
            true,
            erlang:element(4, erlang:element(2, Field)),
            erlang:element(5, erlang:element(2, Field))},
        fun() -> case (erlang:element(3, Field))() of
                {ok, Value} ->
                    {ok, {some, Value}};

                {error, {missing, _}} ->
                    {ok, none};

                {error, Err} ->
                    {error, Err}
            end end,
        fun() ->
            Trace = (erlang:element(4, Field))(),
            {inspect_field,
                erlang:element(2, Trace),
                erlang:element(3, Trace),
                erlang:element(4, Trace),
                true,
                erlang:element(6, Trace),
                erlang:element(7, Trace)}
        end}.

-file("src/envie/schema.gleam", 223).
-spec load(schema(EIQ)) -> {ok, EIQ} | {error, envie@error:error()}.
load(Schema) ->
    (erlang:element(3, Schema))().

-file("src/envie/schema.gleam", 227).
-spec fields(schema(any())) -> list(field_meta()).
fields(Schema) ->
    erlang:element(2, Schema).

-file("src/envie/schema.gleam", 231).
-spec inspect_fields(schema(any())) -> list(inspect_field()).
inspect_fields(Schema) ->
    (erlang:element(4, Schema))().

-file("src/envie/schema.gleam", 237).
-spec run_field(field(EJA)) -> {ok, EJA} | {error, envie@error:error()}.
run_field(Field) ->
    (erlang:element(3, Field))().

-file("src/envie/schema.gleam", 164).
-spec load_field(field(EHS)) -> {ok, EHS} | {error, envie@error:error()}.
load_field(Field) ->
    run_field(Field).

-file("src/envie/schema.gleam", 241).
-spec trace_field(field(any())) -> inspect_field().
trace_field(Field) ->
    (erlang:element(4, Field))().

-file("src/envie/schema.gleam", 160).
-spec build1(field(EHP)) -> schema(EHP).
build1(Field) ->
    {schema,
        [erlang:element(2, Field)],
        fun() -> run_field(Field) end,
        fun() -> [trace_field(Field)] end}.

-file("src/envie/schema.gleam", 168).
-spec build2(field(EHW), field(EHY), fun((EHW, EHY) -> EIA)) -> schema(EIA).
build2(First, Second, Build) ->
    {schema,
        [erlang:element(2, First), erlang:element(2, Second)],
        fun() -> case run_field(First) of
                {ok, A} ->
                    case run_field(Second) of
                        {ok, B} ->
                            {ok, Build(A, B)};

                        {error, Err} ->
                            {error, Err}
                    end;

                {error, Err@1} ->
                    {error, Err@1}
            end end,
        fun() -> [trace_field(First), trace_field(Second)] end}.

-file("src/envie/schema.gleam", 189).
-spec build3(field(EIC), field(EIE), field(EIG), fun((EIC, EIE, EIG) -> EII)) -> schema(EII).
build3(First, Second, Third, Build) ->
    {schema,
        [erlang:element(2, First),
            erlang:element(2, Second),
            erlang:element(2, Third)],
        fun() -> case run_field(First) of
                {ok, A} ->
                    case run_field(Second) of
                        {ok, B} ->
                            case run_field(Third) of
                                {ok, C} ->
                                    {ok, Build(A, B, C)};

                                {error, Err} ->
                                    {error, Err}
                            end;

                        {error, Err@1} ->
                            {error, Err@1}
                    end;

                {error, Err@2} ->
                    {error, Err@2}
            end end,
        fun() ->
            [trace_field(First), trace_field(Second), trace_field(Third)]
        end}.

-file("src/envie/schema.gleam", 215).
-spec map2(field(EIK), field(EIM), fun((EIK, EIM) -> EIO)) -> schema(EIO).
map2(First, Second, Build) ->
    build2(First, Second, Build).

-file("src/envie/schema.gleam", 245).
-spec decode_value(binary(), envie@decode:decoder(EJG), binary()) -> {ok, EJG} |
    {error, envie@error:error()}.
decode_value(Name, Decoder, Raw) ->
    case (erlang:element(2, Decoder))(Raw) of
        {ok, Value} ->
            {ok, Value};

        {error, Reason} ->
            {error, {invalid_value, Name, Raw, Reason}}
    end.

-file("src/envie/schema.gleam", 257).
-spec mask_value(binary(), boolean()) -> binary().
mask_value(Value, Secret) ->
    case Secret of
        true ->
            <<"********"/utf8>>;

        false ->
            Value
    end.

-file("src/envie/schema.gleam", 40).
-spec field(binary(), envie@decode:decoder(EHC)) -> field(EHC).
field(Name, Decoder) ->
    {field,
        {field_meta, Name, false, false, false},
        fun() -> case envie:get(Name) of
                {ok, Value} ->
                    decode_value(Name, Decoder, Value);

                {error, _} ->
                    {error, {missing, Name}}
            end end,
        fun() -> case envie:get(Name) of
                {ok, Value@1} ->
                    case (erlang:element(2, Decoder))(Value@1) of
                        {ok, _} ->
                            {inspect_field,
                                Name,
                                {some, mask_value(Value@1, false)},
                                false,
                                false,
                                false,
                                none};

                        {error, Reason} ->
                            {inspect_field,
                                Name,
                                {some, mask_value(Value@1, false)},
                                false,
                                false,
                                false,
                                {some, {invalid_value, Name, Value@1, Reason}}}
                    end;

                {error, _} ->
                    {inspect_field, Name, none, false, false, false, none}
            end end}.

-file("src/envie/schema.gleam", 108).
-spec default(field(EHI), EHI) -> field(EHI).
default(Field, Value) ->
    {field,
        {field_meta,
            erlang:element(2, erlang:element(2, Field)),
            erlang:element(3, erlang:element(2, Field)),
            true,
            erlang:element(5, erlang:element(2, Field))},
        fun() -> case (erlang:element(3, Field))() of
                {ok, V} ->
                    {ok, V};

                {error, {missing, _}} ->
                    {ok, Value};

                {error, Err} ->
                    {error, Err}
            end end,
        fun() ->
            Trace = (erlang:element(4, Field))(),
            case erlang:element(3, Trace) of
                {some, _} ->
                    Trace;

                none ->
                    {inspect_field,
                        erlang:element(2, Trace),
                        {some,
                            mask_value(
                                <<"<default>"/utf8>>,
                                erlang:element(6, Trace)
                            )},
                        true,
                        erlang:element(5, Trace),
                        erlang:element(6, Trace),
                        none}
            end
        end}.