@deterministic-code/migraters 0.0.1 → 0.0.3

package/rust/src/migrater.rs

@@ -0,0 +1,224 @@
+use std::fs;
+use std::path::PathBuf;
+use std::time::Instant;
+
+use crate::abstractions::SqlDialect;
+use crate::checksum::checksum_hex;
+use crate::infrastructure::MigrationPool;
+use crate::messages::{message, scaffold};
+use crate::migrations::{
+    assert_no_checksum_drift, discover_up_files, down_path_for, is_migration_name, next_sequence,
+};
+
+type BoxError = Box<dyn std::error::Error>;
+
+pub struct SetupArg<'a> {
+    pub connection: &'a str,
+    pub migrations_path: &'a str,
+}
+
+pub struct UpArg<'a> {
+    pub connection: &'a str,
+    pub migrations_path: &'a str,
+    pub one: bool,
+}
+
+pub struct DownArg<'a> {
+    pub connection: &'a str,
+    pub migrations_path: &'a str,
+}
+
+pub struct CreateArg<'a> {
+    pub name: &'a str,
+    pub migrations_path: &'a str,
+}
+
+pub struct CreateResponse {
+    pub up_name: String,
+    pub down_name: String,
+}
+
+#[allow(async_fn_in_trait)]
+pub trait IMigrater: Send + Sync {
+    fn name(&self) -> &'static str;
+    async fn setup(&self, args: SetupArg<'_>) -> Result<(), BoxError>;
+    async fn up(&self, args: UpArg<'_>) -> Result<Vec<String>, BoxError>;
+    async fn down(&self, args: DownArg<'_>) -> Result<Option<String>, BoxError>;
+    fn create(&self, args: CreateArg<'_>) -> Result<CreateResponse, BoxError>;
+}
+
+pub struct Migrater {
+    dialect: &'static dyn SqlDialect,
+}
+
+impl Migrater {
+    pub fn new(dialect: &'static dyn SqlDialect) -> Self {
+        Self { dialect }
+    }
+}
+
+impl IMigrater for Migrater {
+    fn name(&self) -> &'static str {
+        self.dialect.name()
+    }
+
+    async fn setup(&self, args: SetupArg<'_>) -> Result<(), BoxError> {
+        self.dialect.prepare_setup(args.connection)?;
+        let pool = MigrationPool::connect(self.dialect, args.connection).await?;
+        pool.execute(self.dialect.migrates_ddl()).await?;
+        pool.execute(self.dialect.migrate_logs_ddl()).await?;
+        fs::create_dir_all(PathBuf::from(args.migrations_path))?;
+        Ok(())
+    }
+
+    async fn up(&self, args: UpArg<'_>) -> Result<Vec<String>, BoxError> {
+        let pool = MigrationPool::connect(self.dialect, args.connection).await?;
+        let files = discover_up_files(args.migrations_path)?;
+        let mut applied = pool
+            .fetch_applied(&self.dialect.select_applied_checksum_sql())
+            .await?;
+        assert_no_checksum_drift(&files, &applied)?;
+        let mut names = Vec::new();
+        loop {
+            let next = files
+                .iter()
+                .find(|(n, _)| !applied.contains_key(n))
+                .cloned();
+            let Some((name, path)) = next else {
+                return Ok(names);
+            };
+            let sql = fs::read_to_string(&path)?;
+            let sum = checksum_hex(&sql);
+            let log_id = pool.insert_log_started(self.dialect, &name, "up").await?;
+            let started = Instant::now();
+            match pool
+                .apply_statements(
+                    self.dialect,
+                    &sql,
+                    self.dialect.insert_applied_sql(),
+                    &name,
+                    Some(&sum),
+                )
+                .await
+            {
+                Ok(()) => {
+                    let _ = pool
+                        .update_log(
+                            self.dialect,
+                            log_id,
+                            "success",
+                            started.elapsed().as_millis() as i64,
+                            None,
+                        )
+                        .await;
+                }
+                Err(e) => {
+                    let _ = pool
+                        .update_log(
+                            self.dialect,
+                            log_id,
+                            "error",
+                            started.elapsed().as_millis() as i64,
+                            Some(&e.to_string()),
+                        )
+                        .await;
+                    return Err(e);
+                }
+            }
+            applied.insert(name.clone(), Some(sum));
+            names.push(name);
+            if args.one {
+                return Ok(names);
+            }
+        }
+    }
+
+    async fn down(&self, args: DownArg<'_>) -> Result<Option<String>, BoxError> {
+        let pool = MigrationPool::connect(self.dialect, args.connection).await?;
+        let files = discover_up_files(args.migrations_path)?;
+        let applied = pool
+            .fetch_applied(&self.dialect.select_applied_checksum_sql())
+            .await?;
+        if applied.is_empty() {
+            return Ok(None);
+        }
+        assert_no_checksum_drift(&files, &applied)?;
+        let last = files
+            .iter()
+            .rev()
+            .find(|(n, _)| applied.contains_key(n))
+            .cloned();
+        let Some((name, _)) = last else {
+            return Err(message("errors/rollback-not-in-path", &[]).into());
+        };
+        let path = down_path_for(args.migrations_path, &name)
+            .ok_or_else(|| message("errors/rollback-no-down-sibling", &[("name", &name)]))?;
+        let sql = fs::read_to_string(&path)?;
+        let log_id = pool.insert_log_started(self.dialect, &name, "down").await?;
+        let started = Instant::now();
+        match pool
+            .apply_statements(
+                self.dialect,
+                &sql,
+                self.dialect.delete_applied_sql(),
+                &name,
+                None,
+            )
+            .await
+        {
+            Ok(()) => {
+                let _ = pool
+                    .update_log(
+                        self.dialect,
+                        log_id,
+                        "success",
+                        started.elapsed().as_millis() as i64,
+                        None,
+                    )
+                    .await;
+            }
+            Err(e) => {
+                let _ = pool
+                    .update_log(
+                        self.dialect,
+                        log_id,
+                        "error",
+                        started.elapsed().as_millis() as i64,
+                        Some(&e.to_string()),
+                    )
+                    .await;
+                return Err(e);
+            }
+        }
+        Ok(Some(name))
+    }
+
+    fn create(&self, args: CreateArg<'_>) -> Result<CreateResponse, BoxError> {
+        if !is_migration_name(args.name) {
+            return Err(message("errors/invalid-name", &[("name", args.name)]).into());
+        }
+        let dir = PathBuf::from(args.migrations_path);
+        fs::create_dir_all(&dir)?;
+        let seq = if dir.is_dir() {
+            let mut names = Vec::new();
+            for entry in fs::read_dir(&dir)? {
+                let entry = entry?;
+                if let Ok(file_name) = entry.file_name().into_string() {
+                    names.push(file_name);
+                }
+            }
+            next_sequence(names)
+        } else {
+            1
+        };
+        let prefix = format!("{seq:04}");
+        let up_name = format!("{prefix}_{}_up.sql", args.name);
+        let down_name = format!("{prefix}_{}_down.sql", args.name);
+        fs::write(dir.join(&up_name), scaffold("up", &[("name", args.name)]))?;
+        fs::write(
+            dir.join(&down_name),
+            scaffold("down", &[("name", args.name)]),
+        )?;
+        Ok(CreateResponse { up_name, down_name })
+    }
+}

package/rust/src/migrations.rs

@@ -0,0 +1,151 @@
+use std::collections::HashMap;
+use std::fs;
+use std::path::PathBuf;
+
+use crate::checksum::checksum_hex;
+use crate::messages::message;
+
+pub fn catalog_name(stored: &str) -> &str {
+    stored.strip_suffix("_up.sql").unwrap_or(stored)
+}
+
+pub fn is_migration_name(s: &str) -> bool {
+    let mut chars = s.chars();
+    match chars.next() {
+        Some(c) if c.is_ascii_lowercase() => {}
+        _ => return false,
+    }
+    chars.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_')
+}
+
+pub fn parse_sequence(filename: &str) -> Option<u32> {
+    if !filename.ends_with("_up.sql") {
+        return None;
+    }
+    let bytes = filename.as_bytes();
+    let mut end = 0usize;
+    while end < bytes.len() && end < 4 && bytes[end].is_ascii_digit() {
+        end += 1;
+    }
+    if end == 0 {
+        return None;
+    }
+    if end >= bytes.len() || bytes[end] != b'_' {
+        return None;
+    }
+    if end == 4 && bytes.len() > 4 && bytes[4].is_ascii_digit() {
+        return None;
+    }
+    filename[..end].parse::<u32>().ok()
+}
+
+pub fn next_sequence<I, S>(filenames: I) -> u32
+where
+    I: IntoIterator<Item = S>,
+    S: AsRef<str>,
+{
+    let mut max = 0u32;
+    for name in filenames {
+        if let Some(n) = parse_sequence(name.as_ref()) {
+            if n > max {
+                max = n;
+            }
+        }
+    }
+    max + 1
+}
+
+pub fn discover_up_files(
+    migrate_path: &str,
+) -> Result<Vec<(String, PathBuf)>, Box<dyn std::error::Error>> {
+    let dir = PathBuf::from(migrate_path);
+    if !dir.is_dir() {
+        return Err(message("errors/migrate-path-not-dir", &[("path", migrate_path)]).into());
+    }
+    let mut out: Vec<(String, PathBuf)> = Vec::new();
+    for entry in fs::read_dir(&dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        if !path.is_file() {
+            continue;
+        }
+        let file_name = match path.file_name().and_then(|s| s.to_str()) {
+            Some(n) if n.ends_with("_up.sql") => n.to_string(),
+            _ => continue,
+        };
+        let name = file_name[..file_name.len() - "_up.sql".len()].to_string();
+        out.push((name, path));
+    }
+    out.sort_by(|a, b| a.0.cmp(&b.0));
+    Ok(out)
+}
+
+pub fn down_path_for(migrate_path: &str, name: &str) -> Option<PathBuf> {
+    let path = PathBuf::from(migrate_path).join(format!("{name}_down.sql"));
+    path.is_file().then_some(path)
+}
+
+pub fn assert_no_checksum_drift(
+    files: &[(String, PathBuf)],
+    applied: &HashMap<String, Option<String>>,
+) -> Result<(), String> {
+    if std::env::var("MIGRATE_ALLOW_CHECKSUM_DRIFT")
+        .ok()
+        .as_deref()
+        == Some("1")
+    {
+        return Ok(());
+    }
+    let mut lines = Vec::new();
+    for (name, path) in files {
+        let Some(Some(stored)) = applied.get(name).cloned() else {
+            continue;
+        };
+        let sql = fs::read_to_string(path).map_err(|e| e.to_string())?;
+        let current = checksum_hex(&sql);
+        if current != stored {
+            let line = message(
+                "checksum-drift-line",
+                &[
+                    ("name", name),
+                    ("stored", &stored.chars().take(12).collect::<String>()),
+                    ("current", &current.chars().take(12).collect::<String>()),
+                ],
+            );
+            lines.push(line.trim_end().to_string());
+        }
+    }
+    if lines.is_empty() {
+        return Ok(());
+    }
+    Err(message("checksum-drift", &[("lines", &lines.join("\n"))])
+        .trim_end()
+        .to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{discover_up_files, is_migration_name, next_sequence};
+
+    #[test]
+    fn create_name_and_sequence() {
+        assert!(is_migration_name("add_users"));
+        assert!(!is_migration_name("AddUsers"));
+        assert!(!is_migration_name("1bad"));
+        assert_eq!(next_sequence([] as [&str; 0]), 1);
+        assert_eq!(next_sequence(["0001_init_up.sql"]), 2);
+        assert_eq!(
+            next_sequence(["20240101120000_legacy_up.sql", "0003_later_up.sql"]),
+            4
+        );
+    }
+
+    #[test]
+    fn missing_migrations_directory_is_the_shared_error() {
+        let err = discover_up_files("/nope/migraters-missing-dir")
+            .err()
+            .unwrap()
+            .to_string();
+        assert!(err.contains("migrate-path is not a directory"));
+    }
+}

package/rust/src/provider.rs

@@ -0,0 +1,57 @@
+pub fn strip_key(raw: &str) -> String {
+    raw.chars()
+        .filter(|c| !matches!(c, ' ' | '_' | '-'))
+        .flat_map(|c| c.to_lowercase())
+        .collect()
+}
+
+pub fn normalize_provider(raw: &str) -> Option<&'static str> {
+    let key = strip_key(raw);
+    if let Some(name) = crate::cli_spec::providers()
+        .iter()
+        .find(|p| strip_key(p) == key)
+    {
+        return Some(name.as_str());
+    }
+    crate::cli_spec::provider_aliases()
+        .get(&key)
+        .map(|s| s.as_str())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::normalize_provider;
+    use crate::abstractions::all;
+    use crate::cli_spec;
+
+    #[test]
+    fn registry_matches_cli_yaml() {
+        let names: Vec<&str> = all().iter().map(|d| d.name()).collect();
+        let expected: Vec<&str> = cli_spec::providers().iter().map(|s| s.as_str()).collect();
+        for name in &names {
+            assert!(expected.contains(name), "{name}");
+        }
+        if names.len() == expected.len() {
+            let mut sorted = expected.clone();
+            sorted.sort();
+            assert_eq!(names, sorted);
+        }
+        for (alias, canonical) in cli_spec::provider_aliases() {
+            assert_eq!(
+                normalize_provider(alias),
+                Some(canonical.as_str()),
+                "{alias}"
+            );
+        }
+        assert_eq!(normalize_provider("MS-SQL-Server"), Some("sqlserver"));
+        assert_eq!(normalize_provider("nope"), None);
+        for dialect in all() {
+            assert_eq!(
+                dialect
+                    .connection_env_vars()
+                    .join(cli_spec::env_var_list_separator()),
+                crate::cli_spec::join_env_vars(dialect.connection_env_vars())
+            );
+        }
+    }
+}

package/shared/templates/help/create.txt

@@ -0,0 +1,16 @@
+{{usage}}
+
+Creates a new <NNNN>_<name>_up.sql + <NNNN>_<name>_down.sql pair scaffolded
+with TODO placeholders. NNNN is one greater than the highest 1-4-digit
+sequence prefix already present in the migrations directory (starts at 0001).
+Legacy timestamp-prefixed filenames are ignored for numbering.
+
+  --provider         Database dialect. Required.
+  --name             snake_case slug for the new migration. Required. Must
+                     match /^[a-z][a-z0-9_]*$/.
+  --migrations-path  Migrations directory (default: ./sql/<dialect>/migrations).
+                     Created with mkdir -p if it does not exist.
+
+Examples:
+  {{command}} --provider sqlite --name add_users
+  {{command}} --provider postgres --name backfill_email_lower --migrations-path ./db/changes/postgres

package/shared/templates/help/down.txt

@@ -0,0 +1,40 @@
+{{usage}}
+
+Rolls back the MOST RECENTLY applied migration (one step). DESTRUCTIVE: refuses
+to proceed unless the operator types confirm on stdin, or passes --confirm.
+
+  --provider         Database dialect. Required.
+  --connection       Connection string. Required (or set the per-dialect env var below).
+  --migrations-path  Full path to the migrations directory.
+  --migrations-root  Root prefix; the script then looks at <migrations-root>/<dialect>/migrations.
+                     Defaults to 'sql'. Ignored when --migrations-path is also set.
+  --confirm          Skip the interactive prompt.
+
+Examples:
+  # sqlite — bare path or sqlite:// URL.
+  {{command}} --provider sqlite --connection ./app.sqlite
+  {{command}} --provider sqlite --connection sqlite:///absolute/path/app.sqlite
+
+  # postgres — URL or keyword form.
+  {{command}} --provider postgres --connection postgresql://user:pass@host:5432/dbname
+
+  # mysql — URL form.
+  {{command}} --provider mysql --connection mysql://user:pass@host:3306/dbname
+
+  # sqlserver / oracle — pass a driver-native connection string.
+  {{command}} --provider sqlserver --connection "Server=host;Database=dbname;User Id=user;Password=pass;"
+  {{command}} --provider oracle   --connection "user/pass@host:1521/service"
+
+  # env-var fallback when --connection is omitted:
+  SQLITE_PATH=./app.sqlite       {{command}} --provider sqlite
+  DATABASE_URL=postgresql://...  {{command}} --provider postgres
+
+  # custom migrations layout (default looks under sql/<dialect>/migrations):
+  {{command}} --provider sqlite --connection ./app.sqlite --migrations-path ./db/changes/sqlite
+
+Per-dialect env vars consulted when --connection is omitted:
+  sqlite     SQLITE_PATH, DB_PATH
+  postgres   PG_CONNECTION_STRING, DATABASE_URL
+  mysql      MYSQL_URL, DATABASE_URL
+  sqlserver  MSSQL_URL, DATABASE_URL
+  oracle     ORACLE_CONNECT_STRING, DATABASE_URL

package/shared/templates/help/init.txt

@@ -0,0 +1,15 @@
+{{usage}}
+
+Selects the programming language and dialects this tree will compile and
+install. --language is required. Repeat --dialect once per provider.
+Re-running replaces the previous language and dialect set. --all restores
+every dialect. Does not take --connection.
+
+  --language  Programming language runner to install and build. typescript, csharp, or rust.
+  --dialect   Dialect to enable. Repeat for each dialect. Aliases from this file apply.
+  --all       Enable every dialect. Restores the committed full-provider set.
+
+Examples:
+  {{command}} --language typescript --dialect sqlite --dialect postgres
+  {{command}} --language csharp --dialect sqlite
+  {{command}} --language rust --all

package/shared/templates/help/setup.txt

@@ -0,0 +1,45 @@
+{{usage}}
+
+Creates the bookkeeping tables (migrates, migrate_logs) for the chosen dialect
+and the migrations directory (mkdir -p). Idempotent — re-running against an
+already-setup database is a no-op. For sqlite, also mkdir -p of the parent
+directory of --connection so a fresh-tree path like ./.test/foo.sqlite works.
+Pass --create-database to create the database named in --connection if it
+does not exist (postgres, mysql, sqlserver). sqlite creates the file on
+connect. oracle uses the existing service.
+
+  --provider         Database dialect. Required.
+  --connection       Connection string. Required (or set the per-dialect env var below).
+  --migrations-path  Migrations directory (default: ./sql/<dialect>/migrations).
+  --and-up           After setup, immediately invoke migrate-up so the chain is applied in one step.
+  --create-database  Create the database named in --connection if it does not exist.
+
+Examples:
+  # sqlite — bare path or sqlite:// URL; both create a file on disk.
+  {{command}} --provider sqlite --connection ./app.sqlite
+  {{command}} --provider sqlite --connection sqlite:///absolute/path/app.sqlite
+
+  # postgres — URL or keyword form.
+  {{command}} --provider postgres --connection postgresql://user:pass@host:5432/dbname
+
+  # mysql — URL form.
+  {{command}} --provider mysql --connection mysql://user:pass@host:3306/dbname
+
+  # sqlserver / oracle — pass a driver-native connection string.
+  {{command}} --provider sqlserver --connection "Server=host;Database=dbname;User Id=user;Password=pass;"
+  {{command}} --provider oracle   --connection "user/pass@host:1521/service"
+
+  # env-var fallback when --connection is omitted:
+  SQLITE_PATH=./app.sqlite       {{command}} --provider sqlite
+  DATABASE_URL=postgresql://...  {{command}} --provider postgres
+  DATABASE_URL=mysql://...       {{command}} --provider mysql
+
+  # explicit in-memory sqlite:
+  {{command}} --provider sqlite --connection :memory:
+
+Per-dialect env vars consulted when --connection is omitted:
+  sqlite     SQLITE_PATH, DB_PATH
+  postgres   PG_CONNECTION_STRING, DATABASE_URL
+  mysql      MYSQL_URL, DATABASE_URL
+  sqlserver  MSSQL_URL, DATABASE_URL
+  oracle     ORACLE_CONNECT_STRING, DATABASE_URL

package/shared/templates/help/up.txt

@@ -0,0 +1,43 @@
+{{usage}}
+
+Applies ALL pending migrations in sequence, each in its own transaction.
+
+  --provider         Database dialect. Required.
+  --connection       Connection string. Required (or set the per-dialect env var below).
+  --migrations-path  Full path to the migrations directory (e.g. sql/sqlite/migrations).
+  --migrations-root  Root prefix; the script then looks at <migrations-root>/<dialect>/migrations.
+                     Defaults to 'sql'. Ignored when --migrations-path is also set.
+  --one              Apply only the next pending migration, then exit. Default is to apply all pending migrations.
+
+Examples:
+  # sqlite — bare path or sqlite:// URL; both create a file on disk.
+  {{command}} --provider sqlite --connection ./app.sqlite
+  {{command}} --provider sqlite --connection sqlite:///absolute/path/app.sqlite
+
+  # postgres — URL or keyword form.
+  {{command}} --provider postgres --connection postgresql://user:pass@host:5432/dbname
+
+  # mysql — URL form.
+  {{command}} --provider mysql --connection mysql://user:pass@host:3306/dbname
+
+  # sqlserver / oracle — pass a driver-native connection string.
+  {{command}} --provider sqlserver --connection "Server=host;Database=dbname;User Id=user;Password=pass;"
+  {{command}} --provider oracle   --connection "user/pass@host:1521/service"
+
+  # env-var fallback when --connection is omitted:
+  SQLITE_PATH=./app.sqlite       {{command}} --provider sqlite
+  DATABASE_URL=postgresql://...  {{command}} --provider postgres
+
+  # custom migrations layout (default looks under sql/<dialect>/migrations):
+  {{command}} --provider sqlite --connection ./app.sqlite --migrations-path ./db/changes/sqlite
+  {{command}} --provider sqlite --connection ./app.sqlite --migrations-root ./db/changes
+
+  # one-shot: apply the next pending migration only, then exit.
+  {{command}} --provider sqlite --connection ./app.sqlite --one
+
+Per-dialect env vars consulted when --connection is omitted:
+  sqlite     SQLITE_PATH, DB_PATH
+  postgres   PG_CONNECTION_STRING, DATABASE_URL
+  mysql      MYSQL_URL, DATABASE_URL
+  sqlserver  MSSQL_URL, DATABASE_URL
+  oracle     ORACLE_CONNECT_STRING, DATABASE_URL

package/shared/templates/messages/checksum-drift-line.txt

@@ -0,0 +1 @@
+  {{name}}: stored {{stored}}..., current {{current}}...

package/shared/templates/messages/checksum-drift.txt

@@ -0,0 +1,11 @@
+Migration checksum drift detected — the migration file changed AFTER it was applied:
+{{lines}}
+
+The DB and source disagree about the schema you're running. Either the codegen
+regenerated an already-applied migration in place (the canonical bug — emit a NEW
+migration file instead), or the migrate state was hand-edited.
+
+Recovery options:
+  1. Emit a new migration that brings the DB up to the current schema, then deploy.
+  2. For showcase/dev DBs with no real data: wipe the DB file and let migrate:up re-run from scratch.
+  3. If you've verified the DB matches the new file: MIGRATE_ALLOW_CHECKSUM_DRIFT=1 npm run migrate:up

package/shared/templates/messages/down/confirm-mismatch.txt

@@ -0,0 +1 @@
+--confirm value ({{supplied}}) does not match the token printed above ({{token}}). Aborting.

package/shared/templates/messages/down/confirm-prompt.txt

@@ -0,0 +1 @@
+Type confirm to roll back: 

package/shared/templates/messages/down/confirm-stdin-failed.txt

@@ -0,0 +1 @@
+failed to read confirmation from stdin — aborting.

package/shared/templates/messages/down/confirm-token-mismatch.txt

@@ -0,0 +1 @@
+Confirmation did not match — aborting.

package/shared/templates/messages/down/confirm-tty-required.txt

@@ -0,0 +1 @@
+migrate-down requires interactive confirmation when stdin is not a TTY — pass --confirm to proceed.

package/shared/templates/messages/down/destructive-header.txt

@@ -0,0 +1,2 @@
+
+⚠ DESTRUCTIVE: this rolls back the most recently applied migration on {{dialect}}.

package/shared/templates/messages/errors/invalid-name.txt

@@ -0,0 +1 @@
+--name must be snake_case: lowercase letter then [a-z0-9_] (got "{{name}}")

package/shared/templates/messages/errors/migrate-path-not-dir.txt

@@ -0,0 +1 @@
+migrate-path is not a directory: {{path}}

package/shared/templates/messages/errors/missing-connection.txt

@@ -0,0 +1 @@
+missing --connection — pass --connection <url> (e.g. ./app.sqlite for sqlite) or set one of: {{envVars}}. Run with --help for examples.

package/shared/templates/messages/errors/missing-name-hint.txt

@@ -0,0 +1 @@
+missing --name — pass --name <snake_case_slug>.

package/shared/templates/messages/errors/missing-name.txt

@@ -0,0 +1 @@
+missing --name

package/shared/templates/messages/errors/missing-provider-hint.txt

@@ -0,0 +1 @@
+missing --provider — pass --provider <{{providers}}>. Run with --help for examples.

package/shared/templates/messages/errors/missing-provider.txt

@@ -0,0 +1 @@
+missing --provider

package/shared/templates/messages/errors/missing-value-for-flag.txt

@@ -0,0 +1 @@
+missing value for {{flag}}

package/shared/templates/messages/errors/rollback-no-down-sibling.txt

@@ -0,0 +1 @@
+Cannot roll back "{{name}}": no <stem>_down.sql sibling found

package/shared/templates/messages/errors/rollback-no-rollback-sibling.txt

@@ -0,0 +1 @@
+Cannot roll back "{{name}}": no rollback_*.sql sibling found

package/shared/templates/messages/errors/rollback-not-in-path.txt

@@ -0,0 +1 @@
+Most recently applied migration is not present under --migrate-path

package/shared/templates/messages/errors/sqlite-prerequisite.txt

@@ -0,0 +1 @@
+sqlite file: {{path}} does not exist — run 'migrate-setup --provider sqlite --connection {{path}}' to create it