Current section
Files
Jump to
Current section
Files
src/cigogne.erl
-module(cigogne).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/cigogne.gleam").
-export([read_migrations/1, create_engine/1, new_migration/2, update_config/1, include_lib/2, remove_lib/2, apply_migrations/2, apply/1, apply_n/2, apply_all/1, rollback_migrations/2, rollback/1, rollback_n/2, get_all_migrations/1, get_applied_migrations/1, get_unapplied_migrations/1, print_error/1, main/0, apply_migration_if_not_applied/2]).
-export_type([migration_engine/0, cigogne_error/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.
-opaque migration_engine() :: {migration_engine,
cigogne@internal@database:database_data(),
list(cigogne@migration:migration()),
list(cigogne@migration:migration()),
list(cigogne@migration:migration()),
cigogne@config:config()}.
-type cigogne_error() :: {database_error,
cigogne@internal@database:database_error()} |
{f_s_error, cigogne@internal@fs:f_s_error()} |
{migration_error, cigogne@migration:migration_error()} |
{parser_error, cigogne@internal@parser_formatter:parser_error()} |
{config_error, cigogne@config:config_error()} |
nothing_to_rollback |
nothing_to_apply |
{lib_not_included, binary()} |
{compound_error, list(cigogne_error())}.
-file("src/cigogne.gleam", 165).
-spec warn_no_hash_check(cigogne@config:config()) -> nil.
warn_no_hash_check(Config) ->
case erlang:element(5, erlang:element(4, Config)) of
{some, true} ->
gleam_stdlib:println(
<<"Warning: no_hash_check is enabled ! Do not use it in production environments as it can lead to inconsistencies between your migration files and the database."/utf8>>
);
_ ->
nil
end.
-file("src/cigogne.gleam", 175).
-spec init_db_and_get_applied(cigogne@config:config()) -> {ok,
{cigogne@internal@database:database_data(),
list(cigogne@migration:migration())}} |
{error, cigogne_error()}.
init_db_and_get_applied(Config) ->
_pipe = begin
gleam@result:'try'(
cigogne@internal@database:init(Config),
fun(Db_data) ->
gleam@result:'try'(
cigogne@internal@database:apply_cigogne_zero(Db_data),
fun(_) ->
gleam@result:'try'(
cigogne@internal@database:get_applied_migrations(
Db_data
),
fun(Applied) -> {ok, {Db_data, Applied}} end
)
end
)
end
)
end,
gleam@result:map_error(_pipe, fun(Field@0) -> {database_error, Field@0} end).
-file("src/cigogne.gleam", 192).
?DOC(
" Read all migration files from the folder specified in the configuration .\n"
" It is recommended to use `create_engine` and `get_all_migrations` instead of this function.\n"
" It can still be useful if you want to read migrations without connecting to the database.\n"
).
-spec read_migrations(cigogne@config:config()) -> {ok,
list(cigogne@migration:migration())} |
{error, cigogne_error()}.
read_migrations(Config) ->
Files = begin
_pipe = begin
gleam@result:'try'(
cigogne@internal@fs:priv(
erlang:element(2, erlang:element(4, Config))
),
fun(Priv) ->
cigogne@internal@fs:read_directory(
<<<<Priv/binary, "/"/utf8>>/binary,
(cigogne@config:get_migrations_folder(
erlang:element(4, Config)
))/binary>>
)
end
)
end,
gleam@result:map_error(_pipe, fun(Field@0) -> {f_s_error, Field@0} end)
end,
gleam@result:'try'(
Files,
fun(Files@1) ->
Results = gleam@list:map(
Files@1,
fun(File) ->
_pipe@1 = cigogne@internal@parser_formatter:parse(File),
gleam@result:map_error(
_pipe@1,
fun(Field@0) -> {parser_error, Field@0} end
)
end
),
_pipe@2 = cigogne@internal@utils:get_results_or_errors(Results),
gleam@result:map_error(
_pipe@2,
fun(Field@0) -> {compound_error, Field@0} end
)
end
).
-file("src/cigogne.gleam", 145).
?DOC(
" Creates a MigrationEngine from a configuration.\n"
" This function will try to connect to the database, create the migrations table if it doesn't exist.\n"
" Then it will fetch the applied migrations and the existing migration files and check that hashes do match.\n"
" \n"
" Example usage:\n"
" ```gleam\n"
" import cigogne/config\n"
" import cigogne/cigogne\n"
" \n"
" pub fn main() {\n"
" use app_name <- result.try(config.get_app_name())\n"
" use config <- result.try(config.get(app_name))\n"
" use engine <- result.try(cigogne.create_engine(config))\n"
" \n"
" // Now you can use the engine to apply or rollback migrations\n"
" use _ <- result.try(cigogne.apply(engine))\n"
" use _ <- result.try(cigogne.rollback(engine))\n"
"\n"
" // Rest of your application logic\n"
" }\n"
" ```\n"
).
-spec create_engine(cigogne@config:config()) -> {ok, migration_engine()} |
{error, cigogne_error()}.
create_engine(Config) ->
warn_no_hash_check(Config),
gleam@result:'try'(
init_db_and_get_applied(Config),
fun(_use0) ->
{Db_data, Applied} = _use0,
gleam@result:'try'(
read_migrations(Config),
fun(Files) ->
gleam@result:'try'(
begin
_pipe@1 = cigogne@migration:match_migrations(
Applied,
Files,
begin
_pipe = erlang:element(
5,
erlang:element(4, Config)
),
gleam@option:unwrap(_pipe, false)
end
),
gleam@result:map_error(
_pipe@1,
fun(Field@0) -> {migration_error, Field@0} end
)
end,
fun(Applied@1) ->
Unapplied = cigogne@migration:find_unapplied(
Files,
Applied@1
),
{ok,
{migration_engine,
Db_data,
Files,
Applied@1,
Unapplied,
Config}}
end
)
end
)
end
).
-file("src/cigogne.gleam", 217).
?DOC(
" Create a new migration file in the folder specified by the configuration with the provided name.\n"
" Note: Migrations are always created in the `priv/<migrations_folder>` folder.\n"
).
-spec new_migration(cigogne@config:migrations_config(), binary()) -> {ok, nil} |
{error, cigogne_error()}.
new_migration(Migrations_config, Name) ->
gleam@result:'try'(
begin
_pipe = cigogne@migration:new(
<<"priv/"/utf8,
(cigogne@config:get_migrations_folder(Migrations_config))/binary>>,
Name,
gleam@time@timestamp:system_time()
),
gleam@result:map_error(
_pipe,
fun(Field@0) -> {migration_error, Field@0} end
)
end,
fun(New_mig) -> _pipe@1 = New_mig,
_pipe@2 = cigogne@internal@parser_formatter:format(_pipe@1),
_pipe@3 = cigogne@internal@fs:write_file(_pipe@2),
_pipe@4 = gleam@result:map_error(
_pipe@3,
fun(Field@0) -> {f_s_error, Field@0} end
),
gleam@result:map(
_pipe@4,
fun(_) ->
gleam_stdlib:println(
<<"Migration file created : "/utf8,
(erlang:element(2, New_mig))/binary>>
)
end
) end
).
-file("src/cigogne.gleam", 242).
?DOC(
" Update the configuration file at `priv/cigogne.toml` with the provided configuration.\n"
" If the file doesn't exist, it will be created.\n"
" If it already exists, it will be overwritten.\n"
).
-spec update_config(cigogne@config:config()) -> {ok, nil} |
{error, cigogne_error()}.
update_config(Config) ->
gleam@result:map(
begin
_pipe = cigogne@config:write(Config),
gleam@result:map_error(
_pipe,
fun(Field@0) -> {config_error, Field@0} end
)
end,
fun(_) ->
gleam_stdlib:println(
<<"Updated config file at priv/cigogne.toml"/utf8>>
)
end
).
-file("src/cigogne.gleam", 340).
?DOC(
" Include a library's migrations into your project.\n"
" This will create a new migration that applies all migrations from the library that haven't been applied yet.\n"
" This will fail if you haven't added the library to your project.\n"
"\n"
" Example usage:\n"
" ```sh\n"
" gleam add my_lib\n"
" gleam run -m cigogne include --lib-name my_lib\n"
" # There will be a new migration file created in priv/migrations with name `<timestamp>-my_lib`\n"
" ```\n"
).
-spec include_lib(migration_engine(), binary()) -> {ok, nil} |
{error, cigogne_error()}.
include_lib(Migration_engine, Lib_name) ->
gleam@result:'try'(
begin
_pipe = cigogne@config:get(Lib_name),
gleam@result:map_error(
_pipe,
fun(Field@0) -> {config_error, Field@0} end
)
end,
fun(Lib_config) ->
gleam@result:'try'(
read_migrations(Lib_config),
fun(Lib_migrations) ->
Last_migration_for_dep = begin
_pipe@1 = erlang:element(
4,
erlang:element(
4,
erlang:element(6, Migration_engine)
)
),
gleam@list:key_find(_pipe@1, Lib_name)
end,
Lib_migrations@1 = case Last_migration_for_dep of
{error, _} ->
Lib_migrations;
{ok, Name} ->
_pipe@2 = Lib_migrations,
_pipe@3 = gleam@list:drop_while(
_pipe@2,
fun(Mig) ->
cigogne@migration:to_fullname(Mig) /= Name
end
),
gleam@list:drop(_pipe@3, 1)
end,
gleam@result:'try'(
begin
_pipe@4 = cigogne@migration:merge(
Lib_migrations@1,
gleam@time@timestamp:system_time(),
Lib_name
),
gleam@result:map_error(
_pipe@4,
fun(Field@0) -> {migration_error, Field@0} end
)
end,
fun(Merged_mig) ->
Merged_mig@1 = begin
_pipe@5 = Merged_mig,
cigogne@migration:set_folder(
_pipe@5,
<<"priv/"/utf8,
(cigogne@config:get_migrations_folder(
erlang:element(
4,
erlang:element(
6,
Migration_engine
)
)
))/binary>>
)
end,
New_file = cigogne@internal@parser_formatter:format(
Merged_mig@1
),
gleam@result:'try'(
begin
_pipe@6 = New_file,
_pipe@7 = cigogne@internal@fs:write_file(
_pipe@6
),
gleam@result:map_error(
_pipe@7,
fun(Field@0) -> {f_s_error, Field@0} end
)
end,
fun(_) ->
gleam_stdlib:println(
<<"Created migration at "/utf8,
(erlang:element(2, New_file))/binary>>
),
Last_migration@1 = case gleam@list:last(
Lib_migrations@1
) of
{ok, Last_migration} -> Last_migration;
_assert_fail ->
erlang:error(
#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"cigogne"/utf8>>,
function => <<"include_lib"/utf8>>,
line => 378,
value => _assert_fail,
start => 12126,
'end' => 12183,
pattern_start => 12137,
pattern_end => 12155}
)
end,
New_config = begin
_record = erlang:element(
6,
Migration_engine
),
{config,
erlang:element(2, _record),
erlang:element(3, _record),
begin
_record@1 = erlang:element(
4,
erlang:element(
6,
Migration_engine
)
),
{migrations_config,
erlang:element(2, _record@1),
erlang:element(3, _record@1),
begin
_pipe@8 = erlang:element(
4,
erlang:element(
4,
erlang:element(
6,
Migration_engine
)
)
),
gleam@list:key_set(
_pipe@8,
Lib_name,
begin
_pipe@9 = Last_migration@1,
cigogne@migration:to_fullname(
_pipe@9
)
end
)
end,
erlang:element(5, _record@1)}
end}
end,
_pipe@10 = cigogne@config:write(New_config),
gleam@result:map_error(
_pipe@10,
fun(Field@0) -> {config_error, Field@0} end
)
end
)
end
)
end
)
end
).
-file("src/cigogne.gleam", 406).
?DOC(
" Remove a library's migrations from your project.\n"
" This will create a new migration that applies all the down migrations from the migrations created by include for this library.\n"
" This will fail if you haven't included the library yet.\n"
"\n"
" Example usage:\n"
" ```sh\n"
" gleam add my_lib\n"
" gleam run -m cigogne include --lib-name my_lib\n"
" gleam run -m cigogne remove --lib-name my_lib\n"
" # There will be a new migration file created in priv/migrations with name `<timestamp>-remove_my_lib`\n"
" ```\n"
).
-spec remove_lib(migration_engine(), binary()) -> {ok, nil} |
{error, cigogne_error()}.
remove_lib(Migration_engine, Lib_name) ->
Opposite_migrations = begin
_pipe = erlang:element(3, Migration_engine),
_pipe@1 = gleam@list:filter(
_pipe,
fun(Mig) -> erlang:element(4, Mig) =:= Lib_name end
),
_pipe@2 = gleam@list:map(_pipe@1, fun(Mig@1) -> _record = Mig@1,
{migration,
erlang:element(2, _record),
erlang:element(3, _record),
erlang:element(4, _record),
erlang:element(6, Mig@1),
erlang:element(5, Mig@1),
erlang:element(7, _record)} end),
lists:reverse(_pipe@2)
end,
gleam@bool:guard(
gleam@list:is_empty(Opposite_migrations),
{error, {lib_not_included, Lib_name}},
fun() ->
gleam@result:'try'(
begin
_pipe@3 = cigogne@migration:merge(
Opposite_migrations,
gleam@time@timestamp:system_time(),
<<"remove_"/utf8, Lib_name/binary>>
),
gleam@result:map_error(
_pipe@3,
fun(Field@0) -> {migration_error, Field@0} end
)
end,
fun(Merged_mig) ->
Merged_mig@1 = begin
_pipe@4 = Merged_mig,
cigogne@migration:set_folder(
_pipe@4,
<<"priv/"/utf8,
(cigogne@config:get_migrations_folder(
erlang:element(
4,
erlang:element(6, Migration_engine)
)
))/binary>>
)
end,
New_file = cigogne@internal@parser_formatter:format(
Merged_mig@1
),
gleam@result:'try'(
begin
_pipe@5 = New_file,
_pipe@6 = cigogne@internal@fs:write_file(_pipe@5),
gleam@result:map_error(
_pipe@6,
fun(Field@0) -> {f_s_error, Field@0} end
)
end,
fun(_) ->
gleam_stdlib:println(
<<"Created migration at "/utf8,
(erlang:element(2, New_file))/binary>>
),
New_config = begin
_record@1 = erlang:element(6, Migration_engine),
{config,
erlang:element(2, _record@1),
erlang:element(3, _record@1),
begin
_record@2 = erlang:element(
4,
erlang:element(6, Migration_engine)
),
{migrations_config,
erlang:element(2, _record@2),
erlang:element(3, _record@2),
begin
_pipe@7 = erlang:element(
4,
erlang:element(
4,
erlang:element(
6,
Migration_engine
)
)
),
gleam@list:filter(
_pipe@7,
fun(Dep) ->
erlang:element(1, Dep)
/= Lib_name
end
)
end,
erlang:element(5, _record@2)}
end}
end,
_pipe@8 = cigogne@config:write(New_config),
gleam@result:map_error(
_pipe@8,
fun(Field@0) -> {config_error, Field@0} end
)
end
)
end
)
end
).
-file("src/cigogne.gleam", 471).
?DOC(
" Apply migrations to the database.\n"
" It is recommended to use `apply` or `apply_n` instead of this function directly.\n"
" It can still be useful if you want to apply specific migrations or zero migrations.\n"
" All migrations will be applied in a single transaction, so either all are applied or none is.\n"
"\n"
" Be careful though as we don't check if the migration has already been applied or not, see `apply_migration_if_not_applied` for this use case.\n"
).
-spec apply_migrations(migration_engine(), list(cigogne@migration:migration())) -> {ok,
nil} |
{error, cigogne_error()}.
apply_migrations(Engine, Migrations) ->
_pipe = begin
cigogne@internal@database:transaction(
erlang:element(2, Engine),
fun(Transaction) ->
Db_data = begin
_record = erlang:element(2, Engine),
{database_data,
Transaction,
erlang:element(3, _record),
erlang:element(4, _record)}
end,
gleam@list:try_each(
Migrations,
fun(Migration) ->
gleam_stdlib:println(
<<"\nApplying migration "/utf8,
(cigogne@migration:to_fullname(Migration))/binary>>
),
cigogne@internal@database:apply_migration_no_transaction(
Db_data,
Migration
)
end
)
end
)
end,
_pipe@1 = gleam@result:map_error(
_pipe,
fun(Field@0) -> {database_error, Field@0} end
),
gleam@result:map(
_pipe@1,
fun(_) ->
gleam_stdlib:println(
<<"Migrations applied:\n\t"/utf8,
(begin
_pipe@2 = gleam@list:map(
Migrations,
fun cigogne@migration:to_fullname/1
),
gleam@string:join(_pipe@2, <<"\n\t"/utf8>>)
end)/binary>>
)
end
).
-file("src/cigogne.gleam", 250).
?DOC(
" Apply the next migration that wasn't applied yet.\n"
" See `create_engine` for an example usage.\n"
" See `apply_n` to apply multiple migrations at once.\n"
).
-spec apply(migration_engine()) -> {ok, nil} | {error, cigogne_error()}.
apply(Engine) ->
_pipe = erlang:element(5, Engine),
_pipe@1 = gleam@list:first(_pipe),
_pipe@2 = gleam@result:replace_error(_pipe@1, nothing_to_apply),
gleam@result:'try'(_pipe@2, fun(Mig) -> apply_migrations(Engine, [Mig]) end).
-file("src/cigogne.gleam", 278).
?DOC(
" Apply the next `count` migrations.\n"
" If `count` is less than or equal to 0, this function does nothing.\n"
" If there is no migration to apply, it returns an error.\n"
" If there are less than `count` migrations to apply, it applies all of them.\n"
" \n"
" Example usage:\n"
" ```gleam\n"
" use engine <- result.try(cigogne.create_engine(config))\n"
" use _ <- result.try(cigogne.apply_n(engine, 3)) // Apply the next 3 migrations\n"
" ```\n"
).
-spec apply_n(migration_engine(), integer()) -> {ok, nil} |
{error, cigogne_error()}.
apply_n(Engine, Count) ->
gleam@bool:guard(
Count =< 0,
{ok, nil},
fun() ->
Migrations_to_apply = begin
_pipe = erlang:element(5, Engine),
gleam@list:take(_pipe, Count)
end,
case Migrations_to_apply of
[] ->
{error, nothing_to_apply};
_ ->
apply_migrations(Engine, Migrations_to_apply)
end
end
).
-file("src/cigogne.gleam", 326).
?DOC(
" Apply all unapplied migrations.\n"
"\n"
" Example usage:\n"
" ```gleam\n"
" use engine <- result.try(cigogne.create_engine(config))\n"
" use _ <- result.try(cigogne.apply_all(engine))\n"
" ```\n"
).
-spec apply_all(migration_engine()) -> {ok, nil} | {error, cigogne_error()}.
apply_all(Engine) ->
apply_migrations(Engine, erlang:element(5, Engine)).
-file("src/cigogne.gleam", 499).
?DOC(
" Roll back migrations from the database.\n"
" It is recommended to use `rollback` or `rollback_n` instead of this function directly.\n"
" It can still be useful if you want to roll back specific migrations or a zero migrations.\n"
" All migrations will be rolled back in a single transaction, so either all are rolled back or none is.\n"
"\n"
" Be careful though as we don't check if the migration has been applied or not.\n"
).
-spec rollback_migrations(
migration_engine(),
list(cigogne@migration:migration())
) -> {ok, nil} | {error, cigogne_error()}.
rollback_migrations(Engine, Migrations) ->
_pipe = begin
cigogne@internal@database:transaction(
erlang:element(2, Engine),
fun(Transaction) ->
Db_data = begin
_record = erlang:element(2, Engine),
{database_data,
Transaction,
erlang:element(3, _record),
erlang:element(4, _record)}
end,
gleam@list:try_each(
Migrations,
fun(Migration) ->
gleam_stdlib:println(
<<"\nRolling back migration "/utf8,
(cigogne@migration:to_fullname(Migration))/binary>>
),
cigogne@internal@database:rollback_migration_no_transaction(
Db_data,
Migration
)
end
)
end
)
end,
_pipe@1 = gleam@result:map_error(
_pipe,
fun(Field@0) -> {database_error, Field@0} end
),
gleam@result:map(
_pipe@1,
fun(_) ->
gleam_stdlib:println(
<<"Migrations rolled back:\n\t"/utf8,
(begin
_pipe@2 = gleam@list:map(
Migrations,
fun cigogne@migration:to_fullname/1
),
gleam@string:join(_pipe@2, <<"\n\t"/utf8>>)
end)/binary>>
)
end
).
-file("src/cigogne.gleam", 260).
?DOC(
" Roll back the last applied migration.\n"
" See `create_engine` for an example usage.\n"
" See `rollback_n` to rollback multiple migrations at once.\n"
).
-spec rollback(migration_engine()) -> {ok, nil} | {error, cigogne_error()}.
rollback(Engine) ->
_pipe = erlang:element(4, Engine),
_pipe@1 = gleam@list:drop_while(
_pipe,
fun cigogne@migration:is_zero_migration/1
),
_pipe@2 = gleam@list:last(_pipe@1),
_pipe@3 = gleam@result:replace_error(_pipe@2, nothing_to_rollback),
gleam@result:'try'(
_pipe@3,
fun(Mig) -> rollback_migrations(Engine, [Mig]) end
).
-file("src/cigogne.gleam", 301).
?DOC(
" Roll back `count` migrations.\n"
" If `count` is less than or equal to 0, this function does nothing.\n"
" If there is no migration to rollback, it returns an error.\n"
" If there are less than `count` migrations to rollback, it rolls all of them back.\n"
" \n"
" Example usage:\n"
" ```gleam\n"
" use engine <- result.try(cigogne.create_engine(config))\n"
" use _ <- result.try(cigogne.rollback_n(engine, 3)) // Rollback the next 3 migrations\n"
" ```\n"
).
-spec rollback_n(migration_engine(), integer()) -> {ok, nil} |
{error, cigogne_error()}.
rollback_n(Engine, Count) ->
gleam@bool:guard(
Count =< 0,
{ok, nil},
fun() ->
Migrations_to_rollback = begin
_pipe = erlang:element(4, Engine),
_pipe@1 = gleam@list:drop_while(
_pipe,
fun cigogne@migration:is_zero_migration/1
),
_pipe@2 = lists:reverse(_pipe@1),
gleam@list:take(_pipe@2, Count)
end,
case Migrations_to_rollback of
[] ->
{error, nothing_to_rollback};
_ ->
rollback_migrations(Engine, Migrations_to_rollback)
end
end
).
-file("src/cigogne.gleam", 522).
?DOC(" Get all defined migrations in your project.\n").
-spec get_all_migrations(migration_engine()) -> list(cigogne@migration:migration()).
get_all_migrations(Engine) ->
erlang:element(3, Engine).
-file("src/cigogne.gleam", 527).
?DOC(" Get applied migrations in your project.\n").
-spec get_applied_migrations(migration_engine()) -> list(cigogne@migration:migration()).
get_applied_migrations(Engine) ->
erlang:element(4, Engine).
-file("src/cigogne.gleam", 534).
?DOC(" Get unapplied migrations in your project.\n").
-spec get_unapplied_migrations(migration_engine()) -> list(cigogne@migration:migration()).
get_unapplied_migrations(Engine) ->
erlang:element(5, Engine).
-file("src/cigogne.gleam", 540).
-spec show(migration_engine()) -> nil.
show(Engine) ->
Migration_names = begin
_pipe = erlang:element(4, Engine),
gleam@list:map(_pipe, fun cigogne@migration:to_fullname/1)
end,
To_apply = begin
_pipe@1 = erlang:element(5, Engine),
gleam@list:map(_pipe@1, fun cigogne@migration:to_fullname/1)
end,
gleam_stdlib:println(
<<<<"Applied migrations: \n - "/utf8,
(begin
_pipe@2 = Migration_names,
gleam@string:join(_pipe@2, <<"\n - "/utf8>>)
end)/binary>>/binary,
"\n"/utf8>>
),
gleam_stdlib:println(
<<"Migrations to apply: \n - "/utf8,
(begin
_pipe@3 = To_apply,
gleam@string:join(_pipe@3, <<"\n - "/utf8>>)
end)/binary>>
).
-file("src/cigogne.gleam", 552).
-spec print_unapplied(migration_engine()) -> nil.
print_unapplied(Migration_engine) ->
gleam_stdlib:print(<<"Unapplied migrations:"/utf8>>),
gleam@list:each(
erlang:element(5, Migration_engine),
fun(Unapplied_mig) ->
gleam_stdlib:println(
<<<<"\n\n--- == "/utf8,
(cigogne@migration:to_fullname(Unapplied_mig))/binary>>/binary,
" ==\n"/utf8>>
),
gleam_stdlib:println(
begin
_pipe = erlang:element(5, Unapplied_mig),
gleam@string:join(_pipe, <<"\n"/utf8>>)
end
)
end
).
-file("src/cigogne.gleam", 566).
-spec get_error_message(cigogne_error()) -> binary().
get_error_message(Error) ->
case Error of
{compound_error, Errors} ->
<<"Many errors happened ! Here is the list:\n "/utf8,
(begin
_pipe = Errors,
_pipe@1 = gleam@list:map(_pipe, fun get_error_message/1),
gleam@string:join(_pipe@1, <<"\n "/utf8>>)
end)/binary>>;
{config_error, Error@1} ->
<<"Configuration error: "/utf8,
(cigogne@config:get_error_message(Error@1))/binary>>;
{database_error, Error@2} ->
<<"Database error: "/utf8,
(cigogne@internal@database:get_error_message(Error@2))/binary>>;
{f_s_error, Error@3} ->
<<"FS error: "/utf8,
(cigogne@internal@fs:get_error_message(Error@3))/binary>>;
{lib_not_included, Name} ->
<<<<"There were no migrations for library "/utf8, Name/binary>>/binary,
" ! Did you include it ?"/utf8>>;
{migration_error, Error@4} ->
<<"Migration error: "/utf8,
(cigogne@migration:get_error_message(Error@4))/binary>>;
nothing_to_apply ->
<<"There is no migration to apply ! You are up-to-date !"/utf8>>;
nothing_to_rollback ->
<<"There is no migration to rollback !"/utf8>>;
{parser_error, Error@5} ->
<<"Parser error: "/utf8,
(cigogne@internal@parser_formatter:get_error_message(Error@5))/binary>>
end.
-file("src/cigogne.gleam", 562).
?DOC(" Print a MigrateError to the standard error stream.\n").
-spec print_error(cigogne_error()) -> nil.
print_error(Error) ->
gleam_stdlib:println_error(get_error_message(Error)).
-file("src/cigogne.gleam", 69).
?DOC(
" The main entry point of the Cigogne CLI.\n"
" \n"
" Example usage:\n"
" ```sh\n"
" # List all possible actions\n"
" gleam run -m cigogne help\n"
" # Create a new migration\n"
" gleam run -m cigogne new --name AddUsers\n"
" # Apply a single migration\n"
" gleam run -m cigogne up\n"
" # Apply the next 3 migrations\n"
" gleam run -m cigogne up --count 3\n"
" # Apply all unapplied migrations\n"
" gleam run -m cigogne all\n"
" # Rollback a single migration\n"
" gleam run -m cigogne down\n"
" ```\n"
).
-spec main() -> {ok, nil} | {error, nil}.
main() ->
Args = erlang:element(4, argv:load()),
Application_name@1 = case cigogne@config:get_app_name() of
{ok, Application_name} -> Application_name;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"cigogne"/utf8>>,
function => <<"main"/utf8>>,
line => 71,
value => _assert_fail,
start => 2154,
'end' => 2209,
pattern_start => 2165,
pattern_end => 2185})
end,
Cigogne_config@1 = case cigogne@config:get(Application_name@1) of
{ok, Cigogne_config} -> Cigogne_config;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"cigogne"/utf8>>,
function => <<"main"/utf8>>,
line => 72,
value => _assert_fail@1,
start => 2212,
'end' => 2272,
pattern_start => 2223,
pattern_end => 2241})
end,
gleam@result:'try'(
cigogne@internal@cli:get_action(Application_name@1, Args),
fun(Cli_action) -> _pipe@26 = case Cli_action of
{new_migration, Migrations, Name} ->
_pipe = erlang:element(4, Cigogne_config@1),
_pipe@1 = cigogne@config:merge_migrations_config(
_pipe,
Migrations
),
new_migration(_pipe@1, Name);
{show_migrations, Config} ->
_pipe@2 = Cigogne_config@1,
_pipe@3 = cigogne@config:merge(_pipe@2, Config),
_pipe@4 = create_engine(_pipe@3),
gleam@result:map(_pipe@4, fun show/1);
{migrate_up, Config@1, Count} ->
_pipe@5 = Cigogne_config@1,
_pipe@6 = cigogne@config:merge(_pipe@5, Config@1),
_pipe@7 = create_engine(_pipe@6),
gleam@result:'try'(
_pipe@7,
fun(_capture) -> apply_n(_capture, Count) end
);
{migrate_down, Config@2, Count@1} ->
_pipe@8 = Cigogne_config@1,
_pipe@9 = cigogne@config:merge(_pipe@8, Config@2),
_pipe@10 = create_engine(_pipe@9),
gleam@result:'try'(
_pipe@10,
fun(_capture@1) -> rollback_n(_capture@1, Count@1) end
);
{migrate_up_all, Config@3} ->
_pipe@11 = Cigogne_config@1,
_pipe@12 = cigogne@config:merge(_pipe@11, Config@3),
_pipe@13 = create_engine(_pipe@12),
gleam@result:'try'(_pipe@13, fun apply_all/1);
{include_lib, Config@4, Lib_name} ->
_pipe@14 = Cigogne_config@1,
_pipe@15 = cigogne@config:merge(_pipe@14, Config@4),
_pipe@16 = create_engine(_pipe@15),
gleam@result:'try'(
_pipe@16,
fun(_capture@2) -> include_lib(_capture@2, Lib_name) end
);
{remove_lib, Config@5, Lib_name@1} ->
_pipe@17 = Cigogne_config@1,
_pipe@18 = cigogne@config:merge(_pipe@17, Config@5),
_pipe@19 = create_engine(_pipe@18),
gleam@result:'try'(
_pipe@19,
fun(_capture@3) ->
remove_lib(_capture@3, Lib_name@1)
end
);
{update_config, Config@6} ->
_pipe@20 = Cigogne_config@1,
_pipe@21 = cigogne@config:merge(_pipe@20, Config@6),
update_config(_pipe@21);
init_config ->
_pipe@22 = Cigogne_config@1,
update_config(_pipe@22);
{print_unapplied, Config@7} ->
_pipe@23 = Cigogne_config@1,
_pipe@24 = cigogne@config:merge(_pipe@23, Config@7),
_pipe@25 = create_engine(_pipe@24),
gleam@result:map(_pipe@25, fun print_unapplied/1)
end,
gleam@result:map_error(_pipe@26, fun print_error/1) end
).
-file("src/cigogne.gleam", 590).
?DOC(" Apply a migration to the database if it hasn't been applied.\n").
-spec apply_migration_if_not_applied(
migration_engine(),
cigogne@migration:migration()
) -> {ok, nil} | {error, cigogne_error()}.
apply_migration_if_not_applied(Engine, Migration) ->
case cigogne@internal@utils:find_compare(
erlang:element(4, Engine),
Migration,
fun cigogne@migration:compare/2
) of
{ok, _} ->
{ok, nil};
{error, _} ->
apply_migrations(Engine, [Migration])
end.