glsql

-module(glsql).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/glsql.gleam").
-export([run/1, main/0]).

-file("src/glsql.gleam", 95).
-spec render_all(list(glsql@error:error()), binary(), binary()) -> binary().
render_all(Errors, Filename, Source) ->
    _pipe = Errors,
    _pipe@1 = gleam@list:map(
        _pipe,
        fun(_capture) -> glsql@error:render(_capture, Filename, Source) end
    ),
    gleam@string:join(_pipe@1, <<"\n"/utf8>>).

-file("src/glsql.gleam", 28).
-spec run(binary()) -> {ok, integer()} | {error, binary()}.
run(Config_path) ->
    gleam@result:'try'(
        begin
            _pipe = glsql@config:load(Config_path),
            gleam@result:map_error(
                _pipe,
                fun(_capture) ->
                    glsql@error:render(_capture, Config_path, <<""/utf8>>)
                end
            )
        end,
        fun(Cfg) ->
            gleam@result:'try'(
                begin
                    _pipe@1 = simplifile:read(erlang:element(2, Cfg)),
                    gleam@result:map_error(
                        _pipe@1,
                        fun(E) ->
                            <<<<<<<<"error: could not read "/utf8,
                                            (erlang:element(2, Cfg))/binary>>/binary,
                                        " ("/utf8>>/binary,
                                    (gleam@string:inspect(E))/binary>>/binary,
                                ")"/utf8>>
                        end
                    )
                end,
                fun(Source) ->
                    gleam@result:'try'(
                        begin
                            _pipe@2 = glsql@lexer:lex(Source),
                            gleam@result:map_error(
                                _pipe@2,
                                fun(_capture@1) ->
                                    glsql@error:render(
                                        _capture@1,
                                        erlang:element(2, Cfg),
                                        Source
                                    )
                                end
                            )
                        end,
                        fun(Tokens) ->
                            gleam@result:'try'(
                                begin
                                    _pipe@3 = glsql@parser:parse(Tokens),
                                    gleam@result:map_error(
                                        _pipe@3,
                                        fun(_capture@2) ->
                                            glsql@error:render(
                                                _capture@2,
                                                erlang:element(2, Cfg),
                                                Source
                                            )
                                        end
                                    )
                                end,
                                fun(Schema) ->
                                    gleam@result:'try'(
                                        begin
                                            _pipe@4 = glsql@validate:check(
                                                Schema,
                                                Cfg
                                            ),
                                            gleam@result:map_error(
                                                _pipe@4,
                                                fun(_capture@3) ->
                                                    render_all(
                                                        _capture@3,
                                                        erlang:element(2, Cfg),
                                                        Source
                                                    )
                                                end
                                            )
                                        end,
                                        fun(_) ->
                                            gleam@result:'try'(
                                                begin
                                                    _pipe@5 = glsql@resolve:resolve(
                                                        Schema,
                                                        Cfg
                                                    ),
                                                    gleam@result:map_error(
                                                        _pipe@5,
                                                        fun(_capture@4) ->
                                                            render_all(
                                                                _capture@4,
                                                                erlang:element(
                                                                    2,
                                                                    Cfg
                                                                ),
                                                                Source
                                                            )
                                                        end
                                                    )
                                                end,
                                                fun(Resolved) ->
                                                    Files = gleam@list:map(
                                                        erlang:element(
                                                            2,
                                                            Resolved
                                                        ),
                                                        fun(Table) ->
                                                            {<<<<<<(erlang:element(
                                                                                3,
                                                                                Cfg
                                                                            ))/binary,
                                                                            "/"/utf8>>/binary,
                                                                        (erlang:element(
                                                                            3,
                                                                            Table
                                                                        ))/binary>>/binary,
                                                                    ".gleam"/utf8>>,
                                                                glsql@codegen:generate_table(
                                                                    Table,
                                                                    erlang:element(
                                                                        4,
                                                                        Cfg
                                                                    ),
                                                                    erlang:element(
                                                                        2,
                                                                        Cfg
                                                                    )
                                                                )}
                                                        end
                                                    ),
                                                    gleam@result:'try'(
                                                        begin
                                                            _pipe@6 = simplifile:create_directory_all(
                                                                erlang:element(
                                                                    3,
                                                                    Cfg
                                                                )
                                                            ),
                                                            gleam@result:map_error(
                                                                _pipe@6,
                                                                fun(E@1) ->
                                                                    <<<<<<<<"error: could not create "/utf8,
                                                                                    (erlang:element(
                                                                                        3,
                                                                                        Cfg
                                                                                    ))/binary>>/binary,
                                                                                " ("/utf8>>/binary,
                                                                            (gleam@string:inspect(
                                                                                E@1
                                                                            ))/binary>>/binary,
                                                                        ")"/utf8>>
                                                                end
                                                            )
                                                        end,
                                                        fun(_) ->
                                                            gleam@result:'try'(
                                                                gleam@list:try_each(
                                                                    Files,
                                                                    fun(File) ->
                                                                        {Path,
                                                                            Contents} = File,
                                                                        _pipe@7 = simplifile:write(
                                                                            Path,
                                                                            Contents
                                                                        ),
                                                                        gleam@result:map_error(
                                                                            _pipe@7,
                                                                            fun(
                                                                                E@2
                                                                            ) ->
                                                                                <<<<<<<<"error: could not write "/utf8,
                                                                                                Path/binary>>/binary,
                                                                                            " ("/utf8>>/binary,
                                                                                        (gleam@string:inspect(
                                                                                            E@2
                                                                                        ))/binary>>/binary,
                                                                                    ")"/utf8>>
                                                                            end
                                                                        )
                                                                    end
                                                                ),
                                                                fun(_) ->
                                                                    {ok,
                                                                        erlang:length(
                                                                            Files
                                                                        )}
                                                                end
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/glsql.gleam", 14).
-spec main() -> nil.
main() ->
    case run(<<"glsql.toml"/utf8>>) of
        {ok, Count} ->
            gleam_stdlib:println(
                <<<<"Generated "/utf8, (gleam@string:inspect(Count))/binary>>/binary,
                    " modules."/utf8>>
            );

        {error, Message} ->
            gleam_stdlib:println_error(Message),
            erlang:halt(1)
    end.